build: include samples in prepare script

Replace subscribe with effect in assignSelector to ensure the
selector value is tracked and the callback is executed within
the reactive context.

AGENTS.md

@@ -36,15 +36,36 @@ Run tests matching a name: `npx vitest run -t "should create"`
 
 ```
 src/
-  core/              # game.ts, game-host.ts, part.ts, part-factory.ts, region.ts
+  index.ts                          # Barrel export (single public API)
-  samples/           # tic-tac-toe.ts, boop/, onitama/, regicide/, slay-the-spire-like/
+  core/
-  utils/             # mutable-signal.ts, rng.ts, async-queue.ts, command/ (8 files)
+    game.ts                         # Game core logic
-  index.ts           # barrel export
+    game-host.ts                    # GameHost lifecycle manager
-  global.d.ts        # *.yarnproject module declaration
+    part.ts                         # Part entity
-tests/               # mirrors src/ with *.test.ts
+    part-factory.ts                 # Part factory
+    region.ts                       # Region/space management
+  utils/
+    mutable-signal.ts               # MutableSignal<T> (extends Preact Signal)
+    rng.ts                          # Mulberry32 seeded PRNG
+    async-queue.ts                  # Async queue
+    middleware.ts                   # Middleware chain
+    command/                        # CLI-style command system (7 files)
+      types.ts, command-parse.ts, command-registry.ts
+      command-runner.ts, command-validate.ts, command-apply.ts, schema-parse.ts, index.ts
+  samples/
+    tic-tac-toe.ts                  # Simple sample game
+    boop/                           # Boop board game
+    onitama/                        # Onitama card game
+    regicide/                       # Regicide card game
+    slay-the-spire-like/            # Roguelike deckbuilder (see samples/slay-the-spire-like/AGENTS.md)
+tests/                              # Mirrors src/ with *.test.ts (20 files)
+  core/                             # game-host, game, part, part-factory, region
+  samples/                          # Each sample + slay-the-spire-like submodules
+  utils/                            # mutable-signal, rng, async-queue, middleware, command
 ```
 
-`src/utils/command/` is a directory: types.ts, command-parse.ts, command-registry.ts, command-runner.ts, command-validate.ts, command-apply.ts, schema-parse.ts, index.ts.
+`src/global.d.ts` — `*.yarnproject` module declaration.
+
+`testsgames/` and `testsrules/` — empty directories (reserved).
 
 ## Samples Build
 

package-lock.json

@@ -10,6 +10,7 @@
       "license": "MIT",
       "devDependencies": {
         "@preact/signals-core": "^1.5.1",
+        "@types/node": "^25.6.0",
         "inline-schema": "file:../inline-schema",
         "mutative": "^1.3.0",
         "tsup": "^8.0.2",
@@ -958,6 +959,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/node": {
+      "version": "25.6.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.6.0.tgz",
+      "integrity": "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.19.0"
+      }
+    },
     "node_modules/@vitest/expect": {
       "version": "1.6.1",
       "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.6.1.tgz",
@@ -2469,6 +2480,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/undici-types": {
+      "version": "7.19.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.19.2.tgz",
+      "integrity": "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/vite": {
       "version": "5.4.21",
       "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",

package.json

@@ -18,7 +18,7 @@
   "scripts": {
     "build": "tsup",
     "build:samples": "tsup --config tsup.samples.config.ts",
-    "prepare": "npm run build",
+    "prepare": "npm run build && npm run build:samples",
     "test": "vitest",
     "test:run": "vitest run",
     "typecheck": "tsc --noEmit"
@@ -30,6 +30,7 @@
   },
   "devDependencies": {
     "@preact/signals-core": "^1.5.1",
+    "@types/node": "^25.6.0",
     "inline-schema": "file:../inline-schema",
     "mutative": "^1.3.0",
     "tsup": "^8.0.2",

src/core/game-client.ts

@@ -0,0 +1,118 @@
+import { createPromptContext, PromptDef } from "@/utils/command";
+import { computed, effect, signal } from "@preact/signals-core";
+import { createGameContext, IGameContext } from "./game";
+
+export enum ClientStatus {
+  Idle = "idle",
+  Running = "running",
+  Disposed = "disposed",
+}
+
+export type PromptInfo =
+  | {
+      hasPrompt: false;
+      player: string;
+    }
+  | {
+      hasPrompt: true;
+      player: string;
+      def: PromptDef<unknown[]>;
+      tryAnswer(...args: unknown[]): string | null;
+    };
+
+/**
+ * 1. create a client instance
+ * 2. setStatus("running")
+ * 3. select("selector", t => {}) for c# to capture game state
+ * 4. useClient("status" | "prompt") for c# to handle prompt / game status
+ */
+export abstract class BaseGameClient<
+  T extends Record<string, unknown> = Record<string, unknown>,
+  R = unknown,
+> {
+  protected _initialState: T;
+  protected _context: IGameContext<T>;
+  protected _prompts = createPromptContext();
+  protected _status = signal(ClientStatus.Idle);
+  protected _result = signal(null as null | R);
+  public get state() {
+    return this._context.value;
+  }
+  constructor(is: T) {
+    this._initialState = is;
+    this._context = createGameContext(this._prompts, is);
+  }
+
+  async setStatus(status: ClientStatus) {
+    this._status.value = status;
+    if (status === ClientStatus.Disposed) {
+      this._prompts.reset();
+    } else if (status === ClientStatus.Running) {
+      this._prompts.reset();
+      this._context._state.value = this._initialState;
+      this._result.value = null;
+      this._result.value = await this.start(this._context);
+      this.setStatus(ClientStatus.Idle);
+    }
+  }
+
+  abstract start(ctx: IGameContext<T>): Promise<R>;
+
+  assignSelector<S>(selector: (t: T) => S, callback: (s: S) => void) {
+    const selected = computed(() => selector(this._context.value));
+    return effect(() => {
+      callback(selected.value);
+    });
+  }
+
+  addInterruption() {
+    let resolve!: () => void;
+    const promise = new Promise<void>((resolver) => {
+      resolve = resolver;
+    });
+    this._context._state.addInterruption(promise);
+    return resolve;
+  }
+
+  selectPrompt(callback: (prompt: PromptInfo) => void) {
+    return this._prompts.handleCall.use(async (ctx, next) => {
+      function tryAnswer(...args: any[]) {
+        try {
+          const res = ctx.validator(...args);
+          ctx.resolve(res);
+          return null;
+        } catch (reason) {
+          if (typeof reason === "string") {
+            return reason;
+          }
+          throw reason;
+        }
+      }
+
+      try {
+        callback({
+          hasPrompt: true,
+          player: ctx.player || "global",
+          def: ctx.def,
+          tryAnswer,
+        });
+        return await next();
+      } finally {
+        callback({
+          hasPrompt: false,
+          player: ctx.player || "global",
+        });
+      }
+    });
+  }
+  selectStatus(callback: (status: ClientStatus) => void) {
+    return effect(() => {
+      callback(this._status.value);
+    });
+  }
+  selectResult(callback: (status: R | null) => void) {
+    return effect(() => {
+      callback(this._result.value);
+    });
+  }
+}

src/core/game-host.ts

@@ -1,95 +1,39 @@
-import { ReadonlySignal, Signal } from '@preact/signals-core';
+import { createPromptContext } from "@/utils/command";
-import {
+import { PromptContext } from "@/utils/command/command-prompt";
-    CommandSchema,
+import { ReadonlySignal, Signal } from "@preact/signals-core";
-    CommandRegistry,
+import { createGameContext, IGameContext } from "./game";
-    PromptEvent,
-} from '@/utils/command';
-import {createGameCommandRegistry, createGameContext, IGameContext, PromptDef} from './game';
 
-export type GameHostStatus = 'created' | 'running' | 'disposed';
+export type GameHostStatus = "created" | "running" | "disposed";
 
-export class GameHost<TState extends Record<string, unknown>, TResult=unknown> {
+export class GameHost<
+  TState extends Record<string, unknown>,
+  TResult = unknown,
+  TModule extends GameModule<TState, TResult> = GameModule<TState, TResult>,
+> {
   readonly state: ReadonlySignal<TState>;
   readonly status: ReadonlySignal<GameHostStatus>;
-    readonly activePromptSchema: ReadonlySignal<CommandSchema | null>;
+  readonly prompts: PromptContext;
-    readonly activePromptPlayer: ReadonlySignal<string | null>;
-    readonly activePromptHint: ReadonlySignal<string | null>;
 
   private _context: IGameContext<TState>;
   private _start: (ctx: IGameContext<TState>) => Promise<TResult>;
   private _status: Signal<GameHostStatus>;
-    private _activePromptSchema: Signal<CommandSchema | null>;
-    private _activePromptPlayer: Signal<string | null>;
-    private _activePromptHint: Signal<string | null>;
   private _createInitialState: () => TState;
-    private _eventListeners: Map<'start' | 'dispose', Set<() => void>>;
+  private _eventListeners: Map<"start" | "dispose", Set<() => void>>;
   private _isDisposed = false;
 
-    constructor(
+  constructor(public readonly gameModule: TModule) {
-        registry: CommandRegistry<IGameContext<TState>>,
+    const { createInitialState, start } = gameModule;
-        createInitialState: () => TState,
-        start: (ctx: IGameContext<TState>) => Promise<TResult>
-    ) {
     this._createInitialState = createInitialState;
     this._eventListeners = new Map();
 
+    this.prompts = createPromptContext();
     const initialState = createInitialState();
-        this._context = createGameContext(registry, initialState);
+    this._context = createGameContext(this.prompts, initialState);
     this._start = start;
     this.state = this._context._state;
 
-        this._status = new Signal<GameHostStatus>('created');
+    this._status = new Signal<GameHostStatus>("created");
     this.status = this._status;
-
-        this._activePromptSchema = new Signal<CommandSchema | null>(null);
-        this.activePromptSchema = this._activePromptSchema;
-
-        this._activePromptPlayer = new Signal<string | null>(null);
-        this.activePromptPlayer = this._activePromptPlayer;
-        
-        this._activePromptHint = new Signal<string | null>(null);
-        this.activePromptHint = this._activePromptHint;
-
-        this._setupPromptTracking();
-    }
-
-    private _setupPromptTracking() {
-        let currentPromptEvent: PromptEvent | null = null;
-
-        this._context._commands.on('prompt', (e) => {
-            currentPromptEvent = e as PromptEvent;
-            this._activePromptSchema.value = currentPromptEvent.schema;
-            this._activePromptPlayer.value = currentPromptEvent.currentPlayer;
-            this._activePromptHint.value = currentPromptEvent.hintText || null;
-        });
-
-        this._context._commands.on('promptEnd', () => {
-            currentPromptEvent = null;
-            this._activePromptSchema.value = null;
-            this._activePromptPlayer.value = null;
-            this._activePromptHint.value = null;
-        });
-
-        // Initial state
-        this._activePromptSchema.value = null;
-        this._activePromptPlayer.value = null;
-        this._activePromptHint.value = null;
-    }
-
-    tryInput(input: string): string | null {
-        if (this._isDisposed) {
-            return 'GameHost is disposed';
-        }
-        return this._context._commands._tryCommit(input);
-    }
-    
-    tryAnswerPrompt<TArgs extends any[]>(def: PromptDef<TArgs>, ...args: TArgs){
-        return this._context._commands._tryCommit({
-            name: def.schema.name,
-            params: args,
-            options: {},
-            flags: {}
-        });
   }
 
   /**
@@ -110,10 +54,10 @@ export class GameHost<TState extends Record<string, unknown>, TResult=unknown> {
 
   start(seed?: number): Promise<TResult> {
     if (this._isDisposed) {
-            throw new Error('GameHost is disposed');
+      throw new Error("GameHost is disposed");
     }
 
-        this._context._commands._cancel();
+    this.prompts.reset();
 
     const initialState = this._createInitialState();
     this._context._state.value = initialState as any;
@@ -122,8 +66,8 @@ export class GameHost<TState extends Record<string, unknown>, TResult=unknown> {
     this._context._rng.setSeed(seed);
     const promise = this._start(this._context);
 
-        this._status.value = 'running';
+    this._status.value = "running";
-        this._emitEvent('start');
+    this._emitEvent("start");
 
     return promise;
   }
@@ -134,15 +78,15 @@ export class GameHost<TState extends Record<string, unknown>, TResult=unknown> {
     }
 
     this._isDisposed = true;
-        this._context._commands._cancel();
+    this.prompts.reset();
-        this._status.value = 'disposed';
+    this._status.value = "disposed";
 
     // Emit dispose event BEFORE clearing listeners
-        this._emitEvent('dispose');
+    this._emitEvent("dispose");
     this._eventListeners.clear();
   }
 
-    on(event: 'start' | 'dispose', listener: () => void): () => void {
+  on(event: "start" | "dispose", listener: () => void): () => void {
     if (!this._eventListeners.has(event)) {
       this._eventListeners.set(event, new Set());
     }
@@ -153,7 +97,7 @@ export class GameHost<TState extends Record<string, unknown>, TResult=unknown> {
     };
   }
 
-    private _emitEvent(event: 'start' | 'dispose') {
+  private _emitEvent(event: "start" | "dispose") {
     const listeners = this._eventListeners.get(event);
     if (listeners) {
       for (const listener of listeners) {
@@ -163,18 +107,18 @@ export class GameHost<TState extends Record<string, unknown>, TResult=unknown> {
   }
 }
 
-export type GameModule<TState extends Record<string, unknown>, TResult=unknown> = {
+export type GameModule<
-    registry?: CommandRegistry<IGameContext<TState>>;
+  TState extends Record<string, unknown> = Record<string, unknown>,
+  TResult = unknown,
+> = {
   createInitialState: () => TState;
   start: (ctx: IGameContext<TState>) => Promise<TResult>;
-}
+};
 
-export function createGameHost<TState extends Record<string, unknown>>(
+export function createGameHost<
-  gameModule: GameModule<TState>
+  TState extends Record<string, unknown> = Record<string, unknown>,
-): GameHost<TState> {
+  TResult = unknown,
-    return new GameHost(
+  TModule extends GameModule<TState, TResult> = GameModule<TState, TResult>,
-        gameModule.registry || createGameCommandRegistry(),
+>(gameModule: TModule): GameHost<TState, TResult, TModule> {
-        gameModule.createInitialState,
+  return new GameHost(gameModule);
-        gameModule.start
-    );
 }

src/core/game.ts

@@ -1,37 +1,37 @@
-import {MutableSignal, mutableSignal} from "@/utils/mutable-signal";
+import { MutableSignal, mutableSignal } from "@/utils/mutable-signal";
-import {
+import { CommandSchema, parseCommandSchema, PromptDef } from "@/utils/command";
-    Command,
+import { PromptValidator } from "@/utils/command/command-runner";
-    CommandRegistry, CommandResult,
+import { Mulberry32RNG, ReadonlyRNG, RNG } from "@/utils/rng";
-    CommandRunnerContextExport,
+import { PromptContext } from "@/utils/command/command-prompt";
-    CommandSchema,
-    createCommandRegistry,
-    createCommandRunnerContext, parseCommandSchema,
-} from "@/utils/command";
-import {PromptValidator} from "@/utils/command/command-runner";
-import {Mulberry32RNG, ReadonlyRNG, RNG} from "@/utils/rng";
 
-export interface IGameContext<TState extends Record<string, unknown> = {} > {
+export interface IGameContext<TState extends Record<string, unknown> = {}> {
   get value(): TState;
   get rng(): ReadonlyRNG;
-    produce(fn: (draft: TState) => void): void;
+  produce(fn: (draft: TState) => undefined): void;
-    produceAsync(fn: (draft: TState) => void): Promise<void>;
+  produceAsync(fn: (draft: TState) => undefined): Promise<void>;
-    run<T>(input: string): Promise<CommandResult<T>>;
+  prompt: <TResult, TArgs extends any[] = any[]>(
-    runParsed<T>(command: Command): Promise<CommandResult<T>>;
+    def: PromptDef<TArgs>,
-    prompt: <TResult,TArgs extends any[]=any[]>(def: PromptDef<TArgs>, validator: PromptValidator<TResult,TArgs>, currentPlayer?: string | null) => Promise<TResult>;
+    validator: PromptValidator<TResult, TArgs>,
+    player?: string,
+  ) => Promise<TResult>;
 
   // test only
   _state: MutableSignal<TState>;
-    _commands: CommandRunnerContextExport<IGameContext<TState>>;
   _rng: RNG;
 }
+export type IGameContextExport<TState extends Record<string, unknown> = {}> =
+  Omit<IGameContext<TState>, "_state" | "_commands" | "_rng">;
 
-export function createGameContext<TState extends Record<string, unknown> = {} >(
+export function createGameContext<TState extends Record<string, unknown> = {}>(
-    commandRegistry: CommandRegistry<IGameContext<TState>>,
+  promptContext: PromptContext,
-    initialState?: TState | (() => TState)
+  initialState?: TState | (() => TState),
 ): IGameContext<TState> {
-    const stateValue = typeof initialState === 'function' ? initialState() : initialState ?? {} as TState;
+  const stateValue =
+    typeof initialState === "function"
+      ? initialState()
+      : (initialState ?? ({} as TState));
   const state = mutableSignal(stateValue);
-    let commands: CommandRunnerContextExport<IGameContext<TState>> = null as any;
+  const { prompt } = promptContext;
 
   const context: IGameContext<TState> = {
     get value(): TState {
@@ -40,41 +40,25 @@ export function createGameContext<TState extends Record<string, unknown> = {} >(
     get rng() {
       return this._rng;
     },
-        produce(fn) {
+    produce(fn: (draft: TState) => undefined) {
       return state.produce(fn);
     },
-        produceAsync(fn) {
+    produceAsync(fn: (draft: TState) => undefined) {
       return state.produceAsync(fn);
     },
-        run<T>(input: string) {
+    prompt,
-            return commands.run<T>(input);
-        },
-        runParsed<T>(command: Command) {
-            return commands.runParsed<T>(command);
-        },
-        prompt(def, validator, currentPlayer) {
-            return commands.prompt(def.schema, validator, def.hintText, currentPlayer);
-        },
 
     _state: state,
-        _commands: commands,
     _rng: new Mulberry32RNG(),
   };
 
-    context._commands = commands = createCommandRunnerContext(commandRegistry, context);
-    
   return context;
 }
 
-export type PromptDef<TArgs extends any[]=any[]> = {
+export function createPromptDef<TArgs extends any[] = any[]>(
-    schema: CommandSchema,
+  schema: CommandSchema | string,
   hintText?: string,
-}
+): PromptDef<TArgs> {
-export function createPromptDef<TArgs extends any[]=any[]>(schema: CommandSchema | string, hintText?: string): PromptDef<TArgs> {
+  schema = typeof schema === "string" ? parseCommandSchema(schema) : schema;
-    schema = typeof schema === 'string' ? parseCommandSchema(schema) : schema;
   return { schema, hintText };
 }
-
-export function createGameCommandRegistry<TState extends Record<string, unknown> = {} >() {
-    return createCommandRegistry<IGameContext<TState>>();
-}

src/global.d.ts

@@ -1,5 +0,0 @@
-declare module '*.yarnproject' {
-    import type { LoadResult } from 'yarn-spinner-loader';
-    const result: LoadResult;
-    export default result;
-}

src/index.ts

@@ -4,31 +4,75 @@
  */
 
 // Core types
-export type { IGameContext } from './core/game';
+export type { IGameContext } from "./core/game";
-export { createGameCommandRegistry, createPromptDef } from './core/game';
+export { createPromptDef } from "./core/game";
 
-export type { GameHost, GameHostStatus, GameModule } from './core/game-host';
+export type { GameHost, GameHostStatus, GameModule } from "./core/game-host";
-export { createGameHost } from './core/game-host';
+export { createGameHost } from "./core/game-host";
 
-export type { Part } from './core/part';
+export type { Part } from "./core/part";
-export { flip, flipTo, roll } from './core/part';
+export { flip, flipTo, roll } from "./core/part";
 
-export { createParts, createPartsFromTable } from './core/part-factory';
+export { createParts, createPartsFromTable } from "./core/part-factory";
 
-export type { Region, RegionAxis } from './core/region';
+export type { Region, RegionAxis } from "./core/region";
-export { createRegion, createRegionAxis, applyAlign, shuffle, moveToRegion } from './core/region';
+export {
+  createRegion,
+  createRegionAxis,
+  applyAlign,
+  shuffle,
+  moveToRegion,
+} from "./core/region";
+
+export * from "./core/game-client";
 
 // Utils
-export type { Command, CommandDef, CommandResult, CommandSchema, CommandParamSchema, CommandOptionSchema, CommandFlagSchema } from './utils/command';
+export type {
-export { parseCommand, parseCommandSchema, validateCommand, parseCommandWithSchema, applyCommandSchema } from './utils/command';
+  Command,
+  CommandDef,
+  CommandResult,
+  CommandSchema,
+  CommandParamSchema,
+  CommandOptionSchema,
+  CommandFlagSchema,
+} from "./utils/command";
+export {
+  parseCommand,
+  parseCommandSchema,
+  validateCommand,
+  parseCommandWithSchema,
+  applyCommandSchema,
+} from "./utils/command";
 
-export type { CommandRunner, CommandRunnerHandler, CommandRunnerContext, PromptEvent, CommandRunnerEvents } from './utils/command';
+export type {
-export { createCommandRegistry, registerCommand, unregisterCommand, hasCommand, getCommand, runCommand, runCommandParsed, createCommandRunnerContext, type CommandRegistry, type CommandRunnerContextExport } from './utils/command';
+  CommandRunner,
+  CommandRunnerHandler,
+  CommandRunnerContext,
+  PromptEvent,
+  CommandRunnerEvents,
+} from "./utils/command";
+export {
+  createCommandRegistry,
+  registerCommand,
+  unregisterCommand,
+  hasCommand,
+  getCommand,
+  runCommand,
+  runCommandParsed,
+  createCommandRunnerContext,
+  type CommandRegistry,
+  type CommandRunnerContextExport,
+} from "./utils/command";
 
-export type { MutableSignal } from './utils/mutable-signal';
+export type { MutableSignal } from "./utils/mutable-signal";
-export { mutableSignal } from './utils/mutable-signal';
+export { mutableSignal } from "./utils/mutable-signal";
 
-export type { RNG } from './utils/rng';
+export type { RNG, ReadonlyRNG } from "./utils/rng";
-export { createRNG, Mulberry32RNG } from './utils/rng';
+export { createRNG, Mulberry32RNG } from "./utils/rng";
 
-export * from '@preact/signals-core';
+export type { MiddlewareChain } from "./utils/middleware";
+export { createMiddlewareChain } from "./utils/middleware";
+
+export * from "./utils/spawner";
+
+export * from "@preact/signals-core";

src/samples/boop/commands/index.ts

@@ -1,75 +1,11 @@
-import {BoopGame} from "@/samples/boop/types-extensions";
+import { BoopGame } from "@/samples/boop/types-extensions";
-import {PlayerType} from "@/samples/boop/types";
+import { PlayerType } from "@/samples/boop/types";
-import {turn} from "@/samples/boop/commands/turn";
+import { turn } from "@/samples/boop/commands/turn";
-import {createGameCommandRegistry} from "@/core/game";
+import { boop } from "./boop";
-
+import { checkFullBoard } from "./full-board";
-export const registry = createGameCommandRegistry<BoopGame['value']>();
+import { checkGraduates } from "./graduate";
-
+import { place } from "./place";
-/**
+import { checkWin } from "./win";
- * 放置棋子到棋盘
- */
-const placeCmd = registry.register({
-    schema: 'place <row:number> <col:number> <player> <type>',
-    run: async (game, row, col, player, type) => {
-        const {place} = await import('./place');
-        return place(game, row, col, player, type);
-    }
-});
-
-/**
- * 执行boop - 推动周围棋子
- */
-const boopCmd = registry.register({
-    schema: 'boop <row:number> <col:number> <type>',
-    run: async (game, row, col, type) => {
-        const {boop} = await import('./boop');
-        return boop(game, row, col, type);
-    }
-});
-
-/**
- * 检查是否有玩家获胜(三个猫连线)
- */
-const checkWinCmd = registry.register({
-    schema: 'check-win',
-    run: async (game) => {
-        const {checkWin} = await import('./win');
-        return checkWin(game);
-    }
-});
-
-/**
- * 检查并执行小猫升级(三个小猫连线变成猫)
- */
-const checkGraduatesCmd = registry.register({
-    schema: 'check-graduates',
-    run: async (game) => {
-        const {checkGraduates} = await import('./graduate');
-        return checkGraduates(game);
-    }
-});
-
-/**
- * 检查并执行 8-piece 规则
- */
-const checkFullBoardCmd = registry.register({
-    schema: 'check-full-board <player:string>',
-    run: async (game, player) => {
-        const {checkFullBoard} = await import('./full-board');
-        return checkFullBoard(game, player);
-    }
-});
-
-/**
- * 处理一个回合
- */
-const turnCmd = registry.register({
-    schema: 'turn <player:string>',
-    run: async (game, player) => {
-        const {turn} = await import('./turn');
-        return turn(game, player);
-    }
-});
 
 /**
  * 启动游戏主循环
@@ -79,10 +15,11 @@ export async function start(game: BoopGame) {
     const currentPlayer = game.value.currentPlayer;
     const turnOutput = await turn(game, currentPlayer);
 
-        await game.produceAsync(state => {
+    await game.produceAsync((state) => {
       state.winner = turnOutput.winner;
       if (!state.winner) {
-                state.currentPlayer = state.currentPlayer === 'white' ? 'black' : 'white';
+        state.currentPlayer =
+          state.currentPlayer === "white" ? "black" : "white";
       }
     });
     if (game.value.winner) break;
@@ -91,11 +28,4 @@ export async function start(game: BoopGame) {
   return game.value;
 }
 
-export {
+export { place, boop, checkWin, checkGraduates, checkFullBoard, turn };
-    placeCmd as place,
-    boopCmd as boop,
-    checkWinCmd as checkWin,
-    checkGraduatesCmd as checkGraduates,
-    checkFullBoardCmd as checkFullBoard,
-    turnCmd as turn
-};

src/samples/boop/index.ts

@@ -5,38 +5,30 @@ export type {
   WinnerType,
   RegionType,
   BoopPartMeta,
-    BoopPart
+  BoopPart,
-} from './types';
+} from "./types";
 
-export type {BoopGame} from './types-extensions';
+export type { BoopGame } from "./types-extensions";
 
 // Constants
-export {
+export { BOARD_SIZE, MAX_PIECES_PER_PLAYER, WIN_LENGTH } from "./constants";
-    BOARD_SIZE,
-    MAX_PIECES_PER_PLAYER,
-    WIN_LENGTH
-} from './constants';
 
 // State
-export {
+export { createInitialState, type BoopState } from "./state";
-    createInitialState,
-    type BoopState
-} from './state';
 
 // Prompts
-export {prompts} from './prompts';
+export { prompts } from "./prompts";
 
 // Commands
 export {
-    registry,
   start,
   place as placeCmd,
   boop as boopCmd,
   checkWin as checkWinCmd,
   checkGraduates as checkGraduatesCmd,
   checkFullBoard as checkFullBoardCmd,
-    turn as turnCmd
+  turn as turnCmd,
-} from './commands';
+} from "./commands";
 
 // Utils
 export {
@@ -45,5 +37,5 @@ export {
   isCellOccupied,
   getNeighborPositions,
   findPartInRegion,
-    findPartAtPosition
+  findPartAtPosition,
-} from './utils';
+} from "./utils";

src/samples/onitama/commands.ts

@@ -3,12 +3,9 @@ import {
   OnitamaState,
   PlayerType,
   prompts,
-    initializeCards
+  initializeCards,
 } from "./types";
-import {createGameCommandRegistry} from "@/core/game";
+import { moveToRegion } from "@/core/region";
-import {moveToRegion} from "@/core/region";
-
-export const registry = createGameCommandRegistry<OnitamaState>();
 
 /**
  * 检查位置是否在棋盘范围内
@@ -29,8 +26,12 @@ function getPawnAtPosition(state: OnitamaState, x: number, y: number) {
 /**
  * 检查玩家是否拥有某张卡牌
  */
-function playerHasCard(state: OnitamaState, player: PlayerType, cardName: string): boolean {
+function playerHasCard(
-    const cardList = player === 'red' ? state.redCards : state.blackCards;
+  state: OnitamaState,
+  player: PlayerType,
+  cardName: string,
+): boolean {
+  const cardList = player === "red" ? state.redCards : state.blackCards;
   return cardList.includes(cardName);
 }
 
@@ -38,13 +39,17 @@ function playerHasCard(state: OnitamaState, player: PlayerType, cardName: string
  * 获取卡牌的移动候选项，根据玩家视角进行旋转
  * 黑方需要将卡牌旋转180度
  */
-export function getCardMoveCandidates(state: OnitamaState, cardName: string, player: PlayerType) {
+export function getCardMoveCandidates(
+  state: OnitamaState,
+  cardName: string,
+  player: PlayerType,
+) {
   const card = state.cards[cardName];
   const candidates = card.moveCandidates;
 
   // 黑方需要将卡牌旋转180度
-    if (player === 'black') {
+  if (player === "black") {
-        return candidates.map(m => ({ dx: -m.dx, dy: -m.dy }));
+    return candidates.map((m) => ({ dx: -m.dx, dy: -m.dy }));
   }
 
   return candidates;
@@ -53,7 +58,15 @@ export function getCardMoveCandidates(state: OnitamaState, cardName: string, pla
 /**
  * 检查移动是否合法
  */
-export function isValidMove(state: OnitamaState, cardName: string, fromX: number, fromY: number, toX: number, toY: number, player: PlayerType): string | null {
+export function isValidMove(
+  state: OnitamaState,
+  cardName: string,
+  fromX: number,
+  fromY: number,
+  toX: number,
+  toY: number,
+  player: PlayerType,
+): string | null {
   // 检查玩家是否拥有该卡牌
   if (!playerHasCard(state, player, cardName)) {
     return `玩家 ${player} 不拥有卡牌 ${cardName}`;
@@ -80,7 +93,7 @@ export function isValidMove(state: OnitamaState, cardName: string, fromX: number
 
   // 检查移动是否在卡牌的移动候选项中（黑方需要旋转180度）
   const candidates = getCardMoveCandidates(state, cardName, player);
-    const isValid = candidates.some(m => m.dx === dx && m.dy === dy);
+  const isValid = candidates.some((m) => m.dx === dx && m.dy === dy);
   if (!isValid) {
     return `卡牌 ${cardName} 不支持移动 (${dx}, ${dy})`;
   }
@@ -102,7 +115,15 @@ export function isValidMove(state: OnitamaState, cardName: string, fromX: number
 /**
  * 执行移动
  */
-async function handleMove(game: OnitamaGame, player: PlayerType, cardName: string, fromX: number, fromY: number, toX: number, toY: number) {
+async function move(
+  game: OnitamaGame,
+  player: PlayerType,
+  cardName: string,
+  fromX: number,
+  fromY: number,
+  toX: number,
+  toY: number,
+) {
   const state = game.value;
 
   // 验证移动
@@ -113,7 +134,7 @@ async function handleMove(game: OnitamaGame, player: PlayerType, cardName: strin
 
   const capturedPawnId = getPawnAtPosition(state, toX, toY)?.id || null;
 
-    await game.produceAsync(state => {
+  await game.produceAsync((state) => {
     const pawn = state.pawns[getPawnAtPosition(state, fromX, fromY)!.id];
 
     // 如果目标位置有敌方棋子，将其移除（吃掉）
@@ -127,41 +148,40 @@ async function handleMove(game: OnitamaGame, player: PlayerType, cardName: strin
   });
 
   // 交换卡牌
-    await handleSwapCard(game, player, cardName);
+  await swapCard(game, player, cardName);
 
   return {
     from: { x: fromX, y: fromY },
     to: { x: toX, y: toY },
     card: cardName,
-        captured: capturedPawnId 
+    captured: capturedPawnId,
   };
 }
 
-const move = registry.register({
-    schema: 'move <player> <card:string> <fromX:number> <fromY:number> <toX:number> <toY:number>',
-    run: handleMove
-});
-
 /**
  * 交换卡牌：将使用的卡牌与备用卡牌交换
  */
-async function handleSwapCard(game: OnitamaGame, player: PlayerType, usedCard: string) {
+async function swapCard(
-    await game.produceAsync(state => {
+  game: OnitamaGame,
+  player: PlayerType,
+  usedCard: string,
+) {
+  await game.produceAsync((state) => {
     const spareCard = state.spareCard;
     const usedCardData = state.cards[usedCard];
     const spareCardData = state.cards[spareCard];
 
     // 从玩家手牌中移除使用的卡牌
-        if (player === 'red') {
+    if (player === "red") {
-            state.redCards = state.redCards.filter(c => c !== usedCard);
+      state.redCards = state.redCards.filter((c) => c !== usedCard);
       state.redCards.push(spareCard);
     } else {
-            state.blackCards = state.blackCards.filter(c => c !== usedCard);
+      state.blackCards = state.blackCards.filter((c) => c !== usedCard);
       state.blackCards.push(spareCard);
     }
 
     // 更新卡牌区域
-        usedCardData.regionId = 'spare';
+    usedCardData.regionId = "spare";
     spareCardData.regionId = player;
 
     // 更新备用卡牌
@@ -169,75 +189,70 @@ async function handleSwapCard(game: OnitamaGame, player: PlayerType, usedCard: s
   });
 }
 
-const swapCard = registry.register({
-    schema: 'swap-card <player> <card:string>',
-    run: handleSwapCard
-});
-
 /**
  * 检查占领胜利条件：玩家的师父棋子到达对手的初始位置
  * 红色师父需要到达 (2, 4) - 黑色师父的初始位置
  * 黑色师父需要到达 (2, 0) - 红色师父的初始位置
  */
-async function handleCheckConquestWin(game: OnitamaGame): Promise<PlayerType | null> {
+async function checkConquestWin(game: OnitamaGame): Promise<PlayerType | null> {
   const state = game.value;
 
   // 红色师父到达 (2, 4)（黑色师父的初始位置）
-    const redMaster = state.pawns['red-master'];
+  const redMaster = state.pawns["red-master"];
-    if (redMaster && redMaster.regionId === 'board' && redMaster.position[0] === 2 && redMaster.position[1] === 4) {
+  if (
-        return 'red';
+    redMaster &&
+    redMaster.regionId === "board" &&
+    redMaster.position[0] === 2 &&
+    redMaster.position[1] === 4
+  ) {
+    return "red";
   }
 
   // 黑色师父到达 (2, 0)（红色师父的初始位置）
-    const blackMaster = state.pawns['black-master'];
+  const blackMaster = state.pawns["black-master"];
-    if (blackMaster && blackMaster.regionId === 'board' && blackMaster.position[0] === 2 && blackMaster.position[1] === 0) {
+  if (
-        return 'black';
+    blackMaster &&
+    blackMaster.regionId === "board" &&
+    blackMaster.position[0] === 2 &&
+    blackMaster.position[1] === 0
+  ) {
+    return "black";
   }
 
   return null;
 }
 
-const checkConquestWin = registry.register({
-    schema: 'check-conquest-win',
-    run: handleCheckConquestWin
-});
-
 /**
  * 检查吃掉胜利条件：对手的师父棋子被吃掉（不在棋盘上）
  */
-async function handleCheckCaptureWin(game: OnitamaGame): Promise<PlayerType | null> {
+async function checkCaptureWin(game: OnitamaGame): Promise<PlayerType | null> {
   const state = game.value;
 
   // 红色师父不在棋盘上，黑色获胜
-    const redMaster = state.pawns['red-master'];
+  const redMaster = state.pawns["red-master"];
-    if (!redMaster || redMaster.regionId !== 'board') {
+  if (!redMaster || redMaster.regionId !== "board") {
-        return 'black';
+    return "black";
   }
 
   // 黑色师父不在棋盘上，红色获胜
-    const blackMaster = state.pawns['black-master'];
+  const blackMaster = state.pawns["black-master"];
-    if (!blackMaster || blackMaster.regionId !== 'board') {
+  if (!blackMaster || blackMaster.regionId !== "board") {
-        return 'red';
+    return "red";
   }
 
   return null;
 }
 
-const checkCaptureWin = registry.register({
-    schema: 'check-capture-win',
-    run: handleCheckCaptureWin
-});
-
 /**
  * 综合胜利检测
  */
-async function handleCheckWin(game: OnitamaGame): Promise<PlayerType | null> {
+async function checkWin(game: OnitamaGame): Promise<PlayerType | null> {
-    const conquestWinner = await handleCheckConquestWin(game);
+  const conquestWinner = await checkConquestWin(game);
   if (conquestWinner) {
     return conquestWinner;
   }
 
-    const captureWinner = await handleCheckCaptureWin(game);
+  const captureWinner = await checkCaptureWin(game);
   if (captureWinner) {
     return captureWinner;
   }
@@ -245,22 +260,34 @@ async function handleCheckWin(game: OnitamaGame): Promise<PlayerType | null> {
   return null;
 }
 
-const checkWin = registry.register({
-    schema: 'check-win',
-    run: handleCheckWin
-});
-
 /**
  * 获取玩家可用的移动
  */
-export function getAvailableMoves(state: OnitamaState, player: PlayerType): Array<{card: string, fromX: number, fromY: number, toX: number, toY: number}> {
+export function getAvailableMoves(
-    const moves: Array<{card: string, fromX: number, fromY: number, toX: number, toY: number}> = [];
+  state: OnitamaState,
+  player: PlayerType,
+): Array<{
+  card: string;
+  fromX: number;
+  fromY: number;
+  toX: number;
+  toY: number;
+}> {
+  const moves: Array<{
+    card: string;
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+  }> = [];
 
   // 获取玩家的所有卡牌
-    const cardNames = player === 'red' ? state.redCards : state.blackCards;
+  const cardNames = player === "red" ? state.redCards : state.blackCards;
 
   // 获取玩家的所有棋子
-    const playerPawns = Object.values(state.pawns).filter(p => p.owner === player && p.regionId === 'board');
+  const playerPawns = Object.values(state.pawns).filter(
+    (p) => p.owner === player && p.regionId === "board",
+  );
 
   // 对于每张卡牌
   for (const cardName of cardNames) {
@@ -294,7 +321,7 @@ export function getAvailableMoves(state: OnitamaState, player: PlayerType): Arra
 /**
  * 处理回合
  */
-async function handleTurn(game: OnitamaGame, turnPlayer: PlayerType) {
+async function turn(game: OnitamaGame, turnPlayer: PlayerType) {
   const state = game.value;
   const availableMoves = getAvailableMoves(state, turnPlayer);
 
@@ -313,7 +340,7 @@ async function handleTurn(game: OnitamaGame, turnPlayer: PlayerType) {
         }
         return card;
       },
-            turnPlayer
+      turnPlayer,
     );
 
     await swapCard(game, turnPlayer, cardToSwap);
@@ -334,19 +361,27 @@ async function handleTurn(game: OnitamaGame, turnPlayer: PlayerType) {
 
         return { player, card, fromX, fromY, toX, toY };
       },
-            turnPlayer
+      turnPlayer,
     );
 
-        await move(game, moveOutput.player, moveOutput.card, moveOutput.fromX, moveOutput.fromY, moveOutput.toX, moveOutput.toY);
+    await move(
+      game,
+      moveOutput.player,
+      moveOutput.card,
+      moveOutput.fromX,
+      moveOutput.fromY,
+      moveOutput.toX,
+      moveOutput.toY,
+    );
   }
 
   // 检查胜利
   const winner = await checkWin(game);
 
-    await game.produceAsync(state => {
+  await game.produceAsync((state) => {
     state.winner = winner;
     if (!winner) {
-            state.currentPlayer = state.currentPlayer === 'red' ? 'black' : 'red';
+      state.currentPlayer = state.currentPlayer === "red" ? "black" : "red";
       state.turn++;
     }
   });
@@ -354,11 +389,6 @@ async function handleTurn(game: OnitamaGame, turnPlayer: PlayerType) {
   return { winner, move: moveOutput };
 }
 
-const turn = registry.register({
-    schema: 'turn <player>',
-    run: handleTurn
-});
-
 /**
  * 开始游戏主循环
  */

src/samples/regicide/commands/index.ts

@@ -1,37 +1,35 @@
-import {IGameContext} from "@/core/game";
+import { IGameContext } from "@/core/game";
-import {RegicideState} from "@/samples/regicide/state";
+import { RegicideState } from "@/samples/regicide/state";
-import {createGameCommandRegistry} from "@/core/game";
+import { PlayerType, RegicideCard } from "@/samples/regicide/types";
-import {PlayerType, RegicideCard} from "@/samples/regicide/types";
+import { CARD_VALUES, FACE_CARDS } from "@/samples/regicide/constants";
-import {CARD_VALUES, FACE_CARDS} from "@/samples/regicide/constants";
+import { isEnemyDefeated } from "@/samples/regicide/utils";
-import {isEnemyDefeated} from "@/samples/regicide/utils";
 
 export type RegicideGame = IGameContext<RegicideState>;
 
-export const registry = createGameCommandRegistry<RegicideState>();
-
 /**
  * 打出一张牌（对当前敌人造成伤害）
  */
-const playCmd = registry.register({
+async function playCmd(game: RegicideGame, player: string, cardId: string) {
-    schema: 'play <player:string> <cardId:string>',
-    run: async (game: RegicideGame, player: string, cardId: string) => {
   const state = game.value;
   const card = state.cards[cardId];
 
   if (!card) {
-            return {success: false, error: `卡牌 ${cardId} 不存在`};
+    return { success: false, error: `卡牌 ${cardId} 不存在` };
   }
 
   // 检查卡牌是否在玩家手牌中
   const playerKey = player as PlayerType;
   const playerHand = state.playerHands[playerKey];
   if (!playerHand || !playerHand.includes(cardId)) {
-            return {success: false, error: `卡牌 ${cardId} 不在玩家 ${player} 的手牌中`};
+    return {
+      success: false,
+      error: `卡牌 ${cardId} 不在玩家 ${player} 的手牌中`,
+    };
   }
 
   // 检查是否有当前敌人
   if (!state.currentEnemy) {
-            return {success: false, error: '没有活跃的敌人'};
+    return { success: false, error: "没有活跃的敌人" };
   }
 
   // 计算伤害（基础伤害为卡牌面值）
@@ -39,24 +37,27 @@ const playCmd = registry.register({
   let attackReduction = 0;
 
   // 梅花双倍伤害
-        if (card.suit === 'clubs') {
+  if (card.suit === "clubs") {
     damage *= 2;
   }
 
   // 黑桃降低敌人攻击力
-        if (card.suit === 'spades') {
+  if (card.suit === "spades") {
     attackReduction = card.value;
   }
 
   const enemyHpBefore = state.currentEnemy.hp;
 
-        await game.produce(state => {
+  await game.produceAsync((state) => {
     // 对敌人造成伤害
     state.currentEnemy!.hp -= damage;
 
     // 记录黑桃的攻击力降低
     if (attackReduction > 0) {
-                state.currentEnemy!.value = Math.max(0, state.currentEnemy!.value - attackReduction);
+      state.currentEnemy!.value = Math.max(
+        0,
+        state.currentEnemy!.value - attackReduction,
+      );
     }
 
     // 从手牌移除卡牌
@@ -67,15 +68,17 @@ const playCmd = registry.register({
     }
 
     // 将卡牌移到弃牌堆
-            state.cards[cardId].regionId = 'discardPile';
+    state.cards[cardId].regionId = "discardPile";
 
     // 红心能力：将弃牌堆洗回酒馆牌堆
-            if (card.suit === 'hearts') {
+    if (card.suit === "hearts") {
-                const discardIds = state.regions.discardPile.childIds.filter(id => id !== state.currentEnemy!.id);
+      const discardIds = state.regions.discardPile.childIds.filter(
+        (id) => id !== state.currentEnemy!.id,
+      );
       if (discardIds.length > 0) {
         // 将弃牌堆（除当前敌人外）移回酒馆牌堆
         for (const discardId of discardIds) {
-                        state.cards[discardId].regionId = 'tavernDeck';
+          state.cards[discardId].regionId = "tavernDeck";
         }
         state.regions.tavernDeck.childIds.push(...discardIds);
         state.regions.discardPile.childIds = [state.currentEnemy!.id];
@@ -83,7 +86,7 @@ const playCmd = registry.register({
     }
 
     // 方块能力：从酒馆牌堆抓牌
-            if (card.suit === 'diamonds') {
+    if (card.suit === "diamonds") {
       const tavernDeckCount = state.regions.tavernDeck.childIds.length;
       if (tavernDeckCount > 0) {
         const drawCardId = state.regions.tavernDeck.childIds.shift()!;
@@ -104,29 +107,31 @@ const playCmd = registry.register({
       enemyHpBefore,
       enemyHpAfter: game.value.currentEnemy!.hp,
       enemyDefeated,
-                suitAbility: card.suit
+      suitAbility: card.suit,
-            }
+    },
   };
-    }
+}
-});
 
 /**
  * 打出A配合另一张牌
  */
-const playWithACmd = registry.register({
+async function playWithACmd(
-    schema: 'play-with-a <player:string> <aceCardId:string> <otherCardId:string>',
+  game: RegicideGame,
-    run: async (game: RegicideGame, player: string, aceCardId: string, otherCardId: string) => {
+  player: string,
+  aceCardId: string,
+  otherCardId: string,
+) {
   const state = game.value;
   const aceCard = state.cards[aceCardId];
   const otherCard = state.cards[otherCardId];
 
   if (!aceCard || !otherCard) {
-            return {success: false, error: '卡牌不存在'};
+    return { success: false, error: "卡牌不存在" };
   }
 
   // 检查是否是A牌
-        if (aceCard.rank !== 'A') {
+  if (aceCard.rank !== "A") {
-            return {success: false, error: `第一张牌必须是A`};
+    return { success: false, error: `第一张牌必须是A` };
   }
 
   const playerKey = player as PlayerType;
@@ -134,36 +139,39 @@ const playWithACmd = registry.register({
 
   // 检查两张牌都在手牌中
   if (!playerHand.includes(aceCardId) || !playerHand.includes(otherCardId)) {
-            return {success: false, error: '卡牌不在手牌中'};
+    return { success: false, error: "卡牌不在手牌中" };
   }
 
   if (!state.currentEnemy) {
-            return {success: false, error: '没有活跃的敌人'};
+    return { success: false, error: "没有活跃的敌人" };
   }
 
   // 计算两张牌的总伤害
   let totalDamage = aceCard.value + otherCard.value;
 
   // 如果另一张牌是梅花，双倍伤害
-        if (otherCard.suit === 'clubs') {
+  if (otherCard.suit === "clubs") {
     totalDamage *= 2;
   }
 
   let attackReduction = 0;
-        if (aceCard.suit === 'spades') {
+  if (aceCard.suit === "spades") {
     attackReduction += aceCard.value;
   }
-        if (otherCard.suit === 'spades') {
+  if (otherCard.suit === "spades") {
     attackReduction += otherCard.value;
   }
 
-        await game.produce(state => {
+  await game.produceAsync((state) => {
     // 对敌人造成伤害
     state.currentEnemy!.hp -= totalDamage;
 
     // 记录黑桃的攻击力降低
     if (attackReduction > 0) {
-                state.currentEnemy!.value = Math.max(0, state.currentEnemy!.value - attackReduction);
+      state.currentEnemy!.value = Math.max(
+        0,
+        state.currentEnemy!.value - attackReduction,
+      );
     }
 
     // 从手牌移除两张牌
@@ -174,8 +182,8 @@ const playWithACmd = registry.register({
     if (otherIndex !== -1) hand.splice(otherIndex, 1);
 
     // 将卡牌移到弃牌堆
-            state.cards[aceCardId].regionId = 'discardPile';
+    state.cards[aceCardId].regionId = "discardPile";
-            state.cards[otherCardId].regionId = 'discardPile';
+    state.cards[otherCardId].regionId = "discardPile";
   });
 
   const enemyDefeated = isEnemyDefeated(state.currentEnemy);
@@ -186,33 +194,31 @@ const playWithACmd = registry.register({
       damage: totalDamage,
       attackReduction,
       enemyHp: state.currentEnemy!.hp,
-                enemyDefeated
+      enemyDefeated,
-            }
+    },
   };
-    }
+}
-});
 
 /**
  * 让过（不出牌）
  */
-const passCmd = registry.register({
+async function passCmd(game: RegicideGame, player: string) {
-    schema: 'pass <player:string>',
-    run: async (game: RegicideGame, player: string) => {
   // 即使让过，也会受到敌人反击（在回合结束时处理）
-        return {success: true, result: {message: `${player} 让过`}};
+  return { success: true, result: { message: `${player} 让过` } };
-    }
+}
-});
 
 /**
  * 敌人反击 - 玩家必须弃掉点数和 >= 敌人攻击力的牌
  */
-const enemyCounterattackCmd = registry.register({
+async function enemyCounterattackCmd(
-    schema: 'counterattack <player:string> <discardCards:string[]>',
+  game: RegicideGame,
-    run: async (game: RegicideGame, player: string, discardCards: string[]) => {
+  player: string,
+  discardCards: string[],
+) {
   const state = game.value;
 
   if (!state.currentEnemy) {
-            return {success: false, error: '没有活跃的敌人'};
+    return { success: false, error: "没有活跃的敌人" };
   }
 
   const playerKey = player as PlayerType;
@@ -221,7 +227,7 @@ const enemyCounterattackCmd = registry.register({
   // 检查要弃的牌都在手牌中
   for (const cardId of discardCards) {
     if (!playerHand.includes(cardId)) {
-                return {success: false, error: `卡牌 ${cardId} 不在手牌中`};
+      return { success: false, error: `卡牌 ${cardId} 不在手牌中` };
     }
   }
 
@@ -240,19 +246,19 @@ const enemyCounterattackCmd = registry.register({
   if (totalValue < enemyAttack) {
     return {
       success: false,
-                error: `弃牌点数和 (${totalValue}) 小于敌人攻击力 (${enemyAttack})，游戏失败`
+      error: `弃牌点数和 (${totalValue}) 小于敌人攻击力 (${enemyAttack})，游戏失败`,
     };
   }
 
   // 执行弃牌
-        await game.produce(state => {
+  await game.produceAsync((state) => {
     const hand = state.playerHands[playerKey];
     for (const cardId of discardCards) {
       const index = hand.indexOf(cardId);
       if (index !== -1) {
         hand.splice(index, 1);
       }
-                state.cards[cardId].regionId = 'discardPile';
+      state.cards[cardId].regionId = "discardPile";
     }
   });
 
@@ -261,30 +267,27 @@ const enemyCounterattackCmd = registry.register({
     result: {
       discardedCards: discardCards,
       totalValue,
-                enemyAttack
+      enemyAttack,
-            }
+    },
   };
-    }
+}
-});
 
 /**
  * 检查敌人是否被击败，如果击败则翻开下一个敌人
  */
-const checkEnemyDefeatedCmd = registry.register({
+async function checkEnemyDefeatedCmd(game: RegicideGame) {
-    schema: 'check-enemy',
-    run: async (game: RegicideGame) => {
   const state = game.value;
 
   if (!state.currentEnemy) {
-            return {success: false, error: '没有活跃的敌人'};
+    return { success: false as const, error: "没有活跃的敌人" };
   }
 
   const defeated = state.currentEnemy.hp <= 0;
 
   if (defeated) {
-            const defeatedEnemy = {...state.currentEnemy};
+    const defeatedEnemy = { ...state.currentEnemy };
 
-            await game.produce(state => {
+    await game.produceAsync((state) => {
       // 将当前敌人移到弃牌堆
       state.regions.discardPile.childIds.push(state.currentEnemy!.id);
 
@@ -300,20 +303,20 @@ const checkEnemyDefeatedCmd = registry.register({
 
     // 检查是否胜利（没有更多敌人）
     if (!game.value.currentEnemy) {
-                await game.produce(state => {
+      await game.produceAsync((state) => {
-                    state.phase = 'victory';
+        state.phase = "victory";
         state.winner = true;
       });
     }
 
     return {
-                success: true,
+      success: true as const,
       result: {
         defeated: true,
         defeatedEnemy,
         nextEnemy: game.value.currentEnemy,
-                    enemiesRemaining: game.value.enemyDeck.length
+        enemiesRemaining: game.value.enemyDeck.length,
-                }
+      },
     };
   }
 
@@ -321,27 +324,24 @@ const checkEnemyDefeatedCmd = registry.register({
     success: true,
     result: {
       defeated: false,
-                currentEnemy: {...state.currentEnemy},
+      currentEnemy: { ...state.currentEnemy },
-                enemiesRemaining: state.enemyDeck.length
+      enemiesRemaining: state.enemyDeck.length,
-            }
+    },
   };
-    }
+}
-});
 
 /**
  * 检查玩家是否有可出的牌
  */
-const checkCanPlayCmd = registry.register({
+async function checkCanPlayCmd(game: RegicideGame, player: string) {
-    schema: 'check-can-play <player:string>',
-    run: async (game: RegicideGame, player: string) => {
   const state = game.value;
   const playerKey = player as PlayerType;
   const playerHand = state.playerHands[playerKey];
 
   const canPlay = playerHand.length > 0;
-        const canPlayWithA = playerHand.some(cardId => {
+  const canPlayWithA = playerHand.some((cardId) => {
     const card = state.cards[cardId];
-            return card && card.rank === 'A' && playerHand.length > 1;
+    return card && card.rank === "A" && playerHand.length > 1;
   });
 
   return {
@@ -349,27 +349,26 @@ const checkCanPlayCmd = registry.register({
     result: {
       canPlay,
       canPlayWithA,
-                handSize: playerHand.length
+      handSize: playerHand.length,
-            }
+    },
   };
-    }
+}
-});
 
 /**
  * 检查酒馆牌堆是否为空
  */
-const checkTavernDeckCmd = registry.register({
+async function checkTavernDeckCmd(game: RegicideGame) {
-    schema: 'check-tavern-deck',
-    run: async (game: RegicideGame) => {
   const state = game.value;
   const isEmpty = state.regions.tavernDeck.childIds.length === 0;
 
   // 如果酒馆牌堆为空且所有玩家手牌也为空，则游戏失败
   if (isEmpty) {
-            const allHandsEmpty = Object.values(state.playerHands).every(hand => hand.length === 0);
+    const allHandsEmpty = Object.values(state.playerHands).every(
+      (hand) => hand.length === 0,
+    );
     if (allHandsEmpty) {
-                await game.produce(state => {
+      await game.produceAsync((state) => {
-                    state.phase = 'defeat';
+        state.phase = "defeat";
         state.winner = false;
       });
     }
@@ -379,35 +378,32 @@ const checkTavernDeckCmd = registry.register({
     success: true,
     result: {
       isEmpty,
-                cardsRemaining: state.regions.tavernDeck.childIds.length
+      cardsRemaining: state.regions.tavernDeck.childIds.length,
-            }
+    },
   };
-    }
+}
-});
 
 /**
  * 下一个玩家回合
  */
-const nextTurnCmd = registry.register({
+async function nextTurnCmd(game: RegicideGame) {
-    schema: 'next-turn',
-    run: async (game: RegicideGame) => {
   const state = game.value;
-        await game.produce(state => {
+  await game.produce((state) => {
-            state.currentPlayerIndex = (state.currentPlayerIndex + 1) % state.playerCount;
+    state.currentPlayerIndex =
+      (state.currentPlayerIndex + 1) % state.playerCount;
   });
 
-        const players: PlayerType[] = ['player1', 'player2', 'player3', 'player4'];
+  const players: PlayerType[] = ["player1", "player2", "player3", "player4"];
   const currentPlayer = players[game.value.currentPlayerIndex];
 
   return {
     success: true,
     result: {
       currentPlayer,
-                currentPlayerIndex: game.value.currentPlayerIndex
+      currentPlayerIndex: game.value.currentPlayerIndex,
-            }
+    },
   };
-    }
+}
-});
 
 export {
   playCmd as play,

src/samples/regicide/game.ts

@@ -1,8 +1,15 @@
-import {IGameContext} from "@/core/game";
+import { IGameContext } from "@/core/game";
-import {RegicideState} from "@/samples/regicide/state";
+import { RegicideState } from "@/samples/regicide/state";
-import {buildEnemyDeck, buildTavernDeck, createAllCards, getPlayerHandRegionId} from "@/samples/regicide/utils";
+import {
-import {INITIAL_HAND_SIZE} from "@/samples/regicide/constants";
+  buildEnemyDeck,
-import {Enemy, PlayerType, RegicideCard} from "@/samples/regicide/types";
+  buildTavernDeck,
+  createAllCards,
+  getPlayerHandRegionId,
+} from "@/samples/regicide/utils";
+import { INITIAL_HAND_SIZE } from "@/samples/regicide/constants";
+import { Enemy, PlayerType, RegicideCard } from "@/samples/regicide/types";
+import { checkEnemy, nextTurn, pass, playWithA } from "./commands";
+import { enemyCounterattackCmd, playCmd } from ".";
 
 export type RegicideGame = IGameContext<RegicideState>;
 
@@ -12,9 +19,13 @@ export type RegicideGame = IGameContext<RegicideState>;
  * @param playerCount 玩家数量（1-4）
  * @param seed 随机种子（可选）
  */
-export async function setupGame(game: RegicideGame, playerCount: number, seed?: number) {
+export async function setupGame(
+  game: RegicideGame,
+  playerCount: number,
+  seed?: number,
+) {
   if (playerCount < 1 || playerCount > 4) {
-        throw new Error('玩家数量必须为 1-4 人');
+    throw new Error("玩家数量必须为 1-4 人");
   }
 
   if (seed) {
@@ -31,7 +42,7 @@ export async function setupGame(game: RegicideGame, playerCount: number, seed?:
   const tavernDeck = buildTavernDeck(game._rng);
 
   // 初始化游戏状态
-    await game.produceAsync(state => {
+  await game.produceAsync((state) => {
     state.cards = allCards;
     state.playerCount = playerCount;
     state.currentPlayerIndex = 0;
@@ -39,15 +50,15 @@ export async function setupGame(game: RegicideGame, playerCount: number, seed?:
 
     // 设置酒馆牌堆区域
     for (const card of tavernDeck) {
-            card.regionId = 'tavernDeck';
+      card.regionId = "tavernDeck";
       state.regions.tavernDeck.childIds.push(card.id);
     }
 
     // 设置敌人牌堆区域（只存储ID，敌人是独立对象）
-        state.regions.enemyDeck.childIds = enemyDeck.map(e => e.id);
+    state.regions.enemyDeck.childIds = enemyDeck.map((e) => e.id);
 
     // 给每个玩家发牌
-        const players: PlayerType[] = ['player1', 'player2', 'player3', 'player4'];
+    const players: PlayerType[] = ["player1", "player2", "player3", "player4"];
     for (let i = 0; i < playerCount; i++) {
       const player = players[i];
       const regionId = getPlayerHandRegionId(player);
@@ -78,13 +89,13 @@ export async function start(game: RegicideGame) {
 
   // 检查游戏是否已设置
   if (!state.currentEnemy) {
-        throw new Error('请先调用 setupGame 初始化游戏');
+    throw new Error("请先调用 setupGame 初始化游戏");
   }
 
-    const players: PlayerType[] = ['player1', 'player2', 'player3', 'player4'];
+  const players: PlayerType[] = ["player1", "player2", "player3", "player4"];
 
   // 主游戏循环
-    while (state.phase === 'playing') {
+  while (state.phase === "playing") {
     const currentPlayerIndex = state.currentPlayerIndex;
     const currentPlayer = players[currentPlayerIndex];
 
@@ -92,8 +103,9 @@ export async function start(game: RegicideGame) {
     const currentHand = state.playerHands[currentPlayer];
     if (currentHand.length === 0) {
       // 玩家没有手牌，跳过回合
-            await game.produceAsync(state => {
+      await game.produceAsync((state) => {
-                state.currentPlayerIndex = (state.currentPlayerIndex + 1) % state.playerCount;
+        state.currentPlayerIndex =
+          (state.currentPlayerIndex + 1) % state.playerCount;
       });
       continue;
     }
@@ -113,31 +125,37 @@ export async function start(game: RegicideGame) {
 /**
  * 处理完整的玩家回合
  */
-export async function playTurn(game: RegicideGame, player: PlayerType, action: 'play' | 'pass', cardId?: string, secondCardId?: string) {
+export async function playTurn(
+  game: RegicideGame,
+  player: PlayerType,
+  action: "play" | "pass",
+  cardId?: string,
+  secondCardId?: string,
+) {
   const state = game.value;
 
-    if (state.phase !== 'playing') {
+  if (state.phase !== "playing") {
-        return {success: false, error: '游戏已结束'};
+    return { success: false, error: "游戏已结束" };
   }
 
   if (!state.currentEnemy) {
-        return {success: false, error: '没有活跃的敌人'};
+    return { success: false, error: "没有活跃的敌人" };
   }
 
   let playResult: any;
 
   // 执行玩家动作
-    if (action === 'play' && cardId) {
+  if (action === "play" && cardId) {
     // 检查是否是A配合另一张牌
     const card = state.cards[cardId];
-        if (card.rank === 'A' && secondCardId) {
+    if (card.rank === "A" && secondCardId) {
-            playResult = await game.run(`play-with-a ${player} ${cardId} ${secondCardId}`);
+      playResult = await playWithA(game, player, cardId, secondCardId);
     } else {
-            playResult = await game.run(`play ${player} ${cardId}`);
+      playResult = await playCmd(game, player, cardId);
     }
   } else {
     // 让过
-        playResult = await game.run(`pass ${player}`);
+    playResult = await pass(game, player);
   }
 
   if (!playResult.success) {
@@ -145,7 +163,7 @@ export async function playTurn(game: RegicideGame, player: PlayerType, action: '
   }
 
   // 检查敌人是否被击败
-    const checkResult = await game.run<{defeated: boolean; currentEnemy?: any; nextEnemy?: any; defeatedEnemy?: any; enemiesRemaining?: number}>('check-enemy');
+  const checkResult = await checkEnemy(game);
   if (!checkResult.success) {
     return checkResult;
   }
@@ -160,15 +178,19 @@ export async function playTurn(game: RegicideGame, player: PlayerType, action: '
         enemyDefeated: false,
         needsDiscard: true,
         enemyAttack: state.currentEnemy.value,
-                playerHand: state.playerHands[player]
+        playerHand: state.playerHands[player],
-            }
+      },
     };
   }
 
   // 敌人被击败，检查是否还有更多敌人
-    if (state.enemyDeck.length === 0 && state.currentEnemy && state.currentEnemy.hp <= 0) {
+  if (
-        await game.produceAsync(state => {
+    state.enemyDeck.length === 0 &&
-            state.phase = 'victory';
+    state.currentEnemy &&
+    state.currentEnemy.hp <= 0
+  ) {
+    await game.produceAsync((state) => {
+      state.phase = "victory";
       state.winner = true;
     });
     return {
@@ -176,41 +198,44 @@ export async function playTurn(game: RegicideGame, player: PlayerType, action: '
       result: {
         playResult: playResult.result,
         enemyDefeated: true,
-                gameWon: true
+        gameWon: true,
-            }
+      },
     };
   }
 
   // 切换到下一个玩家
-    await game.run('next-turn');
+  await nextTurn(game);
 
   return {
     success: true,
     result: {
       playResult: playResult.result,
       enemyDefeated: true,
-            nextEnemy: state.currentEnemy
+      nextEnemy: state.currentEnemy,
-        }
+    },
   };
 }
 
 /**
  * 处理反击阶段的弃牌
  */
-export async function handleCounterattack(game: RegicideGame, player: PlayerType, discardCardIds: string[]) {
+export async function handleCounterattack(
-    const result = await game.run(`counterattack ${player} ${JSON.stringify(discardCardIds)}`);
+  game: RegicideGame,
-
+  player: PlayerType,
+  discardCardIds: string[],
+) {
+  const result = await enemyCounterattackCmd(game, player, discardCardIds);
   if (!result.success) {
     // 弃牌失败（点数和不足），游戏失败
-        await game.produceAsync(state => {
+    await game.produceAsync((state) => {
-            state.phase = 'defeat';
+      state.phase = "defeat";
       state.winner = false;
     });
     return result;
   }
 
   // 弃牌成功，切换到下一个玩家
-    await game.run('next-turn');
+  await nextTurn(game);
 
   return result;
 }
@@ -223,17 +248,26 @@ export function getGameStatus(game: RegicideGame) {
 
   return {
     phase: state.phase,
-        currentPlayer: ['player1', 'player2', 'player3', 'player4'][state.currentPlayerIndex],
+    currentPlayer: ["player1", "player2", "player3", "player4"][
-        currentEnemy: state.currentEnemy ? {
+      state.currentPlayerIndex
+    ],
+    currentEnemy: state.currentEnemy
+      ? {
           ...state.currentEnemy,
-            hpPercent: Math.round((state.currentEnemy.hp / state.currentEnemy.maxHp) * 100)
+          hpPercent: Math.round(
-        } : null,
+            (state.currentEnemy.hp / state.currentEnemy.maxHp) * 100,
+          ),
+        }
+      : null,
     enemiesRemaining: state.enemyDeck.length,
     tavernDeckCount: state.regions.tavernDeck.childIds.length,
     discardPileCount: state.regions.discardPile.childIds.length,
     playerHands: Object.fromEntries(
-            Object.entries(state.playerHands).map(([player, hand]) => [player, hand.length])
+      Object.entries(state.playerHands).map(([player, hand]) => [
+        player,
+        hand.length,
+      ]),
     ),
-        winner: state.winner
+    winner: state.winner,
   };
 }

src/samples/regicide/index.ts

@@ -7,8 +7,8 @@ export type {
   RegicideCardMeta,
   RegicideCard,
   Enemy,
-    GamePhase
+  GamePhase,
-} from './types';
+} from "./types";
 
 // Constants
 export {
@@ -18,21 +18,17 @@ export {
   ALL_SUITS,
   ALL_RANKS,
   FACE_CARDS,
-    NUMBER_CARDS
+  NUMBER_CARDS,
-} from './constants';
+} from "./constants";
 
 // State
-export {
+export { createInitialState, type RegicideState } from "./state";
-    createInitialState,
-    type RegicideState
-} from './state';
 
 // Prompts
-export {prompts} from './prompts';
+export { prompts } from "./prompts";
 
 // Commands
 export {
-    registry,
   play as playCmd,
   playWithA as playWithACmd,
   pass as passCmd,
@@ -41,7 +37,7 @@ export {
   checkCanPlay as checkCanPlayCmd,
   checkTavernDeck as checkTavernDeckCmd,
   nextTurn as nextTurnCmd,
-} from './commands';
+} from "./commands";
 
 // Game
 export {
@@ -50,8 +46,8 @@ export {
   playTurn,
   handleCounterattack,
   getGameStatus,
-    type RegicideGame
+  type RegicideGame,
-} from './game';
+} from "./game";
 
 // Utils
 export {
@@ -63,5 +59,5 @@ export {
   buildTavernDeck,
   drawFromDeck,
   isEnemyDefeated,
-    getPlayerHandRegionId
+  getPlayerHandRegionId,
-} from './utils';
+} from "./utils";

src/samples/slay-the-spire-like/AGENTS.md

@@ -0,0 +1,68 @@
+# AGENTS.md - slay-the-spire-like
+
+Roguelike deckbuilder combining Slay the Spire combat with Backpack Hero grid inventory.
+
+## Architecture
+
+Three-layer design: **system** (content-agnostic) → **data** (CSV content) → **dialogues** (Yarn Spinner).
+
+### System Layer (`system/`)
+
+| Module | Files | Responsibility |
+|---|---|---|
+| `combat/` | types.ts, effects.ts, triggers.ts, prompts.ts | Combat state, effects pipeline, middleware triggers |
+| `deck/` | types.ts, factory.ts, index.ts | Deck state management |
+| `grid-inventory/` | types.ts, transform.ts, index.ts | Grid backpack, shape collision, adjacency |
+| `map/` | types.ts, generator.ts, index.ts | Procedural node generation (point crawl) |
+| `progress/` | types.ts, encounter.ts, index.ts | Adventure progress, node traversal |
+| `utils/` | parse-shape.ts, shape-collision.ts | Shape parsing and collision detection |
+| `types.ts` | — | `EffectData`, `EffectLifecycle`, `EnemyData`, `CardData`, `IntentData`, `EncounterData`, `ItemData` |
+
+### Data Layer (`data/desert/`)
+
+All content via CSV (loaded by `inline-schema`):
+
+| File | Content |
+|---|---|
+| `card.csv` | Card definitions |
+| `effect.csv` | Effect definitions |
+| `enemy.csv` | Enemies + intents |
+| `intent.csv` | Intent definitions |
+| `item.csv` | Equipment items |
+| `encounter.csv` | Encounter nodes |
+
+### Triggers (`data/desert/triggers/`)
+
+Middleware hooks extending the base trigger system:
+
+| File | Hooks |
+|---|---|
+| `effect.ts` | Orchestrator — calls all sub-modules |
+| `instant.ts` | `onEffectApplied` — attack, draw, gainEnergy, removeWound, summon, etc. |
+| `damage.ts` | `onDamage` — block, spike, expose, aim, roll, charge, molt, tailSting, energyDrain |
+| `turn-start.ts` | `onTurnStart` — discard, defendNext, energyNext, drawNext |
+| `card-events.ts` | `onEnemyIntent`, `onCardPlayed`, `onCardDiscarded`, `onDamage` — storm, crossbow, burnForEnergy, sandwormKing, vulture |
+
+### Dialogue Layer (`data/desert/dialogues/`)
+
+`story.yarn` — branching encounter dialogues (inside `dialogues.yarnproject`). Commands resolve via `tryAnswerPrompt`.
+
+## Key Mechanics
+
+- **Energy**: 3/turn, spent on weapon/armor/tool cards
+- **Uses**: Consumable cards use `uses` cost type instead of energy; tracked as `depletion` on `GameItemMeta`
+- **Grid adjacency**: Items buff adjacent items (e.g. burnForEnergy consumes adjacent item on card play)
+- **Effect lifecycles**: `instant`, `temporary`, `lingering`, `permanent`, `posture`, `item`, `itemTemporary`, `itemUntilPlay`, `itemUntilDiscard`, `itemPermanent`
+- **Trigger pipeline**: `createMiddlewareChain` with `use(async (ctx, next) => ...)` pattern
+- **Cards from items**: `GameCard` instances are generated from `GameItem` inventory items via deck factory
+
+## Testing
+
+Tests live in `tests/samples/slay-the-spire-like/`:
+- `combat/effects.test.ts` — effect application, upkeep, posture damage
+- `combat/triggers.test.ts` — full desert trigger integration tests
+- `deck/factory.test.ts` — deck creation
+- `grid-inventory.test.ts` — placement, adjacency, collision
+- `map/generator.test.ts` — procedural generation
+- `utils/shape-utils.test.ts` — shape parsing
+- `data/index.test.ts` — data loading validation

src/samples/slay-the-spire-like/data/desert/card.csv

@@ -2,39 +2,42 @@
 # type: 'item' = inventory item card, 'status' = status effect card
 # costType: 'energy' = costs energy per turn, 'uses' = limited uses, 'none' = free
 # targetType: 'single' = target one enemy, 'none' = no target
-# onPlay: effects triggered when card is played
-# onDraw: effects triggered when card enters hand
-# onDiscard: effects triggered when card is discarded
 
-id,name,desc,type,costType,costCount,targetType,effects
+# type CardType = 'item' | 'status'
-string,string,string,'item'|'status','energy'|'uses'|'none',int,'single'|'none',['onPlay'|'onDraw'|'onDiscard';'self'|'target'|'all'|'random';@effect;number][]
+# type CardCostType = 'energy' | 'uses' | 'none'
-sword,剑,【攻击2】【攻击2】,item,energy,1,single,[onPlay;target;attack;2];[onPlay;target;attack;2]
+# type CardTargetType = 'player' | 'enemy' | 'enemies'
-greataxe,长斧,对全体【攻击5】,item,energy,2,none,[onPlay;all;attack;5]
+
-spear,长枪,【攻击2】【攻击2】【攻击2】,item,energy,1,single,[onPlay;target;attack;2];[onPlay;target;attack;2];[onPlay;target;attack;2]
+# inject effects = ~cardEffect(card)
-dagger,短刀,【攻击3】【攻击3】,item,energy,1,single,[onPlay;target;attack;3];[onPlay;target;attack;3]
+
-dart,飞镖,【攻击1】抓一张牌,item,energy,0,single,[onPlay;target;attack;1];[onPlay;self;draw;1]
+id,name,desc,type,costType,costCount,targetType
-crossbow,十字弩,【攻击6】对同一目标打出其他十字弩,item,energy,2,single,[onPlay;target;attack;6];[onPlay;self;crossbow;0]
+string,string,string,CardType,CardCostType,int,CardTargetType
-shield,盾,【防御3】,item,energy,1,none,[onPlay;self;defend;3]
+sword,剑,【攻击2】【攻击2】,item,energy,1,enemy
-hat,斗笠,【防御8】,item,energy,2,none,[onPlay;self;defend;8]
+greataxe,长斧,对全体【攻击5】,item,energy,2,enemies
-cape,披风,【防御2】下回合【防御2】,item,energy,1,none,[onPlay;self;defend;2];[onPlay;self;defendNext;2]
+spear,长枪,【攻击2】【攻击2】【攻击2】,item,energy,1,enemy
-bracer,护腕,【防御1】抓1张牌,item,energy,0,none,[onPlay;self;defend;1];[onPlay;self;draw;1]
+dagger,短刀,【攻击3】【攻击3】,item,energy,1,enemy
-greatshield,大盾,【防御5】,item,energy,1,none,[onPlay;self;defend;5]
+dart,飞镖,【攻击1】抓一张牌,item,energy,0,enemy
-chainmail,锁子甲,本回合受到伤害-3,item,energy,1,none,[onPlay;self;damageReduce;3]
+crossbow,十字弩,【攻击6】对同一目标打出其他十字弩,item,energy,2,enemy
-bandage,绷带,从牌堆或弃牌堆随机移除1张伤口,item,uses,3,none,[onPlay;self;removeWound;1]
+shield,盾,【防御3】,item,energy,1,player
-poisonPotion,淬毒药剂,周围物品的【攻击】+2,item,uses,3,none,[onPlay;self;attackBuff;2]
+hat,斗笠,【防御8】,item,energy,2,player
-fortifyPotion,强固药剂,周围物品的【防御】+2,item,uses,3,none,[onPlay;self;defendBuff;2]
+cape,披风,【防御2】下回合【防御2】,item,energy,1,player
-vitalityPotion,活力药剂,获得1点能量,item,uses,3,none,[onPlay;self;gainEnergy;1]
+bracer,护腕,【防御1】抓1张牌,item,energy,0,player
-focusPotion,集中药剂,抓2张牌,item,uses,3,none,[onPlay;self;draw;2]
+greatshield,大盾,【防御5】,item,energy,1,player
-healingPotion,治疗药剂,从牌堆或弃牌堆移除3张伤口,item,uses,3,none,[onPlay;self;removeWound;3]
+chainmail,锁子甲,本回合受到伤害-3,item,energy,1,player
-waterBag,水袋,下回合开始时获得1能量抓2张牌,item,energy,1,none,[onPlay;self;energyNext;1];[onPlay;self;drawNext;2]
+bandage,绷带,从牌堆或弃牌堆随机移除1张伤口,item,uses,3,player
-rope,绳索,周围物品的牌【防御】+2直到打出,item,energy,1,none,[onPlay;self;defendBuffUntilPlay;2]
+poisonPotion,淬毒药剂,周围物品的【攻击】+2,item,uses,3,player
-belt,腰带,从牌堆周围物品的牌当中选择一张加入手牌,item,energy,0,none,[onPlay;self;drawChoice;1]
+fortifyPotion,强固药剂,周围物品的【防御】+2,item,uses,3,player
-torch,火把,下次打出周围物品的牌时将其消耗并获得1能量,item,energy,1,none,[onPlay;self;burnForEnergy;1]
+vitalityPotion,活力药剂,获得1点能量,item,uses,3,player
-whetstone,磨刀石,周围物品的牌【攻击】+3直到打出,item,energy,1,none,[onPlay;self;attackBuffUntilPlay;3]
+focusPotion,集中药剂,抓2张牌,item,uses,3,player
-blacksmithHammer,铁匠锤,从牌堆/弃牌堆选择一张牌随机变为一张周围物品的牌,item,energy,1,none,[onPlay;self;transformRandom;1]
+healingPotion,治疗药剂,从牌堆或弃牌堆移除3张伤口,item,uses,3,player
-wound,伤口,无效果占用手牌和牌堆,status,none,0,none,
+waterBag,水袋,下回合开始时获得1能量抓2张牌,item,energy,1,player
-venom,蛇毒,弃掉时受到3点伤害,status,none,0,none,[onDiscard;self;attack;3]
+rope,绳索,周围物品的牌【防御】+2直到打出,item,energy,1,player
-curse,诅咒,受攻击时物品攻击-1直到弃掉一张该物品的牌,status,none,0,none,[onDraw;self;curse;1]
+belt,腰带,从牌堆周围物品的牌当中选择一张加入手牌,item,energy,0,player
-static,静电,在手里时受电击伤害+1,status,none,0,none,[onDraw;self;static;1]
+torch,火把,下次打出周围物品的牌时将其消耗并获得1能量,item,energy,1,player
-fatigue,疲劳,占用手牌,status,none,0,none,
+whetstone,磨刀石,周围物品的牌【攻击】+3直到打出,item,energy,1,player
-vultureEye,秃鹫之眼,抓到时获得3层暴露,status,none,0,none,[onDraw;self;expose;3]
+blacksmithHammer,铁匠锤,从牌堆/弃牌堆选择一张牌随机变为一张周围物品的牌,item,energy,1,player
+wound,伤口,无效果占用手牌和牌堆,status,none,0,player
+venom,蛇毒,弃掉时受到3点伤害,status,none,0,player
+curse,诅咒,受攻击时物品攻击-1直到弃掉一张该物品的牌,status,none,0,player
+static,静电,在手里时受电击伤害+1,status,none,0,player
+fatigue,疲劳,占用手牌,status,none,0,player
+vultureEye,秃鹫之眼,抓到时获得3层暴露,status,none,0,player

src/samples/slay-the-spire-like/data/desert/card.csv.d.ts

@@ -1,14 +1,18 @@
-import type { Effect } from './effect.csv';
+import type { CardEffect } from './cardEffect.csv';
+
+export type CardType = 'item' | 'status';
+export type CardCostType = 'energy' | 'uses' | 'none';
+export type CardTargetType = 'player' | 'enemy' | 'enemies';
 
 type CardTable = readonly {
     readonly id: string;
     readonly name: string;
     readonly desc: string;
-    readonly type: "item" | "status";
+    readonly type: CardType;
-    readonly costType: "energy" | "uses" | "none";
+    readonly costType: CardCostType;
     readonly costCount: number;
-    readonly targetType: "single" | "none";
+    readonly targetType: CardTargetType;
-    readonly effects: readonly ["onPlay" | "onDraw" | "onDiscard", "self" | "target" | "all" | "random", Effect, number];
+    readonly effects: CardEffect[];
 }[];
 
 export type Card = CardTable[number];

src/samples/slay-the-spire-like/data/desert/cardEffect.csv

@@ -0,0 +1,36 @@
+# type CardEffectTrigger = 'onPlay' | 'onDraw' | 'onDiscard'
+# type CardEffectTarget = 'source' | 'eachTarget' | 'eachEnemy' | 'randomEnemy' | 'player'
+# type CardEffectList = [effect: @effect; stacks: number][]
+
+id,card,trigger,target,effects
+string,@card,CardEffectTrigger,CardEffectTarget,CardEffectList
+sword,sword,onPlay,eachTarget,[attack;2];[attack;2]
+greataxe,greataxe,onPlay,eachTarget,[attack;5]
+spear,spear,onPlay,eachTarget,[attack;2];[attack;2];[attack;2]
+dagger,dagger,onPlay,eachTarget,[attack;3];[attack;3]
+dart,dart,onPlay,eachTarget,[attack;1]
+dart-draw,dart,onPlay,source,[draw;1]
+crossbow,crossbow,onPlay,eachTarget,[attack;6]
+crossbow-combo,crossbow,onPlay,source,[crossbow;0]
+shield,shield,onPlay,source,[defend;3]
+hat,hat,onPlay,source,[defend;8]
+cape,cape,onPlay,source,[defend;2];[defendNext;2]
+bracer,bracer,onPlay,source,[defend;1];[draw;1]
+greatshield,greatshield,onPlay,source,[defend;5]
+chainmail,chainmail,onPlay,source,[damageReduce;3]
+bandage,bandage,onPlay,source,[removeWound;1]
+poisonPotion,poisonPotion,onPlay,source,[attackBuff;2]
+fortifyPotion,fortifyPotion,onPlay,source,[defendBuff;2]
+vitalityPotion,vitalityPotion,onPlay,source,[gainEnergy;1]
+focusPotion,focusPotion,onPlay,source,[draw;2]
+healingPotion,healingPotion,onPlay,source,[removeWound;3]
+waterBag,waterBag,onPlay,source,[energyNext;1];[drawNext;2]
+rope,rope,onPlay,source,[defendBuffUntilPlay;2]
+belt,belt,onPlay,source,[drawChoice;1]
+torch,torch,onPlay,source,[burnForEnergy;1]
+whetstone,whetstone,onPlay,source,[attackBuffUntilPlay;3]
+blacksmithHammer,blacksmithHammer,onPlay,source,[transformRandom;1]
+venom,venom,onDiscard,source,[attack;3]
+curse,curse,onDraw,source,[curse;1]
+static,static,onDraw,source,[static;1]
+vultureEye,vultureEye,onDraw,source,[expose;3]

src/samples/slay-the-spire-like/data/desert/cardEffect.csv.d.ts

@@ -0,0 +1,19 @@
+import type { Card } from './card.csv';
+import type { Effect } from './effect.csv';
+
+export type CardEffectTrigger = 'onPlay' | 'onDraw' | 'onDiscard';
+export type CardEffectTarget = 'source' | 'eachTarget' | 'eachEnemy' | 'randomEnemy' | 'player';
+export type CardEffectList = [effect: Effect, stacks: number][];
+
+type CardEffectTable = readonly {
+    readonly id: string;
+    readonly card: Card;
+    readonly trigger: CardEffectTrigger;
+    readonly target: CardEffectTarget;
+    readonly effects: CardEffectList;
+}[];
+
+export type CardEffect = CardEffectTable[number];
+
+declare function getData(): CardEffectTable;
+export default getData;

src/samples/slay-the-spire-like/data/desert/dialogues/dialogues.yarnproject.d.ts

@@ -0,0 +1,3 @@
+import type { LoadResult } from 'yarn-spinner-loader';
+const result: LoadResult;
+export default result;

src/samples/slay-the-spire-like/data/desert/effect.csv

@@ -11,40 +11,42 @@
 # itemUntilDiscard: 施加buff到周围物品，物品被弃掉后失效
 # itemPermanent: 施加buff到周围物品，持续整场冒险
 
-id, name, description, lifecycle
+# type EffectLifecycle = 'instant' | 'temporary' | 'lingering' | 'permanent' | 'posture' | 'item' | 'itemTemporary' | 'itemUntilPlay' | 'itemUntilDiscard' | 'itemPermanent'
-string, string, string, 'instant'|'temporary'|'lingering'|'permanent'|'posture'|'item'|'itemTemporary'|'itemUntilPlay'|'itemUntilDiscard'|'itemPermanent'
+
-attack, 攻击, 对对手造成伤害, instant
+id, name, description, lifecycle, emoji
-defend, 防御, 抵消下次行动前受到的伤害, posture
+string, string, string, EffectLifecycle, string
-spike, 尖刺, 对攻击者造成X点伤害, permanent
+attack, 攻击, 对对手造成伤害, instant, ⚔️
-venom, 蛇毒, 同名状态牌/1费：打出时移除此牌。弃掉时受到3点伤害, instant
+defend, 防御, 抵消下次行动前受到的伤害, temporary, 🛡️
-curse, 诅咒, 受攻击时物品攻击-1，直到弃掉一张该物品的牌, lingering
+spike, 尖刺, 对攻击者造成X点伤害, permanent, 🌵
-aim, 瞄准, 造成双倍伤害，受伤时失去等量瞄准, posture
+venom, 蛇毒, 同名状态牌/1费：打出时移除此牌。弃掉时受到3点伤害, instant, 🧪
-roll, 滚动, 攻击时每消耗10点滚动造成等量伤害, posture
+curse, 诅咒, 受攻击时物品攻击-1，直到弃掉一张该物品的牌, lingering, 💀
-rollDamage, 滚动攻击, 消耗滚动层数造成的伤害, instant
+aim, 瞄准, 造成双倍伤害，受伤时失去等量瞄准, posture, 🎯
-vultureEye, 秃鹫之眼, 抓到时获得3层暴露（临时debuff，受到的伤害+1/每层）, instant
+roll, 滚动, 攻击时每消耗10点滚动造成等量伤害, posture, 🎲
-tailSting, 尾刺, 攻击时，伤害提升X, posture
+rollDamage, 滚动攻击, 消耗滚动层数造成的伤害, instant, 💥
-energyDrain, 能量吸取, 受伤时，玩家失去X点能量, lingering
+vultureEye, 秃鹫之眼, 抓到时获得3层暴露（临时debuff，受到的伤害+1/每层）, instant, 👁️
-molt, 脱皮, 若脱皮达到生命上限则怪物逃跑, posture
+tailSting, 尾刺, 攻击时，伤害提升X, posture, 🦂
-discard, 劫掠, 回合开始时随机弃掉一张手牌, lingering
+energyDrain, 能量吸取, 受伤时，玩家失去X点能量, lingering, 🔋
-storm, 风暴, 攻击时给玩家塞入1张静电, permanent
+molt, 脱皮, 若脱皮达到生命上限则怪物逃跑, posture, 🐚
-static, 静电, 在手里时受电击伤害+1, permanent
+discard, 劫掠, 回合开始时随机弃掉一张手牌, lingering, 🗑️
-charge, 冲锋, 受到或造成的伤害翻倍并消耗等量冲锋, lingering
+storm, 风暴, 攻击时给玩家塞入1张静电, permanent, ⚡
-summonMummy, 召唤木乃伊, 召唤1个木乃伊, instant
+static, 静电, 在手里时受电击伤害+1, permanent, ⚡
-summonSandwormLarva, 召唤幼沙虫, 召唤1个幼沙虫, instant
+charge, 冲锋, 受到或造成的伤害翻倍并消耗等量冲锋, lingering, 🐎
-reviveMummy, 复活木乃伊, 复活1个已死亡的木乃伊, instant
+summonMummy, 召唤木乃伊, 召唤1个木乃伊, instant, 🧟
-draw, 抓牌, 抓X张牌, instant
+summonSandwormLarva, 召唤幼沙虫, 召唤1个幼沙虫, instant, 🐛
-crossbow, 十字弩连击, 对同一目标打出其他十字弩, instant
+reviveMummy, 复活木乃伊, 复活1个已死亡的木乃伊, instant, 🌅
-defendNext, 下回合防御, 下回合开始时获得防御, temporary
+draw, 抓牌, 抓X张牌, instant, 🃏
-damageReduce, 减伤, 本回合受到的伤害减少X, temporary
+crossbow, 十字弩连击, 对同一目标打出其他十字弩, instant, 🏹
-removeWound, 移除伤口, 从牌堆或弃牌堆移除X张伤口, instant
+defendNext, 下回合防御, 下回合开始时获得防御, temporary, 🛡️
-attackBuff, 攻击增益, 周围物品的攻击+X, itemUntilPlay
+damageReduce, 减伤, 本回合受到的伤害减少X, temporary, 📉
-defendBuff, 防御增益, 周围物品的防御+X, itemUntilPlay
+removeWound, 移除伤口, 从牌堆或弃牌堆移除X张伤口, instant, 🩹
-gainEnergy, 获得能量, 获得X点能量, instant
+attackBuff, 攻击增益, 周围物品的攻击+X, itemUntilPlay, ⬆️
-energyNext, 下回合获能量, 下回合开始时获得X点能量, temporary
+defendBuff, 防御增益, 周围物品的防御+X, itemUntilPlay, ⬆️
-drawNext, 下回合抓牌, 下回合开始时抓X张牌, temporary
+gainEnergy, 获得能量, 获得X点能量, instant, ⚡
-defendBuffUntilPlay, 防御增益直到打出, 周围物品的牌防御+X直到打出, itemUntilPlay
+energyNext, 下回合获能量, 下回合开始时获得X点能量, temporary, ⚡
-drawChoice, 选择抓牌, 从牌堆周围物品的牌中选择一张加入手牌, instant
+drawNext, 下回合抓牌, 下回合开始时抓X张牌, temporary, 🃏
-burnForEnergy, 消耗获能量, 打出周围物品的牌时消耗并获得X能量, itemUntilPlay
+defendBuffUntilPlay, 防御增益直到打出, 周围物品的牌防御+X直到打出, itemUntilPlay, 🛡️
-attackBuffUntilPlay, 攻击增益直到打出, 周围物品的牌攻击+X直到打出, itemUntilPlay
+drawChoice, 选择抓牌, 从牌堆周围物品的牌中选择一张加入手牌, instant, 🔍
-transformRandom, 随机变牌, 选择一张牌随机变为周围物品的牌, instant
+burnForEnergy, 消耗获能量, 打出周围物品的牌时消耗并获得X能量, itemUntilPlay, 🔥
-expose, 暴露, 受到的伤害+1/每层, temporary
+attackBuffUntilPlay, 攻击增益直到打出, 周围物品的牌攻击+X直到打出, itemUntilPlay, ⚔️
+transformRandom, 随机变牌, 选择一张牌随机变为周围物品的牌, instant, 🌀
+expose, 暴露, 受到的伤害+1/每层, temporary, 👁️

src/samples/slay-the-spire-like/data/desert/effect.csv.d.ts

@@ -1,8 +1,11 @@
+export type EffectLifecycle = 'instant' | 'temporary' | 'lingering' | 'permanent' | 'posture' | 'item' | 'itemTemporary' | 'itemUntilPlay' | 'itemUntilDiscard' | 'itemPermanent';
+
 type EffectTable = readonly {
     readonly id: string;
     readonly name: string;
     readonly description: string;
-    readonly lifecycle: "instant" | "temporary" | "lingering" | "permanent" | "posture" | "item" | "itemTemporary" | "itemUntilPlay" | "itemUntilDiscard" | "itemPermanent";
+    readonly lifecycle: EffectLifecycle;
+    readonly emoji: string;
 }[];
 
 export type Effect = EffectTable[number];

src/samples/slay-the-spire-like/data/desert/encounter.csv

@@ -4,24 +4,27 @@
 # shop (2): merchant who sells different stuff
 # camp (2): consumable restock and heal
 # curio (8): random pickup of treasure or resources
-# enemies: array of [enemyId; hp; buffs[]]
+# enemies: array of [enemyId; initialHp; buffs[]]
+
+# type EncounterType = 'minion' | 'elite' | 'event' | 'shop' | 'camp' | 'curio'
+# type EnemyList = [data: @enemy; hp: int; effects: [effect: @effect; stacks: int][]][]
 
 id,type,name,description,enemies,dialogue
-string,'minion'|'elite'|'event'|'shop'|'camp'|'curio',string,string,[@enemy; int; [effect: @effect;stacks: int]][],string
+string,EncounterType,string,string,EnemyList,string
-cactus_pair,minion,仙人掌怪,概念：防+强化。【尖刺X】：对攻击者造成X点伤害。,[仙人掌怪;20;[]];[仙人掌怪;20;[]],
+cactus_pair,minion,仙人掌怪,概念：防+强化。【尖刺X】：对攻击者造成X点伤害。,[仙人掌怪;12;[]];[仙人掌怪;12;[]],
-snake_pair,minion,蛇,概念：攻+强化。给玩家塞入蛇毒牌（1费：打出时移除此牌。弃掉时受到3点伤害）。,[蛇;14;[]];[蛇;14;[]],
+snake_pair,minion,蛇,概念：攻+强化。给玩家塞入蛇毒牌（1费：打出时移除此牌。弃掉时受到3点伤害）。,[蛇;10;[]],
-mummy_cactus,minion,木乃伊,概念：攻+防。【诅咒】：受攻击时物品【攻击】-1，直到弃掉一张该物品的牌。,[木乃伊;18;[]];[仙人掌怪;20;[]],
+mummy_cactus,minion,木乃伊,概念：攻+防。【诅咒】：受攻击时物品【攻击】-1，直到弃掉一张该物品的牌。,[木乃伊;14;[]];[仙人掌怪;12;[]],
-gunslinger,minion,枪手,概念：单回高攻。【瞄准X】：造成双倍伤害。受伤时失去等量【瞄准】,[枪手;16;[]],
+gunslinger,minion,枪手,概念：单回高攻。【瞄准X】：造成双倍伤害。受伤时失去等量【瞄准】,[枪手;12;[]],
-tumbleweed_pair,minion,风卷草,概念：防+强化。【滚动X】：攻击时，每消耗10点【滚动】，造成等量伤害。,[风卷草;22;[]];[风卷草;22;[]],
+tumbleweed_pair,minion,风卷草,概念：防+强化。【滚动X】：攻击时，每消耗10点【滚动】，造成等量伤害。,[风卷草;16;[]],
-vulture_cactus,minion,秃鹫,概念：攻+防。若造成伤害，玩家获得秃鹫之眼（0费状态牌：打出时移除。抓到时获得3层暴露）。,[秃鹫;16;[]];[仙人掌怪;20;[]],
+vulture_cactus,minion,秃鹫,概念：攻+防。若造成伤害，玩家获得秃鹫之眼（0费状态牌：打出时移除。抓到时获得3层暴露）。,[秃鹫;12;[]];[仙人掌怪;12;[]],
-scorpion_snake,minion,沙蝎,概念：攻+强化。【尾刺X】：姿态buff，攻击时，伤害提升X。,[沙蝎;14;[]];[蛇;14;[]],
+scorpion_snake,minion,沙蝎,概念：攻+强化。【尾刺X】：姿态buff，攻击时，伤害提升X。,[沙蝎;10;[]];[蛇;10;[]],
-sandworm_larva,minion,幼沙虫,概念：防+强化。每回合第一次受伤时，玩家失去1点能量。,[幼沙虫;24;[]],
+sandworm_larva,minion,幼沙虫,概念：防+强化。每回合第一次受伤时，玩家失去1点能量。,[幼沙虫;18;[]],
-lizard_pair,minion,蜥蜴,概念：攻+防+逃跑。【脱皮】：若脱皮达到生命上限，则怪物逃跑，玩家不能获得战斗奖励。,[蜥蜴;20;[]];[蜥蜴;20;[]],
+lizard_pair,minion,蜥蜴,概念：攻+防+逃跑。【脱皮】：若脱皮达到生命上限，则怪物逃跑，玩家不能获得战斗奖励。,[蜥蜴;14;[]],
-bandit_gunslinger,minion,沙匪,概念：弱化玩家。【劫掠】：对玩家施加的延时debuff。回合开始时，随机弃掉一张手牌。,[沙匪;16;[]];[枪手;16;[]],
+bandit_gunslinger,minion,沙匪,概念：弱化玩家。【劫掠】：对玩家施加的延时debuff。回合开始时，随机弃掉一张手牌。,[沙匪;12;[]];[枪手;12;[]],
-storm_spirit,elite,风暴之灵,【风暴X】：攻击时，玩家获得1张静电。受伤时失去等量【风暴】。（静电：在手里时受【电击】伤害+1）,[风暴之灵;44;[]],
+storm_spirit,elite,风暴之灵,【风暴X】：攻击时，玩家获得1张静电。受伤时失去等量【风暴】。（静电：在手里时受【电击】伤害+1）,[风暴之灵;30;[]],
-mounted_gunslinger,elite,骑马枪手,【冲锋X】：受到或造成的伤害翻倍并消耗等量的冲锋。,[骑马枪手;50;[]];[枪手;20;[]],
+mounted_gunslinger,elite,骑马枪手,【冲锋X】：受到或造成的伤害翻倍并消耗等量的冲锋。,[骑马枪手;25;[]];[枪手;12;[]],
-sandworm_king,elite,沙虫王,召唤幼体沙虫；每当玩家弃掉一张牌，恢复1生命。,[沙虫王;55;[]],
+sandworm_king,elite,沙虫王,召唤幼体沙虫；每当玩家弃掉一张牌，恢复1生命。,[沙虫王;40;[]],
-desert_guard,elite,沙漠守卫,召唤木乃伊；会复活木乃伊2次。,[沙漠守卫;48;[]];[木乃伊;20;[]],
+desert_guard,elite,沙漠守卫,召唤木乃伊；会复活木乃伊2次。,[沙漠守卫;35;[]];[木乃伊;14;[]],
 desert_merchant,shop,沙漠商人,商店：可以恢复生命、出售装备、附魔物品。,,
 nomad_caravan,shop,游牧商队,商队：出售稀有物品、移除牌组中一张牌。,,
 oasis_campfire,camp,绿洲篝火,篝火：可以恢复生命、补充药水使用次数、获得下次战斗Buff。,,

src/samples/slay-the-spire-like/data/desert/encounter.csv.d.ts

@@ -1,12 +1,15 @@
 import type { Enemy } from './enemy.csv';
 import type { Effect } from './effect.csv';
 
+export type EncounterType = 'minion' | 'elite' | 'event' | 'shop' | 'camp' | 'curio';
+export type EnemyList = [data: Enemy, hp: int, effects: [effect: Effect, stacks: int][]][];
+
 type EncounterTable = readonly {
     readonly id: string;
-    readonly type: "minion" | "elite" | "event" | "shop" | "camp" | "curio";
+    readonly type: EncounterType;
     readonly name: string;
     readonly description: string;
-    readonly enemies: readonly [Enemy, number, readonly [readonly effect: Effect, readonly stacks: number]];
+    readonly enemies: EnemyList;
     readonly dialogue: string;
 }[];
 

src/samples/slay-the-spire-like/data/desert/enemy.csv

@@ -1,16 +1,16 @@
-id,name,description
+id,name,intents,description
-string,string,string
+string,string,@intent[],string
-仙人掌怪,仙人掌怪,防+强化。【尖刺X】：对攻击者造成X点伤害。
+仙人掌怪,仙人掌怪,[仙人掌怪-boost;仙人掌怪-defend;仙人掌怪-attack],防+强化。【尖刺X】：对攻击者造成X点伤害。
-蛇,蛇,攻+强化。给玩家塞入蛇毒牌（1费：打出时移除此牌。弃掉时受到3点伤害）。
+蛇,蛇,[蛇-poison;蛇-attack;蛇-boost],攻+强化。给玩家塞入蛇毒牌（1费：打出时移除此牌。弃掉时受到3点伤害）。
-木乃伊,木乃伊,攻+防。【诅咒】：受攻击时物品【攻击】-1，直到弃掉一张该物品的牌。
+木乃伊,木乃伊,[木乃伊-attack;木乃伊-defend;木乃伊-curse],攻+防。【诅咒】：受攻击时物品【攻击】-1，直到弃掉一张该物品的牌。
-枪手,枪手,单回高攻。【瞄准X】：造成双倍伤害。受伤时失去等量【瞄准】。
+枪手,枪手,[枪手-aim;枪手-attack;枪手-defend],单回高攻。【瞄准X】：造成双倍伤害。受伤时失去等量【瞄准】。
-风卷草,风卷草,防+强化。【滚动X】：攻击时，每消耗10点【滚动】，造成等量伤害。
+风卷草,风卷草,[风卷草-boost;风卷草-defend;风卷草-attack],防+强化。【滚动X】：攻击时，每消耗10点【滚动】，造成等量伤害。
-秃鹫,秃鹫,攻+防。若造成伤害，玩家获得秃鹫之眼（0费状态牌：打出时移除。抓到时获得3层暴露）。
+秃鹫,秃鹫,[秃鹫-attack;秃鹫-defend],攻+防。若造成伤害，玩家获得秃鹫之眼（0费状态牌：打出时移除。抓到时获得3层暴露）。
-沙蝎,沙蝎,攻+强化。【尾刺X】：姿态buff，攻击时，伤害提升X。
+沙蝎,沙蝎,[沙蝎-boost;沙蝎-attack],攻+强化。【尾刺X】：姿态buff，攻击时，伤害提升X。
-幼沙虫,幼沙虫,防+强化。每回合第一次受伤时，玩家失去1点能量。
+幼沙虫,幼沙虫,[幼沙虫-defend;幼沙虫-boost;幼沙虫-attack],防+强化。每回合第一次受伤时，玩家失去1点能量。
-蜥蜴,蜥蜴,攻+防+逃跑。【脱皮】：若脱皮达到生命上限，则怪物逃跑，玩家不能获得战斗奖励。
+蜥蜴,蜥蜴,[蜥蜴-attack;蜥蜴-defend;蜥蜴-molt],攻+防+逃跑。【脱皮】：若脱皮达到生命上限，则怪物逃跑，玩家不能获得战斗奖励。
-沙匪,沙匪,弱化玩家。【劫掠】：对玩家施加的延时debuff。回合开始时，随机弃掉一张手牌。
+沙匪,沙匪,[沙匪-attack;沙匪-heavyAttack;沙匪-debuff],弱化玩家。【劫掠】：对玩家施加的延时debuff。回合开始时，随机弃掉一张手牌。
-风暴之灵,风暴之灵,【风暴X】：攻击时，玩家获得1张静电。受伤时失去等量【风暴】。（静电：在手里时受【电击】伤害+1）
+风暴之灵,风暴之灵,[风暴之灵-storm;风暴之灵-attack;风暴之灵-defend],【风暴X】：攻击时，玩家获得1张静电。受伤时失去等量【风暴】。（静电：在手里时受【电击】伤害+1）
-骑马枪手,骑马枪手,【冲锋X】：受到或造成的伤害翻倍并消耗等量的冲锋。
+骑马枪手,骑马枪手,[骑马枪手-charge;骑马枪手-attack;骑马枪手-defend],【冲锋X】：受到或造成的伤害翻倍并消耗等量的冲锋。
-沙虫王,沙虫王,召唤幼体沙虫；每当玩家弃掉一张牌，恢复1生命。
+沙虫王,沙虫王,[沙虫王-summon;沙虫王-attack;沙虫王-defend],召唤幼体沙虫；每当玩家弃掉一张牌，恢复1生命。
-沙漠守卫,沙漠守卫,召唤木乃伊；会复活木乃伊2次。
+沙漠守卫,沙漠守卫,[沙漠守卫-summon;沙漠守卫-attack;沙漠守卫-defend;沙漠守卫-revive],召唤木乃伊；会复活木乃伊2次。

src/samples/slay-the-spire-like/data/desert/enemy.csv.d.ts

@@ -1,6 +1,9 @@
+import type { Intent } from './intent.csv';
+
 type EnemyTable = readonly {
     readonly id: string;
     readonly name: string;
+    readonly intents: Intent[];
     readonly description: string;
 }[];
 

src/samples/slay-the-spire-like/data/desert/index.ts

@@ -1,15 +1,25 @@
-import getCards from './card.csv';
+import getItems, { Item } from "./item.csv";
-import getEffects from './effect.csv';
-import getEncounters from './encounter.csv';
-import getEnemies from './enemy.csv';
-import getIntents from './intent.csv';
-import getItems from './item.csv';
-export { default as dialogues } from './dialogues/dialogues.yarnproject';
-export { addTriggers } from './triggers';
 
-export const cards = getCards();
+export type * from "./card.csv";
-export const effects = getEffects();
+export type * from "./cardEffect.csv";
-export const encounters = getEncounters();
+export type * from "./effect.csv";
-export const enemies = getEnemies();
+export type * from "./encounter.csv";
-export const intents = getIntents();
+export type * from "./enemy.csv";
-export const items = getItems();
+export type * from "./intent.csv";
+export type * from "./item.csv";
+
+export { default as getCards } from "./card.csv";
+export { default as getEffects } from "./effect.csv";
+export { default as getEncounters } from "./encounter.csv";
+export { default as getEnemies } from "./enemy.csv";
+export { default as getIntents } from "./intent.csv";
+export { default as getItems } from "./item.csv";
+export { default as dialogues } from "./dialogues/dialogues.yarnproject";
+export { addTriggers } from "./triggers";
+
+const itemSet = ["剑", "盾", "水袋", "绷带"] as string[];
+export function getStartingItems(): Item[] {
+  return itemSet.map(function (name): Item {
+    return getItems().find((item: Item) => item.name === name) as Item;
+  });
+}

src/samples/slay-the-spire-like/data/desert/intent.csv

@@ -1,52 +1,55 @@
-# enemyDesert: enemy templates and their intent state machines
+# intentId: unique intent state ID (e.g. '仙人掌怪-boost')
-# enemy: enemy template ID (unique identifier for this enemy type)
+# enemy: enemy template this intent belongs to
-# intentId: intent state ID (unique within each enemy)
 # initialIntent: true if this is the enemy's starting intent
 # nextIntents: possible next intent IDs after this intent resolves
 # brokenIntent: possible intent IDs when defend is broken
-# initBuffs: initial buffs for this enemy type (applied to all instances)
+# initBuffs: initial buffs for this intent (applied when intent becomes active)
 # effects: effects executed when this intent is active
 
-enemy,intentId,initialIntent,nextIntents,brokenIntent,initBuffs,effects
+# type IntentEffectTarget = 'source' | 'eachEnemy' | 'randomEnemy' | 'player'
-@enemy,string,boolean,string[],string[],[@effect;stacks: int][],['self'|'player'|'team';@effect;number][]
+# type IntentEffect = [IntentEffectTarget;@effect;number]
-仙人掌怪,boost,true,boost;defend;defend,,[spike;1],[self;spike;1];[self;defend;4]
+# type IntentEffectList = IntentEffect[]
-仙人掌怪,defend,false,attack,,[spike;1],[self;defend;8]
+
-仙人掌怪,attack,false,boost,,[spike;1],[player;attack;5]
+id,enemy,initialIntent,nextIntents,brokenIntent,effects
-蛇,poison,true,attack;attack,,,,[player;venom;1];[player;attack;4]
+string,@enemy,boolean,@intent[],@intent[],IntentEffectList
-蛇,attack,false,poison;boost,,,,[player;attack;6]
+仙人掌怪-boost,仙人掌怪,true,仙人掌怪-boost;仙人掌怪-defend,,[source;spike;1];[source;defend;4]
-蛇,boost,false,poison;attack,,,,[self;defend;3];[player;venom;1]
+仙人掌怪-defend,仙人掌怪,false,仙人掌怪-attack,,[source;defend;8]
-木乃伊,attack,true,defend;curse,,,,[player;attack;6]
+仙人掌怪-attack,仙人掌怪,false,仙人掌怪-boost,,[player;attack;5]
-木乃伊,defend,false,attack,,,,[self;defend;6]
+蛇-poison,蛇,true,蛇-attack;蛇-attack,,[player;venom;1];[player;attack;4]
-木乃伊,curse,false,defend;attack,attack,,[player;curse;1]
+蛇-attack,蛇,false,蛇-poison;蛇-boost,,[player;attack;6]
-枪手,aim,true,attack,,,,[self;aim;2]
+蛇-boost,蛇,false,蛇-poison;蛇-attack,,[source;defend;3];[player;venom;1]
-枪手,attack,false,aim;defend,aim,,[player;attack;8]
+木乃伊-attack,木乃伊,true,木乃伊-defend;木乃伊-curse,,[player;attack;6]
-枪手,defend,false,aim,aim,,[self;defend;5]
+木乃伊-defend,木乃伊,false,木乃伊-attack,,[source;defend;6]
-风卷草,boost,true,defend;defend;boost,,,,[self;roll;5];[self;defend;4]
+木乃伊-curse,木乃伊,false,木乃伊-defend;木乃伊-attack,木乃伊-attack,[player;curse;1]
-风卷草,defend,false,boost;attack,,,,[self;defend;8]
+枪手-aim,枪手,true,枪手-attack,,[source;aim;2]
-风卷草,attack,false,boost,,,,[player;rollDamage;0]
+枪手-attack,枪手,false,枪手-aim;枪手-defend,枪手-aim,[player;attack;8]
-秃鹫,attack,true,defend;defend,,,,[player;attack;6];[player;vultureEye;1]
+枪手-defend,枪手,false,枪手-aim,枪手-aim,[source;defend;5]
-秃鹫,defend,false,attack;attack,,,,[self;defend;5]
+风卷草-boost,风卷草,true,风卷草-defend;风卷草-defend;风卷草-boost,,[source;roll;5];[source;defend;4]
-沙蝎,boost,true,attack;attack,,[tailSting;1],[self;tailSting;2]
+风卷草-defend,风卷草,false,风卷草-boost;风卷草-attack,,[source;defend;8]
-沙蝎,attack,false,boost;attack,,[tailSting;1],[player;attack;6]
+风卷草-attack,风卷草,false,风卷草-boost,,[player;rollDamage;0]
-幼沙虫,defend,true,defend;boost,,[energyDrain;1],[self;defend;6]
+秃鹫-attack,秃鹫,true,秃鹫-defend;秃鹫-defend,,[player;attack;6];[player;vultureEye;1]
-幼沙虫,boost,false,attack;defend,,[energyDrain;1],[self;energyDrain;1];[self;defend;4]
+秃鹫-defend,秃鹫,false,秃鹫-attack;秃鹫-attack,,[source;defend;5]
-幼沙虫,attack,false,defend;defend,,[energyDrain;1],[player;attack;5]
+沙蝎-boost,沙蝎,true,沙蝎-attack;沙蝎-attack,,[source;tailSting;2]
-蜥蜴,attack,true,defend;molt,,,,[player;attack;5]
+沙蝎-attack,沙蝎,false,沙蝎-boost;沙蝎-attack,,[player;attack;6]
-蜥蜴,defend,false,attack;attack,,,,[self;defend;6]
+幼沙虫-defend,幼沙虫,true,幼沙虫-defend;幼沙虫-boost,,[source;defend;6]
-蜥蜴,molt,false,defend;attack,,,,[self;molt;3]
+幼沙虫-boost,幼沙虫,false,幼沙虫-attack;幼沙虫-defend,,[source;energyDrain;1];[source;defend;4]
-沙匪,attack,true,attack;heavyAttack,,,,[player;attack;6]
+幼沙虫-attack,幼沙虫,false,幼沙虫-defend;幼沙虫-defend,,[player;attack;5]
-沙匪,heavyAttack,false,attack;attack;debuff,,,,[player;attack;10]
+蜥蜴-attack,蜥蜴,true,蜥蜴-defend;蜥蜴-molt,,[player;attack;5]
-沙匪,debuff,false,attack;attack,,,,[player;discard;1]
+蜥蜴-defend,蜥蜴,false,蜥蜴-attack;蜥蜴-attack,,[source;defend;6]
-风暴之灵,storm,true,attack;storm,,,,[self;storm;2];[self;defend;3]
+蜥蜴-molt,蜥蜴,false,蜥蜴-defend;蜥蜴-attack,,[source;molt;3]
-风暴之灵,attack,false,storm;defend,,,,[player;attack;8];[player;static;1]
+沙匪-attack,沙匪,true,沙匪-attack;沙匪-heavyAttack,,[player;attack;6]
-风暴之灵,defend,false,storm;attack,,,,[self;defend;8]
+沙匪-heavyAttack,沙匪,false,沙匪-attack;沙匪-attack;沙匪-debuff,,[player;attack;10]
-骑马枪手,charge,true,attack,,,,[self;charge;2]
+沙匪-debuff,沙匪,false,沙匪-attack;沙匪-attack,,[player;discard;1]
-骑马枪手,attack,false,charge;defend,charge,,[player;attack;6]
+风暴之灵-storm,风暴之灵,true,风暴之灵-attack;风暴之灵-storm,,[source;storm;2];[source;defend;3]
-骑马枪手,defend,false,charge;attack,charge,,[self;defend;5]
+风暴之灵-attack,风暴之灵,false,风暴之灵-storm;风暴之灵-defend,,[player;attack;8];[player;static;1]
-沙虫王,summon,true,attack;defend,,,,[self;summonSandwormLarva;1]
+风暴之灵-defend,风暴之灵,false,风暴之灵-storm;风暴之灵-attack,,[source;defend;8]
-沙虫王,attack,false,summon;defend,,,,[player;attack;9]
+骑马枪手-charge,骑马枪手,true,骑马枪手-attack,,[source;charge;2]
-沙虫王,defend,false,attack;summon,,,,[self;defend;6]
+骑马枪手-attack,骑马枪手,false,骑马枪手-charge;骑马枪手-defend,骑马枪手-charge,[player;attack;6]
-沙漠守卫,summon,true,attack;defend,,,,[self;summonMummy;1]
+骑马枪手-defend,骑马枪手,false,骑马枪手-charge;骑马枪手-attack,骑马枪手-charge,[source;defend;5]
-沙漠守卫,attack,false,defend;summon,,,,[player;attack;8]
+沙虫王-summon,沙虫王,true,沙虫王-attack;沙虫王-defend,,[source;summonSandwormLarva;18]
-沙漠守卫,defend,false,attack;revive,,,,[self;defend;8]
+沙虫王-attack,沙虫王,false,沙虫王-summon;沙虫王-defend,,[player;attack;9]
-沙漠守卫,revive,false,attack;summon,,,,[self;reviveMummy;1]
+沙虫王-defend,沙虫王,false,沙虫王-attack;沙虫王-summon,,[source;defend;6]
+沙漠守卫-summon,沙漠守卫,true,沙漠守卫-attack;沙漠守卫-defend,,[source;summonMummy;14]
+沙漠守卫-attack,沙漠守卫,false,沙漠守卫-defend;沙漠守卫-summon,,[player;attack;8]
+沙漠守卫-defend,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-revive,,[source;defend;8]
+沙漠守卫-revive,沙漠守卫,false,沙漠守卫-attack;沙漠守卫-summon,,[source;reviveMummy;1]

src/samples/slay-the-spire-like/data/desert/intent.csv.d.ts

@@ -1,14 +1,17 @@
 import type { Enemy } from './enemy.csv';
 import type { Effect } from './effect.csv';
 
+export type IntentEffectTarget = 'source' | 'eachEnemy' | 'randomEnemy' | 'player';
+export type IntentEffect = [IntentEffectTarget, Effect, number];
+export type IntentEffectList = IntentEffect[];
+
 type IntentTable = readonly {
+    readonly id: string;
     readonly enemy: Enemy;
-    readonly intentId: string;
     readonly initialIntent: boolean;
-    readonly nextIntents: readonly string[];
+    readonly nextIntents: Intent[];
-    readonly brokenIntent: readonly string[];
+    readonly brokenIntent: Intent[];
-    readonly initBuffs: readonly [Effect, readonly stacks: number];
+    readonly effects: IntentEffectList;
-    readonly effects: readonly ["self" | "player" | "team", Effect, number];
 }[];
 
 export type Intent = IntentTable[number];

src/samples/slay-the-spire-like/data/desert/triggers/card-events.ts

@@ -0,0 +1,129 @@
+import { Triggers } from "@/samples/slay-the-spire-like/system/combat/triggers";
+import { getCombatEntity } from "@/samples/slay-the-spire-like/system/combat/effects";
+import { EffectData } from "@/samples/slay-the-spire-like/system/types";
+import getEffects from "../effect.csv";
+import { IRunContext } from "@/samples/slay-the-spire-like/system/combat/types";
+
+export function addCardEventTriggers(triggers: Triggers, run: IRunContext) {
+  const effects = getEffects();
+
+  function findEffect(id: string): EffectData {
+    const found = effects.find((e) => e.id === id);
+    if (found) return found;
+    return {
+      id,
+      name: id,
+      description: "",
+      lifecycle: "instant",
+    } as EffectData;
+  }
+
+  // storm: give static card to player when storm enemy attacks
+  triggers.onEnemyIntent.use(async (ctx, next) => {
+    await next();
+
+    const enemy = getCombatEntity(ctx.game.value, ctx.enemyId);
+    if (!enemy || !enemy.isAlive) return;
+
+    const storm = enemy.effects.storm?.stacks ?? 0;
+    if (storm > 0) {
+      for (let i = 0; i < storm; i++) {
+        await triggers.onEffectApplied.execute(ctx.game, {
+          effect: findEffect("static"),
+          entityId: "player",
+          stacks: 1,
+          sourceEntityId: ctx.enemyId,
+        });
+      }
+    }
+  });
+
+  // crossbow: replay other crossbows on same target
+  triggers.onEffectApplied.use(async (ctx, next) => {
+    await next();
+
+    if (ctx.effect.id !== "crossbow" || !ctx.cardId || !ctx.targetId) return;
+
+    const { cards, regions } = ctx.game.value.player.deck;
+    const handIds = [...regions.hand.childIds];
+    for (const id of handIds) {
+      const card = cards[id];
+      if (card && card.itemId === "crossbow" && id !== ctx.cardId) {
+        await triggers.onCardPlayed.execute(ctx.game, {
+          cardId: id,
+          targetId: ctx.targetId,
+          sourceEntityId: "player",
+        });
+      }
+    }
+  });
+
+  // burnForEnergy: consume adjacent item, gain energy when its card is played
+  triggers.onCardPlayed.use(async (ctx, next) => {
+    await next();
+
+    const card = ctx.game.value.player.deck.cards[ctx.cardId];
+    if (!card) return;
+    const playedItemId = card.itemId;
+
+    const adjacent = run.getAdjacentItems(playedItemId);
+    for (const adjItemId of adjacent) {
+      const adjEffects = ctx.game.value.player.itemEffects[adjItemId];
+      if (!adjEffects) continue;
+      const burn = adjEffects.burnForEnergy;
+      if (!burn || burn.stacks <= 0) continue;
+
+      const item = run.getItemData(adjItemId);
+      const maxUses =
+        item?.card.costType === "energy" ? item.card.costCount : 0;
+      const consumed = run.getConsumedUses(adjItemId);
+      const toConsume = Math.min(maxUses - consumed, burn.stacks);
+
+      await run.setConsumedUsesAsync(adjItemId, consumed + toConsume);
+      await ctx.game.produceAsync((draft) => {
+        draft.player.energy += burn.stacks;
+        delete draft.player.itemEffects[adjItemId];
+      });
+      break;
+    }
+  });
+
+  // sandwormKing: heal 10 hp when player discards fatigue
+  triggers.onCardDiscarded.use(async (ctx, next) => {
+    await next();
+
+    const card = ctx.game.value.player.deck.cards[ctx.cardId];
+    if (!card || card.cardData.id !== "fatigue") return;
+
+    const sandwormKing = ctx.game.value.enemies.find(
+      (e) => e.enemy.id === "沙虫王" && e.isAlive,
+    );
+    if (!sandwormKing) return;
+
+    await ctx.game.produceAsync((draft) => {
+      const king = draft.enemies.find((e) => e.id === sandwormKing.id);
+      if (king) {
+        king.hp = Math.min(king.hp + 10, king.maxHp);
+      }
+    });
+  });
+
+  // vulture: give vultureEye when vulture deals damage
+  triggers.onDamage.use(async (ctx, next) => {
+    await next();
+
+    const dealt = ctx.amount - (ctx.prevented ?? 0);
+    if (dealt <= 0 || !ctx.sourceEntityId) return;
+
+    const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityId);
+    if (!attacker || !("enemy" in attacker) || attacker.enemy.id !== "秃鹫")
+      return;
+
+    await triggers.onEffectApplied.execute(ctx.game, {
+      effect: findEffect("vultureEye"),
+      entityId: "player",
+      stacks: 1,
+      sourceEntityId: ctx.sourceEntityId,
+    });
+  });
+}

src/samples/slay-the-spire-like/data/desert/triggers/damage.ts

@@ -0,0 +1,194 @@
+import { Triggers } from "@/samples/slay-the-spire-like/system/combat/triggers";
+import {
+  addEntityEffect,
+  getCombatEntity,
+} from "@/samples/slay-the-spire-like/system/combat/effects";
+import { EffectData } from "@/samples/slay-the-spire-like/system/types";
+import getEffects from "../effect.csv";
+
+export function addDamageTriggers(triggers: Triggers) {
+  const effects = getEffects();
+
+  function findEffect(id: string): EffectData {
+    const found = effects.find((e: EffectData) => e.id === id);
+    if (found) return found;
+    return {
+      id,
+      name: id,
+      description: "",
+      lifecycle: "instant",
+    } as EffectData;
+  }
+
+  // block / damage prevention
+  triggers.onDamage.use(async (ctx, next) => {
+    const entity = getCombatEntity(ctx.game.value, ctx.entityId);
+    if (!entity) return;
+
+    let preventable = ctx.amount - (ctx.prevented ?? 0);
+
+    // 1. apply damageReduce before block
+    const damageReduce = entity.effects.damageReduce?.stacks ?? 0;
+    if (damageReduce > 0) {
+      const reduced = Math.min(damageReduce, preventable);
+      ctx.prevented = (ctx.prevented ?? 0) + reduced;
+      preventable -= reduced;
+    }
+
+    // 2. consume defend for damage prevented
+    const blocks = entity.effects.defend?.stacks ?? 0;
+    const blocked = Math.min(blocks, preventable);
+    if (blocked > 0) {
+      ctx.prevented = (ctx.prevented ?? 0) + blocked;
+      preventable -= blocked;
+      await ctx.game.produceAsync((draft) => {
+        const e = getCombatEntity(draft, ctx.entityId);
+        if (e) addEntityEffect(e, findEffect("defend"), -blocked);
+      });
+    }
+
+    const expose = entity.effects.expose?.stacks ?? 0;
+    if (expose > 0) {
+      ctx.amount += expose;
+    }
+
+    await next();
+  });
+
+  // energyDrain: player loses energy when enemy takes damage
+  triggers.onDamage.use(async (ctx, next) => {
+    const entity = getCombatEntity(ctx.game.value, ctx.entityId);
+    if (!entity) return;
+
+    const energyDrain = entity.effects.energyDrain?.stacks ?? 0;
+    if (energyDrain > 0 && ctx.entityId !== "player") {
+      const dealt = Math.min(
+        Math.max(0, entity.hp),
+        ctx.amount - (ctx.prevented ?? 0),
+      );
+      if (dealt > 0) {
+        await ctx.game.produceAsync((draft) => {
+          draft.player.energy = Math.max(0, draft.player.energy - energyDrain);
+        });
+      }
+    }
+
+    await next();
+  });
+
+  // molt: enemy flees if molt >= maxHp
+  triggers.onDamage.use(async (ctx, next) => {
+    const entity = getCombatEntity(ctx.game.value, ctx.entityId);
+    if (!entity || !entity.isAlive) {
+      await next();
+      return;
+    }
+
+    const molt = entity.effects.molt?.stacks ?? 0;
+    if (molt >= entity.maxHp) {
+      await ctx.game.produceAsync((draft) => {
+        const e = draft.enemies.find((en) => en.id === ctx.entityId);
+        if (e) {
+          e.isAlive = false;
+          e.hp = 0;
+        }
+        draft.result = draft.enemies.every((en) => !en.isAlive)
+          ? "victory"
+          : null;
+      });
+      if (ctx.game.value.result) throw ctx.game.value;
+      return;
+    }
+
+    await next();
+  });
+
+  // aim: double damage, lose aim on damage
+  triggers.onDamage.use(async (ctx, next) => {
+    if (ctx.sourceEntityId === "player") {
+      const player = ctx.game.value.player;
+      const aim = player.effects.aim?.stacks ?? 0;
+      if (aim > 0) {
+        ctx.amount *= 2;
+      }
+    }
+    await next();
+  });
+
+  // roll: consume 10 roll per 10 damage
+  triggers.onDamage.use(async (ctx, next) => {
+    if (ctx.sourceEntityId === "player") {
+      const player = ctx.game.value.player;
+      const roll = player.effects.roll?.stacks ?? 0;
+      if (roll >= 10) {
+        const rollDamage = Math.floor(roll / 10) * 10;
+        ctx.amount += rollDamage;
+        await ctx.game.produceAsync((draft) => {
+          addEntityEffect(draft.player, findEffect("roll"), -rollDamage);
+        });
+      }
+    }
+    await next();
+  });
+
+  // tailSting: bonus damage on attack
+  triggers.onDamage.use(async (ctx, next) => {
+    if (ctx.sourceEntityId && ctx.sourceEntityId !== "player") {
+      const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityId);
+      if (attacker) {
+        const tailSting = attacker.effects.tailSting?.stacks ?? 0;
+        if (tailSting > 0) {
+          ctx.amount += tailSting;
+        }
+      }
+    }
+    await next();
+  });
+
+  // charge: double damage dealt/received, consume equal charge
+  triggers.onDamage.use(async (ctx, next) => {
+    const entity = getCombatEntity(ctx.game.value, ctx.entityId);
+    if (entity) {
+      const charge = entity.effects.charge?.stacks ?? 0;
+      if (charge > 0) {
+        const dealt = Math.min(
+          Math.max(0, entity.hp),
+          ctx.amount - (ctx.prevented ?? 0),
+        );
+        const consumed = Math.min(charge, dealt);
+        ctx.amount += dealt;
+        if (consumed > 0) {
+          await ctx.game.produceAsync((draft) => {
+            const e = getCombatEntity(draft, ctx.entityId);
+            if (e) addEntityEffect(e, findEffect("charge"), -consumed);
+          });
+        }
+      }
+    }
+
+    if (ctx.sourceEntityId) {
+      const attacker = getCombatEntity(ctx.game.value, ctx.sourceEntityId);
+      if (attacker) {
+        const charge = attacker.effects.charge?.stacks ?? 0;
+        if (charge > 0) {
+          const baseAmount = ctx.amount;
+          const targetEntity = getCombatEntity(ctx.game.value, ctx.entityId);
+          const dealt = Math.min(
+            Math.max(0, targetEntity?.hp ?? 0),
+            baseAmount - (ctx.prevented ?? 0),
+          );
+          const consumed = Math.min(charge, dealt);
+          ctx.amount += dealt;
+          if (consumed > 0) {
+            await ctx.game.produceAsync((draft) => {
+              const a = getCombatEntity(draft, ctx.sourceEntityId!);
+              if (a) addEntityEffect(a, findEffect("charge"), -consumed);
+            });
+          }
+        }
+      }
+    }
+
+    await next();
+  });
+}

src/samples/slay-the-spire-like/data/desert/triggers/effect.ts

@@ -1,33 +0,0 @@
-import {Triggers} from "@/samples/slay-the-spire-like/system/combat/triggers";
-import {getCombatEntity} from "@/samples/slay-the-spire-like/system/combat/effects";
-
-export function addEffectTriggers(triggers:Triggers){
-    // instant effects
-    triggers.onEffectApplied.use(async (ctx, next) => { 
-        if(ctx.effect.id === "attack") {
-            await triggers.onDamage.execute(ctx.game, {
-                entityKey: ctx.entityKey,
-                amount: ctx.stacks
-            });
-        }else if(ctx.effect.id === "draw") {
-            await triggers.onDraw.execute(ctx.game, {
-                count: ctx.stacks
-            });
-        }
-        await next();
-    });
-    
-    // blocks
-    triggers.onDamage.use(async (ctx, next) => {
-        const entity = getCombatEntity(ctx.game.value, ctx.entityKey);
-        if(!entity) return;
-        
-        const preventable = (ctx.amount - (ctx.prevented ?? 0));
-        const blocks = entity.effects.block?.stacks ?? 0;
-        const blocked = Math.min(blocks, preventable);
-        if(blocked){
-            ctx.prevented = (ctx.prevented ?? 0) + blocked;
-        }
-        await next();
-    });
-}

src/samples/slay-the-spire-like/data/desert/triggers/index.ts

@@ -1,6 +1,15 @@
-import {addEffectTriggers} from './effect';
+import { addInstantEffectTriggers } from "./instant";
-import {Triggers} from "@/samples/slay-the-spire-like/system/combat/triggers";
+import { addDamageTriggers } from "./damage";
+import { addTurnStartTriggers } from "./turn-start";
+import { addCardEventTriggers } from "./card-events";
+import {
+  IRunContext,
+  Triggers,
+} from "@/samples/slay-the-spire-like/system/combat";
 
-export function addTriggers(triggers: Triggers){
+export function addTriggers(triggers: Triggers, run: IRunContext) {
-    addEffectTriggers(triggers);
+  addInstantEffectTriggers(triggers);
+  addDamageTriggers(triggers);
+  addTurnStartTriggers(triggers);
+  addCardEventTriggers(triggers, run);
 }

src/samples/slay-the-spire-like/data/desert/triggers/instant.ts

@@ -0,0 +1,178 @@
+import { Triggers } from "@/samples/slay-the-spire-like/system/combat/triggers";
+import {
+  addEntityEffect,
+  getCombatEntity,
+} from "@/samples/slay-the-spire-like/system/combat/effects";
+import { moveToRegion } from "@/core/region";
+import { CombatGameContext } from "@/samples/slay-the-spire-like/system/combat/types";
+import { GameCard } from "@/samples/slay-the-spire-like/system/deck";
+import getCards from "../card.csv";
+
+export function addInstantEffectTriggers(triggers: Triggers) {
+  const cards = getCards();
+
+  function findCard(id: string) {
+    return cards.find((c) => c.id === id);
+  }
+
+  function createStatusCard(
+    draft: CombatGameContext["value"],
+    cardId: string,
+  ): void {
+    const cardData = findCard(cardId);
+    if (!cardData) return;
+
+    const instanceId = `${cardId}-${draft.player.deck.regions.drawPile.childIds.length}-${draft.player.deck.regions.discardPile.childIds.length}`;
+    const card: GameCard = {
+      id: instanceId,
+      regionId: "",
+      position: [],
+      itemId: cardId,
+      cardData: {
+        id: cardData.id,
+        name: cardData.name,
+        desc: cardData.desc,
+        type: cardData.type,
+        costType: cardData.costType,
+        costCount: cardData.costCount,
+        targetType: cardData.targetType,
+        effects: cardData.effects,
+      },
+    };
+    draft.player.deck.cards[instanceId] = card;
+    moveToRegion(card, null, draft.player.deck.regions.drawPile);
+  }
+
+  function getAllEnemyDataFromState(state: CombatGameContext["value"]) {
+    const seen = new Set<string>();
+    const result: (typeof state.enemies)[number]["enemy"][] = [];
+    for (const enemy of state.enemies) {
+      if (!seen.has(enemy.enemy.id)) {
+        seen.add(enemy.enemy.id);
+        result.push(enemy.enemy);
+      }
+    }
+    return result;
+  }
+
+  function summonEnemy(
+    draft: CombatGameContext["value"],
+    enemyId: string,
+    hp: number,
+  ) {
+    for (const enemyData of getAllEnemyDataFromState(draft)) {
+      if (enemyData.id === enemyId) {
+        const existing = draft.enemies.find(
+          (e) => e.enemy.id === enemyId && !e.isAlive,
+        );
+        if (existing) {
+          existing.isAlive = true;
+          existing.hp = existing.maxHp;
+          return;
+        }
+        const intent =
+          enemyData.intents.find((i) => i.initialIntent) ??
+          enemyData.intents[0];
+        const instanceId = `${enemyData.id}-${draft.enemies.length}`;
+        const intents: Record<string, typeof intent> = {};
+        for (const i of enemyData.intents) {
+          intents[i.id] = i;
+        }
+        draft.enemies.push({
+          id: instanceId,
+          enemy: enemyData,
+          hp,
+          maxHp: hp,
+          isAlive: true,
+          effects: {},
+          intents,
+          currentIntent: intent,
+        });
+        break;
+      }
+    }
+  }
+
+  triggers.onEffectApplied.use(async (ctx, next) => {
+    if (ctx.effect.id === "attack") {
+      await triggers.onDamage.execute(ctx.game, {
+        entityId: ctx.entityId,
+        amount: ctx.stacks,
+        sourceEntityId: ctx.sourceEntityId,
+      });
+
+      const entity = getCombatEntity(ctx.game.value, ctx.entityId);
+      const spike = entity?.effects.spike?.stacks ?? 0;
+      if (spike > 0 && ctx.sourceEntityId) {
+        await triggers.onDamage.execute(ctx.game, {
+          entityId: ctx.sourceEntityId,
+          amount: spike,
+          sourceEntityId: ctx.entityId,
+        });
+      }
+    } else if (ctx.effect.id === "draw") {
+      await triggers.onDraw.execute(ctx.game, { count: ctx.stacks });
+    } else if (ctx.effect.id === "gainEnergy") {
+      await ctx.game.produceAsync((draft) => {
+        draft.player.energy += ctx.stacks;
+      });
+    } else if (ctx.effect.id === "removeWound") {
+      await ctx.game.produceAsync((draft) => {
+        const { cards, regions } = draft.player.deck;
+        let removed = 0;
+        const allPileIds = [
+          ...regions.drawPile.childIds,
+          ...regions.discardPile.childIds,
+        ];
+        for (const cardId of allPileIds) {
+          if (removed >= ctx.stacks) break;
+          const card = cards[cardId];
+          if (card && card.cardData.id === "wound") {
+            const sourceRegion =
+              card.regionId === "drawPile"
+                ? regions.drawPile
+                : regions.discardPile;
+            moveToRegion(card, sourceRegion, null);
+            delete cards[cardId];
+            removed++;
+          }
+        }
+      });
+    } else if (ctx.effect.id === "venom") {
+      await ctx.game.produceAsync((draft) => {
+        createStatusCard(draft, "venom");
+      });
+    } else if (ctx.effect.id === "vultureEye") {
+      await ctx.game.produceAsync((draft) => {
+        createStatusCard(draft, "vultureEye");
+      });
+    } else if (ctx.effect.id === "static") {
+      await ctx.game.produceAsync((draft) => {
+        createStatusCard(draft, "static");
+      });
+    } else if (ctx.effect.id === "summonMummy") {
+      await ctx.game.produceAsync((draft) => {
+        summonEnemy(draft, "木乃伊", ctx.stacks);
+      });
+    } else if (ctx.effect.id === "summonSandwormLarva") {
+      await ctx.game.produceAsync((draft) => {
+        summonEnemy(draft, "幼沙虫", ctx.stacks);
+      });
+    } else if (ctx.effect.id === "reviveMummy") {
+      await ctx.game.produceAsync((draft) => {
+        const deadMummy = draft.enemies.find(
+          (e) => e.enemy.id === "木乃伊" && !e.isAlive,
+        );
+        if (deadMummy) {
+          deadMummy.isAlive = true;
+          deadMummy.hp = deadMummy.maxHp;
+        }
+      });
+    } else if (ctx.effect.id === "curse") {
+      await ctx.game.produceAsync((draft) => {
+        addEntityEffect(draft.player, ctx.effect, ctx.stacks);
+      });
+    }
+    await next();
+  });
+}

src/samples/slay-the-spire-like/data/desert/triggers/turn-start.ts

@@ -0,0 +1,92 @@
+import { Triggers } from "@/samples/slay-the-spire-like/system/combat/triggers";
+import { addEntityEffect } from "@/samples/slay-the-spire-like/system/combat/effects";
+import { EffectData } from "@/samples/slay-the-spire-like/system/types";
+import getEffects from "../effect.csv";
+
+export function addTurnStartTriggers(triggers: Triggers) {
+  const effects = getEffects();
+
+  function findEffect(id: string): EffectData {
+    const found = effects.find((e) => e.id === id);
+    if (found) return found;
+    return {
+      id,
+      name: id,
+      description: "",
+      lifecycle: "instant",
+    } as EffectData;
+  }
+
+  // discard: random discard at turn start
+  triggers.onTurnStart.use(async (ctx, next) => {
+    if (ctx.entityId !== "player") {
+      await next();
+      return;
+    }
+
+    const discard = ctx.game.value.player.effects.discard;
+    if (discard && discard.stacks > 0) {
+      const handIds = [...ctx.game.value.player.deck.regions.hand.childIds];
+      if (handIds.length > 0) {
+        const randomIndex = ctx.game.rng.nextInt(handIds.length);
+        const randomCardId = handIds[randomIndex];
+        await triggers.onCardDiscarded.execute(ctx.game, {
+          cardId: randomCardId,
+        });
+      }
+    }
+
+    await next();
+  });
+
+  // defendNext: gain block next turn
+  // record how many defendNext there is, before buff update
+  // then apply after buff update
+  triggers.onTurnStart.use(async (ctx, next) => {
+    const defendNext = ctx.game.value.player.effects.defendNext;
+    if (!defendNext || defendNext.stacks <= 0) {
+      await next();
+      return;
+    }
+    await next();
+    await ctx.game.produceAsync((draft) => {
+      addEntityEffect(draft.player, findEffect("defend"), defendNext.stacks);
+    });
+  });
+
+  // energyNext: gain energy next turn
+  triggers.onTurnStart.use(async (ctx, next) => {
+    if (ctx.entityId !== "player") {
+      await next();
+      return;
+    }
+
+    const energyNext = ctx.game.value.player.effects.energyNext;
+    if (energyNext && energyNext.stacks > 0) {
+      await ctx.game.produceAsync((draft) => {
+        draft.player.energy += energyNext.stacks;
+        addEntityEffect(draft.player, energyNext.data, -energyNext.stacks);
+      });
+    }
+
+    await next();
+  });
+
+  // drawNext: draw extra cards next turn
+  triggers.onTurnStart.use(async (ctx, next) => {
+    if (ctx.entityId !== "player") {
+      await next();
+      return;
+    }
+
+    const drawNext = ctx.game.value.player.effects.drawNext;
+    if (drawNext && drawNext.stacks > 0) {
+      await ctx.game.produceAsync((draft) => {
+        addEntityEffect(draft.player, drawNext.data, -drawNext.stacks);
+      });
+      await triggers.onDraw.execute(ctx.game, { count: drawNext.stacks });
+    }
+
+    await next();
+  });
+}

src/samples/slay-the-spire-like/data/index.ts

@@ -1,5 +1,6 @@
-import * as desert from './desert';
+import * as desert from "./desert";
+export type { ContentModule } from "./types";
 
 export default {
-    desert
+  desert,
-}
+};

src/samples/slay-the-spire-like/data/types.ts

@@ -0,0 +1,18 @@
+import { LoadResult as YarnDialogues } from "yarn-spinner-loader";
+import { Triggers } from "../system/combat/triggers";
+
+import type * as desert from "./desert";
+import { IRunContext } from "../system/combat";
+
+export type ContentModule = {
+  readonly getCards: () => readonly desert.Card[];
+  readonly getEffects: () => readonly desert.Effect[];
+  readonly getEncounters: () => readonly desert.Encounter[];
+  readonly getEnemies: () => readonly desert.Enemy[];
+  readonly getIntents: () => readonly desert.Intent[];
+  readonly getItems: () => readonly desert.Item[];
+  readonly getStartingItems: () => readonly desert.Item[];
+
+  readonly dialogues: YarnDialogues;
+  readonly addTriggers: (triggers: Triggers, run: IRunContext) => void;
+};

src/samples/slay-the-spire-like/index.ts

@@ -0,0 +1,8 @@
+export * from "./system/combat";
+export * from "./system/deck";
+export * from "./system/encounter";
+export * from "./system/grid-inventory";
+export * from "./system/map";
+export * from "./system/utils";
+export * from "./system/types";
+export { default as data } from "./data";

src/samples/slay-the-spire-like/system/combat/effects.ts

@@ -1,72 +1,94 @@
-import {CombatEntity, CombatState, EffectTable, PlayerEntity} from "./types";
+import {
-import {CardData, EffectData} from "@/samples/slay-the-spire-like/system/types";
+  CombatEntity,
-import {GameItemMeta} from "@/samples/slay-the-spire-like/system/progress/types";
+  CombatGameContext,
-import {GridInventory} from "@/samples/slay-the-spire-like/system/grid-inventory/types";
+  CombatState,
+  EffectTable,
+  IRunContext,
+  PlayerEntity,
+} from "./types";
+import {
+  CardData,
+  CardEffectTarget,
+  EffectData,
+  IntentEffectTarget,
+} from "@/samples/slay-the-spire-like/system/types";
 
-export function addEffect(effects: EffectTable, effect: EffectData, stacks: number){
+export function addEffect(
+  effects: EffectTable,
+  effect: EffectData,
+  stacks: number,
+) {
   let current = effects[effect.id];
 
-    if(!current) current = {data: effect, stacks};
+  if (!current) current = { data: effect, stacks };
   else current.stacks += stacks;
 
-    if(current.stacks === 0 && effects[effect.id])
+  if (current.stacks === 0 && effects[effect.id]) delete effects[effect.id];
-        delete effects[effect.id];
+  else if (current.stacks !== 0 && !effects[effect.id])
-    else if(current.stacks !== 0 && !effects[effect.id])
     effects[effect.id] = current;
 }
 
-export function addEntityEffect(entity: CombatEntity, effect: EffectData, stacks: number){
+export function addEntityEffect(
+  entity: CombatEntity,
+  effect: EffectData,
+  stacks: number,
+) {
   addEffect(entity.effects, effect, stacks);
 }
 
-export function addItemEffect(entity: PlayerEntity, itemKey: string, effect: EffectData, stacks: number){
+export function addItemEffect(
+  entity: PlayerEntity,
+  itemKey: string,
+  effect: EffectData,
+  stacks: number,
+) {
   entity.itemEffects[itemKey] = entity.itemEffects[itemKey] || {};
   addEffect(entity.itemEffects[itemKey], effect, stacks);
 }
 
-export function onEntityEffectUpkeep(entity: CombatEntity){
+export function onEntityEffectUpkeep(entity: CombatEntity) {
-    for(const effect of Object.values(entity.effects)){
+  for (const effect of Object.values(entity.effects)) {
     const lifecycle = effect.data.lifecycle;
-        if(lifecycle === 'temporary')
+    if (lifecycle === "temporary")
       addEntityEffect(entity, effect.data, -effect.stacks);
-        else if(lifecycle === 'lingering')
+    else if (lifecycle === "lingering")
       addEntityEffect(entity, effect.data, effect.stacks >= 0 ? -1 : 1);
   }
 }
 
-export function onEntityPostureDamage(entity: CombatEntity, damage: number){
+export function onEntityPostureDamage(entity: CombatEntity, damage: number) {
-    for(const effect of Object.values(entity.effects)){
+  for (const effect of Object.values(entity.effects)) {
     const lifecycle = effect.data.lifecycle;
-        if(lifecycle === 'posture')
+    if (lifecycle === "posture")
       addEntityEffect(entity, effect.data, -Math.min(damage, effect.stacks));
   }
 }
 
-export function onPlayerItemEffectUpkeep(entity: PlayerEntity){
+export function onPlayerItemEffectUpkeep(entity: PlayerEntity) {
-    for(const [itemKey, itemEffects] of Object.entries(entity.itemEffects)){
+  for (const [itemKey, itemEffects] of Object.entries(entity.itemEffects)) {
-        for(const effect of Object.values(itemEffects)){
+    for (const effect of Object.values(itemEffects)) {
       const lifecycle = effect.data.lifecycle;
-            if(lifecycle === 'itemTemporary')
+      if (lifecycle === "itemTemporary")
         addItemEffect(entity, itemKey, effect.data, -effect.stacks);
     }
   }
 }
 
-export function onItemPlay(entity: PlayerEntity, itemKey: string){
+export function onItemPlay(entity: PlayerEntity, itemKey: string) {
   const effects = entity.itemEffects[itemKey];
-    if(!effects)return;
+  if (!effects) return;
-    for(const effect of Object.values(effects)){
+  for (const effect of Object.values(effects)) {
-        if(effect.data.lifecycle === 'itemUntilPlay'){
+    if (effect.data.lifecycle === "itemUntilPlay") {
       addItemEffect(entity, itemKey, effect.data, -effect.stacks);
     }
   }
 }
 
-export function onItemDiscard(entity: PlayerEntity, itemKey: string){
+export function onItemDiscard(entity: PlayerEntity, itemKey: string) {
   const effects = entity.itemEffects[itemKey];
-    if(!effects)return;
+  if (!effects) return;
-    for(const effect of Object.values(effects)){
+  for (const effect of Object.values(effects)) {
-        if(effect.data.lifecycle === 'itemUntilDiscard'){
+    if (effect.data.lifecycle === "itemUntilDiscard") {
       addItemEffect(entity, itemKey, effect.data, -effect.stacks);
     }
   }
@@ -80,30 +102,70 @@ export function* getAliveEnemies(state: CombatState) {
   }
 }
 
-export function getCombatEntity(state: CombatState, entityKey: string){
+export function* getEffectTargets(
-    return entityKey === 'player' ? state.player : state.enemies.find(e => e.id === entityKey);
+  target: CardEffectTarget | IntentEffectTarget,
+  game: CombatGameContext,
+  targetId?: string,
+  sourceEntityKey: "player" | string = "player",
+) {
+  if (target === "eachEnemy") {
+    for (const enemy of getAliveEnemies(game.value)) {
+      yield enemy;
+    }
+  } else if (target === "source") {
+    const entity = getCombatEntity(game.value, sourceEntityKey);
+    if (entity) yield entity;
+  } else if (target === "player") {
+    yield game.value.player;
+  } else if (target === "eachTarget") {
+    if (!targetId) return;
+    const entity = getCombatEntity(game.value, targetId);
+    if (entity) yield entity;
+  } else if (target === "randomEnemy") {
+    const aliveEnemies = [...getAliveEnemies(game.value)];
+    if (aliveEnemies.length === 0) return;
+    const index = game.rng.nextInt(aliveEnemies.length);
+    yield aliveEnemies[index];
+  }
 }
 
-export function canPlayCard(player: PlayerEntity, costType: CardData['costType'], costCount: number, itemId: string, inventory: GridInventory<GameItemMeta>): boolean {
+export function getCombatEntity(state: CombatState, entityKey: string) {
-    if (costType === 'energy') {
+  return entityKey === "player"
+    ? state.player
+    : state.enemies.find((e) => e.id === entityKey);
+}
+
+export function canPlayCard(
+  player: PlayerEntity,
+  costType: CardData["costType"],
+  costCount: number,
+  itemId: string,
+  run: IRunContext,
+): boolean {
+  if (costType === "energy") {
     return player.energy >= costCount;
   }
-    if (costType === 'uses') {
+  if (costType === "uses") {
-        const item = inventory.items.get(itemId);
+    const item = run.getItemData(itemId);
-        if (!item || !item.meta) return false;
+    if (!item) return false;
-        const depletion = item.meta.depletion ?? 0;
+    const maxUses = item?.card.costType === "uses" ? item.card.costCount : 0;
-        return depletion < costCount;
+    const consumed = run.getConsumedUses(itemId);
+    return consumed < maxUses;
   }
   return true;
 }
 
-export function payCardCost(player: PlayerEntity, costType: CardData['costType'], costCount: number, itemId: string, inventory: GridInventory<GameItemMeta>): void {
+export async function payCardCost(
-    if (costType === 'energy') {
+  player: PlayerEntity,
+  costType: CardData["costType"],
+  costCount: number,
+  itemId: string,
+  run: IRunContext,
+): Promise<void> {
+  if (costType === "energy") {
     player.energy -= costCount;
-    } else if (costType === 'uses') {
+  } else if (costType === "uses") {
-        const item = inventory.items.get(itemId);
+    const consumed = run.getConsumedUses(itemId);
-        if (item && item.meta) {
+    await run.setConsumedUsesAsync(itemId, consumed + costCount);
-            item.meta.depletion = (item.meta.depletion ?? 0) + costCount;
-        }
   }
 }

src/samples/slay-the-spire-like/system/combat/factory.ts

@@ -0,0 +1,104 @@
+import {
+  CombatState,
+  EffectTable,
+  EnemyEntity,
+  IPlayerDeck,
+  IPlayerState,
+  PlayerEntity,
+} from "./types";
+import { EffectData, EncounterData, EnemyData, IntentData } from "../types";
+
+export function buildCombatState(
+  playerState: IPlayerState,
+  deck: IPlayerDeck,
+  encounter: EncounterData,
+): CombatState {
+  const player = createPlayerEntity(playerState, deck);
+  const enemies = createEnemyEntities(encounter);
+
+  return {
+    enemies,
+    player,
+    phase: "playerTurn",
+    turnNumber: 1,
+    result: null,
+    loot: [],
+  };
+}
+
+function createEnemyEntities(encounter: EncounterData): EnemyEntity[] {
+  const enemies: EnemyEntity[] = [];
+  let instanceCounter = 0;
+
+  for (const [enemyData, hp, encounterBuffs] of encounter.enemies) {
+    const instanceId = `${enemyData.id}-${instanceCounter++}`;
+    const intents = buildIntentMap(enemyData);
+    const initialIntent = findInitialIntent(enemyData);
+    const effects = buildEffectTable(encounterBuffs);
+
+    const entity: EnemyEntity = {
+      id: instanceId,
+      enemy: enemyData,
+      hp,
+      maxHp: hp,
+      isAlive: true,
+      effects,
+      intents,
+      currentIntent: initialIntent,
+    };
+    enemies.push(entity);
+  }
+
+  return enemies;
+}
+
+/**
+ * Builds a map of intent ID -> IntentData for an enemy.
+ */
+function buildIntentMap(enemy: EnemyData): Record<string, IntentData> {
+  const intents: Record<string, IntentData> = {};
+  for (const intent of enemy.intents) {
+    intents[intent.id] = intent;
+  }
+  return intents;
+}
+
+/**
+ * Finds the initial intent ID for an enemy.
+ */
+function findInitialIntent(enemy: EnemyData): IntentData {
+  for (const intent of enemy.intents) {
+    if (intent.initialIntent) {
+      return intent;
+    }
+  }
+  if (enemy.intents.length === 0) {
+    throw new Error(`Enemy "${enemy.id}" has no intents`);
+  }
+  return enemy.intents[0];
+}
+
+function buildEffectTable(buffs: readonly [EffectData, number][]): EffectTable {
+  const table: EffectTable = {};
+  for (const [effect, stacks] of buffs) {
+    table[effect.id] = { data: effect, stacks };
+  }
+  return table;
+}
+
+function createPlayerEntity(
+  playerState: IPlayerState,
+  deck: IPlayerDeck,
+): PlayerEntity {
+  return {
+    id: "player",
+    hp: playerState.hp,
+    maxHp: playerState.maxHp,
+    isAlive: playerState.hp > 0,
+    energy: 3,
+    maxEnergy: 3,
+    deck,
+    itemEffects: playerState.itemEffects,
+    effects: {},
+  };
+}

src/samples/slay-the-spire-like/system/combat/index.ts

@@ -0,0 +1,5 @@
+export * from "./effects";
+export * from "./factory";
+export * from "./prompts";
+export * from "./triggers";
+export * from "./types";

src/samples/slay-the-spire-like/system/combat/prompts.ts

@@ -1,43 +1,56 @@
 import { createPromptDef } from "@/core/game";
-import {CombatGameContext} from "./types";
+import { CombatGameContext, IRunContext } from "./types";
-import {canPlayCard} from "@/samples/slay-the-spire-like/system/combat/effects";
+import { canPlayCard } from "@/samples/slay-the-spire-like/system/combat/effects";
 
 export const prompts = {
   mainAction: createPromptDef<[string, string?]>(
     "main-action <cardId:string> [targetId:string]",
-        "选择卡牌并指定目标"
+    "选择卡牌并指定目标",
   ),
 };
 
-export async function promptMainAction(game: CombatGameContext){
+export async function promptMainAction(
+  game: CombatGameContext,
+  run: IRunContext,
+) {
   return await game.prompt(prompts.mainAction, (cardId, targetId) => {
-        if(cardId === 'end-turn') return {
+    if (cardId === "end-turn")
-            action: 'end-turn' as 'end-turn'
+      return {
+        action: "end-turn" as "end-turn",
       };
 
-        const exists = game.value.player.deck.regions.hand.childIds.includes(cardId);
+    const exists =
-        if(!exists) throw `卡牌"${cardId}"不在手牌中`;
+      game.value.player.deck.regions.hand.childIds.includes(cardId);
+    if (!exists) throw `卡牌"${cardId}"不在手牌中`;
 
     const card = game.value.player.deck.cards[cardId];
-        const {cardData, itemId} = card;
+    const { cardData, itemId } = card;
-        if(!canPlayCard(game.value.player, cardData.costType, cardData.costCount, itemId, game.value.inventory)){
+    if (
+      !canPlayCard(
+        game.value.player,
+        cardData.costType,
+        cardData.costCount,
+        itemId,
+        run,
+      )
+    ) {
       throw `无法支付卡牌"${cardId}"的费用`;
     }
 
-        const {targetType} = cardData;
+    const { targetType } = cardData;
-        if(targetType === 'single'){
+    if (targetType === "enemy") {
-            if(!targetId) throw `请指定目标`;
+      if (!targetId) throw `请指定目标`;
-            const target = game.value.enemies.find(e => e.id === targetId);
+      const target = game.value.enemies.find((e) => e.id === targetId);
-            if(!target) throw `目标"${targetId}"不存在`;
+      if (!target) throw `目标"${targetId}"不存在`;
-            if(!target.isAlive) throw `目标"${targetId}"已死亡`;
+      if (!target.isAlive) throw `目标"${targetId}"已死亡`;
-        }else if(targetType === 'none'){
+    } else if (targetType === "enemies" || targetType === "player") {
-            if(targetId) throw `目标"${targetId}"无效`;
+      if (targetId) throw `目标"${targetId}"无效`;
     }
 
     return {
-            action: 'play' as 'play',
+      action: "play" as "play",
       cardId,
-            targetId
+      targetId,
     };
   });
 }

src/samples/slay-the-spire-like/system/combat/triggers.ts

@@ -1,108 +1,200 @@
-import {CombatGameContext} from "./types";
+import { CombatGameContext, IRunContext } from "./types";
 import {
   addEntityEffect,
   addItemEffect,
-    getAliveEnemies, onEntityPostureDamage,
+  getAliveEnemies,
+  onEntityPostureDamage,
   onEntityEffectUpkeep,
-    onPlayerItemEffectUpkeep, onItemDiscard, onItemPlay, payCardCost
+  onPlayerItemEffectUpkeep,
+  onItemDiscard,
+  onItemPlay,
+  payCardCost,
+  getCombatEntity,
+  getEffectTargets,
 } from "@/samples/slay-the-spire-like/system/combat/effects";
-import {promptMainAction} from "@/samples/slay-the-spire-like/system/combat/prompts";
+import { promptMainAction } from "@/samples/slay-the-spire-like/system/combat/prompts";
-import {moveToRegion, shuffle} from "@/core/region";
+import { moveToRegion, shuffle } from "@/core/region";
-import {createMiddlewareChain} from "@/utils/middleware";
+import { createMiddlewareChain } from "@/utils/middleware";
-import {EffectData} from "@/samples/slay-the-spire-like/system/types";
+import { EffectData } from "@/samples/slay-the-spire-like/system/types";
-import {getAdjacentItems} from "@/samples/slay-the-spire-like/system/grid-inventory";
-import {GameItemMeta} from "@/samples/slay-the-spire-like/system/progress";
 
 type TriggerTypes = {
-    onCombatStart: {},
+  onCombatStart: {};
-    onTurnStart: { entityKey: "player" | string, },
+  onTurnStart: { entityId: "player" | string };
-    onTurnEnd: { entityKey: "player" | string, },
+  onTurnEnd: { entityId: "player" | string };
-    onShuffle: {},
+  onShuffle: {};
-    onCardPlayed: { cardId: string, targetId?: string },
+  onCardPlayed: {
-    onCardDiscarded: { cardId: string,  },
+    cardId: string;
-    onCardDrawn: { cardId: string,  },
+    targetId?: string;
-    onDraw: {count: number},
+    sourceEntityId?: "player" | string;
-    onEffectApplied: { effect: EffectData, entityKey: "player" | string, stacks: number, cardId?: string },
+  };
-    onHpChange: { entityKey: "player" | string, amount: number},
+  onCardDiscarded: { cardId: string; sourceEntityId?: "player" | string };
-    onDamage: { entityKey: "player" | string, amount: number, prevented?: number},
+  onCardDrawn: { cardId: string; sourceEntityId?: "player" | string };
-    onEnemyIntent: { enemyId: string },
+  onDraw: { count: number };
-    onIntentUpdate: { enemyId: string },
+  onEffectApplied: {
-}
+    effect: EffectData;
+    entityId: "player" | string;
+    stacks: number;
+    cardId?: string;
+    sourceEntityId?: "player" | string;
+    targetId?: string;
+  };
+  onHpChange: { entityId: "player" | string; amount: number };
+  onDamage: {
+    entityId: "player" | string;
+    amount: number;
+    prevented?: number;
+    sourceEntityId?: "player" | string;
+  };
+  onEnemyIntent: { enemyId: string; sourceEntityId?: "player" | string };
+  onIntentUpdate: { enemyId: string };
+};
 
-function createTriggers(){
+export function createTriggers(run: IRunContext) {
   const triggers = {
-        onCombatStart: createTrigger("onCombatStart"),
+    onCombatStart: createTrigger("onCombatStart", async (ctx) => {
-        onTurnStart: createTrigger("onTurnStart", async ctx => {
+      await triggers.onShuffle.execute(ctx.game, {});
-            await ctx.game.produceAsync(draft => {
+      await triggers.onDraw.execute(ctx.game, { count: 5 });
-                const entity = ctx.entityKey === "player" ? draft.player : draft.enemies.find(e => e.id === ctx.entityKey);
-                if(entity) onEntityEffectUpkeep(entity);
-                if(entity === draft.player)
-                    onPlayerItemEffectUpkeep(draft.player);
-            })
     }),
-        onTurnEnd: createTrigger("onTurnEnd", async ctx => {
+    onTurnStart: createTrigger("onTurnStart", async (ctx) => {
-            if(ctx.entityKey !== "player")return;
+      await ctx.game.produceAsync((draft) => {
-            const {regions} = ctx.game.value.player.deck;
+        const entity = getCombatEntity(draft, ctx.entityId);
-            for(const cardId of Object.values(regions.hand.childIds)){
+        if (entity) onEntityEffectUpkeep(entity);
-                await triggers.onCardDiscarded.execute(ctx.game,{cardId});
+        if (entity === draft.player) onPlayerItemEffectUpkeep(draft.player);
+      });
+    }),
+    onTurnEnd: createTrigger("onTurnEnd", async (ctx) => {
+      if (ctx.entityId !== "player") return;
+      const { regions } = ctx.game.value.player.deck;
+      for (const cardId of Object.values(regions.hand.childIds)) {
+        await triggers.onCardDiscarded.execute(ctx.game, { cardId });
       }
-            await ctx.game.produceAsync(draft => draft.player.energy = draft.player.maxEnergy);
+      await ctx.game.produceAsync((draft) => {
-            await triggers.onDraw.execute(ctx.game,{count: 5});
+        draft.player.energy = draft.player.maxEnergy;
+      });
+      await triggers.onDraw.execute(ctx.game, { count: 5 });
     }),
-        onShuffle: createTrigger("onShuffle", async ctx => {
+    onShuffle: createTrigger("onShuffle", async (ctx) => {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
-                const {cards, regions} = draft.player.deck;
+        const { cards, regions } = draft.player.deck;
-                for(const cardId of Object.values(regions.discardPile.childIds))
+        for (const cardId of Object.values(regions.discardPile.childIds))
           moveToRegion(cards[cardId], regions.discardPile, regions.drawPile);
         shuffle(regions.drawPile, cards, ctx.game.rng);
       });
     }),
-        onCardPlayed: createTrigger("onCardPlayed", async ctx => {
+    onCardPlayed: createTrigger("onCardPlayed", async (ctx) => {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
-                const {cards, regions} = draft.player.deck;
+        const { cards, regions } = draft.player.deck;
         const card = cards[ctx.cardId];
-                payCardCost(draft.player, card.cardData.costType, card.cardData.costCount, card.itemId, draft.inventory);
+        payCardCost(
+          draft.player,
+          card.cardData.costType,
+          card.cardData.costCount,
+          card.itemId,
+          run,
+        );
         moveToRegion(card, regions.hand, regions.discardPile);
         onItemPlay(draft.player, card.itemId);
       });
+      const { cards, regions } = ctx.game.value.player.deck;
+      const card = cards[ctx.cardId];
+      const source = ctx.sourceEntityId ?? "player";
+      for (const { trigger, target, effects } of card.cardData.effects) {
+        if (trigger !== "onPlay") continue;
+        for (const [effect, stacks] of effects)
+          for (const entity of getEffectTargets(
+            target,
+            ctx.game,
+            ctx.targetId,
+            source,
+          ))
+            await triggers.onEffectApplied.execute(ctx.game, {
+              effect,
+              entityId: entity.id,
+              stacks,
+              cardId: ctx.cardId,
+              sourceEntityId: source,
+              targetId: ctx.targetId,
+            });
+      }
     }),
-        onCardDiscarded: createTrigger("onCardDiscarded", async ctx => {
+    onCardDiscarded: createTrigger("onCardDiscarded", async (ctx) => {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
-                const {cards, regions} = draft.player.deck;
+        const { cards, regions } = draft.player.deck;
         moveToRegion(cards[ctx.cardId], regions.hand, regions.discardPile);
         onItemDiscard(draft.player, cards[ctx.cardId].itemId);
       });
+      const { cards, regions } = ctx.game.value.player.deck;
+      const card = cards[ctx.cardId];
+      const source = ctx.sourceEntityId ?? "player";
+      for (const { trigger, target, effects } of card.cardData.effects) {
+        if (trigger !== "onDiscard") continue;
+        for (const [effect, stacks] of effects)
+          for (const entity of getEffectTargets(
+            target,
+            ctx.game,
+            undefined,
+            source,
+          ))
+            await triggers.onEffectApplied.execute(ctx.game, {
+              effect,
+              entityId: entity.id,
+              stacks,
+              cardId: ctx.cardId,
+              sourceEntityId: source,
+            });
+      }
     }),
-        onCardDrawn: createTrigger("onCardDrawn", async ctx => {
+    onCardDrawn: createTrigger("onCardDrawn", async (ctx) => {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
-                const {cards, regions} = draft.player.deck;
+        const { cards, regions } = draft.player.deck;
         moveToRegion(cards[ctx.cardId], regions.drawPile, regions.hand);
       });
+      const { cards, regions } = ctx.game.value.player.deck;
+      const card = cards[ctx.cardId];
+      const source = ctx.sourceEntityId ?? "player";
+      for (const { trigger, target, effects } of card.cardData.effects) {
+        if (trigger !== "onDraw") continue;
+        for (const [effect, stacks] of effects)
+          for (const entity of getEffectTargets(
+            target,
+            ctx.game,
+            undefined,
+            source,
+          ))
+            await triggers.onEffectApplied.execute(ctx.game, {
+              effect,
+              entityId: entity.id,
+              stacks,
+              cardId: ctx.cardId,
+              sourceEntityId: source,
+            });
+      }
     }),
-        onDraw: createTrigger("onDraw", async ctx => {
+    onDraw: createTrigger("onDraw", async (ctx) => {
       let toDraw = ctx.count;
-            while(toDraw > 0){
+      while (toDraw > 0) {
-                let inDraw = ctx.game.value.player.deck.regions.drawPile.childIds.length;
+        let inDraw =
-                if(inDraw <= 0) await triggers.onShuffle.execute(ctx.game,{});
+          ctx.game.value.player.deck.regions.drawPile.childIds.length;
+        if (inDraw <= 0) await triggers.onShuffle.execute(ctx.game, {});
 
         inDraw = ctx.game.value.player.deck.regions.drawPile.childIds.length;
-                if(inDraw <= 0) break;
+        if (inDraw <= 0) break;
 
         const children = ctx.game.value.player.deck.regions.drawPile.childIds;
         const cardId = children[children.length - 1];
-                await triggers.onCardDrawn.execute(ctx.game,{cardId});
+        await triggers.onCardDrawn.execute(ctx.game, { cardId });
         toDraw--;
       }
     }),
-        onEffectApplied: createTrigger("onEffectApplied", async ctx => {
+    onEffectApplied: createTrigger("onEffectApplied", async (ctx) => {
-            if(ctx.effect.lifecycle === 'instant') return;
+      if (ctx.effect.lifecycle === "instant") return;
 
-            if(ctx.effect.lifecycle.startsWith("item")) {
+      if (ctx.effect.lifecycle.startsWith("item")) {
-                if(ctx.cardId){
+        if (ctx.cardId) {
           const card = ctx.game.value.player.deck.cards[ctx.cardId];
-                    const nearby = getAdjacentItems<GameItemMeta>(ctx.game.value.inventory, card.itemId);
+          const nearby = run.getAdjacentItems(card.itemId);
-                    for(const itemId of nearby.keys()){
+          for (const itemId of nearby) {
-                        await ctx.game.produceAsync(draft => {
+            await ctx.game.produceAsync((draft) => {
               addItemEffect(draft.player, itemId, ctx.effect, ctx.stacks);
             });
           }
@@ -110,120 +202,142 @@ function createTriggers(){
         return;
       }
 
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
-                const entity = ctx.entityKey === "player" ? draft.player : draft.enemies.find(e => e.id === ctx.entityKey);
+        const entity =
-                if(entity) addEntityEffect(entity, ctx.effect, ctx.stacks);
+          ctx.entityId === "player"
-            })
+            ? draft.player
+            : draft.enemies.find((e) => e.id === ctx.entityId);
+        if (entity) addEntityEffect(entity, ctx.effect, ctx.stacks);
+      });
     }),
-        onHpChange: createTrigger("onHpChange", async ctx => {
+    onHpChange: createTrigger("onHpChange", async (ctx) => {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
-                const entity = ctx.entityKey === "player" ? draft.player : draft.enemies.find(e => e.id === ctx.entityKey);
+        const entity =
-                if(!entity) return;
+          ctx.entityId === "player"
+            ? draft.player
+            : draft.enemies.find((e) => e.id === ctx.entityId);
+        if (!entity) return;
         entity.hp += ctx.amount;
         entity.isAlive = entity.hp > 0;
-                draft.result = !draft.player.isAlive ? "defeat" : draft.enemies.every(e => !e.isAlive) ? "victory" : null;
+        draft.result = !draft.player.isAlive
+          ? "defeat"
+          : draft.enemies.every((e) => !e.isAlive)
+            ? "victory"
+            : null;
       });
-            if(ctx.game.value.result) throw ctx.game.value;
+      if (ctx.game.value.result) throw ctx.game.value;
     }),
-        onDamage: createTrigger("onDamage", async ctx => {
+    onDamage: createTrigger("onDamage", async (ctx) => {
-            const entity = ctx.entityKey === "player" ? ctx.game.value.player : ctx.game.value.enemies.find(e => e.id === ctx.entityKey);
+      const entity =
-            if(!entity || !entity.isAlive) return;
+        ctx.entityId === "player"
-            const dealt = Math.min(Math.max(0,entity.hp), ctx.amount - (ctx.prevented || 0));
+          ? ctx.game.value.player
-            await ctx.game.produceAsync(draft => {
+          : ctx.game.value.enemies.find((e) => e.id === ctx.entityId);
+      if (!entity || !entity.isAlive) return;
+      const dealt = Math.min(
+        Math.max(0, entity.hp),
+        ctx.amount - (ctx.prevented || 0),
+      );
+      await ctx.game.produceAsync((draft) => {
         onEntityPostureDamage(entity, dealt);
       });
-            await triggers.onHpChange.execute(ctx.game,{entityKey: ctx.entityKey, amount: -dealt});
+      await triggers.onHpChange.execute(ctx.game, {
+        entityId: ctx.entityId,
+        amount: -dealt,
+      });
     }),
-        onEnemyIntent: createTrigger("onEnemyIntent", async ctx => {
+    onEnemyIntent: createTrigger("onEnemyIntent", async (ctx) => {
-            const enemy = ctx.game.value.enemies.find(e => e.id === ctx.enemyId);
+      const enemy = ctx.game.value.enemies.find((e) => e.id === ctx.enemyId);
-            if(!enemy || !enemy.isAlive) return;
+      if (!enemy || !enemy.isAlive) return;
 
-            const intent = enemy.intents[enemy.currentIntentId];
+      const intent = enemy.currentIntent;
-            if(!intent) return;
+      if (!intent) return;
 
-            for(const [target, effect, stacks] of intent.effects){
+      const source = ctx.sourceEntityId ?? enemy.id;
-                if(target === 'team'){
+      for (const [target, effect, stacks] of intent.effects) {
-                    for(const enemy of getAliveEnemies(ctx.game.value)){
+        for (const entity of getEffectTargets(
+          target,
+          ctx.game,
+          undefined,
+          source,
+        ))
           await triggers.onEffectApplied.execute(ctx.game, {
             effect,
-                            entityKey: enemy.id,
+            entityId: entity.id,
             stacks,
+            sourceEntityId: source,
           });
       }
-                }else {
-                    const entityKey = target === 'self' ? ctx.enemyId : 'player';
-                    await triggers.onEffectApplied.execute(ctx.game, {
-                        effect,
-                        entityKey,
-                        stacks,
-                    });
-                }
-            }
     }),
-        onIntentUpdate: createTrigger("onIntentUpdate", async ctx => {
+    onIntentUpdate: createTrigger("onIntentUpdate", async (ctx) => {
-            await ctx.game.produceAsync(draft => {
+      await ctx.game.produceAsync((draft) => {
-                const enemy = draft.enemies.find(e => e.id === ctx.enemyId);
+        const enemy = draft.enemies.find((e) => e.id === ctx.enemyId);
-                if(!enemy) return;
+        if (!enemy) return;
 
-                const intent = enemy.intents[enemy.currentIntentId];
+        const intent = enemy.currentIntent;
-                if(!intent) return;
+        if (!intent) return;
 
         const nextIntents = intent.nextIntents;
-                if(nextIntents.length > 0){
+        if (nextIntents.length > 0) {
           const nextIndex = ctx.game.rng.nextInt(nextIntents.length);
-                    enemy.currentIntentId = nextIntents[nextIndex];
+          enemy.currentIntent = nextIntents[nextIndex];
         }
       });
     }),
-    }
+  };
   return triggers;
 }
-export type Triggers = ReturnType<typeof createTriggers>
+export type Triggers = ReturnType<typeof createTriggers>;
-export function createStartWith(build: (triggers: Triggers) => void){
+export function createStart(triggers: Triggers, run: IRunContext) {
-    const triggers = createTriggers();
+  return async function (game: CombatGameContext) {
-    build(triggers);
+    await triggers.onCombatStart.execute(game, {});
-    return async function(game: CombatGameContext){
-        await triggers.onCombatStart.execute(game,{});
 
     try {
       while (true) {
-                await triggers.onTurnStart.execute(game, {entityKey: "player"});
+        await triggers.onTurnStart.execute(game, { entityId: "player" });
         while (true) {
-                    const action = await promptMainAction(game);
+          const action = await promptMainAction(game, run);
           if (action.action === "end-turn") break;
           if (action.action === "play") {
             await triggers.onCardPlayed.execute(game, action);
           }
         }
-                await triggers.onTurnEnd.execute(game, {entityKey: "player"});
+        await triggers.onTurnEnd.execute(game, { entityId: "player" });
 
         for (const enemy of getAliveEnemies(game.value)) {
-                    await triggers.onTurnStart.execute(game, {entityKey: enemy.id});
+          await triggers.onTurnStart.execute(game, { entityId: enemy.id });
         }
         for (const enemy of getAliveEnemies(game.value)) {
-                    await triggers.onEnemyIntent.execute(game, {enemyId: enemy.id});
+          await triggers.onEnemyIntent.execute(game, { enemyId: enemy.id });
-                    await triggers.onIntentUpdate.execute(game, {enemyId: enemy.id});
+          await triggers.onIntentUpdate.execute(game, { enemyId: enemy.id });
         }
         for (const enemy of getAliveEnemies(game.value)) {
-                    await triggers.onTurnEnd.execute(game, {entityKey: enemy.id});
+          await triggers.onTurnEnd.execute(game, { entityId: enemy.id });
         }
       }
-        }catch(e){
+    } catch (e) {
-            if(e === game.value) return game.value.result;
+      if (e === game.value) return game.value.result;
       throw e;
     }
-    }
+  };
 }
 
-type TriggerContext<TKey extends keyof TriggerTypes> = TriggerTypes[TKey] & { event: TKey, game: CombatGameContext };
+type TriggerContext<TKey extends keyof TriggerTypes> = TriggerTypes[TKey] & {
-function createTrigger<TKey extends keyof TriggerTypes>(event: TKey, fallback?: (ctx: TriggerContext<TKey>) => Promise<void>) {
+  event: TKey;
-    const {use, execute} = createMiddlewareChain<TriggerContext<TKey>,void>(fallback);
+  game: CombatGameContext;
+};
+function createTrigger<TKey extends keyof TriggerTypes>(
+  event: TKey,
+  fallback?: (ctx: TriggerContext<TKey>) => Promise<void>,
+) {
+  const { use, execute } = createMiddlewareChain<TriggerContext<TKey>, void>(
+    fallback,
+  );
   return {
     use,
     execute: async (game: CombatGameContext, ctx: TriggerTypes[TKey]) => {
-            const param = {...ctx, game, event};
+      const param = { ...ctx, game, event };
       await execute(param);
       return param;
     },
-    }
+  };
 }

src/samples/slay-the-spire-like/system/combat/types.ts

@@ -1,47 +1,68 @@
-import type { PlayerDeck } from "../deck/types";
+import { Part } from "@/core/part";
-import {EnemyData, IntentData} from "@/samples/slay-the-spire-like/system/types";
+import { Region } from "@/core/region";
-import {EffectData} from "@/samples/slay-the-spire-like/system/types";
+import {
-import {GridInventory} from "@/samples/slay-the-spire-like/system/grid-inventory";
+  CardData,
-import {GameItemMeta} from "@/samples/slay-the-spire-like/system/progress";
+  EnemyData,
+  IntentData,
+  ItemData,
+} from "@/samples/slay-the-spire-like/system/types";
+import { EffectData } from "@/samples/slay-the-spire-like/system/types";
 
-export type EffectTable = Record<string, {data: EffectData, stacks: number}>;
+export type EffectTable = Record<string, { data: EffectData; stacks: number }>;
 
 export type CombatEntity = {
+  id: string; // player is just "player"
   effects: EffectTable;
   hp: number;
   maxHp: number;
   isAlive: boolean;
 };
 
-export type PlayerEntity = CombatEntity & {
+export interface IPlayerState {
-    energy: number;
+  hp: number;
-    maxEnergy: number;
+  maxHp: number;
-    deck: PlayerDeck;
   itemEffects: Record<string, EffectTable>;
 }
 
+export interface IPlayerDeck {
+  cards: Record<string, Part<{ cardData: CardData; itemId: string }>>;
+  regions: {
+    hand: Region;
+    discardPile: Region;
+    drawPile: Region;
+    exhaustPile: Region;
+  };
+}
+
+export type PlayerEntity = CombatEntity & {
+  energy: number;
+  maxEnergy: number;
+  deck: IPlayerDeck;
+  itemEffects: Record<string, EffectTable>;
+};
+
 export type EnemyEntity = CombatEntity & {
-    id: string;
   enemy: EnemyData;
   intents: Record<string, IntentData>;
-    currentIntentId: string;
+  currentIntent: IntentData;
 };
 
 export type CombatPhase = "playerTurn" | "enemyTurn" | "combatEnd";
 export type CombatResult = "victory" | "defeat";
 
-export type LootEntry = {
+export type LootEntry =
+  | {
       type: "gold";
       amount: number;
-} | {
+    }
-    type: "item",
+  | {
+      type: "item";
       itemId: string;
-};
+    };
 
 export type CombatState = {
   enemies: EnemyEntity[];
   player: PlayerEntity;
-    inventory: GridInventory<GameItemMeta>;
 
   phase: CombatPhase;
   turnNumber: number;
@@ -50,4 +71,13 @@ export type CombatState = {
   loot: LootEntry[];
 };
 
-export type CombatGameContext = import("@/core/game").IGameContext<CombatState>;
+export interface IRunContext {
+  getItemData(id: string): ItemData | null;
+  getAdjacentItems(id: string): Iterable<string>;
+
+  getConsumedUses(id: string): number;
+  setConsumedUsesAsync(id: string, uses: number): Promise<void>;
+}
+
+export type CombatGameContext =
+  import("@/core/game").IGameContextExport<CombatState>;

src/samples/slay-the-spire-like/system/deck/factory.ts

@@ -1,34 +1,36 @@
-import {moveToRegion } from '@/core/region';
+import { moveToRegion } from "@/core/region";
-import { createRegion } from '@/core/region';
+import { createRegion } from "@/core/region";
-import type { GridInventory } from '../grid-inventory/types';
+import type { CardData } from "../types";
-import type { GameItemMeta } from '../progress/types';
+import type { DeckRegions, GameCard, IInventory, PlayerDeck } from "./types";
-import type { CardData } from '../types';
-import type {DeckRegions, GameCard, PlayerDeck} from './types';
 
 function generateCardId(itemId: string, cellIndex: number): string {
   return `card-${itemId}-${cellIndex}`;
 }
 
-function createCard( itemId: string, cardData: CardData, cellIndex: number): GameCard {
+function createCard(
+  itemId: string,
+  cardData: CardData,
+  cellIndex: number,
+): GameCard {
   return {
     id: generateCardId(itemId, cellIndex),
-        regionId: '',
+    regionId: "",
     position: [],
     itemId,
-        cardData
+    cardData,
   };
 }
 
 function createDeckRegions(): DeckRegions {
   return {
-        drawPile: createRegion('drawPile', []),
+    drawPile: createRegion("drawPile", []),
-        hand: createRegion('hand', []),
+    hand: createRegion("hand", []),
-        discardPile: createRegion('discardPile', []),
+    discardPile: createRegion("discardPile", []),
-        exhaustPile: createRegion('exhaustPile', []),
+    exhaustPile: createRegion("exhaustPile", []),
   };
 }
 
-function generateDeckFromInventory(inventory: GridInventory<GameItemMeta>): PlayerDeck {
+function generateDeckFromInventory(inventory: IInventory): PlayerDeck {
   const cards: Record<string, GameCard> = {};
   const regions = createDeckRegions();
 
@@ -46,7 +48,7 @@ function generateDeckFromInventory(inventory: GridInventory<GameItemMeta>): Play
 
   return {
     cards,
-        regions
+    regions,
   };
 }
 

src/samples/slay-the-spire-like/system/deck/index.ts

@@ -1,7 +1,2 @@
-export type { GameCard, GameCardMeta, PlayerDeck, DeckRegions } from './types';
+export * from "./factory";
-export {
+export * from "./types";
-    generateDeckFromInventory,
-    createCard,
-    createPlayerDeck,
-    generateCardId,
-} from './factory';

src/samples/slay-the-spire-like/system/deck/types.ts

@@ -1,6 +1,7 @@
-import type { Part } from '@/core/part';
+import type { Part } from "@/core/part";
-import {CardData} from "@/samples/slay-the-spire-like/system/types";
+import { CardData, ItemData } from "@/samples/slay-the-spire-like/system/types";
-import {Region} from "@/core/region";
+import { Region } from "@/core/region";
+import { ParsedShape } from "../utils/parse-shape";
 
 /**
  * Metadata for a game card.
@@ -11,6 +12,17 @@ export interface GameCardMeta {
   itemId: string;
 }
 
+export interface IInventory {
+  items: Map<
+    string,
+    {
+      id: string;
+      meta?: { itemData: ItemData };
+      shape: ParsedShape;
+    }
+  >;
+}
+
 /**
  * A card instance in the game.
  * Cards are generated from inventory items or created as status effects.
@@ -27,7 +39,7 @@ export interface PlayerDeck {
   regions: DeckRegions;
 }
 
-export interface DeckRegions{
+export interface DeckRegions {
   /** Card IDs in the draw pile */
   drawPile: Region;
   /** Card IDs in the player's hand */

src/samples/slay-the-spire-like/system/encounter/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./run";

src/samples/slay-the-spire-like/system/encounter/run.ts

@@ -0,0 +1,52 @@
+import { RunState } from "./types";
+
+const DEFAULT_MAX_HP = 50;
+const DEFAULT_GOLD = 50;
+
+export function createRunState(): RunState {
+  return {
+    maxHp: DEFAULT_MAX_HP,
+    currentHp: DEFAULT_MAX_HP,
+    gold: DEFAULT_GOLD,
+    _idCounter: { value: 0 },
+  };
+}
+
+export function damagePlayer(runState: RunState, amount: number): void {
+  runState.currentHp = Math.max(0, runState.currentHp - amount);
+}
+
+export function healPlayer(runState: RunState, amount: number): void {
+  runState.currentHp = Math.min(runState.maxHp, runState.currentHp + amount);
+}
+
+export function setMaxHp(runState: RunState, newMax: number): void {
+  const diff = Math.max(0, newMax - runState.maxHp);
+  runState.maxHp = newMax;
+  runState.currentHp = Math.max(0, Math.min(newMax, runState.currentHp + diff));
+}
+
+/**
+ * Adds gold to the player.
+ */
+export function addGold(runState: RunState, amount: number): void {
+  runState.gold += amount;
+}
+
+/**
+ * Spends gold. Returns false if the player doesn't have enough gold.
+ */
+export function spendGold(
+  runState: RunState,
+  amount: number,
+): { success: true } | { success: false; reason: string } {
+  if (amount <= 0) {
+    return { success: false, reason: "金额必须大于零" };
+  }
+  if (runState.gold < amount) {
+    return { success: false, reason: "金币不足" };
+  }
+
+  runState.gold -= amount;
+  return { success: true };
+}

src/samples/slay-the-spire-like/system/encounter/types.ts

@@ -0,0 +1,42 @@
+import { GridInventory } from "../grid-inventory";
+import { GameItemMeta } from "../grid-inventory/types";
+import { EncounterData } from "../types";
+
+export interface RunState {
+  _idCounter: { value: number };
+
+  currentHp: number;
+  maxHp: number;
+  gold: number;
+}
+
+export type EncounterState =
+  | CombatEncounterState
+  | ShopEncounterState
+  | CurioEncounterState
+  | CampEncounterState
+  | DialogueEncounterState;
+
+export type CombatEncounterState = {
+  data: EncounterData<"minion" | "elite">;
+  blocked: boolean;
+};
+
+export type ShopEncounterState = {
+  data: EncounterData<"shop">;
+  items: GridInventory<GameItemMeta & { sellPrice: number }>;
+};
+
+export type CurioEncounterState = {
+  data: EncounterData<"curio">;
+  items: GridInventory<GameItemMeta>;
+};
+
+export type CampEncounterState = {
+  data: EncounterData<"camp">;
+};
+
+export type DialogueEncounterState = {
+  data: EncounterData<"event">;
+  blocked: boolean;
+};

src/samples/slay-the-spire-like/system/grid-inventory/factory.ts

@@ -0,0 +1,121 @@
+import { parseShapeString } from "../utils/parse-shape";
+import type { ParsedShape } from "../utils/parse-shape";
+import { IDENTITY_TRANSFORM, type Transform2D } from "../utils/shape-collision";
+import { createGridInventory, placeItem, validatePlacement } from "./transform";
+import type { GameItemMeta, GridInventory, MutationResult } from "./types";
+import type { ItemData } from "../types";
+import { ReadonlyRNG, RNG } from "@/utils/rng";
+
+/**
+ * Creates and places a GameItemMeta item into the grid inventory.
+ * Parses the shape from itemData.shape and finds the first valid placement automatically.
+ * **Mutates directly** — call inside a `.produce()` callback.
+ */
+export function createItemIn(
+  inventory: GridInventory<GameItemMeta>,
+  id: string,
+  item: ItemData | GameItemMeta,
+): MutationResult {
+  const itemData = "itemData" in item ? item.itemData : item;
+  const shape = parseShapeString(itemData.shape);
+  const transform = findFirstValidPlacement(inventory, shape);
+  if (!transform) {
+    return { success: false, reason: "无可用位置" };
+  }
+
+  const meta: GameItemMeta = "itemData" in item ? item : { itemData, shape };
+  placeItem(inventory, { id, shape, transform, meta });
+  return { success: true };
+}
+
+/**
+ * Searches for the first valid placement in the grid (row by row, left to right).
+ * Returns the transform or null if no valid placement exists.
+ */
+function findFirstValidPlacement(
+  inventory: GridInventory<GameItemMeta>,
+  shape: ParsedShape,
+): Transform2D | null {
+  for (let y = 0; y <= inventory.height - shape.height; y++) {
+    for (let x = 0; x <= inventory.width - shape.width; x++) {
+      const transform: Transform2D = {
+        offset: { x, y },
+        rotation: 0,
+        flipX: false,
+        flipY: false,
+      };
+      const result = validatePlacement(inventory, shape, transform);
+      if (result.valid) {
+        return transform;
+      }
+    }
+  }
+  return null;
+}
+
+function generateInstanceId(counter: { value: number }): string {
+  counter.value++;
+  return `item-${counter.value}`;
+}
+
+export function createShopInventory(
+  allItems: ItemData[],
+  rng: ReadonlyRNG,
+  counter: { value: number },
+) {
+  const shopItems: GameItemMeta[] = [];
+  const rolledIndices = new Set<number>();
+
+  for (let i = 0; i < 5 && rolledIndices.size < allItems.length; i++) {
+    let index: number;
+    do {
+      index = rng.nextInt(allItems.length);
+    } while (rolledIndices.has(index));
+    rolledIndices.add(index);
+
+    const itemData = allItems[index];
+    const shape = parseShapeString(itemData.shape);
+    const tradePrice = Math.floor(
+      (rng.nextInt(5) + rng.nextInt(5) + 1) * 0.2 * itemData.price,
+    );
+
+    shopItems.push({ itemData, shape, tradePrice });
+  }
+
+  const inventory = createGridInventory<GameItemMeta>(6, 4);
+
+  for (let i = 0; i < shopItems.length; i++) {
+    createItemIn(inventory, generateInstanceId(counter), shopItems[i]);
+  }
+
+  return inventory;
+}
+
+export function createCurioItems(
+  allItems: ItemData[],
+  rng: RNG,
+  counter: { value: number },
+) {
+  const curioItems: GameItemMeta[] = [];
+  const rolledIndices = new Set<number>();
+
+  for (let i = 0; i < 2 && rolledIndices.size < allItems.length; i++) {
+    let index: number;
+    do {
+      index = rng.nextInt(allItems.length);
+    } while (rolledIndices.has(index));
+    rolledIndices.add(index);
+
+    const itemData = allItems[index];
+    const shape = parseShapeString(itemData.shape);
+    curioItems.push({ itemData, shape });
+  }
+
+  const inventory = createGridInventory<GameItemMeta>(4, 3);
+
+  for (let i = 0; i < curioItems.length; i++) {
+    createItemIn(inventory, generateInstanceId(counter), curioItems[i]);
+  }
+
+  return inventory;
+}

src/samples/slay-the-spire-like/system/grid-inventory/index.ts

@@ -1,13 +1,3 @@
-export type { CellCoordinate, CellKey, GridInventory, InventoryItem, MutationResult, PlacementResult } from './types';
+export * from "./types";
-export {
+export * from "./transform";
-    createGridInventory,
+export * from "./factory";
-    flipItem,
-    getAdjacentItems,
-    getItemAtCell,
-    getOccupiedCellSet,
-    moveItem,
-    placeItem,
-    removeItem,
-    rotateItem,
-    validatePlacement,
-} from './transform';

src/samples/slay-the-spire-like/system/grid-inventory/transform.ts

@@ -1,5 +1,6 @@
-import type { ParsedShape } from '../utils/parse-shape';
+import { EffectData } from "../types";
-import type { Transform2D } from '../utils/shape-collision';
+import type { ParsedShape } from "../utils/parse-shape";
+import type { Transform2D } from "../utils/shape-collision";
 import {
   checkBoardCollision,
   checkBounds,
@@ -7,14 +8,24 @@ import {
   flipYTransform,
   rotateTransform,
   transformShape,
-} from '../utils/shape-collision';
+} from "../utils/shape-collision";
-import type { CellKey, GridInventory, InventoryItem, MutationResult, PlacementResult } from './types';
+import type {
+  CellKey,
+  GameItemMeta,
+  GridInventory,
+  InventoryItem,
+  MutationResult,
+  PlacementResult,
+} from "./types";
 
 /**
  * Creates a new empty grid inventory.
  * Note: When used inside `.produce()`, call this before returning the draft.
  */
-export function createGridInventory<TMeta = Record<string, unknown>>(width: number, height: number): GridInventory<TMeta> {
+export function createGridInventory<TMeta = Record<string, unknown>>(
+  width: number,
+  height: number,
+): GridInventory<TMeta> {
   return {
     width,
     height,
@@ -26,9 +37,12 @@ export function createGridInventory<TMeta = Record<string, unknown>>(width: numb
 /**
  * Builds a Set of occupied cell keys from a shape and transform.
  */
-function getShapeCellKeys(shape: ParsedShape, transform: Transform2D): Set<CellKey> {
+function getShapeCellKeys(
+  shape: ParsedShape,
+  transform: Transform2D,
+): Set<CellKey> {
   const cells = transformShape(shape, transform);
-    return new Set(cells.map(c => `${c.x},${c.y}` as CellKey));
+  return new Set(cells.map((c) => `${c.x},${c.y}` as CellKey));
 }
 
 /**
@@ -37,15 +51,15 @@ function getShapeCellKeys(shape: ParsedShape, transform: Transform2D): Set<CellK
  */
 export function validatePlacement<TMeta = Record<string, unknown>>(
   inventory: GridInventory<TMeta>,
-    shape: InventoryItem<TMeta>['shape'],
+  shape: InventoryItem<TMeta>["shape"],
-    transform: Transform2D
+  transform: Transform2D,
 ): PlacementResult {
   if (!checkBounds(shape, transform, inventory.width, inventory.height)) {
-        return { valid: false, reason: '超出边界' };
+    return { valid: false, reason: "超出边界" };
   }
 
   if (checkBoardCollision(shape, transform, inventory.occupiedCells)) {
-        return { valid: false, reason: '与已有物品重叠' };
+    return { valid: false, reason: "与已有物品重叠" };
   }
 
   return { valid: true };
@@ -56,7 +70,10 @@ export function validatePlacement<TMeta = Record<string, unknown>>(
  * **Mutates directly** — call inside a `.produce()` callback.
  * Does not validate; call `validatePlacement` first.
  */
-export function placeItem<TMeta = Record<string, unknown>>(inventory: GridInventory<TMeta>, item: InventoryItem<TMeta>): void {
+export function placeItem<TMeta = Record<string, unknown>>(
+  inventory: GridInventory<TMeta>,
+  item: InventoryItem<TMeta>,
+): void {
   const cells = getShapeCellKeys(item.shape, item.transform);
   for (const cellKey of cells) {
     inventory.occupiedCells.add(cellKey);
@@ -68,7 +85,10 @@ export function placeItem<TMeta = Record<string, unknown>>(inventory: GridInvent
  * Removes an item from the grid by its ID.
  * **Mutates directly** — call inside a `.produce()` callback.
  */
-export function removeItem<TMeta = Record<string, unknown>>(inventory: GridInventory<TMeta>, itemId: string): void {
+export function removeItem<TMeta = Record<string, unknown>>(
+  inventory: GridInventory<TMeta>,
+  itemId: string,
+): void {
   const item = inventory.items.get(itemId);
   if (!item) return;
 
@@ -87,11 +107,11 @@ export function removeItem<TMeta = Record<string, unknown>>(inventory: GridInven
 export function moveItem<TMeta = Record<string, unknown>>(
   inventory: GridInventory<TMeta>,
   itemId: string,
-    newTransform: Transform2D
+  newTransform: Transform2D,
 ): MutationResult {
   const item = inventory.items.get(itemId);
   if (!item) {
-        return { success: false, reason: '物品不存在' };
+    return { success: false, reason: "物品不存在" };
   }
 
   // Temporarily remove item's cells for validation
@@ -130,11 +150,11 @@ export function moveItem<TMeta = Record<string, unknown>>(
 export function rotateItem<TMeta = Record<string, unknown>>(
   inventory: GridInventory<TMeta>,
   itemId: string,
-    degrees: number
+  degrees: number,
 ): MutationResult {
   const item = inventory.items.get(itemId);
   if (!item) {
-        return { success: false, reason: '物品不存在' };
+    return { success: false, reason: "物品不存在" };
   }
 
   const rotatedTransform = rotateTransform(item.transform, degrees);
@@ -149,14 +169,15 @@ export function rotateItem<TMeta = Record<string, unknown>>(
 export function flipItem<TMeta = Record<string, unknown>>(
   inventory: GridInventory<TMeta>,
   itemId: string,
-    axis: 'x' | 'y'
+  axis: "x" | "y",
 ): MutationResult {
   const item = inventory.items.get(itemId);
   if (!item) {
-        return { success: false, reason: '物品不存在' };
+    return { success: false, reason: "物品不存在" };
   }
 
-    const flippedTransform = axis === 'x'
+  const flippedTransform =
+    axis === "x"
       ? flipXTransform(item.transform)
       : flipYTransform(item.transform);
 
@@ -166,7 +187,9 @@ export function flipItem<TMeta = Record<string, unknown>>(
 /**
  * Returns a copy of the occupied cells set.
  */
-export function getOccupiedCellSet<TMeta = Record<string, unknown>>(inventory: GridInventory<TMeta>): Set<CellKey> {
+export function getOccupiedCellSet<TMeta = Record<string, unknown>>(
+  inventory: GridInventory<TMeta>,
+): Set<CellKey> {
   return new Set(inventory.occupiedCells);
 }
 
@@ -176,7 +199,7 @@ export function getOccupiedCellSet<TMeta = Record<string, unknown>>(inventory: G
 export function getItemAtCell<TMeta = Record<string, unknown>>(
   inventory: GridInventory<TMeta>,
   x: number,
-    y: number
+  y: number,
 ): InventoryItem<TMeta> | undefined {
   const cellKey = `${x},${y}` as CellKey;
   if (!inventory.occupiedCells.has(cellKey)) {
@@ -199,7 +222,7 @@ export function getItemAtCell<TMeta = Record<string, unknown>>(
  */
 export function getAdjacentItems<TMeta>(
   inventory: GridInventory<TMeta>,
-    itemId: string
+  itemId: string,
 ): Map<string, InventoryItem<TMeta>> {
   const item = inventory.items.get(itemId);
   if (!item) {
@@ -210,7 +233,7 @@ export function getAdjacentItems<TMeta>(
   const adjacent = new Map<string, InventoryItem<TMeta>>();
 
   for (const cellKey of ownCells) {
-        const [cx, cy] = cellKey.split(',').map(Number);
+    const [cx, cy] = cellKey.split(",").map(Number);
     const neighbors: CellKey[] = [
       `${cx + 1},${cy}` as CellKey,
       `${cx - 1},${cy}` as CellKey,
@@ -219,8 +242,11 @@ export function getAdjacentItems<TMeta>(
     ];
 
     for (const neighborKey of neighbors) {
-            if (inventory.occupiedCells.has(neighborKey) && !ownCells.has(neighborKey)) {
+      if (
-                const [nx, ny] = neighborKey.split(',').map(Number);
+        inventory.occupiedCells.has(neighborKey) &&
+        !ownCells.has(neighborKey)
+      ) {
+        const [nx, ny] = neighborKey.split(",").map(Number);
         const neighborItem = getItemAtCell(inventory, nx, ny);
         if (neighborItem) {
           adjacent.set(neighborItem.id, neighborItem);
@@ -231,3 +257,21 @@ export function getAdjacentItems<TMeta>(
 
   return adjacent;
 }
+
+// export type EffectTable = Record<string, { data: EffectData; stacks: number }>;
+export function getItemEffects(inv: GridInventory<GameItemMeta>) {
+  const effects = {} as Record<
+    string,
+    Record<string, { data: EffectData; stacks: number }>
+  >;
+
+  for (const item of inv.items.values()) {
+    if (!item.meta) continue;
+    const { startEffects } = item.meta;
+    if (!startEffects) continue;
+
+    effects[item.id] = startEffects;
+  }
+
+  return effects;
+}

src/samples/slay-the-spire-like/system/grid-inventory/types.ts

@@ -1,5 +1,6 @@
-import type { ParsedShape } from '../utils/parse-shape';
+import { EffectData, ItemData } from "../types";
-import type { Transform2D } from '../utils/shape-collision';
+import type { ParsedShape } from "../utils/parse-shape";
+import type { Transform2D } from "../utils/shape-collision";
 
 /**
  * String key representing a grid cell in "x,y" format.
@@ -32,12 +33,16 @@ export interface InventoryItem<TMeta> {
 /**
  * Result of a placement validation check.
  */
-export type PlacementResult = { valid: true } | { valid: false; reason: string };
+export type PlacementResult =
+  | { valid: true }
+  | { valid: false; reason: string };
 
 /**
  * Result of a mutation operation (move, rotate, flip).
  */
-export type MutationResult = { success: true } | { success: false; reason: string };
+export type MutationResult =
+  | { success: true }
+  | { success: false; reason: string };
 
 /**
  * Grid inventory state.
@@ -54,3 +59,12 @@ export interface GridInventory<TMeta> {
   /** Set of occupied cells in "x,y" format for O(1) collision lookups */
   occupiedCells: Set<CellKey>;
 }
+
+export interface GameItemMeta {
+  itemData: ItemData;
+  shape: ParsedShape;
+  consumedUses?: number;
+  startEffects?: Record<string, { data: EffectData; stacks: number }>;
+  tradePrice?: number;
+}
+export type GameItem = InventoryItem<GameItemMeta>;

src/samples/slay-the-spire-like/system/map/index.ts

@@ -1,5 +1,3 @@
-export { MapNodeType, MapLayerType } from './types';
+export * from "./generator";
-export type { MapNode, MapLayer, PointCrawlMap, MapGenerationConfig } from './types';
+export * from "./navigation";
-
+export * from "./types";
-export { generatePointCrawlMap } from './generator';
-export { getNode, getChildren, getParents, hasPath, findAllPaths } from './generator';

src/samples/slay-the-spire-like/system/map/navigation.ts

@@ -0,0 +1,65 @@
+import { getNode } from "./generator";
+import { PointCrawlMap, PointCrawlMapNavigator } from "./types";
+
+export function canMoveTo(
+  navigator: PointCrawlMapNavigator,
+  map: PointCrawlMap,
+  targetNodeId: string,
+): boolean {
+  const currentNode = getNode(map, navigator.currentNodeId);
+  if (!currentNode) return false;
+
+  return currentNode.childIds.includes(targetNodeId);
+}
+
+export function moveToNode(
+  navigator: PointCrawlMapNavigator,
+  map: PointCrawlMap,
+  targetNodeId: string,
+): boolean {
+  if (!canMoveTo(navigator, map, targetNodeId)) {
+    return false;
+  }
+
+  const targetNode = getNode(map, targetNodeId);
+  if (!targetNode) {
+    return false;
+  }
+
+  // Update current position
+  navigator.currentNodeId = targetNodeId;
+  navigator.visitedNodes.add(targetNodeId);
+  return true;
+}
+
+export function* getReachableChildren(
+  map: PointCrawlMap,
+  navigator: PointCrawlMapNavigator,
+) {
+  const currentNode = getNode(map, navigator.currentNodeId);
+  if (!currentNode) return;
+
+  for (const id of currentNode.childIds) {
+    const node = getNode(map, id);
+    if (!node) continue;
+    yield node;
+  }
+}
+
+export function isAtStartNode(
+  map: PointCrawlMap,
+  navigator: PointCrawlMapNavigator,
+): boolean {
+  return navigator.currentNodeId === map.layers[0]?.nodes[0]?.id;
+}
+
+/**
+ * Checks if the current encounter is the end node.
+ */
+export function isAtEndNode(
+  map: PointCrawlMap,
+  navigator: PointCrawlMapNavigator,
+): boolean {
+  const endLayer = map.layers[map.layers.length - 1];
+  return endLayer?.nodes[0]?.id === navigator.currentNodeId;
+}

src/samples/slay-the-spire-like/system/map/types.ts

@@ -1,25 +1,25 @@
-import {EncounterData} from "@/samples/slay-the-spire-like/system/types";
+import { EncounterData } from "@/samples/slay-the-spire-like/system/types";
 
 /**
  * Types of nodes that can appear on the point crawl map.
  */
 export enum MapNodeType {
-    Start = 'start',
+  Start = "start",
-    End = 'end',
+  End = "end",
-    Minion = 'minion',
+  Minion = "minion",
-    Elite = 'elite',
+  Elite = "elite",
-    Event = 'event',
+  Event = "event",
-    Camp = 'camp',
+  Camp = "camp",
-    Shop = 'shop',
+  Shop = "shop",
-    Curio = 'curio',
+  Curio = "curio",
 }
 
 /**
  * Semantic type of a layer.
  */
 export enum MapLayerType {
-    Wild = 'wild',
+  Wild = "wild",
-    Settlement = 'settlement',
+  Settlement = "settlement",
 }
 
 /**
@@ -47,7 +47,7 @@ export interface MapLayer {
   /** Ordered IDs of nodes in this layer */
   nodeIds: string[];
   /** Semantic type of the layer */
-    layerType: MapLayerType | 'start' | 'end';
+  layerType: MapLayerType | "start" | "end";
   /** Direct references to nodes in this layer (for performance) */
   nodes: MapNode[];
 }
@@ -64,6 +64,11 @@ export interface PointCrawlMap {
   parentIndex?: Map<string, string[]>;
 }
 
+export interface PointCrawlMapNavigator {
+  currentNodeId: string;
+  visitedNodes: Set<string>;
+}
+
 /**
  * Configuration for map generation.
  */

src/samples/slay-the-spire-like/system/progress/index.ts

@@ -1,313 +0,0 @@
-import { getNode } from '../map/generator';
-import type {MapNode, PointCrawlMap} from '../map/types';
-import { placeItem, validatePlacement, createGridInventory, removeItem as gridRemoveItem } from '../grid-inventory/transform';
-import type { GameItem, GameItemMeta, RunMutationResult, RunState } from './types';
-import type { GridInventory } from '../grid-inventory/types';
-import { IDENTITY_TRANSFORM, type Transform2D } from '../utils/shape-collision';
-import { parseShapeString, type ParsedShape } from '../utils/parse-shape';
-import {ItemData} from "@/samples/slay-the-spire-like/system/types";
-
-// Re-export types
-export type {
-    EncounterResult,
-    EncounterState,
-    GameItem,
-    GameItemMeta,
-    PlayerState,
-    RunMutationResult,
-    RunState,
-} from './types';
-
-// -- Constants --
-
-const INVENTORY_WIDTH = 6;
-const INVENTORY_HEIGHT = 4;
-
-const DEFAULT_MAX_HP = 50;
-const DEFAULT_GOLD = 50;
-
-// -- Run creation --
-
-/**
- * Creates a new run state with a generated map, player stats, and starter inventory.
- *
- */
-export function createRunState(map: PointCrawlMap, starterItems: ItemData[]): RunState {
-    // Find the start node
-    const startNode = map.layers[0].nodes[0];
-
-    // Create empty inventory
-    const inventory = createGridInventory<GameItemMeta>(INVENTORY_WIDTH, INVENTORY_HEIGHT);
-    const idCounter = { value: 0 };
-
-    // Place starter items
-    for (const itemData of starterItems) {
-        const shape = parseShapeString(itemData.shape);
-        const itemInstance = tryPlaceItemInInventory(inventory, itemData, shape, idCounter);
-        if (!itemInstance) {
-            // Inventory too small; item skipped
-        }
-    }
-
-    return {
-        map,
-        player: {
-            maxHp: DEFAULT_MAX_HP,
-            currentHp: DEFAULT_MAX_HP,
-            gold: DEFAULT_GOLD,
-        },
-        inventory,
-        currentNodeId: startNode.id,
-        currentEncounter: {
-            nodeId: startNode.id,
-            resolved: false,
-        },
-        resolvedNodeIds: new Set<string>(),
-        _idCounter: idCounter,
-    };
-}
-
-// -- Movement --
-
-/**
- * Checks whether the player can move to the target node.
- * The target must be a child of the current node.
- */
-export function canMoveTo(runState: RunState, targetNodeId: string): boolean {
-    const currentNode = getNode(runState.map, runState.currentNodeId);
-    if (!currentNode) return false;
-
-    return currentNode.childIds.includes(targetNodeId);
-}
-
-/**
- * Moves the player to the target node.
- * The target must be a direct child of the current node.
- *
- * @returns `{ success: true }` on success, or `{ success: false, reason: string }` on failure.
- */
-export function moveToNode(runState: RunState, targetNodeId: string): RunMutationResult {
-    if (!canMoveTo(runState, targetNodeId)) {
-        return { success: false, reason: '无法移动到该节点' };
-    }
-
-    const targetNode = getNode(runState.map, targetNodeId);
-    if (!targetNode) {
-        return { success: false, reason: '目标节点不存在' };
-    }
-
-    // Update current position
-    runState.currentNodeId = targetNodeId;
-
-    // Create new encounter state for the target node
-    const isResolved = runState.resolvedNodeIds.has(targetNodeId);
-    runState.currentEncounter = {
-        nodeId: targetNodeId,
-        resolved: isResolved,
-    };
-
-    return { success: true };
-}
-
-// -- Encounter management --
-
-/**
- * Marks the current encounter as resolved with optional result data.
- */
-export function resolveEncounter(runState: RunState, result?: { goldEarned?: number; hpLost?: number; hpGained?: number; itemRewards?: string[] }): RunMutationResult {
-    if (runState.currentEncounter.resolved) {
-        return { success: false, reason: '该遭遇已解决' };
-    }
-
-    runState.currentEncounter.resolved = true;
-    runState.currentEncounter.result = result;
-    runState.resolvedNodeIds.add(runState.currentNodeId);
-
-    // Apply result effects
-    if (result) {
-        if (result.goldEarned) {
-            runState.player.gold += result.goldEarned;
-        }
-        if (result.hpLost) {
-            runState.player.currentHp = Math.max(0, runState.player.currentHp - result.hpLost);
-        }
-        if (result.hpGained) {
-            runState.player.currentHp = Math.min(runState.player.maxHp, runState.player.currentHp + result.hpGained);
-        }
-    }
-
-    return { success: true };
-}
-
-/**
- * Checks whether the encounter at the given node has been resolved.
- */
-export function isEncounterResolved(runState: RunState, nodeId: string): boolean {
-    return runState.resolvedNodeIds.has(nodeId);
-}
-
-// -- Player stats --
-
-/**
- * Damages the player. Clamps HP to 0 minimum.
- */
-export function damagePlayer(runState: RunState, amount: number): void {
-    runState.player.currentHp = Math.max(0, runState.player.currentHp - amount);
-}
-
-/**
- * Heals the player. Clamps HP to maxHp.
- */
-export function healPlayer(runState: RunState, amount: number): void {
-    runState.player.currentHp = Math.min(runState.player.maxHp, runState.player.currentHp + amount);
-}
-
-/**
- * Sets the player's maximum HP and adjusts current HP proportionally.
- */
-export function setMaxHp(runState: RunState, newMax: number): void {
-    const diff = newMax - runState.player.maxHp;
-    runState.player.maxHp = newMax;
-    runState.player.currentHp = Math.max(0, Math.min(newMax, runState.player.currentHp + diff));
-}
-
-/**
- * Adds gold to the player.
- */
-export function addGold(runState: RunState, amount: number): void {
-    runState.player.gold += amount;
-}
-
-/**
- * Spends gold. Returns false if the player doesn't have enough gold.
- */
-export function spendGold(runState: RunState, amount: number): RunMutationResult {
-    if (amount <= 0) {
-        return { success: false, reason: '金额必须大于零' };
-    }
-    if (runState.player.gold < amount) {
-        return { success: false, reason: '金币不足' };
-    }
-
-    runState.player.gold -= amount;
-    return { success: true };
-}
-
-// -- Inventory management --
-
-/**
- * Adds an item from CSV data to the inventory.
- * Finds the first available valid position.
- *
- * @returns The placed item instance, or undefined if no valid position exists.
- */
-export function addItem(
-    runState: RunState,
-    itemData: ItemData
-): GameItem | undefined {
-    const shape = parseShapeString(itemData.shape);
-    return tryPlaceItemInInventory(runState.inventory, itemData, shape, runState._idCounter);
-}
-
-/**
- * Removes an item from the inventory by its instance ID.
- */
-export function removeItem(runState: RunState, instanceId: string): void {
-    gridRemoveItem(runState.inventory, instanceId);
-}
-
-// -- Query helpers --
-
-/**
- * Returns the node the player is currently at.
- */
-export function getCurrentNode(runState: RunState): MapNode | undefined {
-    return getNode(runState.map, runState.currentNodeId);
-}
-
-/**
- * Returns all reachable child nodes from the current position.
- */
-export function getReachableChildren(runState: RunState): MapNode[] {
-    const currentNode = getNode(runState.map, runState.currentNodeId);
-    if (!currentNode) return [];
-
-    return currentNode.childIds
-        .map(id => getNode(runState.map, id))
-        .filter((n): n is MapNode => n !== undefined);
-}
-
-/**
- * Returns available children that haven't been resolved yet.
- */
-export function getUnresolvedChildren(runState: RunState): MapNode[] {
-    return getReachableChildren(runState).filter(
-        node => !runState.resolvedNodeIds.has(node.id)
-    );
-}
-
-/**
- * Checks if the current encounter is the start node (no encounter).
- */
-export function isAtStartNode(runState: RunState): boolean {
-    return runState.currentNodeId === runState.map.layers[0]?.nodes[0]?.id;
-}
-
-/**
- * Checks if the current encounter is the end node.
- */
-export function isAtEndNode(runState: RunState): boolean {
-    const endLayer = runState.map.layers[runState.map.layers.length - 1];
-    return endLayer?.nodes[0]?.id === runState.currentNodeId;
-}
-
-// -- Internal helpers --
-
-/**
- * Generates a unique item instance ID.
- */
-function generateInstanceId(counter: { value: number }): string {
-    counter.value++;
-    return `item-${counter.value}`;
-}
-
-/**
- * Tries to place an item in the inventory by scanning all possible positions.
- * Returns the placed item instance, or undefined if no valid position exists.
- */
-function tryPlaceItemInInventory(
-    inventory: GridInventory<GameItemMeta>,
-    itemData: ItemData,
-    shape: ParsedShape,
-    idCounter: { value: number }
-): GameItem | undefined {
-    const instanceId = generateInstanceId(idCounter);
-
-    // Try to find a valid position
-    for (let y = 0; y <= inventory.height - shape.height; y++) {
-        for (let x = 0; x <= inventory.width - shape.width; x++) {
-            const transform = {
-                ...IDENTITY_TRANSFORM,
-                offset: { x, y },
-            };
-
-            const validation = validatePlacement(inventory, shape, transform);
-            if (validation.valid) {
-                const item: GameItem = {
-                    id: instanceId,
-                    shape,
-                    transform,
-                    meta: {
-                        itemData,
-                        shape,
-                    },
-                };
-
-                placeItem(inventory, item);
-                return item;
-            }
-        }
-    }
-
-    return undefined;
-}

src/samples/slay-the-spire-like/system/progress/types.ts

@@ -1,87 +0,0 @@
-import type { PointCrawlMap } from '../map/types';
-import type { GridInventory, InventoryItem } from '../grid-inventory/types';
-import type { ParsedShape } from '../utils/parse-shape';
-import {ItemData} from "@/samples/slay-the-spire-like/system/types";
-
-/**
- * Result of an encounter (combat, event, etc.).
- */
-export interface EncounterResult {
-    /** Gold earned from the encounter */
-    goldEarned?: number;
-    /** HP lost during the encounter */
-    hpLost?: number;
-    /** HP gained (e.g., from camp heal) */
-    hpGained?: number;
-    /** Item IDs rewarded */
-    itemRewards?: string[];
-}
-
-/**
- * Runtime state of an encounter at a specific node.
- */
-export interface EncounterState {
-    /** The node ID where this encounter is located */
-    nodeId: string;
-    /** Whether the encounter has been resolved */
-    resolved: boolean;
-    /** Optional result data after resolution */
-    result?: EncounterResult;
-}
-
-/**
- * Metadata attached to each inventory item instance.
- * Bridges CSV item data with the grid inventory system.
- */
-export interface GameItemMeta {
-    /** Original CSV item data */
-    itemData: ItemData;
-    /** Parsed shape for grid placement */
-    shape: ParsedShape;
-    /** Consumed uses, if card cost type is uses**/
-    depletion?: number;
-}
-
-/**
- * An item instance in the game inventory.
- * Extends InventoryItem with game-specific metadata.
- */
-export type GameItem = InventoryItem<GameItemMeta>;
-
-/**
- * Player runtime state.
- */
-export interface PlayerState {
-    /** Maximum HP */
-    maxHp: number;
-    /** Current HP */
-    currentHp: number;
-    /** Current gold */
-    gold: number;
-}
-
-/**
- * Full run state for a game session.
- * Designed to be used inside `MutableSignal.produce()` callbacks.
- */
-export interface RunState {
-    /** Generated point crawl map */
-    map: PointCrawlMap;
-    /** Player HP and gold */
-    player: PlayerState;
-    /** Grid inventory with placed items */
-    inventory: GridInventory<GameItemMeta>;
-    /** Current node ID where the player is located */
-    currentNodeId: string;
-    /** State of the encounter at the current node */
-    currentEncounter: EncounterState;
-    /** Set of node IDs whose encounters have been resolved */
-    resolvedNodeIds: Set<string>;
-    /** Internal counter for generating unique item instance IDs */
-    _idCounter: { value: number };
-}
-
-/**
- * Result of a mutation operation on the run state.
- */
-export type RunMutationResult = { success: true } | { success: false; reason: string };

src/samples/slay-the-spire-like/system/types.ts

@@ -1,61 +1,25 @@
-export type EffectData = {
+import {
-    readonly id: string;
+  Card,
-    readonly name: string;
+  Effect,
-    readonly description: string;
+  Encounter,
-    readonly lifecycle: EffectLifecycle;
+  EncounterType,
-};
+  Enemy,
-export type EffectLifecycle = "instant" | "temporary" | "lingering" | "permanent" | "posture" | "item" | "itemTemporary" | "itemUntilPlay" | "itemUntilDiscard" | "itemPermanent";
+  Intent,
+  Item,
+} from "../data/desert";
 
-export type EnemyData = {
+export type CardData = Card;
-    readonly id: string;
+export type ItemData = Item;
-    readonly name: string;
+export type EffectData = Effect;
-    readonly description: string;
+export type IntentData = Intent;
-};
+export type EnemyData = Enemy;
+export type EncounterData<T extends EncounterType = EncounterType> =
+  Encounter & { type: T };
 
-export type CardType = "item" | "status";
+export {
-export type CardCostType = "energy" | "uses" | "none";
+  CardTargetType,
-export type CardTargetType = "single" | "none";
+  CardEffectTarget,
-export type EffectTarget = "self" | "player" | "team";
+  IntentEffectTarget,
+} from "../data/desert";
 
-export type CardData = {
+export { ContentModule } from "../data";
-    readonly id: string;
-    readonly name: string;
-    readonly desc: string;
-    readonly type: CardType;
-    readonly costType: CardCostType;
-    readonly costCount: number;
-    readonly targetType: CardTargetType;
-    readonly effects: readonly [CardEffectTrigger, CardEffectTarget, EffectData, number][];
-};
-export type CardEffectTrigger = "onPlay" | "onDraw" | "onDiscard";
-export type CardEffectTarget = "self" | "target" | "all" | "random"
-
-export type EncounterType = "minion" | "elite" | "event" | "shop" | "camp" | "curio";
-export type EncounterData = {
-    readonly id: string;
-    readonly type: EncounterType;
-    readonly name: string;
-    readonly description: string;
-    readonly enemies: readonly [EnemyData, number, readonly [effect: EffectData, stacks: number]];
-    readonly dialogue: string;
-};
-
-export type IntentData = {
-    readonly enemy: EnemyData;
-    readonly intentId: string;
-    readonly initialIntent: boolean;
-    readonly nextIntents: readonly string[];
-    readonly brokenIntent: readonly string[];
-    readonly initBuffs: readonly [EffectData, stacks: number];
-    readonly effects: readonly [EffectTarget, EffectData, number][];
-};
-
-export type ItemData = {
-    readonly id: string;
-    readonly type: string;
-    readonly name: string;
-    readonly shape: string;
-    readonly card: CardData;
-    readonly price: number;
-    readonly description: string;
-};

src/samples/slay-the-spire-like/system/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./parse-shape";
+export * from "./shape-collision";

src/samples/slay-the-spire-like/system/utils/shape-collision.ts

@@ -1,4 +1,4 @@
-import type { ParsedShape } from './parse-shape';
+import type { ParsedShape } from "./parse-shape";
 
 /**
  * Represents a 2D point in grid coordinates.
@@ -54,7 +54,7 @@ export function transformPoint(
   point: Point2D,
   transform: Transform2D,
   shapeWidth: number,
-    shapeHeight: number
+  shapeHeight: number,
 ): Point2D {
   let { x, y } = point;
 
@@ -96,10 +96,13 @@ export function transformPoint(
 /**
  * Transforms a shape and returnss its occupied cells in world coordinates.
  */
-export function transformShape(shape: ParsedShape, transform: Transform2D): Point2D[] {
+export function transformShape(
+  shape: ParsedShape,
+  transform: Transform2D,
+): Point2D[] {
   const cells = getOccupiedCells(shape);
-    return cells.map(cell =>
+  return cells.map((cell) =>
-        transformPoint(cell, transform, shape.width, shape.height)
+    transformPoint(cell, transform, shape.width, shape.height),
   );
 }
 
@@ -110,12 +113,12 @@ export function checkCollision(
   shapeA: ParsedShape,
   transformA: Transform2D,
   shapeB: ParsedShape,
-    transformB: Transform2D
+  transformB: Transform2D,
 ): boolean {
   const cellsA = transformShape(shapeA, transformA);
   const cellsB = transformShape(shapeB, transformB);
 
-    const setA = new Set(cellsA.map(c => `${c.x},${c.y}`));
+  const setA = new Set(cellsA.map((c) => `${c.x},${c.y}`));
 
   for (const cell of cellsB) {
     if (setA.has(`${cell.x},${cell.y}`)) {
@@ -135,7 +138,7 @@ export function checkCollision(
 export function checkBoardCollision(
   shape: ParsedShape,
   transform: Transform2D,
-    occupiedCells: Set<string>
+  occupiedCells: Set<string>,
 ): boolean {
   const cells = transformShape(shape, transform);
 
@@ -159,12 +162,17 @@ export function checkBounds(
   shape: ParsedShape,
   transform: Transform2D,
   boardWidth: number,
-    boardHeight: number
+  boardHeight: number,
 ): boolean {
   const cells = transformShape(shape, transform);
 
   for (const cell of cells) {
-        if (cell.x < 0 || cell.x >= boardWidth || cell.y < 0 || cell.y >= boardHeight) {
+    if (
+      cell.x < 0 ||
+      cell.x >= boardWidth ||
+      cell.y < 0 ||
+      cell.y >= boardHeight
+    ) {
       return false;
     }
   }
@@ -176,19 +184,19 @@ export function checkBounds(
  * Validates that a placement is both in bounds and collision-free.
  * @returns Object with `valid` flag and optional `reason` string
  */
-export function validatePlacement(
+export function validateShapePlacement(
   shape: ParsedShape,
   transform: Transform2D,
   boardWidth: number,
   boardHeight: number,
-    occupiedCells: Set<string>
+  occupiedCells: Set<string>,
 ): { valid: true } | { valid: false; reason: string } {
   if (!checkBounds(shape, transform, boardWidth, boardHeight)) {
-        return { valid: false, reason: '超出边界' };
+    return { valid: false, reason: "超出边界" };
   }
 
   if (checkBoardCollision(shape, transform, occupiedCells)) {
-        return { valid: false, reason: '与已有形状重叠' };
+    return { valid: false, reason: "与已有形状重叠" };
   }
 
   return { valid: true };
@@ -199,10 +207,13 @@ export function validatePlacement(
  * @param current The current transform
  * @param degrees Degrees to rotate (typically 90, 180, or 270)
  */
-export function rotateTransform(current: Transform2D, degrees: number): Transform2D {
+export function rotateTransform(
+  current: Transform2D,
+  degrees: number,
+): Transform2D {
   return {
     ...current,
-        rotation: ((current.rotation + degrees) % 360 + 360) % 360,
+    rotation: (((current.rotation + degrees) % 360) + 360) % 360,
   };
 }
 

src/samples/tic-tac-toe.ts

@@ -1,43 +1,77 @@
-import {Part} from "boardgame-core";
+import { Part } from "@/core/part";
-import {createRegion} from "boardgame-core";
+import { createRegion, Region } from "@/core/region";
-import {createGameCommandRegistry, createPromptDef, IGameContext} from "boardgame-core";
+import { createPromptDef, IGameContext } from "@/core/game";
+import { BaseGameClient } from "@/core/game-client";
+import { createMiddlewareChain } from "@/utils/middleware";
 
 const BOARD_SIZE = 3;
 const MAX_TURNS = BOARD_SIZE * BOARD_SIZE;
 const WINNING_LINES: number[][][] = [
-    [[0, 0], [0, 1], [0, 2]],
+  [
-    [[1, 0], [1, 1], [1, 2]],
+    [0, 0],
-    [[2, 0], [2, 1], [2, 2]],
+    [0, 1],
-    [[0, 0], [1, 0], [2, 0]],
+    [0, 2],
-    [[0, 1], [1, 1], [2, 1]],
+  ],
-    [[0, 2], [1, 2], [2, 2]],
+  [
-    [[0, 0], [1, 1], [2, 2]],
+    [1, 0],
-    [[0, 2], [1, 1], [2, 0]],
+    [1, 1],
+    [1, 2],
+  ],
+  [
+    [2, 0],
+    [2, 1],
+    [2, 2],
+  ],
+  [
+    [0, 0],
+    [1, 0],
+    [2, 0],
+  ],
+  [
+    [0, 1],
+    [1, 1],
+    [2, 1],
+  ],
+  [
+    [0, 2],
+    [1, 2],
+    [2, 2],
+  ],
+  [
+    [0, 0],
+    [1, 1],
+    [2, 2],
+  ],
+  [
+    [0, 2],
+    [1, 1],
+    [2, 0],
+  ],
 ];
 
-export type PlayerType = 'X' | 'O';
+export type PlayerType = "X" | "O";
-export type WinnerType = PlayerType | 'draw' | null;
+export type WinnerType = PlayerType | "draw" | null;
 export type TicTacToePart = Part<{ player: PlayerType }>;
 
 export function createInitialState() {
   return {
-        board: createRegion('board', [
+    board: createRegion("board", [
-            { name: 'x', min: 0, max: BOARD_SIZE - 1 },
+      { name: "x", min: 0, max: BOARD_SIZE - 1 },
-            { name: 'y', min: 0, max: BOARD_SIZE - 1 },
+      { name: "y", min: 0, max: BOARD_SIZE - 1 },
     ]),
     parts: {} as Record<string, TicTacToePart>,
-        currentPlayer: 'X' as PlayerType,
+    currentPlayer: "X" as PlayerType,
     winner: null as WinnerType,
     turn: 0,
   };
 }
 export type TicTacToeState = ReturnType<typeof createInitialState>;
 export type TicTacToeGame = IGameContext<TicTacToeState>;
-export const registry = createGameCommandRegistry<TicTacToeState>();
 export const prompts = {
   play: createPromptDef<[PlayerType, number, number]>(
-        'play <player> <row:number> <col:number>')
+    "play <player> <row:number> <col:number>",
-}
+  ),
+};
 
 export async function start(game: TicTacToeGame) {
   while (true) {
@@ -45,10 +79,10 @@ export async function start(game: TicTacToeGame) {
     const turnNumber = game.value.turn + 1;
     const turnOutput = await turn(game, currentPlayer, turnNumber);
 
-        game.produce(state => {
+    await game.produceAsync((state) => {
       state.winner = turnOutput.winner;
       if (!state.winner) {
-                state.currentPlayer = state.currentPlayer === 'X' ? 'O' : 'X';
+        state.currentPlayer = state.currentPlayer === "X" ? "O" : "X";
         state.turn = turnNumber;
       }
     });
@@ -58,10 +92,12 @@ export async function start(game: TicTacToeGame) {
   return game.value;
 }
 
-const turn = registry.register({
+async function turn(
-    schema: 'turn <player> <turnNumber:number>',
+  game: TicTacToeGame,
-    async run(game: TicTacToeGame, turnPlayer: PlayerType, turnNumber: number) {
+  turnPlayer: PlayerType,
-        const {player, row, col} = await game.prompt(
+  turnNumber: number,
+) {
+  const { player, row, col } = await game.prompt(
     prompts.play,
     (player, row, col) => {
       if (player !== turnPlayer) {
@@ -74,32 +110,40 @@ const turn = registry.register({
         return { player, row, col };
       }
     },
-            game.value.currentPlayer
+    game.value.currentPlayer,
   );
 
-        placePiece(game, row, col, turnPlayer);
+  await placePiece(game, row, col, turnPlayer);
 
   const winner = checkWinner(game);
   if (winner) return { winner };
-        if (turnNumber >= MAX_TURNS) return { winner: 'draw' as WinnerType };
+  if (turnNumber >= MAX_TURNS) return { winner: "draw" as WinnerType };
 
   return { winner: null };
-    }
-});
-
-function isValidMove(row: number, col: number): boolean {
-    return !isNaN(row) && !isNaN(col) && row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE;
 }
 
-export function isCellOccupied(host: TicTacToeGame, row: number, col: number): boolean {
+function isValidMove(row: number, col: number): boolean {
+  return (
+    !isNaN(row) &&
+    !isNaN(col) &&
+    row >= 0 &&
+    row < BOARD_SIZE &&
+    col >= 0 &&
+    col < BOARD_SIZE
+  );
+}
+
+export function isCellOccupied(
+  host: TicTacToeGame,
+  row: number,
+  col: number,
+): boolean {
   return !!host.value.board.partMap[`${row},${col}`];
 }
 
 export function hasWinningLine(positions: number[][]): boolean {
-    return WINNING_LINES.some(line =>
+  return WINNING_LINES.some((line) =>
-        line.every(([r, c]) =>
+    line.every(([r, c]) => positions.some(([pr, pc]) => pr === r && pc === c)),
-            positions.some(([pr, pc]) => pr === r && pc === c)
-        )
   );
 }
 
@@ -107,26 +151,80 @@ export function checkWinner(host: TicTacToeGame): WinnerType {
   const parts = host.value.parts;
   const partsArray = Object.values(parts);
 
-    const xPositions = partsArray.filter((p: TicTacToePart) => p.player === 'X').map((p: TicTacToePart) => p.position);
+  const xPositions = partsArray
-    const oPositions = partsArray.filter((p: TicTacToePart) => p.player === 'O').map((p: TicTacToePart) => p.position);
+    .filter((p: TicTacToePart) => p.player === "X")
+    .map((p: TicTacToePart) => p.position);
+  const oPositions = partsArray
+    .filter((p: TicTacToePart) => p.player === "O")
+    .map((p: TicTacToePart) => p.position);
 
-    if (hasWinningLine(xPositions)) return 'X';
+  if (hasWinningLine(xPositions)) return "X";
-    if (hasWinningLine(oPositions)) return 'O';
+  if (hasWinningLine(oPositions)) return "O";
-    if (partsArray.length >= MAX_TURNS) return 'draw';
+  if (partsArray.length >= MAX_TURNS) return "draw";
 
   return null;
 }
 
-export function placePiece(host: TicTacToeGame, row: number, col: number, player: PlayerType) {
+export async function placePiece(
+  host: TicTacToeGame,
+  row: number,
+  col: number,
+  player: PlayerType,
+) {
   const board = host.value.board;
   const moveNumber = Object.keys(host.value.parts).length + 1;
   const piece: TicTacToePart = {
-        regionId: 'board', position: [row, col], player,
+    regionId: "board",
-        id: `piece-${player}-${moveNumber}`
+    position: [row, col],
-    }
+    player,
-    host.produce(state => {
+    id: `piece-${player}-${moveNumber}`,
+  };
+  await host.produceAsync((state) => {
     state.parts[piece.id] = piece;
     board.childIds.push(piece.id);
     board.partMap[`${row},${col}`] = piece.id;
   });
 }
+
+export class Client extends BaseGameClient<TicTacToeState> {
+  private onTurn = createMiddlewareChain(
+    async (ctx: { player: PlayerType; turn: number }) => {
+      return await turn(this._context, ctx.player, ctx.turn);
+    },
+  );
+
+  constructor() {
+    super(createInitialState());
+  }
+
+  async start(game: IGameContext<TicTacToeState>): Promise<TicTacToeState> {
+    while (true) {
+      const currentPlayer = game.value.currentPlayer;
+      const turnNumber = game.value.turn + 1;
+      const turnOutput = await this.onTurn.execute({
+        player: currentPlayer,
+        turn: turnNumber,
+      });
+
+      await game.produceAsync((state) => {
+        state.winner = turnOutput.winner;
+        if (!state.winner) {
+          state.currentPlayer = state.currentPlayer === "X" ? "O" : "X";
+          state.turn = turnNumber;
+        }
+      });
+      if (game.value.winner) break;
+    }
+
+    return game.value;
+  }
+  selectPart(id: string, callback: (t: TicTacToePart) => void): () => void {
+    return this.assignSelector((state) => state.parts[id], callback);
+  }
+  selectTurn(callback: (turns: number) => void): () => void {
+    return this.assignSelector((s) => s.turn, callback);
+  }
+  selectCurrentPlayer(callback: (player: PlayerType) => void) {
+    return this.assignSelector((s) => s.currentPlayer, callback);
+  }
+}

src/utils/command/command-prompt.ts

@@ -0,0 +1,105 @@
+import { createMiddlewareChain } from "../middleware";
+import { PromptValidator } from "./command-runner";
+import { CommandSchema } from "./types";
+
+export interface PromptDef<TArgs extends any[]> {
+  schema: CommandSchema;
+  hintText?: string;
+}
+
+export interface PromptCall<TArgs extends any[] = unknown[], TRes = unknown> {
+  def: PromptDef<TArgs>;
+  player?: string;
+  validator: PromptValidator<TRes, TArgs>;
+
+  resolve(res: TRes): void;
+  reject(reason: string): void;
+  promise: Promise<TRes>;
+}
+
+export type PromptTryResult =
+  | {
+      ok: false;
+      reason: string;
+    }
+  | {
+      ok: true;
+    };
+
+export type PromptContext = ReturnType<typeof createPromptContext>;
+export function createPromptContext() {
+  const map = new Map<string, PromptCall>();
+  const handleCall = createMiddlewareChain(async (call: PromptCall) => {
+    const key = call.player ?? "global";
+    const existing = map.get(key);
+    if (existing) {
+      existing.reject("Prompt overriden");
+    }
+
+    map.set(key, call);
+    try {
+      return await call.promise;
+    } finally {
+      if (map.get(key) === call) map.delete(key);
+    }
+  });
+
+  function tryCommit<TArgs extends any[]>(
+    def: PromptDef<TArgs>,
+    player: string,
+    ...args: TArgs
+  ): PromptTryResult {
+    const call = map.get(player);
+    if (!call) return { ok: false, reason: "No Prompt" };
+
+    try {
+      const res = call.validator(...args);
+      call.resolve(res);
+      return { ok: true };
+    } catch (reason) {
+      if (typeof reason === "string") return { ok: false, reason };
+      throw reason;
+    }
+  }
+
+  function cancel(player: string, reason = "Prompt Cancelled") {
+    map.get(player)?.reject(reason);
+  }
+
+  async function prompt<TArgs extends any[], TRes>(
+    def: PromptDef<TArgs>,
+    validator: PromptValidator<TRes, TArgs>,
+    player?: string,
+  ) {
+    let resolve: (res: TRes) => void;
+    let reject: (reason: string) => void;
+    const promise = new Promise<TRes>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const call = {
+      def,
+      player,
+      validator,
+      resolve: resolve!,
+      reject: reject!,
+      promise,
+    } as PromptCall<unknown[], unknown>;
+    return (await handleCall.execute(call)) as TRes;
+  }
+
+  function reset() {
+    for (const call of map.values()) {
+      call.reject("Prompt Reset");
+    }
+    map.clear();
+  }
+
+  return {
+    prompt,
+    tryCommit,
+    cancel,
+    handleCall,
+    reset,
+  };
+}

src/utils/command/index.ts

@@ -1,6 +1,10 @@
-export { parseCommand } from './command-parse';
+export { parseCommand } from "./command-parse";
-export { parseCommandSchema } from './schema-parse';
+export { parseCommandSchema } from "./schema-parse";
-export { validateCommand, parseCommandWithSchema, applyCommandSchema } from './command-validate';
+export {
+  validateCommand,
+  parseCommandWithSchema,
+  applyCommandSchema,
+} from "./command-validate";
 export {
   createCommandRegistry,
   registerCommand,
@@ -10,13 +14,28 @@ export {
   runCommand,
   runCommandParsed,
   createCommandRunnerContext,
-} from './command-registry';
+} from "./command-registry";
 export type {
   Command,
   CommandParamSchema,
   CommandOptionSchema,
   CommandFlagSchema,
   CommandSchema,
-} from './types';
+} from "./types";
-export type { CommandRunner, CommandDef, CommandResult, CommandRunnerHandler, CommandRunnerContext, PromptEvent, CommandRunnerEvents } from './command-runner';
+export type {
-export type { CommandRegistry, CommandRunnerContextExport } from './command-registry';
+  CommandRunner,
+  CommandDef,
+  CommandResult,
+  CommandRunnerHandler,
+  CommandRunnerContext,
+  PromptEvent,
+  CommandRunnerEvents,
+} from "./command-runner";
+export type {
+  CommandRegistry,
+  CommandRunnerContextExport,
+} from "./command-registry";
+
+export type { PromptDef, PromptTryResult, PromptCall } from "./command-prompt";
+
+export { createPromptContext } from "./command-prompt";

src/utils/middleware.ts

@@ -1,28 +1,38 @@
 type Middleware<TContext, TReturn> = (
   context: TContext,
-  next: () => Promise<TReturn>
+  next: () => Promise<TReturn>,
 ) => Promise<TReturn>;
 
 export type MiddlewareChain<TContext, TReturn> = {
-  use: (middleware: Middleware<TContext, TReturn>) => void;
+  use: (middleware: Middleware<TContext, TReturn>) => () => void;
   execute: (context: TContext) => Promise<TReturn>;
 };
 
-export function createMiddlewareChain<TContext extends object, TReturn=TContext>(
+export function createMiddlewareChain<
-  fallback?: (context: TContext) => Promise<TReturn>
+  TContext extends object,
+  TReturn = TContext,
+>(
+  fallback?: (context: TContext) => Promise<TReturn>,
 ): MiddlewareChain<TContext, TReturn> {
   const middlewares: Middleware<TContext, TReturn>[] = [];
 
   return {
     use(middleware: Middleware<TContext, TReturn>) {
       middlewares.push(middleware);
+
+      return function () {
+        const index = middlewares.indexOf(middleware);
+        if (index !== -1) {
+          middlewares.splice(index, 1);
+        }
+      };
     },
     async execute(context: TContext) {
       let index = 0;
 
       async function dispatch(ctx: TContext): Promise<TReturn> {
         if (index >= middlewares.length) {
-          return fallback ? fallback(ctx) : ctx as unknown as TReturn;
+          return fallback ? fallback(ctx) : (ctx as unknown as TReturn);
         }
         const current = middlewares[index++];
         return current(ctx, () => dispatch(ctx));

src/utils/mutable-signal.ts

@@ -1,13 +1,20 @@
-import {Signal, SignalOptions} from '@preact/signals-core';
+import { Signal, SignalOptions } from "@preact/signals-core";
-import {create} from 'mutative';
+import { create } from "mutative";
 
-export class MutableSignal<T> extends Signal<T> {
+export interface MutableSignal<T> extends Signal<T> {
+  produce(fn: (draft: T) => undefined): void;
+  addInterruption(promise: Promise<void>): void;
+  clearInterruptions(): void;
+  produceAsync(fn: (draft: T) => undefined): Promise<void>;
+}
+
+class MutableSignalImpl<T> extends Signal<T> {
   private _interruptions: Promise<void>[] = [];
 
   public constructor(t?: T, options?: SignalOptions<T>) {
     super(t, options);
   }
-  produce(fn: (draft: T) => void) {
+  produce(fn: (draft: T) => undefined) {
     this.value = create(this.value, fn);
   }
 
@@ -30,13 +37,16 @@ export class MutableSignal<T> extends Signal<T> {
    * 异步版本的 produce。会先等待所有通过 `addInterruption` 添加的 Promise 完成，
    * 然后再更新状态。适用于需要在状态更新前播放动画的场景。
    */
-  async produceAsync(fn: (draft: T) => void): Promise<void> {
+  async produceAsync(fn: (draft: T) => undefined): Promise<void> {
     await Promise.allSettled(this._interruptions);
     this._interruptions = [];
     this.produce(fn);
   }
 }
 
-export function mutableSignal<T>(initial?: T, options?: SignalOptions<T>): MutableSignal<T> {
+export function mutableSignal<T>(
-  return new MutableSignal<T>(initial, options);
+  initial?: T,
+  options?: SignalOptions<T>,
+): MutableSignal<T> {
+  return new MutableSignalImpl<T>(initial, options);
 }

src/utils/spawner.ts

@@ -0,0 +1,39 @@
+import { effect } from "@preact/signals-core";
+
+export type SpawnerFunction = (id: string) => () => void;
+
+export function createSpawner(spawner: SpawnerFunction) {
+  const entries = new Map<string, () => void>();
+
+  function update(set: Set<string>) {
+    for (const key of set) {
+      if (!entries.has(key)) {
+        entries.set(key, spawner(key));
+      }
+    }
+
+    for (const [key, entry] of entries) {
+      if (!set.has(key)) {
+        entry();
+        entries.delete(key);
+      }
+    }
+  }
+
+  return update;
+}
+
+export function spawnerEffect(
+  iterable: () => Iterable<string>,
+  spawner: SpawnerFunction,
+) {
+  const update = createSpawner(spawner);
+
+  return effect(() => {
+    const set = new Set<string>();
+    for (const each of iterable()) {
+      set.add(each);
+    }
+    update(set);
+  });
+}

tests/core/game-host.test.ts

@@ -1,95 +1,84 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
 import {
   registry,
   createInitialState,
   start,
   TicTacToeState,
-    WinnerType,
+} from "@/samples/tic-tac-toe";
-    PlayerType
+import { createGameHost, GameHost } from "@/core/game-host";
-} from '@/samples/tic-tac-toe';
+import type { PromptEvent } from "@/utils/command";
-import { createGameHost, GameHost } from '@/core/game-host';
-import type { PromptEvent } from '@/utils/command';
-import { MutableSignal } from '@/utils/mutable-signal';
-import {IGameContext} from "../../src";
-
-type TestGameHost = GameHost<TicTacToeState> & {
-    _context: IGameContext<TicTacToeState>;
-    context: IGameContext<TicTacToeState>;
-}
 
 function createTestHost() {
-    const host: TestGameHost = createGameHost(
+  const host = createGameHost({ registry, createInitialState, start });
-        { registry, createInitialState, start }
-    );
-    host.context = host._context;
   return { host };
 }
 
 function waitForPromptEvent(host: GameHost<any>): Promise<PromptEvent> {
-    return new Promise(resolve => {
+  return new Promise((resolve) => {
-        host.context._commands.on('prompt', resolve);
+    // @ts-ignore - accessing private _context for testing
+    host._context._commands.on("prompt", resolve);
   });
 }
 
-describe('GameHost', () => {
+describe("GameHost", () => {
-    describe('creation', () => {
+  describe("creation", () => {
-        it('should create host with initial state', () => {
+    it("should create host with initial state", () => {
       const { host } = createTestHost();
 
-            expect(host.context._state.value.currentPlayer).toBe('X');
+      expect(host.state.value.currentPlayer).toBe("X");
-            expect(host.context._state.value.winner).toBeNull();
+      expect(host.state.value.winner).toBeNull();
-            expect(host.context._state.value.turn).toBe(0);
+      expect(host.state.value.turn).toBe(0);
-            expect(Object.keys(host.context._state.value.parts).length).toBe(0);
+      expect(Object.keys(host.state.value.parts).length).toBe(0);
     });
 
     it('should have status "created" by default', () => {
       const { host } = createTestHost();
 
-            expect(host.status.value).toBe('created');
+      expect(host.status.value).toBe("created");
     });
 
-        it('should have null activePromptSchema initially', () => {
+    it("should have null activePromptSchema initially", () => {
       const { host } = createTestHost();
 
       expect(host.activePromptSchema.value).toBeNull();
     });
   });
 
-    describe('tryInput', () => {
+  describe("tryInput", () => {
     it('should return "No active prompt" when no prompt is active', () => {
       const { host } = createTestHost();
 
-            const result = host.tryInput('play X 1 1');
+      const result = host.tryInput("play X 1 1");
-            expect(result).toBe('No active prompt');
+      expect(result).toBe("No active prompt");
     });
 
-        it('should accept valid input when prompt is active', async () => {
+    it("should accept valid input when prompt is active", async () => {
       const { host } = createTestHost();
 
       const promptPromise = waitForPromptEvent(host);
       const runPromise = host.start();
 
       const promptEvent = await promptPromise;
-            expect(promptEvent.schema.name).toBe('play');
+      expect(promptEvent.schema.name).toBe("play");
-            expect(host.activePromptSchema.value?.name).toBe('play');
+      expect(host.activePromptSchema.value?.name).toBe("play");
 
-            const error = host.tryInput('play X 1 1');
+      const error = host.tryInput("play X 1 1");
       expect(error).toBeNull();
 
       // Cancel to end the game since start runs until game over
       const nextPromptPromise = waitForPromptEvent(host);
       const nextPrompt = await nextPromptPromise;
-            nextPrompt.cancel('test cleanup');
+      nextPrompt.cancel("test cleanup");
 
       try {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toBe('test cleanup');
+        expect(error.message).toBe("test cleanup");
       }
     });
 
-        it('should reject invalid input', async () => {
+    it("should reject invalid input", async () => {
       const { host } = createTestHost();
 
       const promptPromise = waitForPromptEvent(host);
@@ -97,29 +86,29 @@ describe('GameHost', () => {
 
       const promptEvent = await promptPromise;
 
-            const error = host.tryInput('invalid command');
+      const error = host.tryInput("invalid command");
       expect(error).not.toBeNull();
 
-            promptEvent.cancel('test cleanup');
+      promptEvent.cancel("test cleanup");
       try {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toBe('test cleanup');
+        expect(error.message).toBe("test cleanup");
       }
     });
 
-        it('should return error when disposed', () => {
+    it("should return error when disposed", () => {
       const { host } = createTestHost();
       host.dispose();
 
-            const result = host.tryInput('play X 1 1');
+      const result = host.tryInput("play X 1 1");
-            expect(result).toBe('GameHost is disposed');
+      expect(result).toBe("GameHost is disposed");
     });
   });
 
-    describe('getActivePromptSchema', () => {
+  describe("getActivePromptSchema", () => {
-        it('should return schema when prompt is active', async () => {
+    it("should return schema when prompt is active", async () => {
       const { host } = createTestHost();
 
       const promptPromise = waitForPromptEvent(host);
@@ -129,26 +118,26 @@ describe('GameHost', () => {
       const schema = host.activePromptSchema.value;
 
       expect(schema).not.toBeNull();
-            expect(schema?.name).toBe('play');
+      expect(schema?.name).toBe("play");
 
-            promptEvent.cancel('test cleanup');
+      promptEvent.cancel("test cleanup");
       try {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toBe('test cleanup');
+        expect(error.message).toBe("test cleanup");
       }
     });
 
-        it('should return null when no prompt is active', () => {
+    it("should return null when no prompt is active", () => {
       const { host } = createTestHost();
 
       expect(host.activePromptSchema.value).toBeNull();
     });
   });
 
-    describe('start', () => {
+  describe("start", () => {
-        it('should reset state and run start command', async () => {
+    it("should reset state and run start command", async () => {
       const { host } = createTestHost();
 
       // First setup - make one move
@@ -157,20 +146,25 @@ describe('GameHost', () => {
       let promptEvent = await promptPromise;
 
       // Make a move
-            promptEvent.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
+      promptEvent.tryCommit({
+        name: "play",
+        params: ["X", 1, 1],
+        options: {},
+        flags: {},
+      });
 
       // Wait for next prompt (next turn) and cancel
       promptPromise = waitForPromptEvent(host);
       promptEvent = await promptPromise;
-            promptEvent.cancel('test end');
+      promptEvent.cancel("test end");
 
       try {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toBe('test end');
+        expect(error.message).toBe("test end");
       }
-            expect(Object.keys(host.context._state.value.parts).length).toBe(1);
+      expect(Object.keys(host.state.value.parts).length).toBe(1);
 
       // Setup listener before calling start
       const newPromptPromise = waitForPromptEvent(host);
@@ -179,15 +173,15 @@ describe('GameHost', () => {
       const newRunPromise = host.start();
 
       // State should be back to initial
-            expect(host.context._state.value.currentPlayer).toBe('X');
+      expect(host.state.value.currentPlayer).toBe("X");
-            expect(host.context._state.value.winner).toBeNull();
+      expect(host.state.value.winner).toBeNull();
-            expect(host.context._state.value.turn).toBe(0);
+      expect(host.state.value.turn).toBe(0);
-            expect(Object.keys(host.context._state.value.parts).length).toBe(0);
+      expect(Object.keys(host.state.value.parts).length).toBe(0);
 
       // New game should be running and prompting
       const newPrompt = await newPromptPromise;
-            expect(newPrompt.schema.name).toBe('play');
+      expect(newPrompt.schema.name).toBe("play");
-            newPrompt.cancel('test end');
+      newPrompt.cancel("test end");
 
       try {
         await newRunPromise;
@@ -196,7 +190,7 @@ describe('GameHost', () => {
       }
     });
 
-        it('should cancel active prompt during start', async () => {
+    it("should cancel active prompt during start", async () => {
       const { host } = createTestHost();
 
       const promptPromise = waitForPromptEvent(host);
@@ -212,31 +206,31 @@ describe('GameHost', () => {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toContain('Cancelled');
+        expect(error.message).toContain("Cancelled");
       }
 
       // State should be reset
-            expect(host.context._state.value.currentPlayer).toBe('X');
+      expect(host.state.value.currentPlayer).toBe("X");
-            expect(host.context._state.value.turn).toBe(0);
+      expect(host.state.value.turn).toBe(0);
     });
 
-        it('should throw error when disposed', () => {
+    it("should throw error when disposed", () => {
       const { host } = createTestHost();
       host.dispose();
 
-            expect(() => host.start()).toThrow('GameHost is disposed');
+      expect(() => host.start()).toThrow("GameHost is disposed");
     });
   });
 
-    describe('dispose', () => {
+  describe("dispose", () => {
-        it('should change status to disposed', () => {
+    it("should change status to disposed", () => {
       const { host } = createTestHost();
       host.dispose();
 
-            expect(host.status.value).toBe('disposed');
+      expect(host.status.value).toBe("disposed");
     });
 
-        it('should cancel active prompt on dispose', async () => {
+    it("should cancel active prompt on dispose", async () => {
       const { host } = createTestHost();
 
       const promptPromise = waitForPromptEvent(host);
@@ -251,25 +245,25 @@ describe('GameHost', () => {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toContain('Cancelled');
+        expect(error.message).toContain("Cancelled");
       }
     });
 
-        it('should be idempotent', () => {
+    it("should be idempotent", () => {
       const { host } = createTestHost();
       host.dispose();
       host.dispose(); // Should not throw
 
-            expect(host.status.value).toBe('disposed');
+      expect(host.status.value).toBe("disposed");
     });
   });
 
-    describe('events', () => {
+  describe("events", () => {
-        it('should emit start event', async () => {
+    it("should emit start event", async () => {
       const { host } = createTestHost();
 
       let setupCount = 0;
-            host.on('start', () => {
+      host.on("start", () => {
         setupCount++;
       });
 
@@ -281,11 +275,11 @@ describe('GameHost', () => {
       expect(setupCount).toBe(1);
 
       // State should be running
-            expect(host.status.value).toBe('running');
+      expect(host.status.value).toBe("running");
 
       // Cancel the background setup command
       const prompt = await promptPromise;
-            prompt.cancel('test end');
+      prompt.cancel("test end");
 
       try {
         await runPromise;
@@ -294,11 +288,11 @@ describe('GameHost', () => {
       }
     });
 
-        it('should emit dispose event', () => {
+    it("should emit dispose event", () => {
       const { host } = createTestHost();
 
       let disposeCount = 0;
-            host.on('dispose', () => {
+      host.on("dispose", () => {
         disposeCount++;
       });
 
@@ -306,11 +300,11 @@ describe('GameHost', () => {
       expect(disposeCount).toBe(1);
     });
 
-        it('should allow unsubscribing from events', () => {
+    it("should allow unsubscribing from events", () => {
       const { host } = createTestHost();
 
       let setupCount = 0;
-            const unsubscribe = host.on('start', () => {
+      const unsubscribe = host.on("start", () => {
         setupCount++;
       });
 
@@ -318,43 +312,48 @@ describe('GameHost', () => {
 
       // No event should be emitted
       // (we can't easily test this without triggering setup, but we verify unsubscribe works)
-            expect(typeof unsubscribe).toBe('function');
+      expect(typeof unsubscribe).toBe("function");
     });
   });
 
-    describe('reactive state', () => {
+  describe("reactive state", () => {
-        it('should have state that reflects game progress', async () => {
+    it("should have state that reflects game progress", async () => {
       const { host } = createTestHost();
 
       // Initial state
-            expect(host.context._state.value.currentPlayer).toBe('X');
+      expect(host.state.value.currentPlayer).toBe("X");
-            expect(host.context._state.value.turn).toBe(0);
+      expect(host.state.value.turn).toBe(0);
 
       // Make a move
       const promptPromise = waitForPromptEvent(host);
       const runPromise = host.start();
 
       const promptEvent = await promptPromise;
-            promptEvent.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
+      promptEvent.tryCommit({
+        name: "play",
+        params: ["X", 1, 1],
+        options: {},
+        flags: {},
+      });
 
       // Wait for next prompt and cancel
       const nextPromptPromise = waitForPromptEvent(host);
       const nextPrompt = await nextPromptPromise;
-            nextPrompt.cancel('test end');
+      nextPrompt.cancel("test end");
 
       try {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toBe('test end');
+        expect(error.message).toBe("test end");
       }
 
-            expect(host.context._state.value.currentPlayer).toBe('O');
+      expect(host.state.value.currentPlayer).toBe("O");
-            expect(host.context._state.value.turn).toBe(1);
+      expect(host.state.value.turn).toBe(1);
-            expect(Object.keys(host.context._state.value.parts).length).toBe(1);
+      expect(Object.keys(host.state.value.parts).length).toBe(1);
     });
 
-        it('should update activePromptSchema reactively', async () => {
+    it("should update activePromptSchema reactively", async () => {
       const { host } = createTestHost();
 
       // Initially null
@@ -368,11 +367,11 @@ describe('GameHost', () => {
 
       // Now schema should be set
       expect(host.activePromptSchema.value).not.toBeNull();
-            expect(host.activePromptSchema.value?.name).toBe('play');
+      expect(host.activePromptSchema.value?.name).toBe("play");
 
       // Cancel and wait
-            const cancelEvent = host.activePromptSchema.value;
+      // @ts-ignore - accessing private _context for testing
-            host.context._commands._cancel();
+      host._context._commands._cancel();
       try {
         await runPromise;
       } catch {
@@ -384,29 +383,30 @@ describe('GameHost', () => {
     });
   });
 
-    describe('full game', () => {
+  describe("full game", () => {
-        it('should run a complete game of tic-tac-toe with X winning diagonally', async () => {
+    it("should run a complete game of tic-tac-toe with X winning diagonally", async () => {
       const { host } = createTestHost();
 
       // Initial state
-            expect(host.context._state.value.currentPlayer).toBe('X');
+      expect(host.state.value.currentPlayer).toBe("X");
-            expect(host.context._state.value.winner).toBeNull();
+      expect(host.state.value.winner).toBeNull();
-            expect(host.context._state.value.turn).toBe(0);
+      expect(host.state.value.turn).toBe(0);
-            expect(Object.keys(host.context._state.value.parts).length).toBe(0);
+      expect(Object.keys(host.state.value.parts).length).toBe(0);
 
       // X wins diagonally: (0,0), (1,1), (2,2)
       // O plays: (0,1), (2,1)
       const moves = [
-                'play X 0 0', // turn 1: X
+        "play X 0 0", // turn 1: X
-                'play O 0 1', // turn 2: O
+        "play O 0 1", // turn 2: O
-                'play X 1 1', // turn 3: X
+        "play X 1 1", // turn 3: X
-                'play O 2 1', // turn 4: O
+        "play O 2 1", // turn 4: O
-                'play X 2 2', // turn 5: X wins!
+        "play X 2 2", // turn 5: X wins!
       ];
 
       // Track prompt events in a queue
       const promptEvents: PromptEvent[] = [];
-            host.context._commands.on('prompt', (e) => {
+      // @ts-ignore - accessing private _context for testing
+      host._context._commands.on("prompt", (e) => {
         promptEvents.push(e);
       });
 
@@ -416,71 +416,83 @@ describe('GameHost', () => {
       for (let i = 0; i < moves.length; i++) {
         // Wait until the next prompt event arrives
         while (i >= promptEvents.length) {
-                    await new Promise(r => setTimeout(r, 10));
+          await new Promise((r) => setTimeout(r, 10));
         }
 
         const promptEvent = promptEvents[i];
-                expect(promptEvent.schema.name).toBe('play');
+        expect(promptEvent.schema.name).toBe("play");
 
         // Submit the move
         const error = host.tryInput(moves[i]);
         expect(error).toBeNull();
 
         // Wait for the command to complete before submitting next move
-                await new Promise(resolve => setImmediate(resolve));
+        await new Promise((resolve) => setImmediate(resolve));
       }
 
       // Wait for setup to complete (game ended with winner)
       try {
         const finalState = await setupPromise;
-                expect(finalState.winner).toBe('X');
+        expect(finalState.winner).toBe("X");
 
         // Final state checks
-                expect(host.context._state.value.winner).toBe('X');
+        expect(host.state.value.winner).toBe("X");
-                expect(host.context._state.value.currentPlayer).toBe('X');
+        expect(host.state.value.currentPlayer).toBe("X");
-                expect(Object.keys(host.context._state.value.parts).length).toBe(5);
+        expect(Object.keys(host.state.value.parts).length).toBe(5);
 
         // Verify winning diagonal
-                const parts = Object.values(host.context._state.value.parts);
+        const parts = Object.values(host.state.value.parts);
-                const xPieces = parts.filter(p => p.player === 'X');
+        const xPieces = parts.filter((p: any) => p.player === "X");
         expect(xPieces).toHaveLength(3);
-                expect(xPieces.some(p => JSON.stringify(p.position) === JSON.stringify([0, 0]))).toBe(true);
+        expect(
-                expect(xPieces.some(p => JSON.stringify(p.position) === JSON.stringify([1, 1]))).toBe(true);
+          xPieces.some(
-                expect(xPieces.some(p => JSON.stringify(p.position) === JSON.stringify([2, 2]))).toBe(true);
+            (p: any) => JSON.stringify(p.position) === JSON.stringify([0, 0]),
+          ),
+        ).toBe(true);
+        expect(
+          xPieces.some(
+            (p: any) => JSON.stringify(p.position) === JSON.stringify([1, 1]),
+          ),
+        ).toBe(true);
+        expect(
+          xPieces.some(
+            (p: any) => JSON.stringify(p.position) === JSON.stringify([2, 2]),
+          ),
+        ).toBe(true);
       } catch (e) {
         // If setup fails due to cancellation, check state directly
         const error = e as Error;
-                if (!error.message.includes('Cancelled')) {
+        if (!error.message.includes("Cancelled")) {
           throw e;
         }
       }
 
       host.dispose();
-            expect(host.status.value).toBe('disposed');
+      expect(host.status.value).toBe("disposed");
     });
   });
 
-    describe('currentPlayer in prompt', () => {
+  describe("currentPlayer in prompt", () => {
-        it('should have currentPlayer in PromptEvent', async () => {
+    it("should have currentPlayer in PromptEvent", async () => {
       const { host } = createTestHost();
 
       const promptPromise = waitForPromptEvent(host);
       const runPromise = host.start();
 
       const promptEvent = await promptPromise;
-            expect(promptEvent.currentPlayer).toBe('X');
+      expect(promptEvent.currentPlayer).toBe("X");
-            expect(host.activePromptPlayer.value).toBe('X');
+      expect(host.activePromptPlayer.value).toBe("X");
 
-            promptEvent.cancel('test cleanup');
+      promptEvent.cancel("test cleanup");
       try {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toBe('test cleanup');
+        expect(error.message).toBe("test cleanup");
       }
     });
 
-        it('should update activePromptPlayer reactively', async () => {
+    it("should update activePromptPlayer reactively", async () => {
       const { host } = createTestHost();
 
       // Initially null
@@ -490,25 +502,30 @@ describe('GameHost', () => {
       let promptPromise = waitForPromptEvent(host);
       let runPromise = host.start();
       let promptEvent = await promptPromise;
-            expect(promptEvent.currentPlayer).toBe('X');
+      expect(promptEvent.currentPlayer).toBe("X");
-            expect(host.activePromptPlayer.value).toBe('X');
+      expect(host.activePromptPlayer.value).toBe("X");
 
       // Make a move
-            promptEvent.tryCommit({ name: 'play', params: ['X', 1, 1], options: {}, flags: {} });
+      promptEvent.tryCommit({
+        name: "play",
+        params: ["X", 1, 1],
+        options: {},
+        flags: {},
+      });
 
       // Second prompt - O's turn
       promptPromise = waitForPromptEvent(host);
       promptEvent = await promptPromise;
-            expect(promptEvent.currentPlayer).toBe('O');
+      expect(promptEvent.currentPlayer).toBe("O");
-            expect(host.activePromptPlayer.value).toBe('O');
+      expect(host.activePromptPlayer.value).toBe("O");
 
       // Cancel
-            promptEvent.cancel('test cleanup');
+      promptEvent.cancel("test cleanup");
       try {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toBe('test cleanup');
+        expect(error.message).toBe("test cleanup");
       }
 
       // After prompt ends, player should be null
@@ -516,35 +533,35 @@ describe('GameHost', () => {
     });
   });
 
-    describe('tryAnswerPrompt', () => {
+  describe("tryAnswerPrompt", () => {
-        it('should answer prompt with valid arguments', async () => {
+    it("should answer prompt with valid arguments", async () => {
       const { host } = createTestHost();
 
       const promptPromise = waitForPromptEvent(host);
       const runPromise = host.start();
 
       const promptEvent = await promptPromise;
-            expect(promptEvent.schema.name).toBe('play');
+      expect(promptEvent.schema.name).toBe("play");
 
       // Use tryAnswerPrompt with the prompt def
-            const { prompts } = await import('@/samples/tic-tac-toe');
+      const { prompts } = await import("@/samples/tic-tac-toe");
-            const error = host.tryAnswerPrompt(prompts.play, 'X', 1, 1);
+      const error = host.tryAnswerPrompt(prompts.play, "X", 1, 1);
       expect(error).toBeNull();
 
       // Wait for next prompt and cancel
       const nextPromptPromise = waitForPromptEvent(host);
       const nextPrompt = await nextPromptPromise;
-            nextPrompt.cancel('test cleanup');
+      nextPrompt.cancel("test cleanup");
 
       try {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toBe('test cleanup');
+        expect(error.message).toBe("test cleanup");
       }
     });
 
-        it('should reject invalid arguments', async () => {
+    it("should reject invalid arguments", async () => {
       const { host } = createTestHost();
 
       const promptPromise = waitForPromptEvent(host);
@@ -553,26 +570,26 @@ describe('GameHost', () => {
       const promptEvent = await promptPromise;
 
       // Use tryAnswerPrompt with invalid position
-            const { prompts } = await import('@/samples/tic-tac-toe');
+      const { prompts } = await import("@/samples/tic-tac-toe");
-            const error = host.tryAnswerPrompt(prompts.play, 'X', 5, 5);
+      const error = host.tryAnswerPrompt(prompts.play, "X", 5, 5);
       expect(error).not.toBeNull();
 
-            promptEvent.cancel('test cleanup');
+      promptEvent.cancel("test cleanup");
       try {
         await runPromise;
       } catch (e) {
         const error = e as Error;
-                expect(error.message).toBe('test cleanup');
+        expect(error.message).toBe("test cleanup");
       }
     });
   });
 
-    describe('addInterruption and clearInterruptions', () => {
+  describe("addInterruption and clearInterruptions", () => {
-        it('should add interruption promise to state', async () => {
+    it("should add interruption promise to state", async () => {
       const { host } = createTestHost();
 
       let resolveInterruption: () => void;
-            const interruptionPromise = new Promise<void>(resolve => {
+      const interruptionPromise = new Promise<void>((resolve) => {
         resolveInterruption = resolve;
       });
 
@@ -589,7 +606,7 @@ describe('GameHost', () => {
       resolveInterruption!();
 
       // Cancel and cleanup
-            promptEvent.cancel('test cleanup');
+      promptEvent.cancel("test cleanup");
       try {
         await runPromise;
       } catch {
@@ -597,15 +614,15 @@ describe('GameHost', () => {
       }
     });
 
-        it('should clear all pending interruptions', async () => {
+    it("should clear all pending interruptions", async () => {
       const { host } = createTestHost();
 
       let resolveInterruption1: () => void;
       let resolveInterruption2: () => void;
-            const interruptionPromise1 = new Promise<void>(resolve => {
+      const interruptionPromise1 = new Promise<void>((resolve) => {
         resolveInterruption1 = resolve;
       });
-            const interruptionPromise2 = new Promise<void>(resolve => {
+      const interruptionPromise2 = new Promise<void>((resolve) => {
         resolveInterruption2 = resolve;
       });
 
@@ -621,7 +638,7 @@ describe('GameHost', () => {
       const runPromise = host.start();
 
       const promptEvent = await promptPromise;
-            promptEvent.cancel('test cleanup');
+      promptEvent.cancel("test cleanup");
 
       try {
         await runPromise;

tests/core/game.test.ts

@@ -1,14 +1,24 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import { createGameContext, createGameCommandRegistry, createPromptDef, IGameContext, PromptDef } from '@/core/game';
+import {
-import type { PromptEvent, Command } from '@/utils/command';
+  createGameContext,
+  createGameCommandRegistry,
+  createPromptDef,
+  IGameContext,
+  PromptDef,
+} from "@/core/game";
+import type {
+  PromptEvent,
+  Command,
+  CommandRunnerContext,
+} from "@/utils/command";
 
 type MyState = {
   score: number;
   round: number;
 };
 
-describe('createGameContext', () => {
+describe("createGameContext", () => {
-    it('should create a game context with state', () => {
+  it("should create a game context with state", () => {
     const registry = createGameCommandRegistry();
     const ctx = createGameContext(registry);
 
@@ -16,7 +26,7 @@ describe('createGameContext', () => {
     expect(ctx._state.value).toBeDefined();
   });
 
-    it('should wire commands to the context', () => {
+  it("should wire commands to the context", () => {
     const registry = createGameCommandRegistry();
     const ctx = createGameContext(registry);
 
@@ -24,7 +34,7 @@ describe('createGameContext', () => {
     expect(ctx._commands.registry).toBe(registry);
   });
 
-    it('should accept initial state as an object', () => {
+  it("should accept initial state as an object", () => {
     const registry = createGameCommandRegistry<MyState>();
     const ctx = createGameContext<MyState>(registry, {
       score: 0,
@@ -35,7 +45,7 @@ describe('createGameContext', () => {
     expect(ctx._state.value.round).toBe(1);
   });
 
-    it('should accept initial state as a factory function', () => {
+  it("should accept initial state as a factory function", () => {
     const registry = createGameCommandRegistry<MyState>();
     const ctx = createGameContext<MyState>(registry, () => ({
       score: 10,
@@ -46,24 +56,32 @@ describe('createGameContext', () => {
     expect(ctx._state.value.round).toBe(3);
   });
 
-    it('should forward prompt events via listener', async () => {
+  it("should forward prompt events via listener", async () => {
     const registry = createGameCommandRegistry();
     const ctx = createGameContext(registry);
 
-        registry.register('test <value>', async function (_ctx, value) {
+    registry.register("test <value>", async function (_ctx, value) {
-            return this.prompt({schema: 'prompt <answer>'}, () => 'ok');
+      return _ctx.prompt(
+        createPromptDef("prompt <answer>"),
+        (answer) => answer,
+      );
     });
 
-        const promptPromise = new Promise<PromptEvent>(resolve => {
+    const promptPromise = new Promise<PromptEvent>((resolve) => {
-            ctx._commands.on('prompt', resolve);
+      ctx._commands.on("prompt", resolve);
     });
-        const runPromise = ctx.run('test hello');
+    const runPromise = ctx.run("test hello");
 
     const promptEvent = await promptPromise;
     expect(promptEvent).not.toBeNull();
-        expect(promptEvent.schema.name).toBe('prompt');
+    expect(promptEvent.schema.name).toBe("prompt");
 
-        const error = promptEvent.tryCommit({ name: 'prompt', params: ['yes'], options: {}, flags: {} });
+    const error = promptEvent.tryCommit({
+      name: "prompt",
+      params: ["yes"],
+      options: {},
+      flags: {},
+    });
     expect(error).toBeNull();
 
     const result = await runPromise;
@@ -71,41 +89,41 @@ describe('createGameContext', () => {
   });
 });
 
-describe('createGameCommand', () => {
+describe("createGameCommand", () => {
-    it('should run a command with access to game context', async () => {
+  it("should run a command with access to game context", async () => {
     const registry = createGameCommandRegistry<{ marker: string }>();
 
-        registry.register('set-marker <id>', async function (ctx, id) {
+    registry.register("set-marker <id>", async function (ctx, id) {
-            ctx.produce(state => {
+      ctx.produce((state) => {
         state.marker = id;
       });
       return id;
     });
 
-        const ctx = createGameContext(registry, { marker: '' });
+    const ctx = createGameContext(registry, { marker: "" });
 
-        const result = await ctx.run('set-marker board');
+    const result = await ctx.run("set-marker board");
     if (!result.success) {
-            console.error('Error:', result.error);
+      console.error("Error:", result.error);
     }
     expect(result.success).toBe(true);
     if (result.success) {
-            expect(result.result).toBe('board');
+      expect(result.result).toBe("board");
     }
-        expect(ctx._state.value.marker).toBe('board');
+    expect(ctx._state.value.marker).toBe("board");
   });
 
-    it('should run a typed command with extended context', async () => {
+  it("should run a typed command with extended context", async () => {
     const registry = createGameCommandRegistry<MyState>();
 
     registry.register(
-            'add-score <amount:number>',
+      "add-score <amount:number>",
       async function (ctx, amount) {
-                ctx.produce(state => {
+        ctx.produce((state) => {
           state.score += amount;
         });
         return ctx.value.score;
-            }
+      },
     );
 
     const ctx = createGameContext<MyState>(registry, () => ({
@@ -113,7 +131,7 @@ describe('createGameCommand', () => {
       round: 1,
     }));
 
-        const result = await ctx.run('add-score 5');
+    const result = await ctx.run("add-score 5");
     expect(result.success).toBe(true);
     if (result.success) {
       expect(result.result).toBe(5);
@@ -121,67 +139,71 @@ describe('createGameCommand', () => {
     expect(ctx._state.value.score).toBe(5);
   });
 
-    it('should return error for unknown command', async () => {
+  it("should return error for unknown command", async () => {
     const registry = createGameCommandRegistry();
     const ctx = createGameContext(registry);
 
-        const result = await ctx.run('nonexistent');
+    const result = await ctx.run("nonexistent");
     expect(result.success).toBe(false);
     if (!result.success) {
-            expect(result.error).toContain('nonexistent');
+      expect(result.error).toContain("nonexistent");
     }
   });
 });
 
-describe('createPromptDef', () => {
+describe("createPromptDef", () => {
-    it('should create a PromptDef with string schema', () => {
+  it("should create a PromptDef with string schema", () => {
-        const promptDef = createPromptDef<[string, number]>('play <player> <score:number>');
+    const promptDef = createPromptDef<[string, number]>(
+      "play <player> <score:number>",
+    );
 
     expect(promptDef).toBeDefined();
-        expect(promptDef.schema.name).toBe('play');
+    expect(promptDef.schema.name).toBe("play");
     expect(promptDef.schema.params).toHaveLength(2);
-        expect(promptDef.schema.params[0].name).toBe('player');
+    expect(promptDef.schema.params[0].name).toBe("player");
-        expect(promptDef.schema.params[1].name).toBe('score');
+    expect(promptDef.schema.params[1].name).toBe("score");
   });
 
-    it('should create a PromptDef with CommandSchema object', () => {
+  it("should create a PromptDef with CommandSchema object", () => {
     const schemaObj = {
-            name: 'test',
+      name: "test",
       params: [],
       options: {},
-            flags: {}
+      flags: {},
     };
     const promptDef = createPromptDef<[]>(schemaObj);
 
     expect(promptDef.schema).toEqual(schemaObj);
   });
 
-    it('should be usable with game.prompt', async () => {
+  it("should be usable with game.prompt", async () => {
     const registry = createGameCommandRegistry<{ score: number }>();
 
-        registry.register('test-prompt', async function(ctx) {
+    registry.register("test-prompt", async function (ctx) {
-            const promptDef = createPromptDef<[number]>('input <value:number>');
+      const promptDef = createPromptDef<[number]>("input <value:number>");
-            const result = await ctx.prompt(
+      const result = await ctx.prompt(promptDef, (value) => {
-                promptDef,
+        if (value < 0) throw "Value must be positive";
-                (value) => {
-                    if (value < 0) throw 'Value must be positive';
         return value;
-                }
+      });
-            );
       return result;
     });
 
     const ctx = createGameContext(registry, { score: 0 });
 
-        const promptPromise = new Promise<PromptEvent>(resolve => {
+    const promptPromise = new Promise<PromptEvent>((resolve) => {
-            ctx._commands.on('prompt', resolve);
+      ctx._commands.on("prompt", resolve);
     });
-        const runPromise = ctx.run('test-prompt');
+    const runPromise = ctx.run("test-prompt");
 
     const promptEvent = await promptPromise;
-        expect(promptEvent.schema.name).toBe('input');
+    expect(promptEvent.schema.name).toBe("input");
 
-        const error = promptEvent.tryCommit({ name: 'input', params: [42], options: {}, flags: {} });
+    const error = promptEvent.tryCommit({
+      name: "input",
+      params: [42],
+      options: {},
+      flags: {},
+    });
     expect(error).toBeNull();
 
     const result = await runPromise;

tests/samples/boop.test.ts

@@ -1,66 +1,81 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import { registry, createInitialState, BoopState } from '@/samples/boop';
+import { registry, createInitialState, BoopState } from "@/samples/boop";
-import { createGameContext } from '@/core/game';
+import { createGameContext } from "@/core/game";
-import type { PromptEvent } from '@/utils/command';
+import type { PromptEvent } from "@/utils/command";
 
 function createTestContext() {
   const ctx = createGameContext(registry, createInitialState());
   return { registry, ctx };
 }
 
-function waitForPrompt(ctx: ReturnType<typeof createTestContext>['ctx']): Promise<PromptEvent> {
+function waitForPrompt(
-    return new Promise(resolve => {
+  ctx: ReturnType<typeof createTestContext>["ctx"],
-        ctx._commands.on('prompt', resolve);
+): Promise<PromptEvent> {
+  return new Promise((resolve) => {
+    ctx._commands.on("prompt", resolve);
   });
 }
 
-describe('Boop Game', () => {
+describe("Boop Game", () => {
-    describe('Setup', () => {
+  describe("Setup", () => {
-        it('should create initial state correctly', () => {
+    it("should create initial state correctly", () => {
       const state = createInitialState();
 
-            expect(state.currentPlayer).toBe('white');
+      expect(state.currentPlayer).toBe("white");
       expect(state.winner).toBeNull();
       expect(state.regions.board).toBeDefined();
       expect(state.regions.white).toBeDefined();
       expect(state.regions.black).toBeDefined();
 
       // 8 kittens per player
-            const whiteKittens = Object.values(state.pieces).filter(p => p.player === 'white' && p.type === 'kitten');
+      const whiteKittens = Object.values(state.pieces).filter(
-            const blackKittens = Object.values(state.pieces).filter(p => p.player === 'black' && p.type === 'kitten');
+        (p) => p.player === "white" && p.type === "kitten",
+      );
+      const blackKittens = Object.values(state.pieces).filter(
+        (p) => p.player === "black" && p.type === "kitten",
+      );
       expect(whiteKittens.length).toBe(8);
       expect(blackKittens.length).toBe(8);
 
       // 8 cats per player (initially in box)
-            const whiteCats = Object.values(state.pieces).filter(p => p.player === 'white' && p.type === 'cat');
+      const whiteCats = Object.values(state.pieces).filter(
-            const blackCats = Object.values(state.pieces).filter(p => p.player === 'black' && p.type === 'cat');
+        (p) => p.player === "white" && p.type === "cat",
+      );
+      const blackCats = Object.values(state.pieces).filter(
+        (p) => p.player === "black" && p.type === "cat",
+      );
       expect(whiteCats.length).toBe(8);
       expect(blackCats.length).toBe(8);
 
       // All cats should be in box (regionId = '')
-            whiteCats.forEach(cat => expect(cat.regionId).toBe(''));
+      whiteCats.forEach((cat) => expect(cat.regionId).toBe(""));
-            blackCats.forEach(cat => expect(cat.regionId).toBe(''));
+      blackCats.forEach((cat) => expect(cat.regionId).toBe(""));
 
       // Kittens should be in player supplies
-            whiteKittens.forEach(k => expect(k.regionId).toBe('white'));
+      whiteKittens.forEach((k) => expect(k.regionId).toBe("white"));
-            blackKittens.forEach(k => expect(k.regionId).toBe('black'));
+      blackKittens.forEach((k) => expect(k.regionId).toBe("black"));
     });
   });
 
-    describe('Place and Boop Commands', () => {
+  describe("Place and Boop Commands", () => {
-        it('should place a kitten via play command', async () => {
+    it("should place a kitten via play command", async () => {
       const { ctx } = createTestContext();
 
       // Use turn command instead of setup which runs indefinitely
       const promptPromise = waitForPrompt(ctx);
-            const runPromise = ctx.run('turn white');
+      const runPromise = ctx.run("turn white");
 
       const promptEvent = await promptPromise;
       expect(promptEvent).not.toBeNull();
-            expect(promptEvent.schema.name).toBe('play');
+      expect(promptEvent.schema.name).toBe("play");
 
       // Place a kitten at position 2,2
-            const error = promptEvent.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
+      const error = promptEvent.tryCommit({
+        name: "play",
+        params: ["white", 2, 2, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
 
       const result = await runPromise;
@@ -72,29 +87,41 @@ describe('Boop Game', () => {
       expect(boardPieces.length).toBeGreaterThan(0);
 
       // Should have one less kitten in supply
-            const whiteSupply = state.regions.white.childIds.filter(id => state.pieces[id].type === 'kitten');
+      const whiteSupply = state.regions.white.childIds.filter(
+        (id) => state.pieces[id].type === "kitten",
+      );
       expect(whiteSupply.length).toBe(7);
     });
   });
 
-    describe('Boop Mechanics', () => {
+  describe("Boop Mechanics", () => {
-        it('should boop adjacent pieces away from placement', async () => {
+    it("should boop adjacent pieces away from placement", async () => {
       const { ctx } = createTestContext();
 
       // White places at 2,2
       let promptPromise = waitForPrompt(ctx);
-            let runPromise = ctx.run('turn white');
+      let runPromise = ctx.run("turn white");
       let promptEvent = await promptPromise;
-            let error = promptEvent.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
+      let error = promptEvent.tryCommit({
+        name: "play",
+        params: ["white", 2, 2, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       let result = await runPromise;
       expect(result.success).toBe(true);
 
       // Black places at 2,3, which will boop white's piece
       promptPromise = waitForPrompt(ctx);
-            runPromise = ctx.run('turn black');
+      runPromise = ctx.run("turn black");
       promptEvent = await promptPromise;
-            error = promptEvent.tryCommit({ name: 'play', params: ['black', 2, 3, 'kitten'], options: {}, flags: {} });
+      error = promptEvent.tryCommit({
+        name: "play",
+        params: ["black", 2, 3, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       result = await runPromise;
       expect(result.success).toBe(true);
@@ -105,152 +132,186 @@ describe('Boop Game', () => {
       expect(boardPieceCount).toBeGreaterThanOrEqual(1);
     });
 
-        it('should handle pieces being booped off the board', async () => {
+    it("should handle pieces being booped off the board", async () => {
       const { ctx } = createTestContext();
 
       // White places at corner
       const promptPromise = waitForPrompt(ctx);
-            const runPromise = ctx.run('turn white');
+      const runPromise = ctx.run("turn white");
       const promptEvent = await promptPromise;
-            const error = promptEvent.tryCommit({ name: 'play', params: ['white', 0, 0, 'kitten'], options: {}, flags: {} });
+      const error = promptEvent.tryCommit({
+        name: "play",
+        params: ["white", 0, 0, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       const result = await runPromise;
       expect(result.success).toBe(true);
 
       const state = ctx.value;
       // Verify placement
-            expect(state.regions.board.partMap['0,0']).toBeDefined();
+      expect(state.regions.board.partMap["0,0"]).toBeDefined();
     });
   });
 
-    describe('Full Game Flow', () => {
+  describe("Full Game Flow", () => {
-        it('should play a turn and switch players', async () => {
+    it("should play a turn and switch players", async () => {
       const { ctx } = createTestContext();
 
       // White's turn - place at 2,2
       let promptPromise = waitForPrompt(ctx);
-            let runPromise = ctx.run('turn white');
+      let runPromise = ctx.run("turn white");
       let prompt = await promptPromise;
-            const error1 = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
+      const error1 = prompt.tryCommit({
+        name: "play",
+        params: ["white", 2, 2, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error1).toBeNull();
       let result = await runPromise;
       expect(result.success).toBe(true);
 
       const stateAfterWhite = ctx.value;
       // Should have placed a piece
-            expect(stateAfterWhite.regions.board.partMap['2,2']).toBeDefined();
+      expect(stateAfterWhite.regions.board.partMap["2,2"]).toBeDefined();
     });
   });
 
-    describe('Kitten vs Cat Hierarchy', () => {
+  describe("Kitten vs Cat Hierarchy", () => {
-        it('should not boop cats when placing a kitten', async () => {
+    it("should not boop cats when placing a kitten", async () => {
       const { ctx } = createTestContext();
 
       // White places a kitten at 2,2
       let promptPromise = waitForPrompt(ctx);
-            let runPromise = ctx.run('turn white');
+      let runPromise = ctx.run("turn white");
       let prompt = await promptPromise;
-            let error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
+      let error = prompt.tryCommit({
+        name: "play",
+        params: ["white", 2, 2, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       let result = await runPromise;
       expect(result.success).toBe(true);
 
       // Manually move white's kitten to box and replace with a cat (for testing)
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                const whiteKitten = state.pieces['white-kitten-1'];
+        const whiteKitten = state.pieces["white-kitten-1"];
-                if (whiteKitten && whiteKitten.regionId === 'board') {
+        if (whiteKitten && whiteKitten.regionId === "board") {
-                    whiteKitten.type = 'cat';
+          (whiteKitten as { type: string }).type = "cat";
         }
       });
 
       // Black places a kitten at 2,3 (adjacent to the cat)
       promptPromise = waitForPrompt(ctx);
-            runPromise = ctx.run('turn black');
+      runPromise = ctx.run("turn black");
       prompt = await promptPromise;
-            error = prompt.tryCommit({ name: 'play', params: ['black', 2, 3, 'kitten'], options: {}, flags: {} });
+      error = prompt.tryCommit({
+        name: "play",
+        params: ["black", 2, 3, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       result = await runPromise;
       expect(result.success).toBe(true);
 
       const state = ctx.value;
       // White's cat should still be at 2,2 (not booped)
-            expect(state.regions.board.partMap['2,2']).toBe('white-kitten-1');
+      expect(state.regions.board.partMap["2,2"]).toBe("white-kitten-1");
       // Black's kitten should be at 2,3
-            expect(state.regions.board.partMap['2,3']).toBe('black-kitten-1');
+      expect(state.regions.board.partMap["2,3"]).toBe("black-kitten-1");
     });
 
-        it('should boop both kittens and cats when placing a cat', async () => {
+    it("should boop both kittens and cats when placing a cat", async () => {
       const { ctx } = createTestContext();
 
       // Manually set up: white cat at 2,3, black cat at 3,2
       // First move cats to white and black supplies
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                const whiteCat = state.pieces['white-cat-1'];
+        const whiteCat = state.pieces["white-cat-1"];
-                const blackCat = state.pieces['black-cat-1'];
+        const blackCat = state.pieces["black-cat-1"];
-                if (whiteCat && whiteCat.regionId === '') {
+        if (whiteCat && whiteCat.regionId === "") {
-                    whiteCat.regionId = 'white';
+          whiteCat.regionId = "white";
           state.regions.white.childIds.push(whiteCat.id);
         }
-                if (blackCat && blackCat.regionId === '') {
+        if (blackCat && blackCat.regionId === "") {
-                    blackCat.regionId = 'black';
+          blackCat.regionId = "black";
           state.regions.black.childIds.push(blackCat.id);
         }
       });
 
       // Now move them to the board
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                const whiteCat = state.pieces['white-cat-1'];
+        const whiteCat = state.pieces["white-cat-1"];
-                const blackCat = state.pieces['black-cat-1'];
+        const blackCat = state.pieces["black-cat-1"];
-                if (whiteCat && whiteCat.regionId === 'white') {
+        if (whiteCat && whiteCat.regionId === "white") {
-                    whiteCat.regionId = 'board';
+          whiteCat.regionId = "board";
           whiteCat.position = [2, 3];
-                    state.regions.board.partMap['2,3'] = whiteCat.id;
+          state.regions.board.partMap["2,3"] = whiteCat.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== whiteCat.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== whiteCat.id,
+          );
         }
-                if (blackCat && blackCat.regionId === 'black') {
+        if (blackCat && blackCat.regionId === "black") {
-                    blackCat.regionId = 'board';
+          blackCat.regionId = "board";
           blackCat.position = [3, 2];
-                    state.regions.board.partMap['3,2'] = blackCat.id;
+          state.regions.board.partMap["3,2"] = blackCat.id;
-                    state.regions.black.childIds = state.regions.black.childIds.filter(id => id !== blackCat.id);
+          state.regions.black.childIds = state.regions.black.childIds.filter(
+            (id) => id !== blackCat.id,
+          );
         }
       });
 
       // Give white another cat for placement
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                const whiteCat2 = state.pieces['white-cat-2'];
+        const whiteCat2 = state.pieces["white-cat-2"];
-                if (whiteCat2 && whiteCat2.regionId === '') {
+        if (whiteCat2 && whiteCat2.regionId === "") {
-                    whiteCat2.regionId = 'white';
+          whiteCat2.regionId = "white";
           state.regions.white.childIds.push(whiteCat2.id);
         }
       });
 
       // White places a cat at 2,2 (should boop black's cat at 3,2 to 4,2)
       const promptPromise = waitForPrompt(ctx);
-            const runPromise = ctx.run('turn white');
+      const runPromise = ctx.run("turn white");
       const prompt = await promptPromise;
-            const error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'cat'], options: {}, flags: {} });
+      const error = prompt.tryCommit({
+        name: "play",
+        params: ["white", 2, 2, "cat"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       const result = await runPromise;
       expect(result.success).toBe(true);
 
       const state = ctx.value;
       // Black's cat should have been booped to 4,2
-            expect(state.regions.board.partMap['4,2']).toBeDefined();
+      expect(state.regions.board.partMap["4,2"]).toBeDefined();
-            const pieceAt42 = state.pieces[state.regions.board.partMap['4,2']];
+      const pieceAt42 = state.pieces[state.regions.board.partMap["4,2"]];
-            expect(pieceAt42?.player).toBe('black');
+      expect(pieceAt42?.player).toBe("black");
-            expect(pieceAt42?.type).toBe('cat');
+      expect(pieceAt42?.type).toBe("cat");
     });
   });
 
-    describe('Boop Obstructions', () => {
+  describe("Boop Obstructions", () => {
-        it('should boop pieces to empty positions', async () => {
+    it("should boop pieces to empty positions", async () => {
       const { ctx } = createTestContext();
 
       // White places at 2,2
       let promptPromise = waitForPrompt(ctx);
-            let runPromise = ctx.run('turn white');
+      let runPromise = ctx.run("turn white");
       let prompt = await promptPromise;
-            let error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
+      let error = prompt.tryCommit({
+        name: "play",
+        params: ["white", 2, 2, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       let result = await runPromise;
       expect(result.success).toBe(true);
@@ -261,9 +322,14 @@ describe('Boop Game', () => {
 
       // Black places at 3,3
       promptPromise = waitForPrompt(ctx);
-            runPromise = ctx.run('turn black');
+      runPromise = ctx.run("turn black");
       prompt = await promptPromise;
-            error = prompt.tryCommit({ name: 'play', params: ['black', 3, 3, 'kitten'], options: {}, flags: {} });
+      error = prompt.tryCommit({
+        name: "play",
+        params: ["black", 3, 3, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       result = await runPromise;
       expect(result.success).toBe(true);
@@ -276,294 +342,334 @@ describe('Boop Game', () => {
       expect(boardPieces.length).toBe(2);
 
       // Find black's piece
-            const blackPiece = boardPieces.find(([pos, id]) => state.pieces[id]?.player === 'black');
+      const blackPiece = boardPieces.find(
+        ([pos, id]) => state.pieces[id]?.player === "black",
+      );
       expect(blackPiece).toBeDefined();
     });
 
-        it('should keep both pieces in place when boop is blocked', async () => {
+    it("should keep both pieces in place when boop is blocked", async () => {
       const { ctx } = createTestContext();
 
       // Setup: place white at 2,2 and 4,4, black at 3,3
-            await ctx._commands.run('place 2 2 white kitten');
+      await ctx._commands.run("place 2 2 white kitten");
-            await ctx._commands.run('place 3 3 black kitten');
+      await ctx._commands.run("place 3 3 black kitten");
-            await ctx._commands.run('place 4 4 white kitten');
+      await ctx._commands.run("place 4 4 white kitten");
 
       const stateBefore = ctx.value;
       // Verify setup - 3 pieces on board
       const boardPiecesBefore = Object.keys(stateBefore.regions.board.partMap);
       expect(boardPiecesBefore.length).toBe(3);
-            expect(stateBefore.regions.board.partMap['2,2']).toBeDefined();
+      expect(stateBefore.regions.board.partMap["2,2"]).toBeDefined();
-            expect(stateBefore.regions.board.partMap['3,3']).toBeDefined();
+      expect(stateBefore.regions.board.partMap["3,3"]).toBeDefined();
-            expect(stateBefore.regions.board.partMap['4,4']).toBeDefined();
+      expect(stateBefore.regions.board.partMap["4,4"]).toBeDefined();
 
       // Black places at 2,3 - should try to boop piece at 3,3 to 4,4
       // but 4,4 is occupied, so both should stay
-            await ctx._commands.run('place 2 3 black kitten');
+      await ctx._commands.run("place 2 3 black kitten");
 
       const state = ctx.value;
       // Should now have 4 pieces on board
       const boardPiecesAfter = Object.keys(state.regions.board.partMap);
       expect(boardPiecesAfter.length).toBe(4);
       // 3,3 should still have the same piece (not booped)
-            expect(state.regions.board.partMap['3,3']).toBeDefined();
+      expect(state.regions.board.partMap["3,3"]).toBeDefined();
       // 4,4 should still be occupied
-            expect(state.regions.board.partMap['4,4']).toBeDefined();
+      expect(state.regions.board.partMap["4,4"]).toBeDefined();
       // 2,3 should have black's new piece
-            expect(state.regions.board.partMap['2,3']).toBeDefined();
+      expect(state.regions.board.partMap["2,3"]).toBeDefined();
     });
   });
 
-    describe('Graduation Mechanic', () => {
+  describe("Graduation Mechanic", () => {
-        it('should graduate three kittens in a row to cats', async () => {
+    it("should graduate three kittens in a row to cats", async () => {
       const { ctx } = createTestContext();
 
       // Manually place three white kittens in a row
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                const k1 = state.pieces['white-kitten-1'];
+        const k1 = state.pieces["white-kitten-1"];
-                const k2 = state.pieces['white-kitten-2'];
+        const k2 = state.pieces["white-kitten-2"];
-                const k3 = state.pieces['white-kitten-3'];
+        const k3 = state.pieces["white-kitten-3"];
 
         if (k1) {
-                    k1.regionId = 'board';
+          k1.regionId = "board";
           k1.position = [0, 0];
-                    state.regions.board.partMap['0,0'] = k1.id;
+          state.regions.board.partMap["0,0"] = k1.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k1.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== k1.id,
+          );
         }
         if (k2) {
-                    k2.regionId = 'board';
+          k2.regionId = "board";
           k2.position = [0, 1];
-                    state.regions.board.partMap['0,1'] = k2.id;
+          state.regions.board.partMap["0,1"] = k2.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k2.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== k2.id,
+          );
         }
         if (k3) {
-                    k3.regionId = 'board';
+          k3.regionId = "board";
           k3.position = [0, 2];
-                    state.regions.board.partMap['0,2'] = k3.id;
+          state.regions.board.partMap["0,2"] = k3.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k3.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== k3.id,
+          );
         }
       });
 
       const stateBefore = ctx.value;
       // Verify three kittens on board
-            expect(stateBefore.regions.board.partMap['0,0']).toBeDefined();
+      expect(stateBefore.regions.board.partMap["0,0"]).toBeDefined();
-            expect(stateBefore.regions.board.partMap['0,1']).toBeDefined();
+      expect(stateBefore.regions.board.partMap["0,1"]).toBeDefined();
-            expect(stateBefore.regions.board.partMap['0,2']).toBeDefined();
+      expect(stateBefore.regions.board.partMap["0,2"]).toBeDefined();
 
       // Count cats in white supply before graduation
       const catsInWhiteSupplyBefore = stateBefore.regions.white.childIds.filter(
-                id => stateBefore.pieces[id].type === 'cat'
+        (id) => stateBefore.pieces[id].type === "cat",
       );
       expect(catsInWhiteSupplyBefore.length).toBe(0);
 
       // Run check-graduates command
-            const result = await ctx._commands.run('check-graduates');
+      const result = await ctx._commands.run("check-graduates");
       expect(result.success).toBe(true);
 
       const state = ctx.value;
       // The three positions on board should now be empty (kittens removed)
-            expect(state.regions.board.partMap['0,0']).toBeUndefined();
+      expect(state.regions.board.partMap["0,0"]).toBeUndefined();
-            expect(state.regions.board.partMap['0,1']).toBeUndefined();
+      expect(state.regions.board.partMap["0,1"]).toBeUndefined();
-            expect(state.regions.board.partMap['0,2']).toBeUndefined();
+      expect(state.regions.board.partMap["0,2"]).toBeUndefined();
 
       // White's supply should now have 3 cats (graduated)
       const catsInWhiteSupply = state.regions.white.childIds.filter(
-                id => state.pieces[id].type === 'cat'
+        (id) => state.pieces[id].type === "cat",
       );
       expect(catsInWhiteSupply.length).toBe(3);
 
       // White's supply should have 5 kittens left (8 - 3 graduated)
       const kittensInWhiteSupply = state.regions.white.childIds.filter(
-                id => state.pieces[id].type === 'kitten'
+        (id) => state.pieces[id].type === "kitten",
       );
       expect(kittensInWhiteSupply.length).toBe(5);
     });
   });
 
-    describe('Win Detection', () => {
+  describe("Win Detection", () => {
-        it('should detect horizontal win with three cats', async () => {
+    it("should detect horizontal win with three cats", async () => {
       const { ctx } = createTestContext();
 
       // Manually set up a winning scenario for white
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                const k1 = state.pieces['white-kitten-1'];
+        const k1 = state.pieces["white-kitten-1"];
-                const k2 = state.pieces['white-kitten-2'];
+        const k2 = state.pieces["white-kitten-2"];
-                const k3 = state.pieces['white-kitten-3'];
+        const k3 = state.pieces["white-kitten-3"];
 
         if (k1) {
-                    k1.type = 'cat';
+          (k1 as { type: string }).type = "cat";
-                    k1.regionId = 'board';
+          k1.regionId = "board";
           k1.position = [0, 0];
-                    state.regions.board.partMap['0,0'] = k1.id;
+          state.regions.board.partMap["0,0"] = k1.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k1.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== k1.id,
+          );
         }
         if (k2) {
-                    k2.type = 'cat';
+          (k2 as { type: string }).type = "cat";
-                    k2.regionId = 'board';
+          k2.regionId = "board";
           k2.position = [0, 1];
-                    state.regions.board.partMap['0,1'] = k2.id;
+          state.regions.board.partMap["0,1"] = k2.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k2.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== k2.id,
+          );
         }
         if (k3) {
-                    k3.type = 'cat';
+          (k3 as { type: string }).type = "cat";
-                    k3.regionId = 'board';
+          k3.regionId = "board";
           k3.position = [0, 2];
-                    state.regions.board.partMap['0,2'] = k3.id;
+          state.regions.board.partMap["0,2"] = k3.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k3.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== k3.id,
+          );
         }
       });
 
       // Run check-win command
-            const result = await ctx._commands.run('check-win');
+      const result = await ctx._commands.run("check-win");
       expect(result.success).toBe(true);
       if (result.success) {
-                expect(result.result).toBe('white');
+        expect(result.result).toBe("white");
       }
     });
 
-        it('should detect vertical win with three cats', async () => {
+    it("should detect vertical win with three cats", async () => {
       const { ctx } = createTestContext();
 
       // Manually set up a vertical winning scenario for black
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                const k1 = state.pieces['black-kitten-1'];
+        const k1 = state.pieces["black-kitten-1"];
-                const k2 = state.pieces['black-kitten-2'];
+        const k2 = state.pieces["black-kitten-2"];
-                const k3 = state.pieces['black-kitten-3'];
+        const k3 = state.pieces["black-kitten-3"];
 
         if (k1) {
-                    k1.type = 'cat';
+          (k1 as { type: string }).type = "cat";
-                    k1.regionId = 'board';
+          k1.regionId = "board";
           k1.position = [0, 0];
-                    state.regions.board.partMap['0,0'] = k1.id;
+          state.regions.board.partMap["0,0"] = k1.id;
-                    state.regions.black.childIds = state.regions.black.childIds.filter(id => id !== k1.id);
+          state.regions.black.childIds = state.regions.black.childIds.filter(
+            (id) => id !== k1.id,
+          );
         }
         if (k2) {
-                    k2.type = 'cat';
+          (k2 as { type: string }).type = "cat";
-                    k2.regionId = 'board';
+          k2.regionId = "board";
           k2.position = [1, 0];
-                    state.regions.board.partMap['1,0'] = k2.id;
+          state.regions.board.partMap["1,0"] = k2.id;
-                    state.regions.black.childIds = state.regions.black.childIds.filter(id => id !== k2.id);
+          state.regions.black.childIds = state.regions.black.childIds.filter(
+            (id) => id !== k2.id,
+          );
         }
         if (k3) {
-                    k3.type = 'cat';
+          (k3 as { type: string }).type = "cat";
-                    k3.regionId = 'board';
+          k3.regionId = "board";
           k3.position = [2, 0];
-                    state.regions.board.partMap['2,0'] = k3.id;
+          state.regions.board.partMap["2,0"] = k3.id;
-                    state.regions.black.childIds = state.regions.black.childIds.filter(id => id !== k3.id);
+          state.regions.black.childIds = state.regions.black.childIds.filter(
+            (id) => id !== k3.id,
+          );
         }
       });
 
       // Run check-win command
-            const result = await ctx._commands.run('check-win');
+      const result = await ctx._commands.run("check-win");
       expect(result.success).toBe(true);
       if (result.success) {
-                expect(result.result).toBe('black');
+        expect(result.result).toBe("black");
       }
     });
 
-        it('should detect diagonal win with three cats', async () => {
+    it("should detect diagonal win with three cats", async () => {
       const { ctx } = createTestContext();
 
       // Manually set up a diagonal winning scenario for white
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                const k1 = state.pieces['white-kitten-1'];
+        const k1 = state.pieces["white-kitten-1"];
-                const k2 = state.pieces['white-kitten-2'];
+        const k2 = state.pieces["white-kitten-2"];
-                const k3 = state.pieces['white-kitten-3'];
+        const k3 = state.pieces["white-kitten-3"];
 
         if (k1) {
-                    k1.type = 'cat';
+          (k1 as { type: string }).type = "cat";
-                    k1.regionId = 'board';
+          k1.regionId = "board";
           k1.position = [0, 0];
-                    state.regions.board.partMap['0,0'] = k1.id;
+          state.regions.board.partMap["0,0"] = k1.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k1.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== k1.id,
+          );
         }
         if (k2) {
-                    k2.type = 'cat';
+          (k2 as { type: string }).type = "cat";
-                    k2.regionId = 'board';
+          k2.regionId = "board";
           k2.position = [1, 1];
-                    state.regions.board.partMap['1,1'] = k2.id;
+          state.regions.board.partMap["1,1"] = k2.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k2.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== k2.id,
+          );
         }
         if (k3) {
-                    k3.type = 'cat';
+          (k3 as { type: string }).type = "cat";
-                    k3.regionId = 'board';
+          k3.regionId = "board";
           k3.position = [2, 2];
-                    state.regions.board.partMap['2,2'] = k3.id;
+          state.regions.board.partMap["2,2"] = k3.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== k3.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== k3.id,
+          );
         }
       });
 
       // Run check-win command
-            const result = await ctx._commands.run('check-win');
+      const result = await ctx._commands.run("check-win");
       expect(result.success).toBe(true);
       if (result.success) {
-                expect(result.result).toBe('white');
+        expect(result.result).toBe("white");
       }
     });
   });
 
-    describe('Placing Cats', () => {
+  describe("Placing Cats", () => {
-        it('should allow placing a cat from supply', async () => {
+    it("should allow placing a cat from supply", async () => {
       const { ctx } = createTestContext();
 
       // Manually give a cat to white's supply
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                const cat = state.pieces['white-cat-1'];
+        const cat = state.pieces["white-cat-1"];
-                if (cat && cat.regionId === '') {
+        if (cat && cat.regionId === "") {
-                    cat.regionId = 'white';
+          cat.regionId = "white";
           state.regions.white.childIds.push(cat.id);
         }
       });
 
       // White places a cat at 2,2
       const promptPromise = waitForPrompt(ctx);
-            const runPromise = ctx.run('turn white');
+      const runPromise = ctx.run("turn white");
       const prompt = await promptPromise;
-            const error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'cat'], options: {}, flags: {} });
+      const error = prompt.tryCommit({
+        name: "play",
+        params: ["white", 2, 2, "cat"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       const result = await runPromise;
       expect(result.success).toBe(true);
 
       const state = ctx.value;
       // Cat should be on the board
-            expect(state.regions.board.partMap['2,2']).toBe('white-cat-1');
+      expect(state.regions.board.partMap["2,2"]).toBe("white-cat-1");
       // Cat should no longer be in supply
-            const whiteCatsInSupply = state.regions.white.childIds.filter(id => state.pieces[id].type === 'cat');
+      const whiteCatsInSupply = state.regions.white.childIds.filter(
+        (id) => state.pieces[id].type === "cat",
+      );
       expect(whiteCatsInSupply.length).toBe(0);
     });
   });
 
-    describe('Check Full Board', () => {
+  describe("Check Full Board", () => {
-        it('should not trigger when player has fewer than 8 pieces on board', async () => {
+    it("should not trigger when player has fewer than 8 pieces on board", async () => {
       const { ctx } = createTestContext();
 
       // White places a single kitten
       const promptPromise = waitForPrompt(ctx);
-            const runPromise = ctx.run('turn white');
+      const runPromise = ctx.run("turn white");
       const prompt = await promptPromise;
-            const error = prompt.tryCommit({ name: 'play', params: ['white', 2, 2, 'kitten'], options: {}, flags: {} });
+      const error = prompt.tryCommit({
+        name: "play",
+        params: ["white", 2, 2, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
       const result = await runPromise;
       expect(result.success).toBe(true);
 
       // check-full-board should return without prompting
-            const fullBoardResult = await ctx._commands.run('check-full-board white');
+      const fullBoardResult = await ctx._commands.run("check-full-board white");
       expect(fullBoardResult.success).toBe(true);
     });
 
-        it('should force graduation when all 8 pieces are on board', async () => {
+    it("should force graduation when all 8 pieces are on board", async () => {
       const { ctx } = createTestContext();
 
       // Manually place all 8 white pieces on the board
-            ctx.produce(state => {
+      ctx.produce((state) => {
         for (let i = 1; i <= 8; i++) {
           const piece = state.pieces[`white-kitten-${i}`];
           if (piece) {
             const row = Math.floor((i - 1) / 4);
             const col = (i - 1) % 4;
-                        piece.regionId = 'board';
+            piece.regionId = "board";
             piece.position = [row, col];
             state.regions.board.partMap[`${row},${col}`] = piece.id;
-                        state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== piece.id);
+            state.regions.white.childIds = state.regions.white.childIds.filter(
+              (id) => id !== piece.id,
+            );
           }
         }
       });
@@ -574,12 +680,17 @@ describe('Boop Game', () => {
 
       // Run check-full-board - should prompt for piece to graduate
       const promptPromise = waitForPrompt(ctx);
-            const runPromise = ctx._commands.run('check-full-board white');
+      const runPromise = ctx._commands.run("check-full-board white");
       const prompt = await promptPromise;
-            expect(prompt.schema.name).toBe('choose');
+      expect(prompt.schema.name).toBe("choose");
 
       // Select a piece to graduate
-            const error = prompt.tryCommit({ name: 'choose', params: ['white', 0, 0], options: {}, flags: {} });
+      const error = prompt.tryCommit({
+        name: "choose",
+        params: ["white", 0, 0],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
 
       const result = await runPromise;
@@ -587,65 +698,73 @@ describe('Boop Game', () => {
 
       const state = ctx.value;
       // Position 0,0 should be empty (piece moved to box)
-            expect(state.regions.board.partMap['0,0']).toBeUndefined();
+      expect(state.regions.board.partMap["0,0"]).toBeUndefined();
     });
 
-        it('should not trigger when player has a winner', async () => {
+    it("should not trigger when player has a winner", async () => {
       const { ctx } = createTestContext();
 
       // Set up a winning state for white
-            ctx.produce(state => {
+      ctx.produce((state) => {
-                state.winner = 'white';
+        state.winner = "white";
         for (let i = 1; i <= 8; i++) {
           const piece = state.pieces[`white-kitten-${i}`];
           if (piece) {
             const row = Math.floor((i - 1) / 4);
             const col = (i - 1) % 4;
-                        piece.regionId = 'board';
+            piece.regionId = "board";
             piece.position = [row, col];
             state.regions.board.partMap[`${row},${col}`] = piece.id;
-                        state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== piece.id);
+            state.regions.white.childIds = state.regions.white.childIds.filter(
+              (id) => id !== piece.id,
+            );
           }
         }
       });
 
       // check-full-board should return without prompting
-            const fullBoardResult = await ctx._commands.run('check-full-board white');
+      const fullBoardResult = await ctx._commands.run("check-full-board white");
       expect(fullBoardResult.success).toBe(true);
     });
   });
 
-    describe('Start Command', () => {
+  describe("Start Command", () => {
-        it('should run a complete game until there is a winner', async () => {
+    it("should run a complete game until there is a winner", async () => {
       const { ctx } = createTestContext();
 
       // Set up a quick win scenario
-            ctx.produce(state => {
+      ctx.produce((state) => {
         // Place three white cats in a row
-                const c1 = state.pieces['white-cat-1'];
+        const c1 = state.pieces["white-cat-1"];
-                const c2 = state.pieces['white-cat-2'];
+        const c2 = state.pieces["white-cat-2"];
-                const c3 = state.pieces['white-cat-3'];
+        const c3 = state.pieces["white-cat-3"];
 
         if (c1) {
-                    c1.type = 'cat';
+          (c1 as { type: string }).type = "cat";
-                    c1.regionId = 'board';
+          c1.regionId = "board";
           c1.position = [0, 0];
-                    state.regions.board.partMap['0,0'] = c1.id;
+          state.regions.board.partMap["0,0"] = c1.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== c1.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== c1.id,
+          );
         }
         if (c2) {
-                    c2.type = 'cat';
+          (c2 as { type: string }).type = "cat";
-                    c2.regionId = 'board';
+          c2.regionId = "board";
           c2.position = [0, 1];
-                    state.regions.board.partMap['0,1'] = c2.id;
+          state.regions.board.partMap["0,1"] = c2.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== c2.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== c2.id,
+          );
         }
         if (c3) {
-                    c3.type = 'cat';
+          (c3 as { type: string }).type = "cat";
-                    c3.regionId = 'board';
+          c3.regionId = "board";
           c3.position = [0, 2];
-                    state.regions.board.partMap['0,2'] = c3.id;
+          state.regions.board.partMap["0,2"] = c3.id;
-                    state.regions.white.childIds = state.regions.white.childIds.filter(id => id !== c3.id);
+          state.regions.white.childIds = state.regions.white.childIds.filter(
+            (id) => id !== c3.id,
+          );
         }
       });
 
@@ -653,11 +772,16 @@ describe('Boop Game', () => {
       // Note: start() runs indefinitely until there's a winner
       // Since we already set up a win, it should complete after one turn
       const promptPromise = waitForPrompt(ctx);
-            const startPromise = ctx.run('turn white');
+      const startPromise = ctx.run("turn white");
 
       const prompt = await promptPromise;
       // Complete the turn
-            const error = prompt.tryCommit({ name: 'play', params: ['white', 3, 3, 'kitten'], options: {}, flags: {} });
+      const error = prompt.tryCommit({
+        name: "play",
+        params: ["white", 3, 3, "kitten"],
+        options: {},
+        flags: {},
+      });
       expect(error).toBeNull();
 
       const result = await startPromise;

tests/samples/regicide.test.ts

@@ -1,6 +1,7 @@
-import {createGameContext} from '@/core/game';
+import { describe, it, expect } from "vitest";
-import {registry} from '@/samples/regicide/commands';
+import { createGameContext } from "@/core/game";
-import {createInitialState} from '@/samples/regicide/state';
+import { registry } from "@/samples/regicide/commands";
+import { createInitialState } from "@/samples/regicide/state";
 import {
   buildEnemyDeck,
   buildTavernDeck,
@@ -8,50 +9,55 @@ import {
   createCard,
   createEnemy,
   getCardValue,
-    isEnemyDefeated
+  isEnemyDefeated,
-} from '@/samples/regicide/utils';
+} from "@/samples/regicide/utils";
-import {Mulberry32RNG} from '@/utils/rng';
+import { Mulberry32RNG } from "@/utils/rng";
-import {CARD_VALUES, ENEMY_COUNT, FACE_CARDS, INITIAL_HAND_SIZE} from '@/samples/regicide/constants';
+import {
-import {PlayerType} from '@/samples/regicide/types';
+  CARD_VALUES,
+  ENEMY_COUNT,
+  FACE_CARDS,
+  INITIAL_HAND_SIZE,
+} from "@/samples/regicide/constants";
+import { PlayerType } from "@/samples/regicide/types";
 
-describe('Regicide - Utils', () => {
+describe("Regicide - Utils", () => {
-    describe('getCardValue', () => {
+  describe("getCardValue", () => {
-        it('should return correct value for number cards', () => {
+    it("should return correct value for number cards", () => {
-            expect(getCardValue('A')).toBe(1);
+      expect(getCardValue("A")).toBe(1);
-            expect(getCardValue('5')).toBe(5);
+      expect(getCardValue("5")).toBe(5);
-            expect(getCardValue('10')).toBe(10);
+      expect(getCardValue("10")).toBe(10);
     });
 
-        it('should return correct value for face cards', () => {
+    it("should return correct value for face cards", () => {
-            expect(getCardValue('J')).toBe(10);
+      expect(getCardValue("J")).toBe(10);
-            expect(getCardValue('Q')).toBe(15);
+      expect(getCardValue("Q")).toBe(15);
-            expect(getCardValue('K')).toBe(20);
+      expect(getCardValue("K")).toBe(20);
     });
   });
 
-    describe('createCard', () => {
+  describe("createCard", () => {
-        it('should create a card with correct properties', () => {
+    it("should create a card with correct properties", () => {
-            const card = createCard('spades_A', 'spades', 'A');
+      const card = createCard("spades_A", "spades", "A");
-            expect(card.id).toBe('spades_A');
+      expect(card.id).toBe("spades_A");
-            expect(card.suit).toBe('spades');
+      expect(card.suit).toBe("spades");
-            expect(card.rank).toBe('A');
+      expect(card.rank).toBe("A");
       expect(card.value).toBe(1);
     });
   });
 
-    describe('createEnemy', () => {
+  describe("createEnemy", () => {
-        it('should create an enemy with correct HP', () => {
+    it("should create an enemy with correct HP", () => {
-            const enemy = createEnemy('enemy_0', 'J', 'spades');
+      const enemy = createEnemy("enemy_0", "J", "spades");
-            expect(enemy.rank).toBe('J');
+      expect(enemy.rank).toBe("J");
       expect(enemy.value).toBe(10);
       expect(enemy.hp).toBe(20);
       expect(enemy.maxHp).toBe(20);
     });
 
-        it('should create enemy with different values for different ranks', () => {
+    it("should create enemy with different values for different ranks", () => {
-            const jEnemy = createEnemy('enemy_0', 'J', 'spades');
+      const jEnemy = createEnemy("enemy_0", "J", "spades");
-            const qEnemy = createEnemy('enemy_1', 'Q', 'hearts');
+      const qEnemy = createEnemy("enemy_1", "Q", "hearts");
-            const kEnemy = createEnemy('enemy_2', 'K', 'diamonds');
+      const kEnemy = createEnemy("enemy_2", "K", "diamonds");
 
       expect(jEnemy.value).toBe(10);
       expect(qEnemy.value).toBe(15);
@@ -63,16 +69,30 @@ describe('Regicide - Utils', () => {
     });
   });
 
-    describe('createAllCards', () => {
+  describe("createAllCards", () => {
-        it('should create 52 cards', () => {
+    it("should create 52 cards", () => {
       const cards = createAllCards();
       expect(Object.keys(cards).length).toBe(52);
     });
 
-        it('should have all suits and ranks', () => {
+    it("should have all suits and ranks", () => {
       const cards = createAllCards();
-            const suits = ['spades', 'hearts', 'diamonds', 'clubs'];
+      const suits = ["spades", "hearts", "diamonds", "clubs"];
-            const ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'];
+      const ranks = [
+        "A",
+        "2",
+        "3",
+        "4",
+        "5",
+        "6",
+        "7",
+        "8",
+        "9",
+        "10",
+        "J",
+        "Q",
+        "K",
+      ];
 
       for (const suit of suits) {
         for (const rank of ranks) {
@@ -85,39 +105,39 @@ describe('Regicide - Utils', () => {
     });
   });
 
-    describe('buildEnemyDeck', () => {
+  describe("buildEnemyDeck", () => {
-        it('should create 12 enemies (J/Q/K)', () => {
+    it("should create 12 enemies (J/Q/K)", () => {
       const rng = new Mulberry32RNG(12345);
       const deck = buildEnemyDeck(rng);
       expect(deck.length).toBe(12);
     });
 
-        it('should have J at top, Q in middle, K at bottom', () => {
+    it("should have J at top, Q in middle, K at bottom", () => {
       const rng = new Mulberry32RNG(12345);
       const deck = buildEnemyDeck(rng);
 
       for (let i = 0; i < 4; i++) {
-                expect(deck[i].rank).toBe('J');
+        expect(deck[i].rank).toBe("J");
       }
 
       for (let i = 4; i < 8; i++) {
-                expect(deck[i].rank).toBe('Q');
+        expect(deck[i].rank).toBe("Q");
       }
 
       for (let i = 8; i < 12; i++) {
-                expect(deck[i].rank).toBe('K');
+        expect(deck[i].rank).toBe("K");
       }
     });
   });
 
-    describe('buildTavernDeck', () => {
+  describe("buildTavernDeck", () => {
-        it('should create 40 cards (A-10)', () => {
+    it("should create 40 cards (A-10)", () => {
       const rng = new Mulberry32RNG(12345);
       const deck = buildTavernDeck(rng);
       expect(deck.length).toBe(40);
     });
 
-        it('should not contain face cards', () => {
+    it("should not contain face cards", () => {
       const rng = new Mulberry32RNG(12345);
       const deck = buildTavernDeck(rng);
 
@@ -127,9 +147,9 @@ describe('Regicide - Utils', () => {
     });
   });
 
-    describe('isEnemyDefeated', () => {
+  describe("isEnemyDefeated", () => {
-        it('should return true when enemy HP <= 0', () => {
+    it("should return true when enemy HP <= 0", () => {
-            const enemy = createEnemy('enemy_0', 'J', 'spades');
+      const enemy = createEnemy("enemy_0", "J", "spades");
       expect(isEnemyDefeated(enemy)).toBe(false);
 
       enemy.hp = 0;
@@ -139,13 +159,13 @@ describe('Regicide - Utils', () => {
       expect(isEnemyDefeated(enemy)).toBe(true);
     });
 
-        it('should return false for null enemy', () => {
+    it("should return false for null enemy", () => {
       expect(isEnemyDefeated(null)).toBe(false);
     });
   });
 });
 
-describe('Regicide - Commands', () => {
+describe("Regicide - Commands", () => {
   function createTestContext() {
     const initialState = createInitialState();
     return createGameContext(registry, initialState);
@@ -157,12 +177,12 @@ describe('Regicide - Commands', () => {
     const enemyDeck = buildEnemyDeck(rng);
     const tavernDeck = buildTavernDeck(rng);
 
-        game.produce(state => {
+    game.produce((state) => {
       state.cards = cards;
       state.playerCount = 2;
       state.currentPlayerIndex = 0;
       state.enemyDeck = [...enemyDeck];
-            state.currentEnemy = {...enemyDeck[0]};
+      state.currentEnemy = { ...enemyDeck[0] };
 
       for (const card of tavernDeck) {
         state.regions.tavernDeck.childIds.push(card.id);
@@ -171,8 +191,8 @@ describe('Regicide - Commands', () => {
       for (let i = 0; i < 6; i++) {
         const card1 = tavernDeck[i];
         const card2 = tavernDeck[i + 6];
-                card1.regionId = 'hand_player1';
+        card1.regionId = "hand_player1";
-                card2.regionId = 'hand_player2';
+        card2.regionId = "hand_player2";
         state.playerHands.player1.push(card1.id);
         state.playerHands.player2.push(card2.id);
         state.regions.hand_player1.childIds.push(card1.id);
@@ -181,8 +201,8 @@ describe('Regicide - Commands', () => {
     });
   }
 
-    describe('play command', () => {
+  describe("play command", () => {
-        it('should deal damage to current enemy', async () => {
+    it("should deal damage to current enemy", async () => {
       const game = createTestContext();
       setupTestGame(game);
 
@@ -195,17 +215,17 @@ describe('Regicide - Commands', () => {
       expect(game.value.currentEnemy!.hp).toBe(enemyHpBefore - card.value);
     });
 
-        it('should double damage for clubs suit', async () => {
+    it("should double damage for clubs suit", async () => {
       const game = createTestContext();
       setupTestGame(game);
 
-            game.produce(state => {
+      game.produce((state) => {
-                state.cards['clubs_5'] = createCard('clubs_5', 'clubs', '5');
+        state.cards["clubs_5"] = createCard("clubs_5", "clubs", "5");
-                state.playerHands.player1.push('clubs_5');
+        state.playerHands.player1.push("clubs_5");
-                state.regions.hand_player1.childIds.push('clubs_5');
+        state.regions.hand_player1.childIds.push("clubs_5");
       });
 
-            const clubsCardId = 'clubs_5';
+      const clubsCardId = "clubs_5";
       const enemyHpBefore = game.value.currentEnemy!.hp;
       const card = game.value.cards[clubsCardId];
 
@@ -215,79 +235,79 @@ describe('Regicide - Commands', () => {
     });
   });
 
-    describe('pass command', () => {
+  describe("pass command", () => {
-        it('should allow player to pass', async () => {
+    it("should allow player to pass", async () => {
       const game = createTestContext();
       setupTestGame(game);
 
-            const result = await game.run('pass player1');
+      const result = await game.run("pass player1");
 
       expect(result.success).toBe(true);
     });
   });
 
-    describe('check-enemy command', () => {
+  describe("check-enemy command", () => {
-        it('should detect defeated enemy and reveal next', async () => {
+    it("should detect defeated enemy and reveal next", async () => {
       const game = createTestContext();
       setupTestGame(game);
 
       const firstEnemy = game.value.currentEnemy!;
-            game.produce(state => {
+      game.produce((state) => {
         state.currentEnemy!.hp = 0;
       });
 
-            await game.run('check-enemy');
+      await game.run("check-enemy");
 
       expect(game.value.regions.discardPile.childIds).toContain(firstEnemy.id);
       expect(game.value.currentEnemy).not.toBe(firstEnemy);
     });
 
-        it('should not defeat enemy if HP > 0', async () => {
+    it("should not defeat enemy if HP > 0", async () => {
       const game = createTestContext();
       setupTestGame(game);
 
       const currentEnemyId = game.value.currentEnemy!.id;
 
-            await game.run('check-enemy');
+      await game.run("check-enemy");
 
       expect(game.value.currentEnemy!.id).toBe(currentEnemyId);
     });
   });
 
-    describe('next-turn command', () => {
+  describe("next-turn command", () => {
-        it('should switch to next player', async () => {
+    it("should switch to next player", async () => {
       const game = createTestContext();
       setupTestGame(game);
 
       expect(game.value.currentPlayerIndex).toBe(0);
 
-            await game.run('next-turn');
+      await game.run("next-turn");
 
       expect(game.value.currentPlayerIndex).toBe(1);
     });
 
-        it('should wrap around to first player', async () => {
+    it("should wrap around to first player", async () => {
       const game = createTestContext();
       setupTestGame(game);
 
-            game.produce(state => {
+      game.produce((state) => {
         state.currentPlayerIndex = 1;
       });
 
-            await game.run('next-turn');
+      await game.run("next-turn");
 
       expect(game.value.currentPlayerIndex).toBe(0);
     });
   });
 });
 
-describe('Regicide - Game Flow', () => {
+describe("Regicide - Game Flow", () => {
   function createTestContext() {
     const initialState = createInitialState();
     return createGameContext(registry, initialState);
   }
 
-    it('should complete a full turn cycle', async () => {
+  it("should complete a full turn cycle", async () => {
     const game = createTestContext();
 
     const cards = createAllCards();
@@ -295,12 +315,12 @@ describe('Regicide - Game Flow', () => {
     const enemyDeck = buildEnemyDeck(rng);
     const tavernDeck = buildTavernDeck(rng);
 
-        game.produce(state => {
+    game.produce((state) => {
       state.cards = cards;
       state.playerCount = 1;
       state.currentPlayerIndex = 0;
       state.enemyDeck = [...enemyDeck.slice(1)];
-            state.currentEnemy = {...enemyDeck[0]};
+      state.currentEnemy = { ...enemyDeck[0] };
 
       for (const card of tavernDeck) {
         state.regions.tavernDeck.childIds.push(card.id);
@@ -308,7 +328,7 @@ describe('Regicide - Game Flow', () => {
 
       for (let i = 0; i < 6; i++) {
         const card = tavernDeck[i];
-                card.regionId = 'hand_player1';
+        card.regionId = "hand_player1";
         state.playerHands.player1.push(card.id);
         state.regions.hand_player1.childIds.push(card.id);
       }
@@ -323,14 +343,14 @@ describe('Regicide - Game Flow', () => {
     expect(game.value.currentEnemy!.hp).toBeLessThan(enemyHpBefore);
   });
 
-    it('should win game when all enemies defeated', async () => {
+  it("should win game when all enemies defeated", async () => {
     const game = createTestContext();
 
     const cards = createAllCards();
     const rng = new Mulberry32RNG(12345);
     const tavernDeck = buildTavernDeck(rng);
 
-        game.produce(state => {
+    game.produce((state) => {
       state.cards = cards;
       state.playerCount = 1;
       state.currentPlayerIndex = 0;
@@ -342,12 +362,12 @@ describe('Regicide - Game Flow', () => {
       }
     });
 
-        game.produce(state => {
+    game.produce((state) => {
-            state.phase = 'victory';
+      state.phase = "victory";
       state.winner = true;
     });
 
-        expect(game.value.phase).toBe('victory');
+    expect(game.value.phase).toBe("victory");
     expect(game.value.winner).toBe(true);
   });
 });

tests/samples/slay-the-spire-like/combat/effects.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
 import {
   addEffect,
   addEntityEffect,
@@ -12,47 +12,124 @@ import {
   getCombatEntity,
   canPlayCard,
   payCardCost,
-} from '@/samples/slay-the-spire-like/system/combat/effects';
+} from "@/samples/slay-the-spire-like/system/combat/effects";
-import type { CombatEntity, CombatState, EffectTable, PlayerEntity, EnemyEntity } from '@/samples/slay-the-spire-like/system/combat/types';
+import type {
-import type { EffectData } from '@/samples/slay-the-spire-like/system/types';
+  CombatEntity,
-import type { GridInventory, InventoryItem } from '@/samples/slay-the-spire-like/system/grid-inventory/types';
+  CombatState,
-import type { GameItemMeta } from '@/samples/slay-the-spire-like/system/progress/types';
+  EffectTable,
-import type { ParsedShape } from '@/samples/slay-the-spire-like/system/utils/parse-shape';
+  IRunContext,
-import type { Transform2D } from '@/samples/slay-the-spire-like/system/utils/shape-collision';
+  PlayerEntity,
+  EnemyEntity,
+} from "@/samples/slay-the-spire-like/system/combat/types";
+import type {
+  EffectData,
+  ItemData,
+} from "@/samples/slay-the-spire-like/system/types";
+import type {
+  CellKey,
+  GridInventory,
+  InventoryItem,
+} from "@/samples/slay-the-spire-like/system/grid-inventory/types";
+import type { GameItemMeta } from "@/samples/slay-the-spire-like/system/grid-inventory/types";
+import type { ParsedShape } from "@/samples/slay-the-spire-like/system/utils/parse-shape";
+import type { Transform2D } from "@/samples/slay-the-spire-like/system/utils/shape-collision";
+import { CardEffect } from "@/samples/slay-the-spire-like/data/desert";
 
-function createEffect(id: string, lifecycle: EffectData['lifecycle']): EffectData {
+function createRunContext(
-    return { id, name: id, description: '', lifecycle };
+  items: Map<string, InventoryItem<GameItemMeta>>,
-}
+): IRunContext {
-
-function createCard(id: string, costType: 'energy' | 'uses' | 'none', costCount: number) {
-    return { id, name: id, desc: '', type: 'item' as const, costType, costCount, targetType: 'none' as const, effects: [] as const };
-}
-
-function createItem(itemId: string, cardId: string, costType: 'energy' | 'uses' | 'none', costCount: number, depletion = 0): InventoryItem<GameItemMeta> {
   return {
-        id: itemId,
+    getItemData(id: string): ItemData | null {
-        shape: { id: '1x1', cells: [{ x: 0, y: 0 }] } as unknown as ParsedShape,
+      const item = items.get(id);
-        transform: { x: 0, y: 0, rotation: 0, flipX: false, flipY: false } as unknown as Transform2D,
+      return item?.meta?.itemData ?? null;
-        meta: {
+    },
-            itemData: { id: itemId, type: 'weapon', name: itemId, shape: '1x1', card: createCard(cardId, costType, costCount), price: 0, description: '' },
+    getAdjacentItems(_id: string): Iterable<string> {
-            shape: { id: '1x1', cells: [{ x: 0, y: 0 }] } as unknown as ParsedShape,
+      return [];
-            depletion: costType === 'uses' ? depletion : undefined,
+    },
+    getConsumedUses(id: string): number {
+      const item = items.get(id);
+      return item?.meta?.consumedUses ?? 0;
+    },
+    setConsumedUsesAsync(id: string, uses: number): Promise<void> {
+      const item = items.get(id);
+      if (item?.meta) {
+        item.meta.consumedUses = uses;
+      }
+      return Promise.resolve();
     },
   };
 }
 
-function createInventory(items: InventoryItem<GameItemMeta>[]): GridInventory<GameItemMeta> {
+function createEffect(
+  id: string,
+  lifecycle: EffectData["lifecycle"],
+): EffectData {
+  return { id, name: id, description: "", lifecycle, emoji: "" };
+}
+
+function createCard(
+  id: string,
+  costType: "energy" | "uses" | "none",
+  costCount: number,
+) {
+  return {
+    id,
+    name: id,
+    desc: "",
+    type: "item" as const,
+    costType,
+    costCount,
+    targetType: "player" as const,
+    effects: [] as CardEffect[],
+  };
+}
+
+function createItem(
+  itemId: string,
+  cardId: string,
+  costType: "energy" | "uses" | "none",
+  costCount: number,
+  depletion = 0,
+): InventoryItem<GameItemMeta> {
+  return {
+    id: itemId,
+    shape: { id: "1x1", cells: [{ x: 0, y: 0 }] } as unknown as ParsedShape,
+    transform: {
+      offset: { x: 0, y: 0 },
+      flipX: false,
+      flipY: false,
+    } as unknown as Transform2D,
+    meta: {
+      itemData: {
+        id: itemId,
+        type: "weapon",
+        name: itemId,
+        shape: "1x1",
+        card: createCard(cardId, costType, costCount),
+        price: 0,
+        description: "",
+      },
+      shape: { id: "1x1", cells: [{ x: 0, y: 0 }] } as unknown as ParsedShape,
+      consumedUses: costType === "uses" ? depletion : undefined,
+    },
+  };
+}
+
+function createInventory(
+  items: InventoryItem<GameItemMeta>[],
+): GridInventory<GameItemMeta> {
   const map = new Map<string, InventoryItem<GameItemMeta>>();
-    const occupied = new Set<string>();
+  const occupied = new Set<CellKey>();
   for (const item of items) {
     map.set(item.id, item);
-        occupied.add(`${item.transform.x},${item.transform.y}`);
+    occupied.add(`${item.transform.offset.x},${item.transform.offset.y}`);
   }
   return { width: 6, height: 4, items: map, occupiedCells: occupied };
 }
 
 function createCombatEntity(hp = 10, maxHp = 10): CombatEntity {
   return {
+    id: "",
     effects: {},
     hp,
     maxHp,
@@ -65,7 +142,15 @@ function createPlayerEntity(hp = 30, maxHp = 30): PlayerEntity {
     ...createCombatEntity(hp, maxHp),
     energy: 3,
     maxEnergy: 3,
-        deck: { cards: {}, regions: { drawPile: { id: 'drawPile', axes: [], childIds: [], partMap: {} }, hand: { id: 'hand', axes: [], childIds: [], partMap: {} }, discardPile: { id: 'discardPile', axes: [], childIds: [], partMap: {} }, exhaustPile: { id: 'exhaustPile', axes: [], childIds: [], partMap: {} } } },
+    deck: {
+      cards: {},
+      regions: {
+        drawPile: { id: "drawPile", axes: [], childIds: [], partMap: {} },
+        hand: { id: "hand", axes: [], childIds: [], partMap: {} },
+        discardPile: { id: "discardPile", axes: [], childIds: [], partMap: {} },
+        exhaustPile: { id: "exhaustPile", axes: [], childIds: [], partMap: {} },
+      },
+    },
     itemEffects: {},
   };
 }
@@ -74,334 +159,336 @@ function createEnemyEntity(id: string, hp = 10, maxHp = 10): EnemyEntity {
   return {
     ...createCombatEntity(hp, maxHp),
     id,
-        enemy: { id, name: id, description: '' },
+    enemy: { id, name: id, description: "", intents: null! },
     intents: {},
-        currentIntentId: '',
+    currentIntent: null!,
   };
 }
 
-function createCombatState(playerHp = 30, enemies: EnemyEntity[] = []): CombatState {
+function createCombatState(
+  playerHp = 30,
+  enemies: EnemyEntity[] = [],
+): CombatState {
   return {
     player: createPlayerEntity(playerHp),
     enemies,
-        inventory: { width: 6, height: 4, items: new Map(), occupiedCells: new Set() },
+    phase: "playerTurn",
-        phase: 'playerTurn',
     turnNumber: 1,
     result: null,
     loot: [],
   };
 }
 
-describe('combat/effects', () => {
+describe("combat/effects", () => {
-    describe('addEffect', () => {
+  describe("addEffect", () => {
-        it('should add a new effect to an empty table', () => {
+    it("should add a new effect to an empty table", () => {
       const table: EffectTable = {};
-            const effect = createEffect('strength', 'temporary');
+      const effect = createEffect("strength", "temporary");
 
       addEffect(table, effect, 3);
 
-            expect(table['strength']).toBeDefined();
+      expect(table["strength"]).toBeDefined();
-            expect(table['strength'].data).toBe(effect);
+      expect(table["strength"].data).toBe(effect);
-            expect(table['strength'].stacks).toBe(3);
+      expect(table["strength"].stacks).toBe(3);
     });
 
-        it('should stack with existing effect of same id', () => {
+    it("should stack with existing effect of same id", () => {
       const table: EffectTable = {};
-            const effect = createEffect('strength', 'lingering');
+      const effect = createEffect("strength", "lingering");
 
       addEffect(table, effect, 2);
       addEffect(table, effect, 3);
 
-            expect(table['strength'].stacks).toBe(5);
+      expect(table["strength"].stacks).toBe(5);
     });
 
-        it('should remove effect when stacks reach 0', () => {
+    it("should remove effect when stacks reach 0", () => {
       const table: EffectTable = {};
-            const effect = createEffect('strength', 'temporary');
+      const effect = createEffect("strength", "temporary");
 
       addEffect(table, effect, 3);
       addEffect(table, effect, -3);
 
-            expect(table['strength']).toBeUndefined();
+      expect(table["strength"]).toBeUndefined();
     });
 
-        it('should not add effect when stacks is 0', () => {
+    it("should not add effect when stacks is 0", () => {
       const table: EffectTable = {};
-            const effect = createEffect('strength', 'temporary');
+      const effect = createEffect("strength", "temporary");
 
       addEffect(table, effect, 0);
 
-            expect(table['strength']).toBeUndefined();
+      expect(table["strength"]).toBeUndefined();
     });
 
-        it('should handle negative stacks', () => {
+    it("should handle negative stacks", () => {
       const table: EffectTable = {};
-            const effect = createEffect('weak', 'temporary');
+      const effect = createEffect("weak", "temporary");
 
       addEffect(table, effect, -2);
 
-            expect(table['weak'].stacks).toBe(-2);
+      expect(table["weak"].stacks).toBe(-2);
     });
   });
 
-    describe('addEntityEffect', () => {
+  describe("addEntityEffect", () => {
-        it('should add effect to entity.effects', () => {
+    it("should add effect to entity.effects", () => {
       const entity = createCombatEntity();
-            const effect = createEffect('vulnerable', 'lingering');
+      const effect = createEffect("vulnerable", "lingering");
 
       addEntityEffect(entity, effect, 2);
 
-            expect(entity.effects['vulnerable'].stacks).toBe(2);
+      expect(entity.effects["vulnerable"].stacks).toBe(2);
     });
   });
 
-    describe('addItemEffect', () => {
+  describe("addItemEffect", () => {
-        it('should add effect to player.itemEffects[itemKey]', () => {
+    it("should add effect to player.itemEffects[itemKey]", () => {
       const player = createPlayerEntity();
-            const effect = createEffect('adjacent-buff', 'itemTemporary');
+      const effect = createEffect("adjacent-buff", "itemTemporary");
 
-            addItemEffect(player, 'sword-1', effect, 3);
+      addItemEffect(player, "sword-1", effect, 3);
 
-            expect(player.itemEffects['sword-1']['adjacent-buff'].stacks).toBe(3);
+      expect(player.itemEffects["sword-1"]["adjacent-buff"].stacks).toBe(3);
     });
 
-        it('should initialize itemEffects entry if not present', () => {
+    it("should initialize itemEffects entry if not present", () => {
       const player = createPlayerEntity();
-            const effect = createEffect('adjacent-buff', 'itemTemporary');
+      const effect = createEffect("adjacent-buff", "itemTemporary");
 
-            addItemEffect(player, 'new-item', effect, 1);
+      addItemEffect(player, "new-item", effect, 1);
 
-            expect(player.itemEffects['new-item']).toBeDefined();
+      expect(player.itemEffects["new-item"]).toBeDefined();
     });
 
-        it('should stack with existing item effect', () => {
+    it("should stack with existing item effect", () => {
       const player = createPlayerEntity();
-            const effect = createEffect('adjacent-buff', 'itemTemporary');
+      const effect = createEffect("adjacent-buff", "itemTemporary");
 
-            addItemEffect(player, 'sword-1', effect, 2);
+      addItemEffect(player, "sword-1", effect, 2);
-            addItemEffect(player, 'sword-1', effect, 3);
+      addItemEffect(player, "sword-1", effect, 3);
 
-            expect(player.itemEffects['sword-1']['adjacent-buff'].stacks).toBe(5);
+      expect(player.itemEffects["sword-1"]["adjacent-buff"].stacks).toBe(5);
     });
   });
 
-    describe('onEntityEffectUpkeep', () => {
+  describe("onEntityEffectUpkeep", () => {
-        it('should remove temporary effects', () => {
+    it("should remove temporary effects", () => {
       const entity = createCombatEntity();
-            const tempEffect = createEffect('temp-shield', 'temporary');
+      const tempEffect = createEffect("temp-shield", "temporary");
 
       addEntityEffect(entity, tempEffect, 5);
       onEntityEffectUpkeep(entity);
 
-            expect(entity.effects['temp-shield']).toBeUndefined();
+      expect(entity.effects["temp-shield"]).toBeUndefined();
     });
 
-        it('should decrement lingering effects by 1', () => {
+    it("should decrement lingering effects by 1", () => {
       const entity = createCombatEntity();
-            const lingeringEffect = createEffect('poison', 'lingering');
+      const lingeringEffect = createEffect("poison", "lingering");
 
       addEntityEffect(entity, lingeringEffect, 3);
       onEntityEffectUpkeep(entity);
 
-            expect(entity.effects['poison'].stacks).toBe(2);
+      expect(entity.effects["poison"].stacks).toBe(2);
     });
 
-        it('should remove lingering effects when stacks reach 0', () => {
+    it("should remove lingering effects when stacks reach 0", () => {
       const entity = createCombatEntity();
-            const lingeringEffect = createEffect('poison', 'lingering');
+      const lingeringEffect = createEffect("poison", "lingering");
 
       addEntityEffect(entity, lingeringEffect, 1);
       onEntityEffectUpkeep(entity);
 
-            expect(entity.effects['poison']).toBeUndefined();
+      expect(entity.effects["poison"]).toBeUndefined();
     });
 
-        it('should not affect permanent effects', () => {
+    it("should not affect permanent effects", () => {
       const entity = createCombatEntity();
-            const permEffect = createEffect('max-hp-up', 'permanent');
+      const permEffect = createEffect("max-hp-up", "permanent");
 
       addEntityEffect(entity, permEffect, 5);
       onEntityEffectUpkeep(entity);
 
-            expect(entity.effects['max-hp-up'].stacks).toBe(5);
+      expect(entity.effects["max-hp-up"].stacks).toBe(5);
     });
 
-        it('should not affect instant effects', () => {
+    it("should not affect instant effects", () => {
       const entity = createCombatEntity();
-            const instantEffect = createEffect('instant-damage', 'instant');
+      const instantEffect = createEffect("instant-damage", "instant");
 
       addEntityEffect(entity, instantEffect, 10);
       onEntityEffectUpkeep(entity);
 
-            expect(entity.effects['instant-damage'].stacks).toBe(10);
+      expect(entity.effects["instant-damage"].stacks).toBe(10);
     });
 
-        it('should increment lingering effects with negative stacks', () => {
+    it("should increment lingering effects with negative stacks", () => {
       const entity = createCombatEntity();
-            const lingeringEffect = createEffect('regen', 'lingering');
+      const lingeringEffect = createEffect("regen", "lingering");
 
       addEntityEffect(entity, lingeringEffect, -3);
       onEntityEffectUpkeep(entity);
 
-            expect(entity.effects['regen'].stacks).toBe(-2);
+      expect(entity.effects["regen"].stacks).toBe(-2);
     });
   });
 
-    describe('onEntityPostureDamage', () => {
+  describe("onEntityPostureDamage", () => {
-        it('should reduce posture effects by damage amount', () => {
+    it("should reduce posture effects by damage amount", () => {
       const entity = createCombatEntity();
-            const postureEffect = createEffect('block', 'posture');
+      const postureEffect = createEffect("block", "posture");
 
       addEntityEffect(entity, postureEffect, 10);
       onEntityPostureDamage(entity, 4);
 
-            expect(entity.effects['block'].stacks).toBe(6);
+      expect(entity.effects["block"].stacks).toBe(6);
     });
 
-        it('should not reduce posture effects below 0', () => {
+    it("should not reduce posture effects below 0", () => {
       const entity = createCombatEntity();
-            const postureEffect = createEffect('block', 'posture');
+      const postureEffect = createEffect("block", "posture");
 
       addEntityEffect(entity, postureEffect, 3);
       onEntityPostureDamage(entity, 10);
 
-            expect(entity.effects['block']).toBeUndefined();
+      expect(entity.effects["block"]).toBeUndefined();
     });
 
-        it('should not affect non-posture effects', () => {
+    it("should not affect non-posture effects", () => {
       const entity = createCombatEntity();
-            const postureEffect = createEffect('block', 'posture');
+      const postureEffect = createEffect("block", "posture");
-            const permEffect = createEffect('strength', 'permanent');
+      const permEffect = createEffect("strength", "permanent");
 
       addEntityEffect(entity, postureEffect, 5);
       addEntityEffect(entity, permEffect, 3);
       onEntityPostureDamage(entity, 2);
 
-            expect(entity.effects['block'].stacks).toBe(3);
+      expect(entity.effects["block"].stacks).toBe(3);
-            expect(entity.effects['strength'].stacks).toBe(3);
+      expect(entity.effects["strength"].stacks).toBe(3);
     });
 
-        it('should handle zero damage', () => {
+    it("should handle zero damage", () => {
       const entity = createCombatEntity();
-            const postureEffect = createEffect('block', 'posture');
+      const postureEffect = createEffect("block", "posture");
 
       addEntityEffect(entity, postureEffect, 5);
       onEntityPostureDamage(entity, 0);
 
-            expect(entity.effects['block'].stacks).toBe(5);
+      expect(entity.effects["block"].stacks).toBe(5);
     });
   });
 
-    describe('onPlayerItemEffectUpkeep', () => {
+  describe("onPlayerItemEffectUpkeep", () => {
-        it('should remove itemTemporary effects', () => {
+    it("should remove itemTemporary effects", () => {
       const player = createPlayerEntity();
-            const effect = createEffect('adjacent-buff', 'itemTemporary');
+      const effect = createEffect("adjacent-buff", "itemTemporary");
 
-            addItemEffect(player, 'sword-1', effect, 5);
+      addItemEffect(player, "sword-1", effect, 5);
       onPlayerItemEffectUpkeep(player);
 
-            expect(player.itemEffects['sword-1']['adjacent-buff']).toBeUndefined();
+      expect(player.itemEffects["sword-1"]["adjacent-buff"]).toBeUndefined();
     });
 
-        it('should not affect itemPermanent effects', () => {
+    it("should not affect itemPermanent effects", () => {
       const player = createPlayerEntity();
-            const effect = createEffect('adjacent-buff', 'itemPermanent');
+      const effect = createEffect("adjacent-buff", "itemPermanent");
 
-            addItemEffect(player, 'sword-1', effect, 5);
+      addItemEffect(player, "sword-1", effect, 5);
       onPlayerItemEffectUpkeep(player);
 
-            expect(player.itemEffects['sword-1']['adjacent-buff'].stacks).toBe(5);
+      expect(player.itemEffects["sword-1"]["adjacent-buff"].stacks).toBe(5);
     });
 
-        it('should not affect itemUntilPlay effects', () => {
+    it("should not affect itemUntilPlay effects", () => {
       const player = createPlayerEntity();
-            const effect = createEffect('charged', 'itemUntilPlay');
+      const effect = createEffect("charged", "itemUntilPlay");
 
-            addItemEffect(player, 'sword-1', effect, 3);
+      addItemEffect(player, "sword-1", effect, 3);
       onPlayerItemEffectUpkeep(player);
 
-            expect(player.itemEffects['sword-1']['charged'].stacks).toBe(3);
+      expect(player.itemEffects["sword-1"]["charged"].stacks).toBe(3);
     });
   });
 
-    describe('onItemPlay', () => {
+  describe("onItemPlay", () => {
-        it('should remove itemUntilPlay effects', () => {
+    it("should remove itemUntilPlay effects", () => {
       const player = createPlayerEntity();
-            const effect = createEffect('charged', 'itemUntilPlay');
+      const effect = createEffect("charged", "itemUntilPlay");
 
-            addItemEffect(player, 'sword-1', effect, 3);
+      addItemEffect(player, "sword-1", effect, 3);
-            onItemPlay(player, 'sword-1');
+      onItemPlay(player, "sword-1");
 
-            expect(player.itemEffects['sword-1']['charged']).toBeUndefined();
+      expect(player.itemEffects["sword-1"]["charged"]).toBeUndefined();
     });
 
-        it('should not affect other lifecycle effects', () => {
+    it("should not affect other lifecycle effects", () => {
       const player = createPlayerEntity();
-            const permEffect = createEffect('passive', 'itemPermanent');
+      const permEffect = createEffect("passive", "itemPermanent");
-            const playEffect = createEffect('charged', 'itemUntilPlay');
+      const playEffect = createEffect("charged", "itemUntilPlay");
 
-            addItemEffect(player, 'sword-1', permEffect, 5);
+      addItemEffect(player, "sword-1", permEffect, 5);
-            addItemEffect(player, 'sword-1', playEffect, 3);
+      addItemEffect(player, "sword-1", playEffect, 3);
-            onItemPlay(player, 'sword-1');
+      onItemPlay(player, "sword-1");
 
-            expect(player.itemEffects['sword-1']['passive'].stacks).toBe(5);
+      expect(player.itemEffects["sword-1"]["passive"].stacks).toBe(5);
-            expect(player.itemEffects['sword-1']['charged']).toBeUndefined();
+      expect(player.itemEffects["sword-1"]["charged"]).toBeUndefined();
     });
 
-        it('should do nothing for item with no effects', () => {
+    it("should do nothing for item with no effects", () => {
       const player = createPlayerEntity();
 
-            expect(() => onItemPlay(player, 'nonexistent')).not.toThrow();
+      expect(() => onItemPlay(player, "nonexistent")).not.toThrow();
     });
   });
 
-    describe('onItemDiscard', () => {
+  describe("onItemDiscard", () => {
-        it('should remove itemUntilDiscard effects', () => {
+    it("should remove itemUntilDiscard effects", () => {
       const player = createPlayerEntity();
-            const effect = createEffect('discard-buff', 'itemUntilDiscard');
+      const effect = createEffect("discard-buff", "itemUntilDiscard");
 
-            addItemEffect(player, 'sword-1', effect, 3);
+      addItemEffect(player, "sword-1", effect, 3);
-            onItemDiscard(player, 'sword-1');
+      onItemDiscard(player, "sword-1");
 
-            expect(player.itemEffects['sword-1']['discard-buff']).toBeUndefined();
+      expect(player.itemEffects["sword-1"]["discard-buff"]).toBeUndefined();
     });
 
-        it('should not affect other lifecycle effects', () => {
+    it("should not affect other lifecycle effects", () => {
       const player = createPlayerEntity();
-            const permEffect = createEffect('passive', 'itemPermanent');
+      const permEffect = createEffect("passive", "itemPermanent");
-            const discardEffect = createEffect('discard-buff', 'itemUntilDiscard');
+      const discardEffect = createEffect("discard-buff", "itemUntilDiscard");
 
-            addItemEffect(player, 'sword-1', permEffect, 5);
+      addItemEffect(player, "sword-1", permEffect, 5);
-            addItemEffect(player, 'sword-1', discardEffect, 3);
+      addItemEffect(player, "sword-1", discardEffect, 3);
-            onItemDiscard(player, 'sword-1');
+      onItemDiscard(player, "sword-1");
 
-            expect(player.itemEffects['sword-1']['passive'].stacks).toBe(5);
+      expect(player.itemEffects["sword-1"]["passive"].stacks).toBe(5);
-            expect(player.itemEffects['sword-1']['discard-buff']).toBeUndefined();
+      expect(player.itemEffects["sword-1"]["discard-buff"]).toBeUndefined();
     });
 
-        it('should do nothing for item with no effects', () => {
+    it("should do nothing for item with no effects", () => {
       const player = createPlayerEntity();
 
-            expect(() => onItemDiscard(player, 'nonexistent')).not.toThrow();
+      expect(() => onItemDiscard(player, "nonexistent")).not.toThrow();
     });
   });
 
-    describe('getAliveEnemies', () => {
+  describe("getAliveEnemies", () => {
-        it('should yield only alive enemies', () => {
+    it("should yield only alive enemies", () => {
       const state = createCombatState(30, [
-                createEnemyEntity('slime-1', 10, 10),
+        createEnemyEntity("slime-1", 10, 10),
-                createEnemyEntity('slime-2', 0, 10),
+        createEnemyEntity("slime-2", 0, 10),
-                createEnemyEntity('slime-3', 5, 10),
+        createEnemyEntity("slime-3", 5, 10),
       ]);
 
       const alive = [...getAliveEnemies(state)];
 
       expect(alive.length).toBe(2);
-            expect(alive[0].id).toBe('slime-1');
+      expect(alive[0].id).toBe("slime-1");
-            expect(alive[1].id).toBe('slime-3');
+      expect(alive[1].id).toBe("slime-3");
     });
 
-        it('should return empty for no enemies', () => {
+    it("should return empty for no enemies", () => {
       const state = createCombatState(30, []);
 
       const alive = [...getAliveEnemies(state)];
@@ -409,10 +496,10 @@ describe('combat/effects', () => {
       expect(alive.length).toBe(0);
     });
 
-        it('should return empty when all enemies are dead', () => {
+    it("should return empty when all enemies are dead", () => {
       const state = createCombatState(30, [
-                createEnemyEntity('slime-1', 0, 10),
+        createEnemyEntity("slime-1", 0, 10),
-                createEnemyEntity('slime-2', 0, 10),
+        createEnemyEntity("slime-2", 0, 10),
       ]);
 
       const alive = [...getAliveEnemies(state)];
@@ -421,130 +508,142 @@ describe('combat/effects', () => {
     });
   });
 
-    describe('getCombatEntity', () => {
+  describe("getCombatEntity", () => {
     it('should return player for "player" key', () => {
       const state = createCombatState(30);
 
-            const entity = getCombatEntity(state, 'player');
+      const entity = getCombatEntity(state, "player");
 
       expect(entity).toBe(state.player);
     });
 
-        it('should return enemy by id', () => {
+    it("should return enemy by id", () => {
-            const enemy = createEnemyEntity('boss-1', 50, 50);
+      const enemy = createEnemyEntity("boss-1", 50, 50);
       const state = createCombatState(30, [enemy]);
 
-            const entity = getCombatEntity(state, 'boss-1');
+      const entity = getCombatEntity(state, "boss-1");
 
       expect(entity).toBe(enemy);
     });
 
-        it('should return undefined for non-existent enemy', () => {
+    it("should return undefined for non-existent enemy", () => {
-            const state = createCombatState(30, [createEnemyEntity('slime-1')]);
+      const state = createCombatState(30, [createEnemyEntity("slime-1")]);
 
-            const entity = getCombatEntity(state, 'nonexistent');
+      const entity = getCombatEntity(state, "nonexistent");
 
       expect(entity).toBeUndefined();
     });
   });
 
-    describe('canPlayCard', () => {
+  describe("canPlayCard", () => {
-        it('should allow playing energy card when player has enough energy', () => {
+    it("should allow playing energy card when player has enough energy", () => {
       const player = createPlayerEntity();
       player.energy = 3;
       const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);
 
-            const result = canPlayCard(player, 'energy', 2, 'any', inventory);
+      const result = canPlayCard(player, "energy", 2, "any", run);
 
       expect(result).toBe(true);
     });
 
-        it('should reject playing energy card when player lacks energy', () => {
+    it("should reject playing energy card when player lacks energy", () => {
       const player = createPlayerEntity();
       player.energy = 1;
       const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);
 
-            const result = canPlayCard(player, 'energy', 2, 'any', inventory);
+      const result = canPlayCard(player, "energy", 2, "any", run);
 
       expect(result).toBe(false);
     });
 
-        it('should allow playing uses card when item has remaining uses', () => {
+    it("should allow playing uses card when item has remaining uses", () => {
       const player = createPlayerEntity();
-            const item = createItem('potion-1', 'potion-card', 'uses', 3, 1);
+      const item = createItem("potion-1", "potion-card", "uses", 3, 1);
       const inventory = createInventory([item]);
+      const run = createRunContext(inventory.items);
 
-            const result = canPlayCard(player, 'uses', 3, 'potion-1', inventory);
+      const result = canPlayCard(player, "uses", 3, "potion-1", run);
 
       expect(result).toBe(true);
     });
 
-        it('should reject playing uses card when item is depleted', () => {
+    it("should reject playing uses card when item is depleted", () => {
       const player = createPlayerEntity();
-            const item = createItem('potion-1', 'potion-card', 'uses', 3, 3);
+      const item = createItem("potion-1", "potion-card", "uses", 3, 3);
       const inventory = createInventory([item]);
+      const run = createRunContext(inventory.items);
 
-            const result = canPlayCard(player, 'uses', 3, 'potion-1', inventory);
+      const result = canPlayCard(player, "uses", 3, "potion-1", run);
 
       expect(result).toBe(false);
     });
 
-        it('should reject playing uses card when item not in inventory', () => {
+    it("should reject playing uses card when item not in inventory", () => {
       const player = createPlayerEntity();
       const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);
 
-            const result = canPlayCard(player, 'uses', 1, 'missing', inventory);
+      const result = canPlayCard(player, "uses", 1, "missing", run);
 
       expect(result).toBe(false);
     });
 
-        it('should always allow playing none cost card', () => {
+    it("should always allow playing none cost card", () => {
       const player = createPlayerEntity();
       player.energy = 0;
       const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);
 
-            const result = canPlayCard(player, 'none', 0, 'any', inventory);
+      const result = canPlayCard(player, "none", 0, "any", run);
 
       expect(result).toBe(true);
     });
   });
 
-    describe('payCardCost', () => {
+  describe("payCardCost", () => {
-        it('should deduct energy for energy cost card', () => {
+    it("should deduct energy for energy cost card", async () => {
       const player = createPlayerEntity();
       player.energy = 3;
       const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);
 
-            payCardCost(player, 'energy', 2, 'any', inventory);
+      await payCardCost(player, "energy", 2, "any", run);
 
       expect(player.energy).toBe(1);
     });
 
-        it('should increment depletion for uses cost card', () => {
+    it("should increment depletion for uses cost card", async () => {
       const player = createPlayerEntity();
-            const item = createItem('potion-1', 'potion-card', 'uses', 3, 1);
+      const item = createItem("potion-1", "potion-card", "uses", 3, 1);
       const inventory = createInventory([item]);
+      const run = createRunContext(inventory.items);
 
-            payCardCost(player, 'uses', 3, 'potion-1', inventory);
+      await payCardCost(player, "uses", 3, "potion-1", run);
 
-            expect(item.meta?.depletion).toBe(4);
+      expect(item.meta?.consumedUses).toBe(4);
     });
 
-        it('should do nothing for none cost card', () => {
+    it("should do nothing for none cost card", async () => {
       const player = createPlayerEntity();
       player.energy = 3;
       const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);
 
-            payCardCost(player, 'none', 0, 'any', inventory);
+      await payCardCost(player, "none", 0, "any", run);
 
       expect(player.energy).toBe(3);
     });
 
-        it('should handle missing item gracefully for uses cost', () => {
+    it("should handle missing item gracefully for uses cost", async () => {
       const player = createPlayerEntity();
       const inventory = createInventory([]);
+      const run = createRunContext(inventory.items);
 
-            expect(() => payCardCost(player, 'uses', 1, 'missing', inventory)).not.toThrow();
+      await expect(
+        payCardCost(player, "uses", 1, "missing", run),
+      ).resolves.not.toThrow();
     });
   });
 });

tests/samples/slay-the-spire-like/combat/triggers.test.ts

@@ -0,0 +1,680 @@
+import { describe, it, expect } from "vitest";
+import {
+  createGameContext,
+  createGameCommandRegistry,
+  IGameContext,
+} from "@/core/game";
+import { createRegion } from "@/core/region";
+import {
+  createTriggers,
+  Triggers,
+} from "@/samples/slay-the-spire-like/system/combat/triggers";
+import { addTriggers } from "@/samples/slay-the-spire-like/data/desert/triggers";
+import {
+  CombatState,
+  EnemyEntity,
+  IRunContext,
+} from "@/samples/slay-the-spire-like/system/combat/types";
+import { EffectData } from "@/samples/slay-the-spire-like/system/types";
+import {
+  GameCard,
+  DeckRegions,
+} from "@/samples/slay-the-spire-like/system/deck";
+import {
+  CellKey,
+  GridInventory,
+  InventoryItem,
+} from "@/samples/slay-the-spire-like/system/grid-inventory/types";
+import { GameItemMeta } from "@/samples/slay-the-spire-like/system/grid-inventory/types";
+import {
+  CardEffect,
+  getCards,
+  getEffects,
+  getEnemies,
+} from "@/samples/slay-the-spire-like/data/desert";
+const cards = getCards();
+const effects = getEffects();
+const enemies = getEnemies();
+
+function createEffect(
+  id: string,
+  lifecycle: EffectData["lifecycle"] = "instant",
+): EffectData {
+  const found = effects.find((e) => e.id === id);
+  if (found) return found;
+  return { id, name: id, description: "", lifecycle, emoji: "" };
+}
+
+function createDeckRegions(): DeckRegions {
+  return {
+    drawPile: createRegion("drawPile", []),
+    hand: createRegion("hand", []),
+    discardPile: createRegion("discardPile", []),
+    exhaustPile: createRegion("exhaustPile", []),
+  };
+}
+
+function createCard(
+  id: string,
+  itemId: string,
+  costType: "energy" | "uses" | "none" = "energy",
+  costCount = 0,
+): GameCard {
+  const cardData = cards.find((c) => c.id === itemId) ?? {
+    id: itemId,
+    name: itemId,
+    desc: "",
+    type: "item" as const,
+    costType,
+    costCount,
+    targetType: "player" as const,
+    effects: [] as CardEffect[],
+  };
+  return {
+    id,
+    regionId: "",
+    position: [0],
+    itemId,
+    cardData,
+  };
+}
+
+function createEnemyEntity(
+  enemyId: string,
+  hp: number,
+  maxHp: number,
+  instanceIndex = 0,
+): EnemyEntity {
+  const enemyData = enemies.find((e) => e.id === enemyId);
+  if (!enemyData) throw new Error(`Enemy "${enemyId}" not found`);
+  const intent =
+    enemyData.intents.find((i) => i.initialIntent) ?? enemyData.intents[0];
+  const instanceId = `${enemyId}-${instanceIndex}`;
+  const intentMap: Record<string, typeof intent> = {};
+  for (const i of enemyData.intents) {
+    intentMap[i.id] = i;
+  }
+  return {
+    id: instanceId,
+    enemy: enemyData,
+    hp,
+    maxHp,
+    isAlive: true,
+    effects: {},
+    intents: intentMap,
+    currentIntent: intent,
+  };
+}
+
+function createInventory(
+  itemsList: InventoryItem<GameItemMeta>[],
+): GridInventory<GameItemMeta> {
+  const map = new Map<string, InventoryItem<GameItemMeta>>();
+  const occupied = new Set<CellKey>();
+  for (const item of itemsList) {
+    map.set(item.id, item);
+    occupied.add(`${item.transform.offset.x},${item.transform.offset.y}`);
+  }
+  return { width: 6, height: 4, items: map, occupiedCells: occupied };
+}
+
+function createCombatState(overrides: Partial<CombatState> = {}): CombatState {
+  const regions = createDeckRegions();
+  return {
+    player: {
+      id: "player",
+      effects: {},
+      hp: 30,
+      maxHp: 30,
+      isAlive: true,
+      energy: 3,
+      maxEnergy: 3,
+      deck: { cards: {}, regions },
+      itemEffects: {},
+    },
+    enemies: [],
+    phase: "playerTurn",
+    turnNumber: 1,
+    result: null,
+    loot: [],
+    ...overrides,
+  };
+}
+
+function createTestContext(state?: CombatState): IGameContext<CombatState> {
+  const registry = createGameCommandRegistry<CombatState>();
+  const ctx = createGameContext(registry, state ?? createCombatState());
+  ctx._rng.setSeed(42);
+  return ctx;
+}
+
+function getTriggers(): Triggers {
+  const run: IRunContext = {
+    getConsumedUses() {
+      return 0;
+    },
+    getItemData() {
+      return null;
+    },
+    *getAdjacentItems() {},
+    async setConsumedUsesAsync() {},
+  };
+  const triggers = createTriggers(run);
+  addTriggers(triggers, run);
+  return triggers;
+}
+
+function addCardToHand(ctx: IGameContext<CombatState>, card: GameCard) {
+  ctx._state.produce((draft) => {
+    draft.player.deck.cards[card.id] = card;
+    card.regionId = "hand";
+    draft.player.deck.regions.hand.childIds.push(card.id);
+  });
+}
+
+function addCardToDrawPile(ctx: IGameContext<CombatState>, card: GameCard) {
+  ctx._state.produce((draft) => {
+    draft.player.deck.cards[card.id] = card;
+    card.regionId = "drawPile";
+    draft.player.deck.regions.drawPile.childIds.push(card.id);
+  });
+}
+
+function addCardToDiscardPile(ctx: IGameContext<CombatState>, card: GameCard) {
+  ctx._state.produce((draft) => {
+    draft.player.deck.cards[card.id] = card;
+    card.regionId = "discardPile";
+    draft.player.deck.regions.discardPile.childIds.push(card.id);
+  });
+}
+
+function makeDummyEnemy() {
+  return createEnemyEntity("仙人掌怪", 999, 999);
+}
+
+describe("desert triggers", () => {
+  describe("instant effects", () => {
+    it("should apply attack effect as damage", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [makeDummyEnemy()],
+        }),
+      );
+      const triggers = getTriggers();
+      const attackEffect = createEffect("attack");
+
+      await triggers.onEffectApplied.execute(ctx, {
+        effect: attackEffect,
+        entityId: "player",
+        stacks: 5,
+        sourceEntityId: "enemy-0",
+      });
+
+      expect(ctx.value.player.hp).toBe(25);
+    });
+
+    it("should apply draw effect", async () => {
+      const ctx = createTestContext();
+      const triggers = getTriggers();
+      const drawEffect = createEffect("draw");
+
+      addCardToDrawPile(ctx, createCard("card-1", "sword"));
+      addCardToDrawPile(ctx, createCard("card-2", "sword"));
+
+      await triggers.onEffectApplied.execute(ctx, {
+        effect: drawEffect,
+        entityId: "player",
+        stacks: 2,
+      });
+
+      expect(ctx.value.player.deck.regions.hand.childIds.length).toBe(2);
+      expect(ctx.value.player.deck.regions.drawPile.childIds.length).toBe(0);
+    });
+
+    it("should apply gainEnergy effect", async () => {
+      const ctx = createTestContext();
+      const triggers = getTriggers();
+      const gainEnergyEffect = createEffect("gainEnergy");
+
+      const initialEnergy = ctx.value.player.energy;
+      await triggers.onEffectApplied.execute(ctx, {
+        effect: gainEnergyEffect,
+        entityId: "player",
+        stacks: 2,
+      });
+
+      expect(ctx.value.player.energy).toBe(initialEnergy + 2);
+    });
+
+    it("should remove wound cards from draw and discard piles", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [makeDummyEnemy()],
+        }),
+      );
+      const triggers = getTriggers();
+      const removeWoundEffect = createEffect("removeWound");
+
+      addCardToDrawPile(ctx, createCard("wound-1", "wound", "none", 0));
+      addCardToDiscardPile(ctx, createCard("wound-2", "wound", "none", 0));
+      addCardToDrawPile(ctx, createCard("sword-1", "sword"));
+
+      await triggers.onEffectApplied.execute(ctx, {
+        effect: removeWoundEffect,
+        entityId: "player",
+        stacks: 2,
+      });
+
+      expect(ctx.value.player.deck.cards["wound-1"]).toBeUndefined();
+      expect(ctx.value.player.deck.cards["wound-2"]).toBeUndefined();
+      expect(ctx.value.player.deck.cards["sword-1"]).toBeDefined();
+    });
+  });
+
+  describe("damage pipeline", () => {
+    it("should prevent damage with block", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [makeDummyEnemy()],
+        }),
+      );
+      const triggers = getTriggers();
+      const defendEffect = createEffect("defend", "temporary");
+
+      ctx._state.produce((draft) => {
+        draft.player.effects.defend = { data: defendEffect, stacks: 5 };
+      });
+
+      await triggers.onDamage.execute(ctx, {
+        entityId: "player",
+        amount: 8,
+        sourceEntityId: "enemy-0",
+      });
+
+      expect(ctx.value.player.hp).toBe(27);
+      expect(ctx.value.player.effects.defend?.stacks).toBe(undefined);
+    });
+
+    it("should reduce damage with damageReduce", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [makeDummyEnemy()],
+        }),
+      );
+      const triggers = getTriggers();
+      const damageReduceEffect = createEffect("damageReduce", "temporary");
+
+      ctx._state.produce((draft) => {
+        draft.player.effects.damageReduce = {
+          data: damageReduceEffect,
+          stacks: 3,
+        };
+      });
+
+      await triggers.onDamage.execute(ctx, {
+        entityId: "player",
+        amount: 8,
+        sourceEntityId: "enemy-0",
+      });
+
+      expect(ctx.value.player.hp).toBe(25);
+    });
+
+    it("should increase damage with expose", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [makeDummyEnemy()],
+        }),
+      );
+      const triggers = getTriggers();
+      const exposeEffect = createEffect("expose", "temporary");
+
+      ctx._state.produce((draft) => {
+        draft.player.effects.expose = { data: exposeEffect, stacks: 2 };
+      });
+
+      await triggers.onDamage.execute(ctx, {
+        entityId: "player",
+        amount: 5,
+        sourceEntityId: "enemy-0",
+      });
+
+      expect(ctx.value.player.hp).toBe(23);
+    });
+  });
+
+  describe("spike reflection", () => {
+    it("should damage attacker when entity has spike", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("仙人掌怪", 12, 12)],
+        }),
+      );
+      const triggers = getTriggers();
+      const spikeEffect = createEffect("spike", "permanent");
+      const attackEffect = createEffect("attack", "instant");
+
+      ctx._state.produce((draft) => {
+        const enemy = draft.enemies[0];
+        enemy.effects.spike = { data: spikeEffect, stacks: 3 };
+      });
+
+      await triggers.onEffectApplied.execute(ctx, {
+        effect: attackEffect,
+        entityId: "仙人掌怪-0",
+        stacks: 5,
+        sourceEntityId: "player",
+      });
+
+      expect(ctx.value.player.hp).toBe(27);
+    });
+  });
+
+  describe("storm static card generation", () => {
+    it("should give player static cards when storm enemy executes intent", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("风暴之灵", 30, 30)],
+        }),
+      );
+      const triggers = getTriggers();
+
+      await triggers.onEnemyIntent.execute(ctx, { enemyId: "风暴之灵-0" });
+
+      const staticCards = Object.values(ctx.value.player.deck.cards).filter(
+        (c: GameCard) => c.itemId === "static",
+      );
+      expect(staticCards.length).toBe(2);
+    });
+  });
+
+  describe("energyDrain", () => {
+    it("should drain player energy when energyDrain enemy takes damage", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("幼沙虫", 18, 18)],
+        }),
+      );
+      const triggers = getTriggers();
+      const energyDrainEffect = createEffect("energyDrain", "lingering");
+
+      ctx._state.produce((draft) => {
+        const enemy = draft.enemies[0];
+        enemy.effects.energyDrain = { data: energyDrainEffect, stacks: 1 };
+      });
+
+      await triggers.onDamage.execute(ctx, {
+        entityId: "幼沙虫-0",
+        amount: 5,
+        sourceEntityId: "player",
+      });
+
+      expect(ctx.value.player.energy).toBe(2);
+    });
+  });
+
+  describe("molt flee", () => {
+    it("should make enemy flee when molt >= maxHp after taking damage", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("蜥蜴", 14, 14)],
+        }),
+      );
+      const triggers = getTriggers();
+      const moltEffect = createEffect("molt", "posture");
+
+      ctx._state.produce((draft) => {
+        const enemy = draft.enemies[0];
+        enemy.effects.molt = { data: moltEffect, stacks: 14 };
+      });
+
+      let threw = false;
+      try {
+        await triggers.onDamage.execute(ctx, {
+          entityId: "蜥蜴-0",
+          amount: 1,
+          sourceEntityId: "player",
+        });
+      } catch (e) {
+        threw = true;
+      }
+
+      expect(threw).toBe(true);
+      expect(ctx.value.result).toBe("victory");
+      expect(ctx.value.enemies[0].isAlive).toBe(false);
+    });
+  });
+
+  describe("discard at turn start", () => {
+    it("should randomly discard a card when discard effect is active", async () => {
+      const ctx = createTestContext();
+      const triggers = getTriggers();
+      const discardEffect = createEffect("discard", "lingering");
+
+      addCardToHand(ctx, createCard("card-1", "sword"));
+      addCardToHand(ctx, createCard("card-2", "shield"));
+      addCardToHand(ctx, createCard("card-3", "dagger"));
+
+      ctx._state.produce((draft) => {
+        draft.player.effects.discard = { data: discardEffect, stacks: 1 };
+      });
+
+      await triggers.onTurnStart.execute(ctx, { entityId: "player" });
+
+      expect(ctx.value.player.deck.regions.hand.childIds.length).toBe(2);
+      expect(ctx.value.player.deck.regions.discardPile.childIds.length).toBe(1);
+    });
+  });
+
+  describe("next-turn effects", () => {
+    it("should gain block from defendNext at turn start", async () => {
+      const ctx = createTestContext();
+      const triggers = getTriggers();
+      const defendNextEffect = createEffect("defendNext", "temporary");
+
+      ctx._state.produce((draft) => {
+        draft.player.effects.defendNext = { data: defendNextEffect, stacks: 5 };
+      });
+
+      await triggers.onTurnStart.execute(ctx, { entityId: "player" });
+
+      expect(ctx.value.player.effects.defend?.stacks).toBe(5);
+      expect(ctx.value.player.effects.defendNext).toBeUndefined();
+    });
+
+    it("should gain energy from energyNext at turn start", async () => {
+      const ctx = createTestContext();
+      const triggers = getTriggers();
+      const energyNextEffect = createEffect("energyNext", "temporary");
+
+      ctx._state.produce((draft) => {
+        draft.player.effects.energyNext = { data: energyNextEffect, stacks: 2 };
+      });
+
+      await triggers.onTurnStart.execute(ctx, { entityId: "player" });
+
+      expect(ctx.value.player.energy).toBe(5);
+      expect(ctx.value.player.effects.energyNext).toBeUndefined();
+    });
+
+    it("should draw extra cards from drawNext at turn start", async () => {
+      const ctx = createTestContext();
+      const triggers = getTriggers();
+      const drawNextEffect = createEffect("drawNext", "temporary");
+
+      addCardToDrawPile(ctx, createCard("card-1", "sword"));
+      addCardToDrawPile(ctx, createCard("card-2", "sword"));
+      addCardToDrawPile(ctx, createCard("card-3", "sword"));
+
+      ctx._state.produce((draft) => {
+        draft.player.effects.drawNext = { data: drawNextEffect, stacks: 2 };
+      });
+
+      await triggers.onTurnStart.execute(ctx, { entityId: "player" });
+
+      expect(ctx.value.player.deck.regions.hand.childIds.length).toBe(2);
+      expect(ctx.value.player.effects.drawNext).toBeUndefined();
+    });
+  });
+
+  describe("posture damage effects", () => {
+    it("should double damage with aim", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("仙人掌怪", 12, 12)],
+        }),
+      );
+      const triggers = getTriggers();
+      const aimEffect = createEffect("aim", "posture");
+
+      ctx._state.produce((draft) => {
+        draft.player.effects.aim = { data: aimEffect, stacks: 2 };
+      });
+
+      await triggers.onDamage.execute(ctx, {
+        entityId: "仙人掌怪-0",
+        amount: 5,
+        sourceEntityId: "player",
+      });
+
+      expect(ctx.value.enemies[0].hp).toBe(2);
+    });
+
+    it("should add bonus damage with roll", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("仙人掌怪", 99, 99)],
+        }),
+      );
+      const triggers = getTriggers();
+      const rollEffect = createEffect("roll", "posture");
+
+      ctx._state.produce((draft) => {
+        draft.player.effects.roll = { data: rollEffect, stacks: 20 };
+      });
+
+      await triggers.onDamage.execute(ctx, {
+        entityId: "仙人掌怪-0",
+        amount: 5,
+        sourceEntityId: "player",
+      });
+
+      expect(ctx.value.enemies[0].hp).toBe(74);
+      expect(ctx.value.player.effects.roll).toBeUndefined();
+    });
+
+    it("should add bonus damage with tailSting", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("沙蝎", 10, 10)],
+        }),
+      );
+      const triggers = getTriggers();
+      const tailStingEffect = createEffect("tailSting", "posture");
+
+      ctx._state.produce((draft) => {
+        const enemy = draft.enemies[0];
+        enemy.effects.tailSting = { data: tailStingEffect, stacks: 2 };
+      });
+
+      await triggers.onDamage.execute(ctx, {
+        entityId: "player",
+        amount: 5,
+        sourceEntityId: "沙蝎-0",
+      });
+
+      expect(ctx.value.player.hp).toBe(23);
+    });
+
+    it("should double damage with charge on attacker", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("骑马枪手", 25, 25)],
+        }),
+      );
+      const triggers = getTriggers();
+      const chargeEffect = createEffect("charge", "lingering");
+
+      ctx._state.produce((draft) => {
+        const enemy = draft.enemies[0];
+        enemy.effects.charge = { data: chargeEffect, stacks: 2 };
+      });
+
+      await triggers.onDamage.execute(ctx, {
+        entityId: "player",
+        amount: 5,
+        sourceEntityId: "骑马枪手-0",
+      });
+
+      expect(ctx.value.player.hp).toBe(20);
+    });
+  });
+
+  describe("crossbow chain", () => {
+    it("should replay other crossbows on same target", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("仙人掌怪", 20, 20)],
+        }),
+      );
+      const triggers = getTriggers();
+      const crossbowEffect = createEffect("crossbow");
+
+      addCardToHand(ctx, createCard("crossbow-1", "crossbow"));
+      addCardToHand(ctx, createCard("crossbow-2", "crossbow"));
+
+      await triggers.onEffectApplied.execute(ctx, {
+        effect: crossbowEffect,
+        entityId: "player",
+        stacks: 0,
+        cardId: "crossbow-1",
+        sourceEntityId: "player",
+        targetId: "仙人掌怪-0",
+      });
+
+      expect(ctx.value.enemies[0].hp).toBe(8);
+    });
+  });
+
+  describe("sandwormKing fatigue heal", () => {
+    it("should heal sandworm king when player discards fatigue", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("沙虫王", 30, 40)],
+        }),
+      );
+      const triggers = getTriggers();
+
+      addCardToHand(ctx, createCard("fatigue-1", "fatigue", "none", 0));
+
+      await triggers.onCardDiscarded.execute(ctx, {
+        cardId: "fatigue-1",
+        sourceEntityId: "player",
+      });
+
+      expect(ctx.value.enemies[0].hp).toBe(40);
+    });
+  });
+
+  describe("vulture on-damage", () => {
+    it("should give player vultureEye when vulture deals damage", async () => {
+      const ctx = createTestContext(
+        createCombatState({
+          enemies: [createEnemyEntity("秃鹫", 12, 12)],
+        }),
+      );
+      const triggers = getTriggers();
+
+      await triggers.onDamage.execute(ctx, {
+        entityId: "player",
+        amount: 5,
+        sourceEntityId: "秃鹫-0",
+      });
+
+      const vultureEyeCards = Object.values(ctx.value.player.deck.cards).filter(
+        (c: GameCard) => c.itemId === "vultureEye",
+      );
+      expect(vultureEyeCards.length).toBe(1);
+    });
+  });
+});

tests/samples/slay-the-spire-like/data/index.test.ts

@@ -1,8 +1,13 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import data from '@/samples/slay-the-spire-like/data';
+import data from "@/samples/slay-the-spire-like/data";
+import { CardData } from "@/samples/slay-the-spire-like";
 
-describe('data import', () => {
+describe("data import", () => {
-    it('should import properly', () => {
+  it("should import properly", () => {
-        expect(data.desert.effects).toBeDefined();
+    expect(data.desert.getEffects).toBeDefined();
+    expect(
+      data.desert.getCards().find((c: CardData) => c.id === "crossbow")?.effects
+        ?.length,
+    ).toBe(2);
   });
 });

tests/samples/slay-the-spire-like/deck/factory.test.ts

@@ -1,17 +1,26 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
 import {
   generateDeckFromInventory,
   createCard,
   createDeckRegions,
   createPlayerDeck,
   generateCardId,
-} from '@/samples/slay-the-spire-like/system/deck/factory';
+} from "@/samples/slay-the-spire-like/system/deck/factory";
-import { createGridInventory, placeItem } from '@/samples/slay-the-spire-like/system/grid-inventory';
+import {
-import type { GridInventory, InventoryItem } from '@/samples/slay-the-spire-like/system/grid-inventory';
+  createGridInventory,
-import type { GameItemMeta } from '@/samples/slay-the-spire-like/system/progress/types';
+  placeItem,
-import { IDENTITY_TRANSFORM } from '@/samples/slay-the-spire-like/system/utils/shape-collision';
+} from "@/samples/slay-the-spire-like/system/grid-inventory";
-import { parseShapeString } from '@/samples/slay-the-spire-like/system/utils/parse-shape';
+import type {
-import type { CardData, ItemData } from '@/samples/slay-the-spire-like/system/types';
+  GridInventory,
+  InventoryItem,
+} from "@/samples/slay-the-spire-like/system/grid-inventory";
+import type { GameItemMeta } from "@/samples/slay-the-spire-like/system/grid-inventory/types";
+import { IDENTITY_TRANSFORM } from "@/samples/slay-the-spire-like/system/utils/shape-collision";
+import { parseShapeString } from "@/samples/slay-the-spire-like/system/utils/parse-shape";
+import type {
+  CardData,
+  ItemData,
+} from "@/samples/slay-the-spire-like/system/types";
 
 /**
  * Helper: create a minimal CardData for testing.
@@ -21,10 +30,10 @@ function createTestCardData(id: string, name: string, desc: string): CardData {
     id,
     name,
     desc,
-        type: 'item',
+    type: "item",
-        costType: 'energy',
+    costType: "energy",
     costCount: 1,
-        targetType: 'single',
+    targetType: "enemy",
     effects: [],
   };
 }
@@ -32,10 +41,15 @@ function createTestCardData(id: string, name: string, desc: string): CardData {
 /**
  * Helper: create a minimal ItemData for testing.
  */
-function createTestItemData(id: string, name: string, shapeStr: string, desc: string): ItemData {
+function createTestItemData(
+  id: string,
+  name: string,
+  shapeStr: string,
+  desc: string,
+): ItemData {
   return {
     id,
-        type: 'weapon',
+    type: "weapon",
     name,
     shape: shapeStr,
     card: createTestCardData(id, name, desc),
@@ -47,7 +61,11 @@ function createTestItemData(id: string, name: string, shapeStr: string, desc: st
 /**
  * Helper: create a minimal GameItemMeta for testing.
  */
-function createTestMeta(name: string, desc: string, shapeStr: string): GameItemMeta {
+function createTestMeta(
+  name: string,
+  desc: string,
+  shapeStr: string,
+): GameItemMeta {
   const shape = parseShapeString(shapeStr);
   const itemData = createTestItemData(name.toLowerCase(), name, shapeStr, desc);
   return {
@@ -63,9 +81,9 @@ function createTestInventory(): GridInventory<GameItemMeta> {
   const inv = createGridInventory<GameItemMeta>(6, 4);
 
   // Item "短刀" with shape "oe" (2 cells)
-    const meta1 = createTestMeta('短刀', '【攻击3】【攻击3】', 'oe');
+  const meta1 = createTestMeta("短刀", "【攻击3】【攻击3】", "oe");
   const item1: InventoryItem<GameItemMeta> = {
-        id: 'dagger-1',
+    id: "dagger-1",
     shape: meta1.shape,
     transform: { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
     meta: meta1,
@@ -73,9 +91,9 @@ function createTestInventory(): GridInventory<GameItemMeta> {
   placeItem(inv, item1);
 
   // Item "盾" with shape "oesw" (4 cells)
-    const meta2 = createTestMeta('盾', '【防御3】', 'oesw');
+  const meta2 = createTestMeta("盾", "【防御3】", "oesw");
   const item2: InventoryItem<GameItemMeta> = {
-        id: 'shield-1',
+    id: "shield-1",
     shape: meta2.shape,
     transform: { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 0 } },
     meta: meta2,
@@ -85,30 +103,30 @@ function createTestInventory(): GridInventory<GameItemMeta> {
   return inv;
 }
 
-describe('deck/factory', () => {
+describe("deck/factory", () => {
-    describe('generateCardId', () => {
+  describe("generateCardId", () => {
-        it('should generate deterministic unique IDs', () => {
+    it("should generate deterministic unique IDs", () => {
-            expect(generateCardId('item-1', 0)).toBe('card-item-1-0');
+      expect(generateCardId("item-1", 0)).toBe("card-item-1-0");
-            expect(generateCardId('item-1', 1)).toBe('card-item-1-1');
+      expect(generateCardId("item-1", 1)).toBe("card-item-1-1");
-            expect(generateCardId('item-2', 0)).toBe('card-item-2-0');
+      expect(generateCardId("item-2", 0)).toBe("card-item-2-0");
     });
   });
 
-    describe('createCard', () => {
+  describe("createCard", () => {
-        it('should create a card with itemId and cardData', () => {
+    it("should create a card with itemId and cardData", () => {
-            const cardData = createTestCardData('wound', '伤口', '无法被弃牌');
+      const cardData = createTestCardData("wound", "伤口", "无法被弃牌");
-            const card = createCard('wound-1', cardData, 0);
+      const card = createCard("wound-1", cardData, 0);
 
-            expect(card.id).toBe('card-wound-1-0');
+      expect(card.id).toBe("card-wound-1-0");
-            expect(card.itemId).toBe('wound-1');
+      expect(card.itemId).toBe("wound-1");
       expect(card.cardData).toBe(cardData);
-            expect(card.regionId).toBe('');
+      expect(card.regionId).toBe("");
       expect(card.position).toEqual([]);
     });
   });
 
-    describe('generateDeckFromInventory', () => {
+  describe("generateDeckFromInventory", () => {
-        it('should generate correct number of cards based on shape cell counts', () => {
+    it("should generate correct number of cards based on shape cell counts", () => {
       const inv = createTestInventory();
 
       // "短刀" has 2 cells, "盾" has 4 cells = 6 total
@@ -121,26 +139,26 @@ describe('deck/factory', () => {
       expect(deck.regions.exhaustPile.childIds).toEqual([]);
     });
 
-        it('should link cards to their source items', () => {
+    it("should link cards to their source items", () => {
       const inv = createTestInventory();
       const deck = generateDeckFromInventory(inv);
 
       const daggerCards = Object.values(deck.cards).filter(
-                c => c.itemId === 'dagger-1'
+        (c) => c.itemId === "dagger-1",
       );
       const shieldCards = Object.values(deck.cards).filter(
-                c => c.itemId === 'shield-1'
+        (c) => c.itemId === "shield-1",
       );
 
       expect(daggerCards.length).toBe(2);
       expect(shieldCards.length).toBe(4);
 
       // Verify card data
-            expect(daggerCards[0].cardData.name).toBe('短刀');
+      expect(daggerCards[0].cardData.name).toBe("短刀");
-            expect(shieldCards[0].cardData.name).toBe('盾');
+      expect(shieldCards[0].cardData.name).toBe("盾");
     });
 
-        it('should set displayName and description from item data', () => {
+    it("should set displayName and description from item data", () => {
       const inv = createTestInventory();
       const deck = generateDeckFromInventory(inv);
 
@@ -150,26 +168,26 @@ describe('deck/factory', () => {
       }
 
       const daggerCard = Object.values(deck.cards).find(
-                c => c.cardData.name === '短刀'
+        (c) => c.cardData.name === "短刀",
       );
-            expect(daggerCard?.cardData.name).toBe('短刀');
+      expect(daggerCard?.cardData.name).toBe("短刀");
-            expect(daggerCard?.cardData.desc).toBe('【攻击3】【攻击3】');
+      expect(daggerCard?.cardData.desc).toBe("【攻击3】【攻击3】");
     });
 
-        it('should assign unique IDs to each card from same item', () => {
+    it("should assign unique IDs to each card from same item", () => {
       const inv = createTestInventory();
       const deck = generateDeckFromInventory(inv);
 
       const daggerCards = Object.values(deck.cards).filter(
-                c => c.itemId === 'dagger-1'
+        (c) => c.itemId === "dagger-1",
       );
 
-            const ids = daggerCards.map(c => c.id);
+      const ids = daggerCards.map((c) => c.id);
       const uniqueIds = new Set(ids);
       expect(uniqueIds.size).toBe(ids.length);
     });
 
-        it('should handle empty inventory', () => {
+    it("should handle empty inventory", () => {
       const inv = createGridInventory<GameItemMeta>(6, 4);
       const deck = generateDeckFromInventory(inv);
 
@@ -177,7 +195,7 @@ describe('deck/factory', () => {
       expect(deck.regions.drawPile.childIds).toEqual([]);
     });
 
-        it('should place all cards in draw pile initially', () => {
+    it("should place all cards in draw pile initially", () => {
       const inv = createTestInventory();
       const deck = generateDeckFromInventory(inv);
 
@@ -186,21 +204,23 @@ describe('deck/factory', () => {
       }
 
       // All cards are in draw pile
-            expect(new Set(deck.regions.drawPile.childIds).size).toBe(Object.keys(deck.cards).length);
+      expect(new Set(deck.regions.drawPile.childIds).size).toBe(
+        Object.keys(deck.cards).length,
+      );
     });
   });
 
-    describe('createDeckRegions', () => {
+  describe("createDeckRegions", () => {
-        it('should create regions for all deck zones', () => {
+    it("should create regions for all deck zones", () => {
       const regions = createDeckRegions();
 
-            expect(regions.drawPile.id).toBe('drawPile');
+      expect(regions.drawPile.id).toBe("drawPile");
-            expect(regions.hand.id).toBe('hand');
+      expect(regions.hand.id).toBe("hand");
-            expect(regions.discardPile.id).toBe('discardPile');
+      expect(regions.discardPile.id).toBe("discardPile");
-            expect(regions.exhaustPile.id).toBe('exhaustPile');
+      expect(regions.exhaustPile.id).toBe("exhaustPile");
     });
 
-        it('should have empty childIds initially', () => {
+    it("should have empty childIds initially", () => {
       const regions = createDeckRegions();
 
       expect(regions.drawPile.childIds).toEqual([]);
@@ -210,8 +230,8 @@ describe('deck/factory', () => {
     });
   });
 
-    describe('createPlayerDeck', () => {
+  describe("createPlayerDeck", () => {
-        it('should create an empty deck structure', () => {
+    it("should create an empty deck structure", () => {
       const deck = createPlayerDeck();
 
       expect(deck.cards).toEqual({});

tests/samples/slay-the-spire-like/grid-inventory.test.ts

@@ -1,6 +1,6 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import { parseShapeString } from '@/samples/slay-the-spire-like/system/utils/parse-shape';
+import { parseShapeString } from "@/samples/slay-the-spire-like/system/utils/parse-shape";
-import { IDENTITY_TRANSFORM } from '@/samples/slay-the-spire-like/system/utils/shape-collision';
+import { IDENTITY_TRANSFORM } from "@/samples/slay-the-spire-like/system/utils/shape-collision";
 import {
   createGridInventory,
   placeItem,
@@ -12,14 +12,62 @@ import {
   getItemAtCell,
   getAdjacentItems,
   validatePlacement,
-    type GridInventory,
   type InventoryItem,
-} from '@/samples/slay-the-spire-like/system/grid-inventory';
+} from "@/samples/slay-the-spire-like/system/grid-inventory";
+import { createItemIn } from "@/samples/slay-the-spire-like/system/grid-inventory/factory";
+import type {
+  GameItem,
+  GameItemMeta,
+} from "@/samples/slay-the-spire-like/system/grid-inventory/types";
+import type {
+  CardData,
+  ItemData,
+} from "@/samples/slay-the-spire-like/system/types";
+
+/**
+ * Helper: create a minimal CardData for testing.
+ */
+function createTestCardData(id: string, name: string, desc: string): CardData {
+  return {
+    id,
+    name,
+    desc,
+    type: "item",
+    costType: "energy",
+    costCount: 1,
+    targetType: "enemy",
+    effects: [],
+  };
+}
+
+/**
+ * Helper: create a minimal ItemData for testing.
+ */
+function createTestItemData(
+  id: string,
+  name: string,
+  shapeStr: string,
+  desc: string,
+): ItemData {
+  return {
+    id,
+    type: "weapon",
+    name,
+    shape: shapeStr,
+    card: createTestCardData(id, name, desc),
+    price: 10,
+    description: desc,
+  };
+}
 
 /**
  * Helper: create a test inventory item.
  */
-function createTestItem(id: string, shapeStr: string, transform = IDENTITY_TRANSFORM): InventoryItem {
+function createTestItem(
+  id: string,
+  shapeStr: string,
+  transform = IDENTITY_TRANSFORM,
+): InventoryItem<Record<string, never>> {
   const shape = parseShapeString(shapeStr);
   return {
     id,
@@ -28,9 +76,9 @@ function createTestItem(id: string, shapeStr: string, transform = IDENTITY_TRANS
   };
 }
 
-describe('grid-inventory', () => {
+describe("grid-inventory", () => {
-    describe('createGridInventory', () => {
+  describe("createGridInventory", () => {
-        it('should create an empty inventory with correct dimensions', () => {
+    it("should create an empty inventory with correct dimensions", () => {
       const inv = createGridInventory(6, 4);
       expect(inv.width).toBe(6);
       expect(inv.height).toBe(4);
@@ -39,111 +87,117 @@ describe('grid-inventory', () => {
     });
   });
 
-    describe('placeItem', () => {
+  describe("placeItem", () => {
-        it('should place a single-cell item', () => {
+    it("should place a single-cell item", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('sword', 'o');
+      const item = createTestItem("sword", "o");
       placeItem(inv, item);
 
       expect(inv.items.size).toBe(1);
-            expect(inv.items.has('sword')).toBe(true);
+      expect(inv.items.has("sword")).toBe(true);
-            expect(inv.occupiedCells.has('0,0')).toBe(true);
+      expect(inv.occupiedCells.has("0,0")).toBe(true);
     });
 
-        it('should place a multi-cell item', () => {
+    it("should place a multi-cell item", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('axe', 'oee');
+      const item = createTestItem("axe", "oee");
       placeItem(inv, item);
 
       expect(inv.items.size).toBe(1);
       expect(inv.occupiedCells.size).toBe(3);
-            expect(inv.occupiedCells.has('0,0')).toBe(true);
+      expect(inv.occupiedCells.has("0,0")).toBe(true);
-            expect(inv.occupiedCells.has('1,0')).toBe(true);
+      expect(inv.occupiedCells.has("1,0")).toBe(true);
-            expect(inv.occupiedCells.has('2,0')).toBe(true);
+      expect(inv.occupiedCells.has("2,0")).toBe(true);
     });
 
-        it('should place multiple items', () => {
+    it("should place multiple items", () => {
       const inv = createGridInventory(6, 4);
-            const itemA = createTestItem('a', 'o');
+      const itemA = createTestItem("a", "o");
-            const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 0 } });
+      const itemB = createTestItem("b", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 3, y: 0 },
+      });
       placeItem(inv, itemA);
       placeItem(inv, itemB);
 
       expect(inv.items.size).toBe(2);
       expect(inv.occupiedCells.size).toBe(2);
-            expect(inv.occupiedCells.has('0,0')).toBe(true);
+      expect(inv.occupiedCells.has("0,0")).toBe(true);
-            expect(inv.occupiedCells.has('3,0')).toBe(true);
+      expect(inv.occupiedCells.has("3,0")).toBe(true);
     });
   });
 
-    describe('removeItem', () => {
+  describe("removeItem", () => {
-        it('should remove an item and free its cells', () => {
+    it("should remove an item and free its cells", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('sword', 'oee');
+      const item = createTestItem("sword", "oee");
       placeItem(inv, item);
 
-            removeItem(inv, 'sword');
+      removeItem(inv, "sword");
 
       expect(inv.items.size).toBe(0);
       expect(inv.occupiedCells.size).toBe(0);
     });
 
-        it('should only free the removed item\'s cells', () => {
+    it("should only free the removed item's cells", () => {
       const inv = createGridInventory(6, 4);
-            const itemA = createTestItem('a', 'o');
+      const itemA = createTestItem("a", "o");
-            const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } });
+      const itemB = createTestItem("b", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 2, y: 0 },
+      });
       placeItem(inv, itemA);
       placeItem(inv, itemB);
 
-            removeItem(inv, 'a');
+      removeItem(inv, "a");
 
       expect(inv.items.size).toBe(1);
       expect(inv.occupiedCells.size).toBe(1);
-            expect(inv.occupiedCells.has('0,0')).toBe(false);
+      expect(inv.occupiedCells.has("0,0")).toBe(false);
-            expect(inv.occupiedCells.has('2,0')).toBe(true);
+      expect(inv.occupiedCells.has("2,0")).toBe(true);
     });
 
-        it('should do nothing for non-existent item', () => {
+    it("should do nothing for non-existent item", () => {
       const inv = createGridInventory(6, 4);
-            removeItem(inv, 'nonexistent');
+      removeItem(inv, "nonexistent");
       expect(inv.items.size).toBe(0);
     });
   });
 
-    describe('validatePlacement', () => {
+  describe("validatePlacement", () => {
-        it('should return valid for empty board', () => {
+    it("should return valid for empty board", () => {
       const inv = createGridInventory(6, 4);
-            const shape = parseShapeString('o');
+      const shape = parseShapeString("o");
       const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM);
       expect(result).toEqual({ valid: true });
     });
 
-        it('should return invalid for out of bounds', () => {
+    it("should return invalid for out of bounds", () => {
       const inv = createGridInventory(6, 4);
-            const shape = parseShapeString('o');
+      const shape = parseShapeString("o");
       const result = validatePlacement(inv, shape, {
         ...IDENTITY_TRANSFORM,
         offset: { x: 6, y: 0 },
       });
-            expect(result).toEqual({ valid: false, reason: '超出边界' });
+      expect(result).toEqual({ valid: false, reason: "超出边界" });
     });
 
-        it('should return invalid for collision with existing item', () => {
+    it("should return invalid for collision with existing item", () => {
       const inv = createGridInventory(6, 4);
-            const existing = createTestItem('a', 'oee');
+      const existing = createTestItem("a", "oee");
       placeItem(inv, existing);
 
-            const shape = parseShapeString('o');
+      const shape = parseShapeString("o");
       const result = validatePlacement(inv, shape, IDENTITY_TRANSFORM);
-            expect(result).toEqual({ valid: false, reason: '与已有物品重叠' });
+      expect(result).toEqual({ valid: false, reason: "与已有物品重叠" });
     });
 
-        it('should return valid when there is room nearby', () => {
+    it("should return valid when there is room nearby", () => {
       const inv = createGridInventory(6, 4);
-            const existing = createTestItem('a', 'o');
+      const existing = createTestItem("a", "o");
       placeItem(inv, existing);
 
-            const shape = parseShapeString('o');
+      const shape = parseShapeString("o");
       const result = validatePlacement(inv, shape, {
         ...IDENTITY_TRANSFORM,
         offset: { x: 1, y: 0 },
@@ -152,160 +206,169 @@ describe('grid-inventory', () => {
     });
   });
 
-    describe('moveItem', () => {
+  describe("moveItem", () => {
-        it('should move item to a new position', () => {
+    it("should move item to a new position", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('sword', 'o');
+      const item = createTestItem("sword", "o");
       placeItem(inv, item);
 
-            const result = moveItem(inv, 'sword', {
+      const result = moveItem(inv, "sword", {
         ...IDENTITY_TRANSFORM,
         offset: { x: 5, y: 3 },
       });
 
       expect(result).toEqual({ success: true });
-            expect(inv.occupiedCells.has('0,0')).toBe(false);
+      expect(inv.occupiedCells.has("0,0")).toBe(false);
-            expect(inv.occupiedCells.has('5,3')).toBe(true);
+      expect(inv.occupiedCells.has("5,3")).toBe(true);
       expect(item.transform.offset).toEqual({ x: 5, y: 3 });
     });
 
-        it('should reject move that goes out of bounds', () => {
+    it("should reject move that goes out of bounds", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('sword', 'o');
+      const item = createTestItem("sword", "o");
       placeItem(inv, item);
 
-            const result = moveItem(inv, 'sword', {
+      const result = moveItem(inv, "sword", {
         ...IDENTITY_TRANSFORM,
         offset: { x: 6, y: 0 },
       });
 
-            expect(result).toEqual({ success: false, reason: '超出边界' });
+      expect(result).toEqual({ success: false, reason: "超出边界" });
-            expect(inv.occupiedCells.has('0,0')).toBe(true);
+      expect(inv.occupiedCells.has("0,0")).toBe(true);
       expect(item.transform.offset).toEqual({ x: 0, y: 0 });
     });
 
-        it('should reject move that collides with another item', () => {
+    it("should reject move that collides with another item", () => {
       const inv = createGridInventory(6, 4);
-            const itemA = createTestItem('a', 'o');
+      const itemA = createTestItem("a", "o");
-            const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } });
+      const itemB = createTestItem("b", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 2, y: 0 },
+      });
       placeItem(inv, itemA);
       placeItem(inv, itemB);
 
-            const result = moveItem(inv, 'b', {
+      const result = moveItem(inv, "b", {
         ...IDENTITY_TRANSFORM,
         offset: { x: 0, y: 0 },
       });
 
-            expect(result).toEqual({ success: false, reason: '与已有物品重叠' });
+      expect(result).toEqual({ success: false, reason: "与已有物品重叠" });
-            expect(inv.occupiedCells.has('2,0')).toBe(true);
+      expect(inv.occupiedCells.has("2,0")).toBe(true);
     });
 
-        it('should return error for non-existent item', () => {
+    it("should return error for non-existent item", () => {
       const inv = createGridInventory(6, 4);
-            const result = moveItem(inv, 'ghost', IDENTITY_TRANSFORM);
+      const result = moveItem(inv, "ghost", IDENTITY_TRANSFORM);
-            expect(result).toEqual({ success: false, reason: '物品不存在' });
+      expect(result).toEqual({ success: false, reason: "物品不存在" });
     });
 
-        it('should move multi-cell item correctly', () => {
+    it("should move multi-cell item correctly", () => {
       const inv = createGridInventory(6, 4);
       // oes: cells at (0,0), (1,0), (1,1)
-            const item = createTestItem('axe', 'oes');
+      const item = createTestItem("axe", "oes");
       placeItem(inv, item);
 
       const newTransform = { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 1 } };
-            moveItem(inv, 'axe', newTransform);
+      moveItem(inv, "axe", newTransform);
 
       // Old cells should be freed
-            expect(inv.occupiedCells.has('0,0')).toBe(false);
+      expect(inv.occupiedCells.has("0,0")).toBe(false);
-            expect(inv.occupiedCells.has('1,0')).toBe(false);
+      expect(inv.occupiedCells.has("1,0")).toBe(false);
-            expect(inv.occupiedCells.has('1,1')).toBe(false);
+      expect(inv.occupiedCells.has("1,1")).toBe(false);
       // New cells: (0,0)+offset(3,1)=(3,1), (1,0)+(3,1)=(4,1), (1,1)+(3,1)=(4,2)
-            expect(inv.occupiedCells.has('3,1')).toBe(true);
+      expect(inv.occupiedCells.has("3,1")).toBe(true);
-            expect(inv.occupiedCells.has('4,1')).toBe(true);
+      expect(inv.occupiedCells.has("4,1")).toBe(true);
-            expect(inv.occupiedCells.has('4,2')).toBe(true);
+      expect(inv.occupiedCells.has("4,2")).toBe(true);
     });
   });
 
-    describe('rotateItem', () => {
+  describe("rotateItem", () => {
-        it('should rotate item by 90 degrees', () => {
+    it("should rotate item by 90 degrees", () => {
       const inv = createGridInventory(6, 4);
       // Horizontal line: (0,0), (1,0)
-            const item = createTestItem('bar', 'oe', {
+      const item = createTestItem("bar", "oe", {
         ...IDENTITY_TRANSFORM,
         offset: { x: 0, y: 1 }, // Place away from edge so rotation stays in bounds
       });
       placeItem(inv, item);
 
-            const result = rotateItem(inv, 'bar', 90);
+      const result = rotateItem(inv, "bar", 90);
 
       expect(result).toEqual({ success: true });
       expect(item.transform.rotation).toBe(90);
     });
 
-        it('should reject rotation that goes out of bounds', () => {
+    it("should reject rotation that goes out of bounds", () => {
       const inv = createGridInventory(3, 3);
       // Item at the edge: place a 2-wide item at x=1
-            const item = createTestItem('bar', 'oe', {
+      const item = createTestItem("bar", "oe", {
         ...IDENTITY_TRANSFORM,
         offset: { x: 1, y: 0 },
       });
       placeItem(inv, item);
 
       // Rotating 90° would make it vertical starting at (1,0), going to (1,-1) -> out of bounds
-            const result = rotateItem(inv, 'bar', 90);
+      const result = rotateItem(inv, "bar", 90);
 
-            expect(result).toEqual({ success: false, reason: '超出边界' });
+      expect(result).toEqual({ success: false, reason: "超出边界" });
     });
 
-        it('should reject rotation that collides', () => {
+    it("should reject rotation that collides", () => {
       const inv = createGridInventory(4, 4);
-            const itemA = createTestItem('a', 'o');
+      const itemA = createTestItem("a", "o");
-            const itemB = createTestItem('b', 'oe', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } });
+      const itemB = createTestItem("b", "oe", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 2, y: 0 },
+      });
       placeItem(inv, itemA);
       placeItem(inv, itemB);
 
       // Rotating b 90° would place cells at (2,0) and (2,-1) -> (2,-1) is out of bounds
       // Let's try a different scenario: rotate b 270° -> (2,0) and (2,1) which is fine
       // But rotating to collide with a at (0,0)... need item close to a
-            const itemC = createTestItem('c', 'os', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 0 } });
+      const itemC = createTestItem("c", "os", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 1, y: 0 },
+      });
       placeItem(inv, itemC);
 
       // Rotating c 90° would give cells at (1,0) and (0,0) -> collision with a
-            const result = rotateItem(inv, 'c', 90);
+      const result = rotateItem(inv, "c", 90);
-            expect(result).toEqual({ success: false, reason: '与已有物品重叠' });
+      expect(result).toEqual({ success: false, reason: "与已有物品重叠" });
     });
 
-        it('should return error for non-existent item', () => {
+    it("should return error for non-existent item", () => {
       const inv = createGridInventory(6, 4);
-            const result = rotateItem(inv, 'ghost', 90);
+      const result = rotateItem(inv, "ghost", 90);
-            expect(result).toEqual({ success: false, reason: '物品不存在' });
+      expect(result).toEqual({ success: false, reason: "物品不存在" });
     });
   });
 
-    describe('flipItem', () => {
+  describe("flipItem", () => {
-        it('should flip item horizontally', () => {
+    it("should flip item horizontally", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('bar', 'oe');
+      const item = createTestItem("bar", "oe");
       placeItem(inv, item);
 
-            const result = flipItem(inv, 'bar', 'x');
+      const result = flipItem(inv, "bar", "x");
 
       expect(result).toEqual({ success: true });
       expect(item.transform.flipX).toBe(true);
     });
 
-        it('should flip item vertically', () => {
+    it("should flip item vertically", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('bar', 'os');
+      const item = createTestItem("bar", "os");
       placeItem(inv, item);
 
-            const result = flipItem(inv, 'bar', 'y');
+      const result = flipItem(inv, "bar", "y");
 
       expect(result).toEqual({ success: true });
       expect(item.transform.flipY).toBe(true);
     });
 
-        it('should reject flip that causes collision', () => {
+    it("should reject flip that causes collision", () => {
       // oes local cells: (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0).
       // Place flipper at offset (0,2): world cells (0,2),(1,2),(1,3).
       // flipY gives local (0,1),(1,1),(1,0) + offset(0,2) = (0,3),(1,3),(1,2) — same cells rearranged.
@@ -313,7 +376,10 @@ describe('grid-inventory', () => {
       // Use oes at offset (0,0): cells (0,0),(1,0),(1,1). flipY: (0,1),(1,1),(1,0).
       // Place blocker at (0,1) — which is NOT occupied by oes initially.
       const inv = createGridInventory(4, 4);
-            const blocker = createTestItem('blocker', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 1 } });
+      const blocker = createTestItem("blocker", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 0, y: 1 },
+      });
       // oes at (0,1): cells (0,1),(1,1),(1,2). This overlaps blocker at (0,1)!
       // Let me try: blocker at (1,0), flipper at offset (0,2).
       // flipper oes at (0,2): (0,2),(1,2),(1,3). blocker at (1,0) — no overlap.
@@ -326,30 +392,33 @@ describe('grid-inventory', () => {
       // Place flipper at (0,0): cells (0,0),(1,0),(1,1). Place blocker at (0,1) — but (0,1) is not occupied.
       // flipY: (0,1),(1,1),(1,0). (0,1) hits blocker!
       const inv2 = createGridInventory(4, 4);
-            const blocker2 = createTestItem('blocker', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 1 } });
+      const blocker2 = createTestItem("blocker", "o", {
-            const flipper2 = createTestItem('flipper', 'oes'); // at (0,0): (0,0),(1,0),(1,1)
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 0, y: 1 },
+      });
+      const flipper2 = createTestItem("flipper", "oes"); // at (0,0): (0,0),(1,0),(1,1)
       placeItem(inv2, blocker2);
       placeItem(inv2, flipper2);
 
-            const result = flipItem(inv2, 'flipper', 'y');
+      const result = flipItem(inv2, "flipper", "y");
-            expect(result).toEqual({ success: false, reason: '与已有物品重叠' });
+      expect(result).toEqual({ success: false, reason: "与已有物品重叠" });
     });
 
-        it('should return error for non-existent item', () => {
+    it("should return error for non-existent item", () => {
       const inv = createGridInventory(6, 4);
-            const result = flipItem(inv, 'ghost', 'x');
+      const result = flipItem(inv, "ghost", "x");
-            expect(result).toEqual({ success: false, reason: '物品不存在' });
+      expect(result).toEqual({ success: false, reason: "物品不存在" });
     });
   });
 
-    describe('getOccupiedCellSet', () => {
+  describe("getOccupiedCellSet", () => {
-        it('should return a copy of occupied cells', () => {
+    it("should return a copy of occupied cells", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('a', 'oe');
+      const item = createTestItem("a", "oe");
       placeItem(inv, item);
 
       const cells = getOccupiedCellSet(inv);
-            expect(cells).toEqual(new Set(['0,0', '1,0']));
+      expect(cells).toEqual(new Set(["0,0", "1,0"]));
 
       // Mutating the copy should not affect the original
       cells.clear();
@@ -357,50 +426,68 @@ describe('grid-inventory', () => {
     });
   });
 
-    describe('getItemAtCell', () => {
+  describe("getItemAtCell", () => {
-        it('should return item at occupied cell', () => {
+    it("should return item at occupied cell", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('sword', 'oee');
+      const item = createTestItem("sword", "oee");
       placeItem(inv, item);
 
       const found = getItemAtCell(inv, 1, 0);
       expect(found).toBeDefined();
-            expect(found!.id).toBe('sword');
+      expect(found!.id).toBe("sword");
     });
 
-        it('should return undefined for empty cell', () => {
+    it("should return undefined for empty cell", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('sword', 'o');
+      const item = createTestItem("sword", "o");
       placeItem(inv, item);
 
       const found = getItemAtCell(inv, 5, 5);
       expect(found).toBeUndefined();
     });
 
-        it('should return correct item when multiple items exist', () => {
+    it("should return correct item when multiple items exist", () => {
       const inv = createGridInventory(6, 4);
-            const itemA = createTestItem('a', 'o');
+      const itemA = createTestItem("a", "o");
-            const itemB = createTestItem('b', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 2 } });
+      const itemB = createTestItem("b", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 3, y: 2 },
+      });
       placeItem(inv, itemA);
       placeItem(inv, itemB);
 
-            expect(getItemAtCell(inv, 0, 0)!.id).toBe('a');
+      expect(getItemAtCell(inv, 0, 0)!.id).toBe("a");
-            expect(getItemAtCell(inv, 3, 2)!.id).toBe('b');
+      expect(getItemAtCell(inv, 3, 2)!.id).toBe("b");
     });
   });
 
-    describe('getAdjacentItems', () => {
+  describe("getAdjacentItems", () => {
-        it('should return orthogonally adjacent items', () => {
+    it("should return orthogonally adjacent items", () => {
       const inv = createGridInventory(6, 4);
-            const center = createTestItem('center', 'o', {
+      const center = createTestItem("center", "o", {
         ...IDENTITY_TRANSFORM,
         offset: { x: 2, y: 2 },
       });
-            const top = createTestItem('top', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 1 } });
+      const top = createTestItem("top", "o", {
-            const left = createTestItem('left', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 2 } });
+        ...IDENTITY_TRANSFORM,
-            const right = createTestItem('right', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 3, y: 2 } });
+        offset: { x: 2, y: 1 },
-            const bottom = createTestItem('bottom', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 3 } });
+      });
-            const diagonal = createTestItem('diagonal', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 1 } });
+      const left = createTestItem("left", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 1, y: 2 },
+      });
+      const right = createTestItem("right", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 3, y: 2 },
+      });
+      const bottom = createTestItem("bottom", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 2, y: 3 },
+      });
+      const diagonal = createTestItem("diagonal", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 1, y: 1 },
+      });
 
       placeItem(inv, center);
       placeItem(inv, top);
@@ -409,77 +496,167 @@ describe('grid-inventory', () => {
       placeItem(inv, bottom);
       placeItem(inv, diagonal);
 
-            const adj = getAdjacentItems(inv, 'center');
+      const adj = getAdjacentItems(inv, "center");
       expect(adj.size).toBe(4);
-            expect(adj.has('top')).toBe(true);
+      expect(adj.has("top")).toBe(true);
-            expect(adj.has('left')).toBe(true);
+      expect(adj.has("left")).toBe(true);
-            expect(adj.has('right')).toBe(true);
+      expect(adj.has("right")).toBe(true);
-            expect(adj.has('bottom')).toBe(true);
+      expect(adj.has("bottom")).toBe(true);
-            expect(adj.has('diagonal')).toBe(false);
+      expect(adj.has("diagonal")).toBe(false);
     });
 
-        it('should return empty for item with no neighbors', () => {
+    it("should return empty for item with no neighbors", () => {
       const inv = createGridInventory(6, 4);
-            const item = createTestItem('alone', 'o');
+      const item = createTestItem("alone", "o");
       placeItem(inv, item);
 
-            const adj = getAdjacentItems(inv, 'alone');
+      const adj = getAdjacentItems(inv, "alone");
       expect(adj.size).toBe(0);
     });
 
-        it('should return empty for non-existent item', () => {
+    it("should return empty for non-existent item", () => {
       const inv = createGridInventory(6, 4);
-            const adj = getAdjacentItems(inv, 'ghost');
+      const adj = getAdjacentItems(inv, "ghost");
       expect(adj.size).toBe(0);
     });
 
-        it('should handle multi-cell items with multiple adjacencies', () => {
+    it("should handle multi-cell items with multiple adjacencies", () => {
       const inv = createGridInventory(6, 4);
       // Horizontal bar at (0,0)-(1,0)
-            const bar = createTestItem('bar', 'oe');
+      const bar = createTestItem("bar", "oe");
       // Item above left cell
-            const topA = createTestItem('topA', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 0, y: -1 } });
+      const topA = createTestItem("topA", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 0, y: -1 },
+      });
       // Item above right cell
-            const topB = createTestItem('topB', 'o', { ...IDENTITY_TRANSFORM, offset: { x: 1, y: -1 } });
+      const topB = createTestItem("topB", "o", {
+        ...IDENTITY_TRANSFORM,
+        offset: { x: 1, y: -1 },
+      });
 
       placeItem(inv, bar);
       placeItem(inv, topA);
       placeItem(inv, topB);
 
-            const adj = getAdjacentItems(inv, 'bar');
+      const adj = getAdjacentItems(inv, "bar");
       expect(adj.size).toBe(2);
-            expect(adj.has('topA')).toBe(true);
+      expect(adj.has("topA")).toBe(true);
-            expect(adj.has('topB')).toBe(true);
+      expect(adj.has("topB")).toBe(true);
     });
   });
 
-    describe('integration: fill a 4x6 backpack', () => {
+  describe("integration: fill a 4x6 backpack", () => {
-        it('should place items fitting a slay-the-spire-like backpack', () => {
+    it("should place items fitting a slay-the-spire-like backpack", () => {
       const inv = createGridInventory(4, 6);
 
       // Sword: 1x3 horizontal at (0,0)
-            const sword = createTestItem('sword', 'oee');
+      const sword = createTestItem("sword", "oee");
       // Shield: 2x2 at (0,1)
-            const shield = createTestItem('shield', 'oes', {
+      const shield = createTestItem("shield", "oes", {
         ...IDENTITY_TRANSFORM,
         offset: { x: 0, y: 1 },
       });
 
-            expect(validatePlacement(inv, sword.shape, sword.transform)).toEqual({ valid: true });
+      expect(validatePlacement(inv, sword.shape, sword.transform)).toEqual({
+        valid: true,
+      });
       placeItem(inv, sword);
 
-            expect(validatePlacement(inv, shield.shape, shield.transform)).toEqual({ valid: true });
+      expect(validatePlacement(inv, shield.shape, shield.transform)).toEqual({
+        valid: true,
+      });
       placeItem(inv, shield);
 
       expect(inv.items.size).toBe(2);
       expect(inv.occupiedCells.size).toBe(6); // sword(3) + shield(3)
 
       // Adjacent items should detect each other
-            const adjSword = getAdjacentItems(inv, 'sword');
+      const adjSword = getAdjacentItems(inv, "sword");
-            expect(adjSword.has('shield')).toBe(true);
+      expect(adjSword.has("shield")).toBe(true);
 
-            const adjShield = getAdjacentItems(inv, 'shield');
+      const adjShield = getAdjacentItems(inv, "shield");
-            expect(adjShield.has('sword')).toBe(true);
+      expect(adjShield.has("sword")).toBe(true);
+    });
+  });
+
+  describe("createItemIn", () => {
+    it("should place item at first valid position", () => {
+      const inv = createGridInventory<GameItemMeta>(6, 4);
+      const itemData = createTestItemData("sword", "长剑", "oee", "攻击");
+
+      const result = createItemIn(inv, "sword-1", itemData);
+
+      expect(result).toEqual({ success: true });
+      expect(inv.items.size).toBe(1);
+      expect(inv.occupiedCells.size).toBe(3); // shape "oee" has 3 cells
+      expect(inv.items.get("sword-1")?.meta?.itemData.id).toBe("sword");
+    });
+
+    it("should skip occupied cells and find next valid position", () => {
+      const inv = createGridInventory<GameItemMeta>(6, 4);
+
+      // Place first item manually at origin
+      const firstItem = createTestItem(
+        "existing",
+        "oee",
+      ) as unknown as GameItem;
+      placeItem(inv, firstItem);
+
+      const itemData = createTestItemData("shield", "盾牌", "o", "防御");
+
+      const result = createItemIn(inv, "shield-1", itemData);
+
+      expect(result).toEqual({ success: true });
+      // Shield should be at x=3, y=0 (first available spot after "oee" at x=0-2)
+      const placedItem = inv.items.get("shield-1");
+      expect(placedItem?.transform.offset).toEqual({ x: 3, y: 0 });
+    });
+
+    it("should return error when no valid placement exists", () => {
+      const inv = createGridInventory<GameItemMeta>(3, 3);
+
+      // Fill the grid completely with 1x1 items
+      for (let i = 0; i < 9; i++) {
+        const itemData = createTestItemData(`item${i}`, `物品${i}`, "o", "");
+        createItemIn(inv, `item-${i}`, itemData);
+      }
+
+      // Try to place one more item
+      const itemData = createTestItemData("overflow", "溢出", "oee", "");
+      const result = createItemIn(inv, "overflow-1", itemData);
+
+      expect(result).toEqual({ success: false, reason: "无可用位置" });
+    });
+
+    it("should handle multi-cell items correctly", () => {
+      const inv = createGridInventory<GameItemMeta>(4, 4);
+      const itemData = createTestItemData("lshape", "L形", "oes", "特殊");
+
+      const result = createItemIn(inv, "lshape-1", itemData);
+
+      expect(result).toEqual({ success: true });
+      expect(inv.items.size).toBe(1);
+      // Shape "oes" has 3 cells
+      expect(inv.occupiedCells.size).toBe(3);
+    });
+
+    it("should not place item when inventory is completely full", () => {
+      const inv = createGridInventory<GameItemMeta>(2, 2);
+
+      // Fill with 1x1 items
+      const itemData = createTestItemData("small", "小物品", "o", "");
+      createItemIn(inv, "small-1", itemData);
+      createItemIn(inv, "small-2", itemData);
+      createItemIn(inv, "small-3", itemData);
+      createItemIn(inv, "small-4", itemData);
+
+      // Grid is now full
+      const overflowItem = createTestItemData("overflow", "溢出", "o", "");
+      const result = createItemIn(inv, "overflow-5", overflowItem);
+
+      expect(result).toEqual({ success: false, reason: "无可用位置" });
+      expect(inv.items.size).toBe(4);
     });
   });
 });

tests/samples/slay-the-spire-like/map/generator.test.ts

@@ -1,19 +1,26 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import { generatePointCrawlMap, hasPath } from '@/samples/slay-the-spire-like/system/map/generator';
+import {
-import { MapNodeType, MapLayerType } from '@/samples/slay-the-spire-like/system/map/types';
+  generatePointCrawlMap,
-import { createRNG } from '@/utils/rng';
+  hasPath,
-import { encounters } from '@/samples/slay-the-spire-like/data/desert';
+} from "@/samples/slay-the-spire-like/system/map/generator";
+import {
+  MapNodeType,
+  MapLayerType,
+} from "@/samples/slay-the-spire-like/system/map/types";
+import { createRNG } from "@/utils/rng";
+import { getEncounters } from "@/samples/slay-the-spire-like/data/desert";
+const encounters = getEncounters();
 
-describe('generatePointCrawlMap', () => {
+describe("generatePointCrawlMap", () => {
-    it('should generate a map with 10 layers', () => {
+  it("should generate a map with 10 layers", () => {
     const map = generatePointCrawlMap(createRNG(123), encounters);
     expect(map.layers.length).toBe(10);
   });
 
-    it('should have correct layer structure', () => {
+  it("should have correct layer structure", () => {
     const map = generatePointCrawlMap(createRNG(123), encounters);
     const expectedStructure = [
-            'start',
+      "start",
       MapLayerType.Wild,
       MapLayerType.Wild,
       MapLayerType.Settlement,
@@ -22,7 +29,7 @@ describe('generatePointCrawlMap', () => {
       MapLayerType.Settlement,
       MapLayerType.Wild,
       MapLayerType.Wild,
-            'end',
+      "end",
     ];
 
     for (let i = 0; i < expectedStructure.length; i++) {
@@ -30,7 +37,7 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should have correct node counts per layer', () => {
+  it("should have correct node counts per layer", () => {
     const map = generatePointCrawlMap(createRNG(123), encounters);
     const expectedCounts = [1, 3, 3, 4, 3, 3, 4, 3, 3, 1];
 
@@ -39,19 +46,23 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should have Start and End nodes with correct types', () => {
+  it("should have Start and End nodes with correct types", () => {
     const map = generatePointCrawlMap(createRNG(123), encounters);
-        const startNode = map.nodes.get('node-0-0');
+    const startNode = map.nodes.get("node-0-0");
-        const endNode = map.nodes.get('node-9-0');
+    const endNode = map.nodes.get("node-9-0");
 
     expect(startNode?.type).toBe(MapNodeType.Start);
     expect(endNode?.type).toBe(MapNodeType.End);
   });
 
-    it('should have wild layers with minion/elite/event types', () => {
+  it("should have wild layers with minion/elite/event types", () => {
     const map = generatePointCrawlMap(createRNG(123), encounters);
     const wildLayerIndices = [1, 2, 4, 5, 7, 8];
-        const validWildTypes = new Set([MapNodeType.Minion, MapNodeType.Elite, MapNodeType.Event]);
+    const validWildTypes = new Set([
+      MapNodeType.Minion,
+      MapNodeType.Elite,
+      MapNodeType.Event,
+    ]);
 
     for (const layerIdx of wildLayerIndices) {
       const layer = map.layers[layerIdx];
@@ -63,13 +74,13 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should have settlement layers with at least 1 camp, 1 shop, 1 curio', () => {
+  it("should have settlement layers with at least 1 camp, 1 shop, 1 curio", () => {
     const map = generatePointCrawlMap(createRNG(123), encounters);
     const settlementLayerIndices = [3, 6];
 
     for (const layerIdx of settlementLayerIndices) {
       const layer = map.layers[layerIdx];
-            const nodeTypes = layer.nodeIds.map(id => map.nodes.get(id)!.type);
+      const nodeTypes = layer.nodeIds.map((id) => map.nodes.get(id)!.type);
 
       expect(nodeTypes).toContain(MapNodeType.Camp);
       expect(nodeTypes).toContain(MapNodeType.Shop);
@@ -78,16 +89,18 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should have Start connected to all 3 wild nodes', () => {
+  it("should have Start connected to all 3 wild nodes", () => {
     const map = generatePointCrawlMap(createRNG(42), encounters);
-        const startNode = map.nodes.get('node-0-0');
+    const startNode = map.nodes.get("node-0-0");
     const wildLayer = map.layers[1];
 
     expect(startNode?.childIds.length).toBe(3);
-        expect(startNode?.childIds).toEqual(expect.arrayContaining(wildLayer.nodeIds));
+    expect(startNode?.childIds).toEqual(
+      expect.arrayContaining(wildLayer.nodeIds),
+    );
   });
 
-    it('should have each wild node connect to 1 wild node in wild→wild layers', () => {
+  it("should have each wild node connect to 1 wild node in wild→wild layers", () => {
     const map = generatePointCrawlMap(createRNG(42), encounters);
     const wildToWildTransitions = [
       { src: 1, tgt: 2 },
@@ -106,7 +119,7 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should have each wild node connect to 2 settlement nodes in wild→settlement layers', () => {
+  it("should have each wild node connect to 2 settlement nodes in wild→settlement layers", () => {
     const map = generatePointCrawlMap(createRNG(42), encounters);
     const wildToSettlementTransitions = [
       { src: 2, tgt: 3 },
@@ -126,7 +139,7 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should have settlement nodes connect correctly (1-2-2-1 pattern)', () => {
+  it("should have settlement nodes connect correctly (1-2-2-1 pattern)", () => {
     const map = generatePointCrawlMap(createRNG(42), encounters);
     const settlementToWildTransitions = [
       { src: 3, tgt: 4 },
@@ -154,10 +167,10 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should have all 3 wild nodes connect to End', () => {
+  it("should have all 3 wild nodes connect to End", () => {
     const map = generatePointCrawlMap(createRNG(42), encounters);
     const lastWildLayer = map.layers[8];
-        const endNode = map.nodes.get('node-9-0');
+    const endNode = map.nodes.get("node-9-0");
 
     for (const wildId of lastWildLayer.nodeIds) {
       const wildNode = map.nodes.get(wildId);
@@ -165,10 +178,10 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should have all nodes reachable from Start and can reach End', () => {
+  it("should have all nodes reachable from Start and can reach End", () => {
     const map = generatePointCrawlMap(createRNG(123), encounters);
-        const startId = 'node-0-0';
+    const startId = "node-0-0";
-        const endId = 'node-9-0';
+    const endId = "node-9-0";
 
     for (const nodeId of map.nodes.keys()) {
       if (nodeId === startId || nodeId === endId) continue;
@@ -177,7 +190,7 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should not have crossing edges in wild→wild transitions', () => {
+  it("should not have crossing edges in wild→wild transitions", () => {
     const map = generatePointCrawlMap(createRNG(12345), encounters);
     const wildToWildTransitions = [
       { src: 1, tgt: 2 },
@@ -215,7 +228,7 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should not have crossing edges in wild→settlement transitions', () => {
+  it("should not have crossing edges in wild→settlement transitions", () => {
     const map = generatePointCrawlMap(createRNG(12345), encounters);
     const wildToSettlementTransitions = [
       { src: 2, tgt: 3 },
@@ -252,7 +265,7 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should not have crossing edges in settlement→wild transitions', () => {
+  it("should not have crossing edges in settlement→wild transitions", () => {
     const map = generatePointCrawlMap(createRNG(12345), encounters);
     const settlementToWildTransitions = [
       { src: 3, tgt: 4 },
@@ -289,7 +302,7 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should assign encounters to all non-Start/End nodes', () => {
+  it("should assign encounters to all non-Start/End nodes", () => {
     const map = generatePointCrawlMap(createRNG(456), encounters);
 
     for (const node of map.nodes.values()) {
@@ -298,14 +311,17 @@ describe('generatePointCrawlMap', () => {
         expect(node.encounter).toBeUndefined();
       } else {
         // All other nodes (minion/elite/event/camp/shop/curio) must have encounters
-                expect(node.encounter, `Node ${node.id} (${node.type}) should have encounter data`).toBeDefined();
+        expect(
+          node.encounter,
+          `Node ${node.id} (${node.type}) should have encounter data`,
+        ).toBeDefined();
         expect(node.encounter!.name).toBeTruthy();
         expect(node.encounter!.description).toBeTruthy();
       }
     }
   });
 
-    it('should assign encounters to all nodes across multiple seeds', () => {
+  it("should assign encounters to all nodes across multiple seeds", () => {
     // Test multiple seeds to ensure no random failure
     for (let seed = 0; seed < 20; seed++) {
       const map = generatePointCrawlMap(createRNG(seed), encounters);
@@ -314,14 +330,17 @@ describe('generatePointCrawlMap', () => {
         if (node.type === MapNodeType.Start || node.type === MapNodeType.End) {
           continue;
         }
-                expect(node.encounter, `Seed ${seed}: Node ${node.id} (${node.type}) missing encounter`).toBeDefined();
+        expect(
+          node.encounter,
+          `Seed ${seed}: Node ${node.id} (${node.type}) missing encounter`,
+        ).toBeDefined();
         expect(node.encounter!.name).toBeTruthy();
         expect(node.encounter!.description).toBeTruthy();
       }
     }
   });
 
-    it('should minimize same-layer repetitions in wild layer pairs', () => {
+  it("should minimize same-layer repetitions in wild layer pairs", () => {
     // Test that wild layers in pairs (1-2, 4-5, 7-8) have minimal duplicate types within each layer
     const map = generatePointCrawlMap(createRNG(12345), encounters);
     const wildPairIndices = [
@@ -335,12 +354,12 @@ describe('generatePointCrawlMap', () => {
       const layer2 = map.layers[layer2Idx];
 
       // Count repetitions in layer 1
-            const layer1Types = layer1.nodeIds.map(id => map.nodes.get(id)!.type);
+      const layer1Types = layer1.nodeIds.map((id) => map.nodes.get(id)!.type);
       const layer1Unique = new Set(layer1Types).size;
       const layer1Repetitions = layer1Types.length - layer1Unique;
 
       // Count repetitions in layer 2
-            const layer2Types = layer2.nodeIds.map(id => map.nodes.get(id)!.type);
+      const layer2Types = layer2.nodeIds.map((id) => map.nodes.get(id)!.type);
       const layer2Unique = new Set(layer2Types).size;
       const layer2Repetitions = layer2Types.length - layer2Unique;
 
@@ -351,7 +370,7 @@ describe('generatePointCrawlMap', () => {
     }
   });
 
-    it('should minimize adjacent repetitions in wild→wild connections', () => {
+  it("should minimize adjacent repetitions in wild→wild connections", () => {
     // Test that wild nodes connected by wild→wild edges have different types
     const map = generatePointCrawlMap(createRNG(12345), encounters);
     const wildToWildPairs = [

tests/samples/slay-the-spire-like/utils/shape-utils.test.ts

@@ -1,18 +1,18 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import { parseShapeString } from '@/samples/slay-the-spire-like/system/utils/parse-shape';
+import { parseShapeString } from "@/samples/slay-the-spire-like/system/utils/parse-shape";
 import {
   checkCollision,
   checkBoardCollision,
   checkBounds,
-    validatePlacement,
+  validateShapePlacement,
   transformShape,
   getOccupiedCells,
   IDENTITY_TRANSFORM,
-} from '@/samples/slay-the-spire-like/system/utils/shape-collision';
+} from "@/samples/slay-the-spire-like/system/utils/shape-collision";
 
-describe('parseShapeString', () => {
+describe("parseShapeString", () => {
-    it('should parse a single cell with o', () => {
+  it("should parse a single cell with o", () => {
-        const result = parseShapeString('o');
+    const result = parseShapeString("o");
     expect(result.grid).toEqual([[true]]);
     expect(result.width).toBe(1);
     expect(result.height).toBe(1);
@@ -21,8 +21,8 @@ describe('parseShapeString', () => {
     expect(result.originY).toBe(0);
   });
 
-    it('should parse a horizontal line', () => {
+  it("should parse a horizontal line", () => {
-        const result = parseShapeString('oee');
+    const result = parseShapeString("oee");
     expect(result.width).toBe(3);
     expect(result.height).toBe(1);
     expect(result.count).toBe(3);
@@ -31,8 +31,8 @@ describe('parseShapeString', () => {
     expect(result.originY).toBe(0);
   });
 
-    it('should parse a vertical line', () => {
+  it("should parse a vertical line", () => {
-        const result = parseShapeString('oss');
+    const result = parseShapeString("oss");
     expect(result.width).toBe(1);
     expect(result.height).toBe(3);
     expect(result.count).toBe(3);
@@ -41,8 +41,8 @@ describe('parseShapeString', () => {
     expect(result.originY).toBe(0);
   });
 
-    it('should parse an L shape', () => {
+  it("should parse an L shape", () => {
-        const result = parseShapeString('oes');
+    const result = parseShapeString("oes");
     expect(result.width).toBe(2);
     expect(result.height).toBe(2);
     expect(result.count).toBe(3);
@@ -52,47 +52,47 @@ describe('parseShapeString', () => {
     ]);
   });
 
-    it('should handle return command', () => {
+  it("should handle return command", () => {
-        const result = parseShapeString('oeerww');
+    const result = parseShapeString("oeerww");
     expect(result.width).toBe(4);
     expect(result.height).toBe(1);
     expect(result.count).toBe(4);
     expect(result.grid).toEqual([[true, true, true, true]]);
   });
 
-    it('should handle case insensitivity', () => {
+  it("should handle case insensitivity", () => {
-        const resultLower = parseShapeString('oes');
+    const resultLower = parseShapeString("oes");
-        const resultUpper = parseShapeString('OES');
+    const resultUpper = parseShapeString("OES");
     expect(resultLower.grid).toEqual(resultUpper.grid);
     expect(resultLower.count).toBe(resultUpper.count);
   });
 
-    it('should return empty grid for empty input', () => {
+  it("should return empty grid for empty input", () => {
-        const result = parseShapeString('');
+    const result = parseShapeString("");
     expect(result.grid).toEqual([[]]);
     expect(result.width).toBe(0);
     expect(result.height).toBe(1);
     expect(result.count).toBe(0);
   });
 
-    it('should track origin correctly', () => {
+  it("should track origin correctly", () => {
     // eeso: e(1,0), e(2,0), s(2,1), o sets origin at (2,1)
     // After normalization: minX=1, minY=0, so originX = 2-1 = 1, originY = 1-0 = 1
-        const result = parseShapeString('eeso');
+    const result = parseShapeString("eeso");
     expect(result.originX).toBe(1);
     expect(result.originY).toBe(1);
   });
 
-    it('should track origin at first o only', () => {
+  it("should track origin at first o only", () => {
-        const result = parseShapeString('oes');
+    const result = parseShapeString("oes");
     expect(result.originX).toBe(0);
     expect(result.originY).toBe(0);
   });
 
-    it('should handle complex T shape', () => {
+  it("should handle complex T shape", () => {
     // oewers: o(0,0), e(1,0), w(0,0), e(1,0), r->(0,0), s(0,1)
     // Filled: (0,0), (1,0), (0,1) - 3 cells
-        const result = parseShapeString('oewers');
+    const result = parseShapeString("oewers");
     expect(result.width).toBe(2);
     expect(result.height).toBe(2);
     expect(result.count).toBe(3);
@@ -103,16 +103,16 @@ describe('parseShapeString', () => {
   });
 });
 
-describe('shape-collision', () => {
+describe("shape-collision", () => {
-    describe('getOccupiedCells', () => {
+  describe("getOccupiedCells", () => {
-        it('should return cells for a single cell shape', () => {
+    it("should return cells for a single cell shape", () => {
-            const shape = parseShapeString('o');
+      const shape = parseShapeString("o");
       const cells = getOccupiedCells(shape);
       expect(cells).toEqual([{ x: 0, y: 0 }]);
     });
 
-        it('should return cells for a horizontal line', () => {
+    it("should return cells for a horizontal line", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
       const cells = getOccupiedCells(shape);
       expect(cells).toEqual([
         { x: 0, y: 0 },
@@ -120,8 +120,8 @@ describe('shape-collision', () => {
       ]);
     });
 
-        it('should return cells for an L shape', () => {
+    it("should return cells for an L shape", () => {
-            const shape = parseShapeString('oes');
+      const shape = parseShapeString("oes");
       const cells = getOccupiedCells(shape);
       expect(cells).toEqual([
         { x: 0, y: 0 },
@@ -131,49 +131,49 @@ describe('shape-collision', () => {
     });
   });
 
-    describe('checkCollision', () => {
+  describe("checkCollision", () => {
-        it('should detect collision between overlapping shapes', () => {
+    it("should detect collision between overlapping shapes", () => {
-            const shapeA = parseShapeString('o');
+      const shapeA = parseShapeString("o");
-            const shapeB = parseShapeString('o');
+      const shapeB = parseShapeString("o");
 
       const result = checkCollision(
         shapeA,
         { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
         shapeB,
-                { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } }
+        { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
       );
       expect(result).toBe(true);
     });
 
-        it('should not detect collision between non-overlapping shapes', () => {
+    it("should not detect collision between non-overlapping shapes", () => {
-            const shapeA = parseShapeString('o');
+      const shapeA = parseShapeString("o");
-            const shapeB = parseShapeString('o');
+      const shapeB = parseShapeString("o");
 
       const result = checkCollision(
         shapeA,
         { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
         shapeB,
-                { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } }
+        { ...IDENTITY_TRANSFORM, offset: { x: 2, y: 0 } },
       );
       expect(result).toBe(false);
     });
 
-        it('should detect collision with adjacent shapes', () => {
+    it("should detect collision with adjacent shapes", () => {
-            const shapeA = parseShapeString('o');
+      const shapeA = parseShapeString("o");
-            const shapeB = parseShapeString('o');
+      const shapeB = parseShapeString("o");
 
       const result = checkCollision(
         shapeA,
         { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
         shapeB,
-                { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 0 } }
+        { ...IDENTITY_TRANSFORM, offset: { x: 1, y: 0 } },
       );
       expect(result).toBe(false);
     });
 
-        it('should detect collision with rotation', () => {
+    it("should detect collision with rotation", () => {
-            const shapeA = parseShapeString('oe');
+      const shapeA = parseShapeString("oe");
-            const shapeB = parseShapeString('os');
+      const shapeB = parseShapeString("os");
 
       // shapeA is horizontal at (0,0)-(1,0)
       // shapeB rotated 90° becomes vertical at (0,0)-(0,1)
@@ -182,130 +182,142 @@ describe('shape-collision', () => {
         shapeA,
         { ...IDENTITY_TRANSFORM, offset: { x: 0, y: 0 } },
         shapeB,
-                { ...IDENTITY_TRANSFORM, rotation: 90, offset: { x: 0, y: 0 } }
+        { ...IDENTITY_TRANSFORM, rotation: 90, offset: { x: 0, y: 0 } },
       );
       expect(result).toBe(true);
     });
   });
 
-    describe('checkBoardCollision', () => {
+  describe("checkBoardCollision", () => {
-        it('should detect collision with occupied cells', () => {
+    it("should detect collision with occupied cells", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
-            const occupied = new Set(['0,0', '1,0']);
+      const occupied = new Set(["0,0", "1,0"]);
 
       const result = checkBoardCollision(shape, IDENTITY_TRANSFORM, occupied);
       expect(result).toBe(true);
     });
 
-        it('should not detect collision with empty board', () => {
+    it("should not detect collision with empty board", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
       const occupied = new Set<string>();
 
       const result = checkBoardCollision(shape, IDENTITY_TRANSFORM, occupied);
       expect(result).toBe(false);
     });
 
-        it('should detect collision after translation', () => {
+    it("should detect collision after translation", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
-            const occupied = new Set(['5,5', '6,5']);
+      const occupied = new Set(["5,5", "6,5"]);
 
       const result = checkBoardCollision(
         shape,
         { ...IDENTITY_TRANSFORM, offset: { x: 5, y: 5 } },
-                occupied
+        occupied,
       );
       expect(result).toBe(true);
     });
   });
 
-    describe('checkBounds', () => {
+  describe("checkBounds", () => {
-        it('should return true for shape within bounds', () => {
+    it("should return true for shape within bounds", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
 
       const result = checkBounds(shape, IDENTITY_TRANSFORM, 10, 10);
       expect(result).toBe(true);
     });
 
-        it('should return false for shape outside bounds', () => {
+    it("should return false for shape outside bounds", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
 
       const result = checkBounds(
         shape,
         { ...IDENTITY_TRANSFORM, offset: { x: 9, y: 0 } },
         10,
-                10
+        10,
       );
       expect(result).toBe(false);
     });
 
-        it('should return false for negative coordinates', () => {
+    it("should return false for negative coordinates", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
 
       const result = checkBounds(
         shape,
         { ...IDENTITY_TRANSFORM, offset: { x: -1, y: 0 } },
         10,
-                10
+        10,
       );
       expect(result).toBe(false);
     });
 
-        it('should return true for shape at boundary edge', () => {
+    it("should return true for shape at boundary edge", () => {
-            const shape = parseShapeString('o');
+      const shape = parseShapeString("o");
 
       const result = checkBounds(
         shape,
         { ...IDENTITY_TRANSFORM, offset: { x: 9, y: 9 } },
         10,
-                10
+        10,
       );
       expect(result).toBe(true);
     });
   });
 
-    describe('validatePlacement', () => {
+  describe("validatePlacement", () => {
-        it('should return valid for good placement', () => {
+    it("should return valid for good placement", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
       const occupied = new Set<string>();
 
-            const result = validatePlacement(shape, IDENTITY_TRANSFORM, 10, 10, occupied);
+      const result = validateShapePlacement(
+        shape,
+        IDENTITY_TRANSFORM,
+        10,
+        10,
+        occupied,
+      );
       expect(result).toEqual({ valid: true });
     });
 
-        it('should return invalid for out of bounds', () => {
+    it("should return invalid for out of bounds", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
       const occupied = new Set<string>();
 
-            const result = validatePlacement(
+      const result = validateShapePlacement(
         shape,
         { ...IDENTITY_TRANSFORM, offset: { x: 9, y: 0 } },
         10,
         10,
-                occupied
+        occupied,
       );
-            expect(result).toEqual({ valid: false, reason: '超出边界' });
+      expect(result).toEqual({ valid: false, reason: "超出边界" });
     });
 
-        it('should return invalid for collision', () => {
+    it("should return invalid for collision", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
-            const occupied = new Set(['0,0', '1,0']);
+      const occupied = new Set(["0,0", "1,0"]);
 
-            const result = validatePlacement(shape, IDENTITY_TRANSFORM, 10, 10, occupied);
+      const result = validateShapePlacement(
-            expect(result).toEqual({ valid: false, reason: '与已有形状重叠' });
+        shape,
+        IDENTITY_TRANSFORM,
+        10,
+        10,
+        occupied,
+      );
+      expect(result).toEqual({ valid: false, reason: "与已有形状重叠" });
     });
   });
 
-    describe('transformShape', () => {
+  describe("transformShape", () => {
-        it('should apply translation correctly', () => {
+    it("should apply translation correctly", () => {
-            const shape = parseShapeString('o');
+      const shape = parseShapeString("o");
       const transform = { ...IDENTITY_TRANSFORM, offset: { x: 5, y: 3 } };
 
       const cells = transformShape(shape, transform);
       expect(cells).toEqual([{ x: 5, y: 3 }]);
     });
 
-        it('should apply 90° rotation correctly', () => {
+    it("should apply 90° rotation correctly", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
       const transform = { ...IDENTITY_TRANSFORM, rotation: 90 };
 
       const cells = transformShape(shape, transform);
@@ -315,8 +327,8 @@ describe('shape-collision', () => {
       ]);
     });
 
-        it('should apply horizontal flip correctly', () => {
+    it("should apply horizontal flip correctly", () => {
-            const shape = parseShapeString('oe');
+      const shape = parseShapeString("oe");
       const transform = { ...IDENTITY_TRANSFORM, flipX: true };
 
       const cells = transformShape(shape, transform);
@@ -326,8 +338,8 @@ describe('shape-collision', () => {
       ]);
     });
 
-        it('should apply vertical flip correctly', () => {
+    it("should apply vertical flip correctly", () => {
-            const shape = parseShapeString('os');
+      const shape = parseShapeString("os");
       const transform = { ...IDENTITY_TRANSFORM, flipY: true };
 
       const cells = transformShape(shape, transform);
@@ -337,8 +349,8 @@ describe('shape-collision', () => {
       ]);
     });
 
-        it('should combine rotation and translation', () => {
+    it("should combine rotation and translation", () => {
-            const shape = parseShapeString('os');
+      const shape = parseShapeString("os");
       const transform = {
         ...IDENTITY_TRANSFORM,
         rotation: 90,

tests/utils/command-prompt.test.ts

@@ -0,0 +1,219 @@
+import { describe, it, expect } from "vitest";
+import { createPromptContext } from "@/utils/command/command-prompt";
+import type { CommandSchema } from "@/utils/command/types";
+
+const mockSchema: CommandSchema = {
+  name: "test",
+  params: [{ name: "value", required: true, variadic: false }],
+  options: {},
+  flags: {},
+};
+
+describe("createPromptContext", () => {
+  describe("prompt", () => {
+    it("should store prompt and return promise", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator);
+      await new Promise((r) => setTimeout(r, 0));
+
+      const result = ctx.tryCommit("global", "hello");
+      expect(result).toEqual({ ok: true });
+      await expect(promise).resolves.toBe("hello");
+    });
+
+    it("should associate prompt with specific player", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      const result = ctx.tryCommit("player1", "hello");
+      expect(result).toEqual({ ok: true });
+      await expect(promise).resolves.toBe("hello");
+    });
+
+    it("should cancel existing prompt when new prompt starts for same player", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise1 = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      const promise2 = ctx.prompt({ schema: mockSchema }, validator, "player1");
+
+      // Resolve promise2 first, then both will settle
+      ctx.tryCommit("player1", "test");
+      const [result1, result2] = await Promise.allSettled([promise1, promise2]);
+
+      expect(result1.status).toBe("rejected");
+      expect((result1 as PromiseRejectedResult).reason).toBe(
+        "Prompt overriden",
+      );
+      expect(result2.status).toBe("fulfilled");
+    });
+
+    it("should allow different players to have independent prompts", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise1 = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      const promise2 = ctx.prompt({ schema: mockSchema }, validator, "player2");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.tryCommit("player1", "hello");
+      ctx.tryCommit("player2", "world");
+
+      await expect(promise1).resolves.toBe("hello");
+      await expect(promise2).resolves.toBe("world");
+    });
+  });
+
+  describe("tryCommit", () => {
+    it("should return ok:true when prompt exists and validation passes", () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value.toUpperCase();
+
+      ctx.prompt({ schema: mockSchema }, validator, "player1");
+      const result = ctx.tryCommit("player1", "hello");
+
+      expect(result).toEqual({ ok: true });
+    });
+
+    it("should return ok:false with reason when no prompt exists", () => {
+      const ctx = createPromptContext();
+      const result = ctx.tryCommit("nonexistent", "hello");
+
+      expect(result).toEqual({ ok: false, reason: "No Prompt" });
+    });
+
+    it("should return ok:false when validator throws string", () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => {
+        if (value.length < 3) throw "Value too short";
+        return value;
+      };
+
+      ctx.prompt({ schema: mockSchema }, validator, "player1");
+      const result = ctx.tryCommit("player1", "ab");
+
+      expect(result).toEqual({ ok: false, reason: "Value too short" });
+    });
+
+    it("should throw when validator throws non-string error", () => {
+      const ctx = createPromptContext();
+      const validator = () => {
+        throw new Error("unexpected");
+      };
+
+      ctx.prompt({ schema: mockSchema }, validator, "player1");
+      expect(() => ctx.tryCommit("player1", "test")).toThrow("unexpected");
+    });
+
+    it("should pass validator return value to promise resolver", async () => {
+      const ctx = createPromptContext();
+      const validator = (a: number, b: number) => a + b;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.tryCommit("player1", 2, 3);
+      await expect(promise).resolves.toBe(5);
+    });
+  });
+
+  describe("cancel", () => {
+    it("should reject promise with default message", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.cancel("player1");
+
+      const result = await Promise.allSettled([promise]);
+      expect(result[0].status).toBe("rejected");
+      expect((result[0] as PromiseRejectedResult).reason).toBe(
+        "Prompt Cancelled",
+      );
+    });
+
+    it("should reject promise with custom reason", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.cancel("player1", "Custom cancel reason");
+
+      const result = await Promise.allSettled([promise]);
+      expect(result[0].status).toBe("rejected");
+      expect((result[0] as PromiseRejectedResult).reason).toBe(
+        "Custom cancel reason",
+      );
+    });
+
+    it("should do nothing when no prompt exists for player", () => {
+      const ctx = createPromptContext();
+      ctx.cancel("nonexistent");
+    });
+
+    it("should only cancel prompt for specific player", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise1 = ctx.prompt({ schema: mockSchema }, validator, "player1");
+      const promise2 = ctx.prompt({ schema: mockSchema }, validator, "player2");
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.cancel("player1");
+      ctx.tryCommit("player2", "test");
+
+      const [result1, result2] = await Promise.allSettled([promise1, promise2]);
+      expect(result1.status).toBe("rejected");
+      expect((result1 as PromiseRejectedResult).reason).toBe(
+        "Prompt Cancelled",
+      );
+
+      expect(result2.status).toBe("fulfilled");
+    });
+  });
+
+  describe("handleCall", () => {
+    it("should be a middleware chain that can be extended", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      let middlewareCalled = false;
+      ctx.handleCall.use(async (call, next) => {
+        middlewareCalled = true;
+        return next();
+      });
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator);
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(middlewareCalled).toBe(true);
+      ctx.tryCommit("global", "test");
+      await expect(promise).resolves.toBe("test");
+    });
+
+    it("should remove prompt from map after resolution", async () => {
+      const ctx = createPromptContext();
+      const validator = (value: string) => value;
+
+      const promise = ctx.prompt({ schema: mockSchema }, validator);
+      await new Promise((r) => setTimeout(r, 0));
+
+      ctx.tryCommit("global", "test");
+      await promise;
+
+      const result = ctx.tryCommit("global", "another");
+      expect(result).toEqual({ ok: false, reason: "No Prompt" });
+    });
+  });
+});

tests/utils/command-runner.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import { parseCommandSchema } from '@/utils/command/schema-parse';
+import { parseCommandSchema } from "@/utils/command/schema-parse";
 import {
   createCommandRegistry,
   registerCommand,
@@ -10,109 +10,120 @@ import {
   createCommandRunnerContext,
   type CommandRegistry,
   type CommandRunnerContextExport,
-} from '@/utils/command/command-registry';
+} from "@/utils/command/command-registry";
-import type { CommandRunner, PromptEvent } from '@/utils/command/command-runner';
+import type {
+  CommandRunner,
+  PromptEvent,
+} from "@/utils/command/command-runner";
 
 type TestContext = {
   counter: number;
   log: string[];
 };
 
-describe('CommandRegistry', () => {
+describe("CommandRegistry", () => {
-    it('should create an empty registry', () => {
+  it("should create an empty registry", () => {
     const registry = createCommandRegistry<TestContext>();
     expect(registry.size).toBe(0);
   });
 
-    it('should register a command', () => {
+  it("should register a command", () => {
     const registry = createCommandRegistry<TestContext>();
     const runner: CommandRunner<TestContext, number> = {
-            schema: parseCommandSchema('add <a> <b>'),
+      schema: parseCommandSchema("add <a> <b>"),
       run: async function (cmd) {
         return Number(cmd.params[0]) + Number(cmd.params[1]);
       },
     };
     registerCommand(registry, runner);
     expect(registry.size).toBe(1);
-        expect(hasCommand(registry, 'add')).toBe(true);
+    expect(hasCommand(registry, "add")).toBe(true);
   });
 
-    it('should unregister a command', () => {
+  it("should unregister a command", () => {
     const registry = createCommandRegistry<TestContext>();
     const runner: CommandRunner<TestContext> = {
-            schema: parseCommandSchema('remove'),
+      schema: parseCommandSchema("remove"),
       run: async () => {},
     };
     registerCommand(registry, runner);
-        expect(hasCommand(registry, 'remove')).toBe(true);
+    expect(hasCommand(registry, "remove")).toBe(true);
-        unregisterCommand(registry, 'remove');
+    unregisterCommand(registry, "remove");
-        expect(hasCommand(registry, 'remove')).toBe(false);
+    expect(hasCommand(registry, "remove")).toBe(false);
   });
 
-    it('should get a command runner', () => {
+  it("should get a command runner", () => {
     const registry = createCommandRegistry<TestContext>();
     const runner: CommandRunner<TestContext> = {
-            schema: parseCommandSchema('get'),
+      schema: parseCommandSchema("get"),
       run: async () => {},
     };
     registerCommand(registry, runner);
-        const retrieved = getCommand(registry, 'get');
+    const retrieved = getCommand(registry, "get");
     expect(retrieved).toBe(runner);
   });
 
-    it('should return undefined for unknown command', () => {
+  it("should return undefined for unknown command", () => {
     const registry = createCommandRegistry<TestContext>();
-        const retrieved = getCommand(registry, 'unknown');
+    const retrieved = getCommand(registry, "unknown");
     expect(retrieved).toBeUndefined();
   });
 });
 
-describe('runCommand', () => {
+describe("runCommand", () => {
-    it('should run a command successfully', async () => {
+  it("should run a command successfully", async () => {
     const registry = createCommandRegistry<TestContext>();
     const runner: CommandRunner<TestContext, number> = {
-            schema: parseCommandSchema('add <a> <b>'),
+      schema: parseCommandSchema("add <a> <b>"),
       run: async function (cmd) {
         return Number(cmd.params[0]) + Number(cmd.params[1]);
       },
     };
     registerCommand(registry, runner);
 
-        const result = await runCommand(registry, { counter: 0, log: [] }, 'add 1 2');
+    const result = await runCommand(
+      registry,
+      { counter: 0, log: [] },
+      "add 1 2",
+    );
     expect(result.success).toBe(true);
     if (result.success) {
       expect(result.result).toBe(3);
     }
   });
 
-    it('should fail for unknown command', async () => {
+  it("should fail for unknown command", async () => {
     const registry = createCommandRegistry<TestContext>();
-        const result = await runCommand(registry, { counter: 0, log: [] }, 'unknown');
+    const result = await runCommand(
+      registry,
+      { counter: 0, log: [] },
+      "unknown",
+    );
     expect(result.success).toBe(false);
     if (!result.success) {
-            expect(result.error).toContain('Unknown command');
+      expect(result.error).toContain("Unknown command");
     }
   });
 
-    it('should fail for invalid command params', async () => {
+  it("should fail for invalid command params", async () => {
     const registry = createCommandRegistry<TestContext>();
     const runner: CommandRunner<TestContext> = {
-            schema: parseCommandSchema('add <a> <b>'),
+      schema: parseCommandSchema("add <a> <b>"),
       run: async () => {},
     };
     registerCommand(registry, runner);
 
-        const result = await runCommand(registry, { counter: 0, log: [] }, 'add 1');
+    const result = await runCommand(registry, { counter: 0, log: [] }, "add 1");
     expect(result.success).toBe(false);
     if (!result.success) {
-            expect(result.error).toContain('参数不足');
+      expect(result.error).toContain("参数不足");
     }
   });
 
-    it('should access context via this.context', async () => {
+  it("should access context via this.context", async () => {
     const registry = createCommandRegistry<TestContext>();
     const runner: CommandRunner<TestContext, number> = {
-            schema: parseCommandSchema('increment'),
+      schema: parseCommandSchema("increment"),
       run: async function () {
         this.context.counter++;
         return this.context.counter;
@@ -121,30 +132,30 @@ describe('runCommand', () => {
     registerCommand(registry, runner);
 
     const ctx = { counter: 0, log: [] };
-        await runCommand(registry, ctx, 'increment');
+    await runCommand(registry, ctx, "increment");
     expect(ctx.counter).toBe(1);
   });
 
-    it('should handle async errors', async () => {
+  it("should handle async errors", async () => {
     const registry = createCommandRegistry<TestContext>();
     const runner: CommandRunner<TestContext> = {
-            schema: parseCommandSchema('fail'),
+      schema: parseCommandSchema("fail"),
       run: async () => {
-                throw new Error('Something went wrong');
+        throw new Error("Something went wrong");
       },
     };
     registerCommand(registry, runner);
 
-        const result = await runCommand(registry, { counter: 0, log: [] }, 'fail');
+    const result = await runCommand(registry, { counter: 0, log: [] }, "fail");
     expect(result.success).toBe(false);
     if (!result.success) {
-            expect(result.error).toBe('Something went wrong');
+      expect(result.error).toBe("Something went wrong");
     }
   });
 });
 
-describe('CommandRunnerContext', () => {
+describe("CommandRunnerContext", () => {
-    it('should create a runner context', () => {
+  it("should create a runner context", () => {
     const registry = createCommandRegistry<TestContext>();
     const ctx = { counter: 0, log: [] };
     const runnerCtx = createCommandRunnerContext(registry, ctx);
@@ -152,10 +163,10 @@ describe('CommandRunnerContext', () => {
     expect(runnerCtx.context).toBe(ctx);
   });
 
-    it('should run commands via runner context', async () => {
+  it("should run commands via runner context", async () => {
     const registry = createCommandRegistry<TestContext>();
     const runner: CommandRunner<TestContext, string> = {
-            schema: parseCommandSchema('greet <name>'),
+      schema: parseCommandSchema("greet <name>"),
       run: async function (cmd) {
         this.context.log.push(`Hello, ${cmd.params[0]}!`);
         return `Hello, ${cmd.params[0]}!`;
@@ -165,19 +176,19 @@ describe('CommandRunnerContext', () => {
 
     const ctx = { counter: 0, log: [] };
     const runnerCtx = createCommandRunnerContext(registry, ctx);
-        const result = await runnerCtx.run('greet World');
+    const result = await runnerCtx.run("greet World");
     expect(result.success).toBe(true);
     if (result.success) {
-            expect(result.result).toBe('Hello, World!');
+      expect(result.result).toBe("Hello, World!");
     }
-        expect(ctx.log).toEqual(['Hello, World!']);
+    expect(ctx.log).toEqual(["Hello, World!"]);
   });
 
-    it('should allow commands to call other commands via this.run', async () => {
+  it("should allow commands to call other commands via this.run", async () => {
     const registry = createCommandRegistry<TestContext>();
 
     const addRunner: CommandRunner<TestContext, number> = {
-            schema: parseCommandSchema('add <a> <b>'),
+      schema: parseCommandSchema("add <a> <b>"),
       run: async function (cmd) {
         return Number(cmd.params[0]) + Number(cmd.params[1]);
       },
@@ -186,12 +197,12 @@ describe('CommandRunnerContext', () => {
     registerCommand(registry, addRunner);
 
     const multiplyRunner: CommandRunner<TestContext, number> = {
-            schema: parseCommandSchema('multiply <a> <b>'),
+      schema: parseCommandSchema("multiply <a> <b>"),
       run: async function (cmd) {
         const a = Number(cmd.params[0]);
         const b = Number(cmd.params[1]);
         const addResult = await this.run(`add ${a} ${a}`);
-                if (!addResult.success) throw new Error('add failed');
+        if (!addResult.success) throw new Error("add failed");
         return (addResult.result as number) * b;
       },
     };
@@ -199,18 +210,18 @@ describe('CommandRunnerContext', () => {
     registerCommand(registry, multiplyRunner);
 
     const ctx = { counter: 0, log: [] };
-        const result = await runCommand(registry, ctx, 'multiply 3 4');
+    const result = await runCommand(registry, ctx, "multiply 3 4");
     expect(result.success).toBe(true);
     if (result.success) {
       expect(result.result).toBe(24);
     }
   });
 
-    it('should allow commands to call other commands via this.runParsed', async () => {
+  it("should allow commands to call other commands via this.runParsed", async () => {
     const registry = createCommandRegistry<TestContext>();
 
     const doubleRunner: CommandRunner<TestContext, number> = {
-            schema: parseCommandSchema('double <n>'),
+      schema: parseCommandSchema("double <n>"),
       run: async function (cmd) {
         return Number(cmd.params[0]) * 2;
       },
@@ -219,11 +230,16 @@ describe('CommandRunnerContext', () => {
     registerCommand(registry, doubleRunner);
 
     const quadrupleRunner: CommandRunner<TestContext, number> = {
-            schema: parseCommandSchema('quadruple <n>'),
+      schema: parseCommandSchema("quadruple <n>"),
       run: async function (cmd) {
         const n = Number(cmd.params[0]);
-                const doubleResult = await this.runParsed({ name: 'double', params: [String(n)], options: {}, flags: {} });
+        const doubleResult = await this.runParsed({
-                if (!doubleResult.success) throw new Error('double failed');
+          name: "double",
+          params: [String(n)],
+          options: {},
+          flags: {},
+        });
+        if (!doubleResult.success) throw new Error("double failed");
         return (doubleResult.result as number) * 2;
       },
     };
@@ -231,7 +247,7 @@ describe('CommandRunnerContext', () => {
     registerCommand(registry, quadrupleRunner);
 
     const ctx = { counter: 0, log: [] };
-        const result = await runCommand(registry, ctx, 'quadruple 5');
+    const result = await runCommand(registry, ctx, "quadruple 5");
     expect(result.success).toBe(true);
     if (result.success) {
       expect(result.result).toBe(20);
@@ -239,14 +255,17 @@ describe('CommandRunnerContext', () => {
   });
 });
 
-describe('prompt', () => {
+describe("prompt", () => {
-    it('should dispatch prompt event with string schema', async () => {
+  it("should dispatch prompt event with string schema", async () => {
     const registry = createCommandRegistry<TestContext>();
 
     const chooseRunner: CommandRunner<TestContext, string> = {
-            schema: parseCommandSchema('choose'),
+      schema: parseCommandSchema("choose"),
       run: async function () {
-                const result = await this.prompt('select <card>', (cmd) => cmd.params[0] as string);
+        const result = await this.prompt(
+          parseCommandSchema("select <card>"),
+          (cmd) => cmd.params[0] as string,
+        );
         return result;
       },
     };
@@ -257,27 +276,30 @@ describe('prompt', () => {
     let promptEvent: PromptEvent | null = null;
 
     const runnerCtx = createCommandRunnerContext(registry, ctx);
-        runnerCtx.on('prompt', (e) => {
+    runnerCtx.on("prompt", (e) => {
       promptEvent = e;
     });
 
-        const runPromise = runnerCtx.run('choose');
+    const runPromise = runnerCtx.run("choose");
 
     await new Promise((r) => setTimeout(r, 0));
     expect(promptEvent).not.toBeNull();
-        expect(promptEvent!.schema.name).toBe('select');
+    expect(promptEvent!.schema.name).toBe("select");
 
-        promptEvent!.cancel('test cleanup');
+    promptEvent!.cancel("test cleanup");
     await runPromise;
   });
 
-    it('should resolve prompt with valid input', async () => {
+  it("should resolve prompt with valid input", async () => {
     const registry = createCommandRegistry<TestContext>();
 
     const chooseRunner: CommandRunner<TestContext, string> = {
-            schema: parseCommandSchema('choose'),
+      schema: parseCommandSchema("choose"),
       run: async function () {
-                const result = await this.prompt('select <card>', (card) => card as string);
+        const result = await this.prompt(
+          parseCommandSchema("select <card>"),
+          (card) => card as string,
+        );
         this.context.log.push(`selected ${result}`);
         return result;
       },
@@ -289,36 +311,39 @@ describe('prompt', () => {
     let promptEvent: PromptEvent | null = null;
 
     const runnerCtx = createCommandRunnerContext(registry, ctx);
-        runnerCtx.on('prompt', (e) => {
+    runnerCtx.on("prompt", (e) => {
       promptEvent = e;
     });
 
-        const runPromise = runnerCtx.run('choose');
+    const runPromise = runnerCtx.run("choose");
 
     await new Promise((r) => setTimeout(r, 0));
     expect(promptEvent).not.toBeNull();
 
-        const parsed = { name: 'select', params: ['Ace'], options: {}, flags: {} };
+    const parsed = { name: "select", params: ["Ace"], options: {}, flags: {} };
     const error = promptEvent!.tryCommit(parsed);
     expect(error).toBeNull();
 
     const result = await runPromise;
     expect(result.success).toBe(true);
     if (result.success) {
-            expect(result.result).toBe('Ace');
+      expect(result.result).toBe("Ace");
     }
-        expect(ctx.log).toEqual(['selected Ace']);
+    expect(ctx.log).toEqual(["selected Ace"]);
   });
 
-    it('should reject prompt with invalid input', async () => {
+  it("should reject prompt with invalid input", async () => {
     const registry = createCommandRegistry<TestContext>();
 
     const chooseRunner: CommandRunner<TestContext, string> = {
-            schema: parseCommandSchema('choose'),
+      schema: parseCommandSchema("choose"),
       run: async function () {
         try {
-                    await this.prompt('select <card>', (card) => card as string);
+          await this.prompt(
-                    return 'unexpected success';
+            parseCommandSchema("select <card>"),
+            (card) => card as string,
+          );
+          return "unexpected success";
         } catch (e) {
           return (e as Error).message;
         }
@@ -331,30 +356,30 @@ describe('prompt', () => {
     let promptEvent: PromptEvent | null = null;
 
     const runnerCtx = createCommandRunnerContext(registry, ctx);
-        runnerCtx.on('prompt', (e) => {
+    runnerCtx.on("prompt", (e) => {
       promptEvent = e;
     });
 
-        const runPromise = runnerCtx.run('choose');
+    const runPromise = runnerCtx.run("choose");
 
     await new Promise((r) => setTimeout(r, 0));
     expect(promptEvent).not.toBeNull();
 
-        promptEvent!.cancel('user cancelled');
+    promptEvent!.cancel("user cancelled");
 
     const result = await runPromise;
     expect(result.success).toBe(true);
     if (result.success) {
-            expect(result.result).toBe('user cancelled');
+      expect(result.result).toBe("user cancelled");
     }
   });
 
-    it('should accept CommandSchema object in prompt', async () => {
+  it("should accept CommandSchema object in prompt", async () => {
     const registry = createCommandRegistry<TestContext>();
-        const schema = parseCommandSchema('pick <item>');
+    const schema = parseCommandSchema("pick <item>");
 
     const pickRunner: CommandRunner<TestContext, string> = {
-            schema: parseCommandSchema('pick'),
+      schema: parseCommandSchema("pick"),
       run: async function () {
         const result = await this.prompt(schema, (item) => item as string);
         return result;
@@ -367,34 +392,45 @@ describe('prompt', () => {
     let promptEvent: PromptEvent | null = null;
 
     const runnerCtx = createCommandRunnerContext(registry, ctx);
-        runnerCtx.on('prompt', (e) => {
+    runnerCtx.on("prompt", (e) => {
       promptEvent = e;
     });
 
-        const runPromise = runnerCtx.run('pick');
+    const runPromise = runnerCtx.run("pick");
 
     await new Promise((r) => setTimeout(r, 0));
     expect(promptEvent).not.toBeNull();
-        expect(promptEvent!.schema.name).toBe('pick');
+    expect(promptEvent!.schema.name).toBe("pick");
 
-        const error = promptEvent!.tryCommit({ name: 'pick', params: ['sword'], options: {}, flags: {} });
+    const error = promptEvent!.tryCommit({
+      name: "pick",
+      params: ["sword"],
+      options: {},
+      flags: {},
+    });
     expect(error).toBeNull();
 
     const result = await runPromise;
     expect(result.success).toBe(true);
     if (result.success) {
-            expect(result.result).toBe('sword');
+      expect(result.result).toBe("sword");
     }
   });
 
-    it('should allow multiple sequential prompts', async () => {
+  it("should allow multiple sequential prompts", async () => {
     const registry = createCommandRegistry<TestContext>();
 
     const multiPromptRunner: CommandRunner<TestContext, string[]> = {
-            schema: parseCommandSchema('multi'),
+      schema: parseCommandSchema("multi"),
       run: async function () {
-                const first = await this.prompt('first <a>', (a) => a as string);
+        const first = await this.prompt(
-                const second = await this.prompt('second <b>', (b) => b as string);
+          parseCommandSchema("first <a>"),
+          (a) => a as string,
+        );
+        const second = await this.prompt(
+          parseCommandSchema("second <b>"),
+          (b) => b as string,
+        );
         return [first, second];
       },
     };
@@ -405,48 +441,58 @@ describe('prompt', () => {
     const promptEvents: PromptEvent[] = [];
 
     const runnerCtx = createCommandRunnerContext(registry, ctx);
-        runnerCtx.on('prompt', (e) => {
+    runnerCtx.on("prompt", (e) => {
       promptEvents.push(e);
     });
 
-        const runPromise = runnerCtx.run('multi');
+    const runPromise = runnerCtx.run("multi");
 
     await new Promise((r) => setTimeout(r, 0));
     expect(promptEvents.length).toBe(1);
-        expect(promptEvents[0].schema.name).toBe('first');
+    expect(promptEvents[0].schema.name).toBe("first");
 
-        const error1 = promptEvents[0].tryCommit({ name: 'first', params: ['one'], options: {}, flags: {} });
+    const error1 = promptEvents[0].tryCommit({
+      name: "first",
+      params: ["one"],
+      options: {},
+      flags: {},
+    });
     expect(error1).toBeNull();
 
     await new Promise((r) => setTimeout(r, 0));
     expect(promptEvents.length).toBe(2);
-        expect(promptEvents[1].schema.name).toBe('second');
+    expect(promptEvents[1].schema.name).toBe("second");
 
-        const error2 = promptEvents[1].tryCommit({ name: 'second', params: ['two'], options: {}, flags: {} });
+    const error2 = promptEvents[1].tryCommit({
+      name: "second",
+      params: ["two"],
+      options: {},
+      flags: {},
+    });
     expect(error2).toBeNull();
 
     const result = await runPromise;
     expect(result.success).toBe(true);
     if (result.success) {
-            expect(result.result).toEqual(['one', 'two']);
+      expect(result.result).toEqual(["one", "two"]);
     }
   });
 
-    it('should validate input with validator function', async () => {
+  it("should validate input with validator function", async () => {
     const registry = createCommandRegistry<TestContext>();
 
     const chooseRunner: CommandRunner<TestContext, string> = {
-            schema: parseCommandSchema('choose'),
+      schema: parseCommandSchema("choose"),
       run: async function () {
         const result = await this.prompt(
-                    'select <card>',
+          parseCommandSchema("select <card>"),
           (card) => {
             const cardStr = card as string;
-                        if (!['Ace', 'King', 'Queen'].includes(cardStr)) {
+            if (!["Ace", "King", "Queen"].includes(cardStr)) {
               throw `Invalid card: ${cardStr}. Must be Ace, King, or Queen.`;
             }
             return cardStr;
-                    }
+          },
         );
         return result;
       },
@@ -458,39 +504,52 @@ describe('prompt', () => {
     let promptEvent: PromptEvent | null = null;
 
     const runnerCtx = createCommandRunnerContext(registry, ctx);
-        runnerCtx.on('prompt', (e) => {
+    runnerCtx.on("prompt", (e) => {
       promptEvent = e;
     });
 
-        const runPromise = runnerCtx.run('choose');
+    const runPromise = runnerCtx.run("choose");
 
     await new Promise((r) => setTimeout(r, 0));
     expect(promptEvent).not.toBeNull();
 
     // Try invalid input
-        const invalidError = promptEvent!.tryCommit({ name: 'select', params: ['Jack'], options: {}, flags: {} });
+    const invalidError = promptEvent!.tryCommit({
-        expect(invalidError).toContain('Invalid card: Jack');
+      name: "select",
+      params: ["Jack"],
+      options: {},
+      flags: {},
+    });
+    expect(invalidError).toContain("Invalid card: Jack");
 
     // Try valid input
-        const validError = promptEvent!.tryCommit({ name: 'select', params: ['Ace'], options: {}, flags: {} });
+    const validError = promptEvent!.tryCommit({
+      name: "select",
+      params: ["Ace"],
+      options: {},
+      flags: {},
+    });
     expect(validError).toBeNull();
 
     const result = await runPromise;
     expect(result.success).toBe(true);
     if (result.success) {
-            expect(result.result).toBe('Ace');
+      expect(result.result).toBe("Ace");
     }
   });
 
-    it('should allow cancel with custom reason', async () => {
+  it("should allow cancel with custom reason", async () => {
     const registry = createCommandRegistry<TestContext>();
 
     const chooseRunner: CommandRunner<TestContext, string> = {
-            schema: parseCommandSchema('choose'),
+      schema: parseCommandSchema("choose"),
       run: async function () {
         try {
-                    await this.prompt('select <card>', (cmd) => cmd.params[0] as string);
+          await this.prompt(
-                    return 'unexpected success';
+            parseCommandSchema("select <card>"),
+            (cmd) => cmd.params[0] as string,
+          );
+          return "unexpected success";
         } catch (e) {
           return (e as Error).message;
         }
@@ -503,21 +562,21 @@ describe('prompt', () => {
     let promptEvent: PromptEvent | null = null;
 
     const runnerCtx = createCommandRunnerContext(registry, ctx);
-        runnerCtx.on('prompt', (e) => {
+    runnerCtx.on("prompt", (e) => {
       promptEvent = e;
     });
 
-        const runPromise = runnerCtx.run('choose');
+    const runPromise = runnerCtx.run("choose");
 
     await new Promise((r) => setTimeout(r, 0));
     expect(promptEvent).not.toBeNull();
 
-        promptEvent!.cancel('custom cancellation reason');
+    promptEvent!.cancel("custom cancellation reason");
 
     const result = await runPromise;
     expect(result.success).toBe(true);
     if (result.success) {
-            expect(result.result).toBe('custom cancellation reason');
+      expect(result.result).toBe("custom cancellation reason");
     }
   });
 });

tests/utils/command.test.ts

@@ -1,174 +1,176 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import { parseCommand, type Command } from '@/utils/command';
+import { parseCommand, type Command } from "@/utils/command";
 
-describe('parseCommand', () => {
+describe("parseCommand", () => {
-    it('should parse empty string', () => {
+  it("should parse empty string", () => {
-        const result = parseCommand('');
+    const result = parseCommand("");
     expect(result).toEqual({
-            name: '',
+      name: "",
       flags: {},
       options: {},
-            params: []
+      params: [],
     });
   });
 
-    it('should parse command name only', () => {
+  it("should parse command name only", () => {
-        const result = parseCommand('move');
+    const result = parseCommand("move");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: {},
       options: {},
-            params: []
+      params: [],
     });
   });
 
-    it('should parse command with params', () => {
+  it("should parse command with params", () => {
-        const result = parseCommand('move meeple1 region1');
+    const result = parseCommand("move meeple1 region1");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: {},
       options: {},
-            params: ['meeple1', 'region1']
+      params: ["meeple1", "region1"],
     });
   });
 
-    it('should parse command with long flags', () => {
+  it("should parse command with long flags", () => {
-        const result = parseCommand('move meeple1 --force --quiet');
+    const result = parseCommand("move meeple1 --force --quiet");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: { force: true, quiet: true },
       options: {},
-            params: ['meeple1']
+      params: ["meeple1"],
     });
   });
 
-    it('should parse command with short flags', () => {
+  it("should parse command with short flags", () => {
-        const result = parseCommand('move meeple1 -f -q');
+    const result = parseCommand("move meeple1 -f -q");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: { f: true, q: true },
       options: {},
-            params: ['meeple1']
+      params: ["meeple1"],
     });
   });
 
-    it('should parse command with long options', () => {
+  it("should parse command with long options", () => {
-        const result = parseCommand('move meeple1 --x 10 --y 20');
+    const result = parseCommand("move meeple1 --x 10 --y 20");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: {},
-            options: { x: '10', y: '20' },
+      options: { x: "10", y: "20" },
-            params: ['meeple1']
+      params: ["meeple1"],
     });
   });
 
-    it('should parse command with short options', () => {
+  it("should parse command with short options", () => {
-        const result = parseCommand('move meeple1 -x 10 -y 20');
+    const result = parseCommand("move meeple1 -x 10 -y 20");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: {},
-            options: { x: '10', y: '20' },
+      options: { x: "10", y: "20" },
-            params: ['meeple1']
+      params: ["meeple1"],
     });
   });
 
-    it('should parse command with mixed flags和选项', () => {
+  it("should parse command with mixed flags和选项", () => {
-        const result = parseCommand('move meeple1 region1 --force -x 10 -q');
+    const result = parseCommand("move meeple1 region1 --force -x 10 -q");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: { force: true, q: true },
-            options: { x: '10' },
+      options: { x: "10" },
-            params: ['meeple1', 'region1']
+      params: ["meeple1", "region1"],
     });
   });
 
-    it('should handle extra whitespace', () => {
+  it("should handle extra whitespace", () => {
-        const result = parseCommand('  move   meeple1   --force  ');
+    const result = parseCommand("  move   meeple1   --force  ");
     expect(result).toEqual({
-            name: 'move',
+      name: "move",
       flags: { force: true },
       options: {},
-            params: ['meeple1']
+      params: ["meeple1"],
     });
   });
 
-    it('should parse complex command', () => {
+  it("should parse complex command", () => {
-        const result = parseCommand('place meeple1 board --x 5 --y 3 --rotate 90 --force');
+    const result = parseCommand(
+      "place meeple1 board --x 5 --y 3 --rotate 90 --force",
+    );
     expect(result).toEqual({
-            name: 'place',
+      name: "place",
       flags: { force: true },
-            options: { x: '5', y: '3', rotate: '90' },
+      options: { x: "5", y: "3", rotate: "90" },
-            params: ['meeple1', 'board']
+      params: ["meeple1", "board"],
     });
   });
 
-    it('should treat negative number as option value', () => {
+  it("should treat negative number as option value", () => {
-        const result = parseCommand('set --value -10');
+    const result = parseCommand("set --value -10");
     expect(result).toEqual({
-            name: 'set',
+      name: "set",
       flags: {},
-            options: { value: '-10' },
+      options: { value: "-10" },
-            params: []
+      params: [],
     });
   });
 
-    it('should parse quoted string with double quotes', () => {
+  it("should parse quoted string with double quotes", () => {
     const result = parseCommand('place tile "large castle" --x 5');
     expect(result).toEqual({
-            name: 'place',
+      name: "place",
       flags: {},
-            options: { x: '5' },
+      options: { x: "5" },
-            params: ['tile', 'large castle']
+      params: ["tile", "large castle"],
     });
   });
 
-    it('should parse quoted string with single quotes', () => {
+  it("should parse quoted string with single quotes", () => {
     const result = parseCommand("place tile 'large castle' --x 5");
     expect(result).toEqual({
-            name: 'place',
+      name: "place",
       flags: {},
-            options: { x: '5' },
+      options: { x: "5" },
-            params: ['tile', 'large castle']
+      params: ["tile", "large castle"],
     });
   });
 
-    it('should handle escaped quotes', () => {
+  it("should handle escaped quotes", () => {
     const result = parseCommand('say "hello \\"world\\""');
     expect(result).toEqual({
-            name: 'say',
+      name: "say",
       flags: {},
       options: {},
-            params: ['hello "world"']
+      params: ['hello "world"'],
     });
   });
 
-    it('should handle escaped backslash', () => {
+  it("should handle escaped backslash", () => {
     const result = parseCommand('set path "C:\\\\Users"');
     expect(result).toEqual({
-            name: 'set',
+      name: "set",
       flags: {},
       options: {},
-            params: ['path', 'C:\\Users']
+      params: ["path", "C:\\Users"],
     });
   });
 
-    it('should handle mixed quotes', () => {
+  it("should handle mixed quotes", () => {
-        const result = parseCommand('cmd "hello world" \'foo bar\' --flag');
+    const result = parseCommand("cmd \"hello world\" 'foo bar' --flag");
     expect(result).toEqual({
-            name: 'cmd',
+      name: "cmd",
       flags: { flag: true },
       options: {},
-            params: ['hello world', 'foo bar']
+      params: ["hello world", "foo bar"],
     });
   });
 
-    it('should handle quote in middle of argument', () => {
+  it("should handle quote in middle of argument", () => {
     const result = parseCommand('cmd "hello\'s world"');
     expect(result).toEqual({
-            name: 'cmd',
+      name: "cmd",
       flags: {},
       options: {},
-            params: ["hello's world"]
+      params: ["hello's world"],
     });
   });
 });

tests/utils/middleware.test.ts

@@ -1,27 +1,30 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
-import { createMiddlewareChain, type MiddlewareChain } from '@/utils/middleware';
+import {
+  createMiddlewareChain,
+  type MiddlewareChain,
+} from "@/utils/middleware";
 
-describe('createMiddlewareChain', () => {
+describe("createMiddlewareChain", () => {
-    describe('basic execution', () => {
+  describe("basic execution", () => {
-        it('should return context when no middlewares and no fallback', async () => {
+    it("should return context when no middlewares and no fallback", async () => {
       const chain = createMiddlewareChain<{ value: number }>();
       const result = await chain.execute({ value: 42 });
 
       expect(result).toEqual({ value: 42 });
     });
 
-        it('should call fallback when no middlewares', async () => {
+    it("should call fallback when no middlewares", async () => {
       const chain = createMiddlewareChain<{ value: number }, string>(
-                async ctx => `value is ${ctx.value}`
+        async (ctx) => `value is ${ctx.value}`,
       );
       const result = await chain.execute({ value: 42 });
 
-            expect(result).toBe('value is 42');
+      expect(result).toBe("value is 42");
     });
 
-        it('should pass context to fallback', async () => {
+    it("should pass context to fallback", async () => {
       const chain = createMiddlewareChain<{ a: number; b: number }, number>(
-                async ctx => ctx.a + ctx.b
+        async (ctx) => ctx.a + ctx.b,
       );
       const result = await chain.execute({ a: 3, b: 7 });
 
@@ -29,8 +32,8 @@ describe('createMiddlewareChain', () => {
     });
   });
 
-    describe('single middleware', () => {
+  describe("single middleware", () => {
-        it('should execute a single middleware', async () => {
+    it("should execute a single middleware", async () => {
       const chain = createMiddlewareChain<{ count: number }>();
       chain.use(async (ctx, next) => {
         ctx.count *= 2;
@@ -42,9 +45,9 @@ describe('createMiddlewareChain', () => {
       expect(result.count).toBe(10);
     });
 
-        it('should allow middleware to modify return value', async () => {
+    it("should allow middleware to modify return value", async () => {
       const chain = createMiddlewareChain<{ value: number }, number>(
-                async ctx => ctx.value
+        async (ctx) => ctx.value,
       );
       chain.use(async (ctx, next) => {
         const result = await next();
@@ -56,7 +59,7 @@ describe('createMiddlewareChain', () => {
       expect(result).toBe(42);
     });
 
-        it('should allow middleware to short-circuit without calling next', async () => {
+    it("should allow middleware to short-circuit without calling next", async () => {
       const chain = createMiddlewareChain<{ value: number }>();
       chain.use(async (_ctx, _next) => {
         return { value: 999 };
@@ -68,8 +71,8 @@ describe('createMiddlewareChain', () => {
     });
   });
 
-    describe('multiple middlewares', () => {
+  describe("multiple middlewares", () => {
-        it('should execute middlewares in order', async () => {
+    it("should execute middlewares in order", async () => {
       const order: number[] = [];
       const chain = createMiddlewareChain<{ value: number }>();
 
@@ -91,7 +94,7 @@ describe('createMiddlewareChain', () => {
       expect(order).toEqual([1, 2, 3, 4]);
     });
 
-        it('should accumulate modifications through the chain', async () => {
+    it("should accumulate modifications through the chain", async () => {
       const chain = createMiddlewareChain<{ value: number }>();
 
       chain.use(async (ctx, next) => {
@@ -112,9 +115,9 @@ describe('createMiddlewareChain', () => {
       expect(result.value).toBe(5);
     });
 
-        it('should allow middleware to modify result on the way back', async () => {
+    it("should allow middleware to modify result on the way back", async () => {
       const chain = createMiddlewareChain<{ base: number }, number>(
-                async ctx => ctx.base
+        async (ctx) => ctx.base,
       );
 
       chain.use(async (_ctx, next) => {
@@ -131,7 +134,7 @@ describe('createMiddlewareChain', () => {
       expect(result).toBe(20);
     });
 
-        it('should allow middleware to short-circuit in the middle', async () => {
+    it("should allow middleware to short-circuit in the middle", async () => {
       const executed: number[] = [];
       const chain = createMiddlewareChain<{ value: number }>();
 
@@ -155,13 +158,14 @@ describe('createMiddlewareChain', () => {
     });
   });
 
-    describe('nested next calls', () => {
+  describe("nested next calls", () => {
-        it('should advance index on each next call, skipping remaining middlewares', async () => {
+    it("should advance index on each next call, skipping remaining middlewares", async () => {
       const chain = createMiddlewareChain<{ counter: number }>();
 
       chain.use(async (_ctx, next) => {
         await next();
         await next();
+        return undefined as unknown as { counter: number };
       });
 
       const result = await chain.execute({ counter: 0 });
@@ -169,12 +173,12 @@ describe('createMiddlewareChain', () => {
       expect(result).toBeUndefined();
     });
 
-        it('should allow middleware to call next conditionally', async () => {
+    it("should allow middleware to call next conditionally", async () => {
       const chain = createMiddlewareChain<{ skip: boolean; value: number }>();
 
       chain.use(async (ctx, next) => {
         if (ctx.skip) {
-                    return { value: -1 };
+          return { skip: ctx.skip, value: -1 };
         }
         return next();
       });
@@ -190,33 +194,33 @@ describe('createMiddlewareChain', () => {
       expect(resultB.value).toBe(10);
     });
 
-        it('should handle middleware that awaits next multiple times with a fallback', async () => {
+    it("should handle middleware that awaits next multiple times with a fallback", async () => {
       const log: string[] = [];
       const chain = createMiddlewareChain<{ value: number }, string[]>(
-                async _ctx => log
+        async (_ctx) => log,
       );
 
       chain.use(async (_ctx, next) => {
-                log.push('before');
+        log.push("before");
         await next();
-                log.push('after-first');
+        log.push("after-first");
         await next();
-                log.push('after-second');
+        log.push("after-second");
         return log;
       });
       chain.use(async (_ctx, next) => {
-                log.push('mw2');
+        log.push("mw2");
         return next();
       });
 
       const result = await chain.execute({ value: 0 });
 
-            expect(result).toEqual(['before', 'mw2', 'after-first', 'after-second']);
+      expect(result).toEqual(["before", "mw2", "after-first", "after-second"]);
     });
 
-        it('should return fallback result on second next call when no more middlewares remain', async () => {
+    it("should return fallback result on second next call when no more middlewares remain", async () => {
       const chain = createMiddlewareChain<{ value: number }, number>(
-                async ctx => ctx.value * 10
+        async (ctx) => ctx.value * 10,
       );
 
       chain.use(async (_ctx, next) => {
@@ -232,9 +236,9 @@ describe('createMiddlewareChain', () => {
       expect(result).toBe(50);
     });
 
-        it('should return fallback result on second next call when no more middlewares remain', async () => {
+    it("should return fallback result on second next call when no more middlewares remain", async () => {
       const chain = createMiddlewareChain<{ value: number }, number>(
-                async ctx => ctx.value * 10
+        async (ctx) => ctx.value * 10,
       );
 
       chain.use(async (_ctx, next) => {
@@ -251,17 +255,17 @@ describe('createMiddlewareChain', () => {
     });
   });
 
-    describe('async behavior', () => {
+  describe("async behavior", () => {
-        it('should handle async middlewares', async () => {
+    it("should handle async middlewares", async () => {
       const chain = createMiddlewareChain<{ value: number }>();
 
       chain.use(async (ctx, next) => {
-                await new Promise(resolve => setTimeout(resolve, 10));
+        await new Promise((resolve) => setTimeout(resolve, 10));
         ctx.value += 1;
         return next();
       });
       chain.use(async (ctx, next) => {
-                await new Promise(resolve => setTimeout(resolve, 10));
+        await new Promise((resolve) => setTimeout(resolve, 10));
         ctx.value += 2;
         return next();
       });
@@ -271,12 +275,12 @@ describe('createMiddlewareChain', () => {
       expect(result.value).toBe(3);
     });
 
-        it('should handle async fallback', async () => {
+    it("should handle async fallback", async () => {
       const chain = createMiddlewareChain<{ value: number }, number>(
-                async ctx => {
+        async (ctx) => {
-                    await new Promise(resolve => setTimeout(resolve, 10));
+          await new Promise((resolve) => setTimeout(resolve, 10));
           return ctx.value * 10;
-                }
+        },
       );
 
       const result = await chain.execute({ value: 5 });
@@ -285,28 +289,32 @@ describe('createMiddlewareChain', () => {
     });
   });
 
-    describe('error handling', () => {
+  describe("error handling", () => {
-        it('should propagate errors from middleware', async () => {
+    it("should propagate errors from middleware", async () => {
       const chain = createMiddlewareChain<{ value: number }>();
 
       chain.use(async () => {
-                throw new Error('middleware error');
+        throw new Error("middleware error");
       });
 
-            await expect(chain.execute({ value: 1 })).rejects.toThrow('middleware error');
+      await expect(chain.execute({ value: 1 })).rejects.toThrow(
+        "middleware error",
+      );
     });
 
-        it('should propagate errors from fallback', async () => {
+    it("should propagate errors from fallback", async () => {
       const chain = createMiddlewareChain<{ value: number }, number>(
         async () => {
-                    throw new Error('fallback error');
+          throw new Error("fallback error");
-                }
+        },
       );
 
-            await expect(chain.execute({ value: 1 })).rejects.toThrow('fallback error');
+      await expect(chain.execute({ value: 1 })).rejects.toThrow(
+        "fallback error",
+      );
     });
 
-        it('should allow middleware to catch errors from downstream', async () => {
+    it("should allow middleware to catch errors from downstream", async () => {
       const chain = createMiddlewareChain<{ value: number }>();
 
       chain.use(async (_ctx, next) => {
@@ -317,7 +325,7 @@ describe('createMiddlewareChain', () => {
         }
       });
       chain.use(async () => {
-                throw new Error('downstream error');
+        throw new Error("downstream error");
       });
 
       const result = await chain.execute({ value: 1 });
@@ -326,20 +334,20 @@ describe('createMiddlewareChain', () => {
     });
   });
 
-    describe('return type override', () => {
+  describe("return type override", () => {
-        it('should support different TReturn type than TContext', async () => {
+    it("should support different TReturn type than TContext", async () => {
       const chain = createMiddlewareChain<{ name: string }, string>(
-                async ctx => `Hello, ${ctx.name}!`
+        async (ctx) => `Hello, ${ctx.name}!`,
       );
 
-            const result = await chain.execute({ name: 'World' });
+      const result = await chain.execute({ name: "World" });
 
-            expect(result).toBe('Hello, World!');
+      expect(result).toBe("Hello, World!");
     });
 
-        it('should allow middleware to transform return type', async () => {
+    it("should allow middleware to transform return type", async () => {
       const chain = createMiddlewareChain<{ items: number[] }, number>(
-                async ctx => ctx.items.reduce((a, b) => a + b, 0)
+        async (ctx) => ctx.items.reduce((a, b) => a + b, 0),
       );
 
       chain.use(async (_ctx, next) => {
@@ -353,8 +361,8 @@ describe('createMiddlewareChain', () => {
     });
   });
 
-    describe('reusability', () => {
+  describe("reusability", () => {
-        it('should reset index on each execute call', async () => {
+    it("should reset index on each execute call", async () => {
       const chain = createMiddlewareChain<{ count: number }>();
 
       chain.use(async (ctx, next) => {
@@ -369,11 +377,11 @@ describe('createMiddlewareChain', () => {
       expect(resultB.count).toBe(1);
     });
 
-        it('should share middlewares across execute calls', async () => {
+    it("should share middlewares across execute calls", async () => {
       const chain = createMiddlewareChain<{ log: string[] }>();
 
       chain.use(async (ctx, next) => {
-                ctx.log.push('always');
+        ctx.log.push("always");
         return next();
       });
 
@@ -384,17 +392,17 @@ describe('createMiddlewareChain', () => {
     });
   });
 
-    describe('edge cases', () => {
+  describe("edge cases", () => {
-        it('should handle empty context object', async () => {
+    it("should handle empty context object", async () => {
       const chain = createMiddlewareChain<Record<string, never>>();
       const result = await chain.execute({});
 
       expect(result).toEqual({});
     });
 
-        it('should handle middleware that returns a completely different object', async () => {
+    it("should handle middleware that returns a completely different object", async () => {
       const chain = createMiddlewareChain<{ x: number }, { y: string }>(
-                async () => ({ y: 'default' })
+        async () => ({ y: "default" }),
       );
 
       chain.use(async (_ctx, next) => {
@@ -403,12 +411,12 @@ describe('createMiddlewareChain', () => {
 
       const result = await chain.execute({ x: 42 });
 
-            expect(result).toEqual({ y: 'default' });
+      expect(result).toEqual({ y: "default" });
     });
 
-        it('should handle middleware that mutates context without returning', async () => {
+    it("should handle middleware that mutates context without returning", async () => {
       const chain = createMiddlewareChain<{ value: number }>(
-                async ctx => ctx
+        async (ctx) => ctx,
       );
 
       chain.use(async (ctx, next) => {
@@ -421,11 +429,12 @@ describe('createMiddlewareChain', () => {
       expect(result.value).toBe(100);
     });
 
-        it('should return undefined when middleware does not call next or return', async () => {
+    it("should return undefined when middleware does not call next or return", async () => {
       const chain = createMiddlewareChain<{ value: number }>();
 
       chain.use(async (ctx) => {
         ctx.value = 100;
+        return undefined as unknown as { value: number };
       });
 
       const result = await chain.execute({ value: 0 });

tsconfig.json

@@ -5,18 +5,20 @@
     "lib": ["ES2020"],
     "moduleResolution": "bundler",
     "strict": true,
+    "types": ["node"],
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "declaration": true,
     "declarationMap": true,
     "outDir": "./dist",
-    "rootDir": "./src",
+
+    "rootDir": ".",
     "baseUrl": ".",
     "paths": {
-      "@/*": ["src/*"]
+      "@/*": ["src/*"],
-    }
     },
-  "include": ["src/**/*"],
+  },
-  "exclude": ["node_modules", "dist", "tests"]
+  "include": ["src/**/*", "tests/**/*", "*.config.ts"],
+  "exclude": ["node_modules", "dist"],
 }

tsup.config.ts

@@ -1,20 +1,20 @@
-import { defineConfig } from 'tsup';
+import { defineConfig } from "tsup";
-import { fileURLToPath } from 'url';
+import { fileURLToPath } from "url";
-import { csvLoader } from 'inline-schema/csv-loader/rollup';
+import { csvLoader } from "inline-schema/csv-loader/rollup";
 
-const srcDir = fileURLToPath(new URL('./src', import.meta.url));
+const srcDir = fileURLToPath(new URL("./src", import.meta.url));
 
 export default defineConfig({
-  entry: ['src/index.ts'],
+  entry: ["src/index.ts"],
-  format: ['esm'],
+  format: ["esm"],
   dts: true,
   clean: true,
   sourcemap: true,
-  external: ['@preact/signals-core', 'mutative', 'inline-schema'],
+  external: ["@preact/signals-core", "mutative", "inline-schema"],
   plugins: [csvLoader()],
   esbuildOptions(options) {
     options.alias = {
-      '@': srcDir,
+      "@": srcDir,
     };
   },
 });

tsup.samples.config.ts

@@ -1,13 +1,13 @@
-import { defineConfig } from 'tsup';
+import { defineConfig } from "tsup";
-import { fileURLToPath } from 'url';
+import { fileURLToPath } from "url";
-import * as fs from 'fs';
+import * as fs from "fs";
-import * as path from 'path';
+import * as path from "path";
-import {csvLoader} from 'inline-schema/csv-loader/esbuild';
+import { csvLoader } from "inline-schema/csv-loader/esbuild";
-import {yarnSpinnerPlugin} from 'yarn-spinner-loader/esbuild';
+import { yarnSpinnerPlugin } from "yarn-spinner-loader/esbuild";
-import type { Plugin } from 'esbuild';
+import type { Plugin } from "esbuild";
 
-const srcDir = fileURLToPath(new URL('./src', import.meta.url));
+const srcDir = fileURLToPath(new URL("./src", import.meta.url));
-const samplesDir = fileURLToPath(new URL('./src/samples', import.meta.url));
+const samplesDir = fileURLToPath(new URL("./src/samples", import.meta.url));
 
 // Auto-discover samples entry points
 function getSamplesEntries(): Record<string, string> {
@@ -18,13 +18,13 @@ function getSamplesEntries(): Record<string, string> {
     const fullPath = path.join(samplesDir, item);
     if (fs.statSync(fullPath).isDirectory()) {
       // Directory sample (e.g. boop) - look for index.ts
-      const indexPath = path.join(fullPath, 'index.ts');
+      const indexPath = path.join(fullPath, "index.ts");
       if (fs.existsSync(indexPath)) {
         entries[item] = indexPath;
       }
-    } else if (item.endsWith('.ts')) {
+    } else if (item.endsWith(".ts")) {
       // Single file sample (e.g. tic-tac-toe.ts)
-      entries[item.replace('.ts', '')] = fullPath;
+      entries[item.replace(".ts", "")] = fullPath;
     }
   }
   return entries;
@@ -37,20 +37,20 @@ const samplesEntries = getSamplesEntries();
  */
 function rewriteBoardgameImports(): Plugin {
   return {
-    name: 'rewrite-boardgame-imports',
+    name: "rewrite-boardgame-imports",
     setup(build) {
-      build.onResolve({ filter: /^@\/(core|utils)\// }, args => {
+      build.onResolve({ filter: /^@\/(core|utils)\// }, (args) => {
         // Mark these as external and rewrite to 'boardgame-core'
         return {
-          path: 'boardgame-core',
+          path: "boardgame-core",
           external: true,
         };
       });
 
       // Also handle @/index imports
-      build.onResolve({ filter: /^@\/index$/ }, args => {
+      build.onResolve({ filter: /^@\/index$/ }, (args) => {
         return {
-          path: 'boardgame-core',
+          path: "boardgame-core",
           external: true,
         };
       });
@@ -60,11 +60,25 @@ function rewriteBoardgameImports(): Plugin {
 
 export default defineConfig({
   entry: samplesEntries,
-  format: ['esm'],
+  format: ["esm"],
   dts: true,
   clean: true,
   sourcemap: true,
-  outDir: 'dist/samples',
+  outDir: "dist/samples",
-  external: ['@preact/signals-core', 'mutative', 'inline-schema', 'boardgame-core'],
+  external: [
-  esbuildPlugins: [csvLoader({ writeToDisk: true }), rewriteBoardgameImports(), yarnSpinnerPlugin()],
+    "@preact/signals-core",
+    "mutative",
+    "inline-schema",
+    "boardgame-core",
+  ],
+  esbuildPlugins: [
+    csvLoader({ writeToDisk: true }),
+    rewriteBoardgameImports(),
+    yarnSpinnerPlugin(),
+  ],
+  esbuildOptions(options) {
+    options.alias = {
+      "@": srcDir,
+    };
+  },
 });