def-game 4.0.0 → 5.0.1

package/README.md

@@ -1,236 +1,96 @@
-# def-game
-- a framework for creating online board games
+# def-game V5
 
---- 
+ターン制ゲームのルールを通信・永続化から独立させる、TypeScript の最小 contract とメモリ上の simulator です。
 
-このフレームワークは、オンラインボードゲームを作成する際の開発を支援する。
-フレームワークは、開発者が定義するべき情報を明確に分類する。
-
-このフレームワークを使って、ゲームルールを定義した共通モジュールを作成する。
-その共通モジュールはサーバーサイドプロジェクトとクライアントサイドプロジェクトからimportすることを前提とする。
-開発者は、サーバーサイド側のコードを修正する必要がない。
-共通モジュールで定義したゲームロジックがそのまま動くようになっているからである。
-また、サーバークライアント間での型共有が容易になるのも利点の一つである。
-
-ここからは、このフレームワークが要求するデータ型や関数についての説明を行う。
-`固有の用語`と`データ型`については、インラインコードブロックで示す。
-
-
-# 設計 | design
-
-## アウトライン
-このフレームワークが要求する関数のすべては、`GameRule`に定義されている。
-```ts
-export interface GameRule<T extends Map, S extends Map, C extends ReqMap, L extends DefaultGameLogicState<S>, P extends GameParameters> {
-    initialGameLogicState: (staticValues: any) => L;
-    createRoom: (state: GameState<T, S, C, L, P>, param: GameParameters) => GameState<T, S, C, L, P>;
-    onStartGame: (state: GameState<T, S, C, L, P>, joiner: Player) => GameState<T, S, C, L, P>;
-    generateTasks(state: GameState<T, S, C, L, P>, event: ToServer<C>): Task<C, T>[];
-    prioritizeTasks(newTasks: Task<C, T>[], gameState: GameState<T, S, C, L, P>): GameState<T, S, C, L, P>;
-    doTasks(state: GameState<T, S, C, L, P>): GameState<T, S, C, L, P>;
-}
-```
-
-### initialGameLogicState
-`initialGameLogicState: (staticValues: any) => L;`
-`ゲームロジック状態`のデフォルトを作成する関数である。
-これはプレイヤーが参加する前に仮に作成される`ゲーム状態`である。
-引数の`staticValues`は、静的な設定値のオブジェクトである。これはプログラム上にハードコードされたものである。
-
-ここで重要なのは、できる限り関数（計算）の中で`staticValues`から他の値を算出することである。
-これは、ランダムマップの生成や、ゲーム内の計算で使用される値などを算出することを念頭においている。
-逆に`initialGameLogicState`の中でのハードコードは避け、`staticValues`にすべてを集約することも大切である。
-
-このようにして`ゲームロジック状態`のデフォルト`L`が作成される。これは`ルーム`が作成される前の段階である。
-
-### createRoom
-`createRoom: (state: GameState<T, S, C, L, P>, param: GameParameters) => GameState<T, S, C, L, P>;`
-この関数は、`ルーム`が作成されるタイミングで実行される関数である。
-開発者は、`GameParameters`を設定することができる。
-これは`ルーム`を作成する段階で、入力可能な設定値のことである。画面から入力されることを想定している。
-
-例えば、プレイヤーの人数や制限時間、ゲームに固有なパラメータなどなんでも`ゲームロジック状態`に設定できる。
-そして、この関数は、`GameState`が持つ`GameParameters`を更新することを行う。
-これは、プレイヤーの待ち合わせ処理などの`ゲームロジック状態`とは分離して処理を行う場合を想定しており、`GameParameters`はそこで使用される。
-
-それに加えて、必要であれば、`ゲームロジック状態`に含まれる設定値などもこのタイミングで更新を行う。
-それらを全ての更新を行なった`GameState<T, S, C, L, P>`を返す。
-
-この段階で、`ルーム`に参加しているプレイヤーに対しては、UIを提供する必要があり、
-UIに関する情報は、`ゲームロジック状態`の中に保持することを推奨している。
-
-### onStartGame
-`onStartGame: (state: GameState<T, S, C, L, P>, joiner: Player) => GameState<T, S, C, L, P>;`
-これは、プレイヤーの参加ごとに呼び出される関数である。
-プレイヤーの待ち合わせ処理を実装する。
-参加したプレイヤーに対しては適切なUI情報を返す。
-この関数が実行されている段階ですでにWebSocket接続が確立されている。
-
-
-### generateTasks | prioritizeTasks | doTasks
-この3つの関数は、ゲームの進行を定義するのに重要な関数となる。
-サーバーサイドプロジェクトにデフォルトで実装されている処理フローは、`src/simulatir.ts`で確認することができる。
-以下の部分である。
-```ts
-        // ------ Game Logic ------
-        const tasks = this.rules.generateTasks(state, action);
-        const updatedQueueState = this.rules.prioritizeTasks(tasks, state);
-        const newState = this.rules.doTasks(updatedQueueState);
+```sh
+npm install def-game@^5
 ```
 
-`タスク`というゲーム状態を更新する最小の単位となる概念を導入している。
-`ゲーム状態`は`タスクキュー`をもつ。
-
-
-1. `generateTasks(state: GameState<T, S, C, L, P>, event: ToServer<C>): Task<C, T>[];`
-
-プレイヤーからの`イベント`を受け取った時に、実行されるのがこの関数である。
-この関数では`ゲーム状態`を更新しない。新しく発生する`タスク`の配列を返す。
-
-この関数では、`イベント`を受け取った際のバリデーションを実装することができる。
-
-2. `prioritizeTasks(newTasks: Task<C, T>[], gameState: GameState<T, S, C, L, P>): GameState<T, S, C, L, P>;`
-
-この関数では、`ゲーム状態`が持つ`タスクキュー`と`generateTasks`により生成された新しい`タスク`の配列をマージする処理を実装する。
-`タスク`の優先度に応じて並び替える処理を実装できる。
-
-3. `doTasks(state: GameState<T, S, C, L, P>): GameState<T, S, C, L, P>;`
-
-この関数は、`タスクキュー`をループして、一つ一つのタスクを実行する処理を記述する。
-ここで重要なのは、一つのタスクが`タスクリザルト`を返すことである。
+## 公開 API
 
-`タスクリザルト`は、次のタスクを実行するのか、一旦停止して処理を終えるのかと言った情報を持つことができる。
-この処理は、特にユーザー間のやり取りが発生する場合に有用である。
+- `GameDefinition`: 初期状態の生成、コマンドによる状態遷移、Actor 別の projection。
+- `TransitionResult`: 成功時の次状態と Effect、または失敗理由。
+- `CommandContext`: Actor と system の実行元の区別。
+- `GameSimulator`: 同じゲーム定義へコマンドを順に流し、状態・View・Effect を検証する実行器。
 
-- ユーザーA: request
-- タスク生成: (task1, task2, task3, task4)
-- task1はユーザーBからの応答を要請する
-  - タスクの実行を一時中断: (task2, task3, task4)
-- ユーザーB: request
-- タスク生成: (task1B)
-  - 優先度による並び替え: (task1B, task2, task3, task4)
-- タスクキューの実行再開
+型の詳細と契約は [game-definition.ts](src/game-definition.ts)、実行器は [game-simulator.ts](src/game-simulator.ts) を参照してください。
+[シナリオテスト](test/game-simulator.test.cjs) に、2人の入力待ちと system timeout を扱う実行例があります。
 
-また、より堅牢なシステムを作るために、次に期待されるタスクを`ゲーム状態`に持たせることが可能である。
-この例でいえば、"task1はユーザーBからの応答を要請する"際に、`タスクリザルト`は、タスクの実行を一時中断するだけでなく、次に期待されるタスクを"task1B"に設定する。
-これにより、再開時に、"task1B"以外の実行をキャンセルする。
+## 責務
 
+各ゲームは GameState と Command を定義し、1コマンドで次の外部入力を待てる安定状態まで遷移させます。入力状態は変更せず、失敗時はエラーだけを返します。現在の入力待ちはゲーム自身の状態として表現します。
 
-### privaten
-`privaten(destinationId: PlayerId, l: L): L`
+接続、認証、永続化、時刻の取得、Alarm、外部 I/O は実行側の責務です。実行側が検証済みの Actor または system を context に指定します。リクエストに書かれた実行元をそのまま信用してはいけません。ゲーム側でも実行元と現在の状態に対してコマンドを検証します。
 
-`privaten(destinationId, gameLogicState): GameLogicState`は情報秘匿のための関数である。
-基本的には、`ゲームロジック状態`が更新されるたびに、`ゲームロジック状態`をシリアライズしたものをクライアント側に通知する。
-クライアントから`ゲームロジック状態`の一部を隠さなければならない状況に対処するため、この関数を実装する。
+Effect は副作用の宣言です。本番の実行側は次状態を保存してから Effect を実行します。simulator は Effect を実行せず、遷移結果に含めて返します。
 
-これはサーバーサイドに実装されている`broadcast`関数であり、各プレイヤーごとに`privaten`を呼び出す。
-```ts
-async broadcast<T>(result: Game1State) {
-    Object.keys(result.gameLogicState.forClient).forEach(async to => {
-        await this.sendTo(to, JSON.stringify(gameRule.privaten(to, result.gameLogicState)));
-    });
-}
-```
+projection は秘密情報を除いた Actor 別の View と availableActions を生成します。availableActions は表示補助であり、コマンド実行時の検証を置き換えません。
 
+simulator の getState は検証用の全状態への参照です。呼び出し側も状態を直接変更しないでください。deep clone、freeze、失敗時の rollback は行いません。クライアントへ公開する情報には getView を使用します。
 
-## 型による支援
+## V4 からの移行
 
-規則的な命名と強い型付によって、型システムやAIによる補完の精度向上を狙っている。
+V5 は破壊的変更です。GameRule、GameEngine、TaskQueue に関する型、旧通信型と helper は削除しています。V4 を利用する既存ゲームは移植が完了するまで V4 を使用してください。
 
-`GameRule<T extends Map, S extends Map, C extends ReqMap, L extends DefaultGameLogicState<S>, P extends GameParameters>`
-を見てもらえれば、分かる通りいくつかのRecord型(`Map`)定義を要請している。
+- 旧ライフサイクルを GameDefinition の初期化・コマンド処理・projection に移します。
+- task queue に未来の処理を保存する代わりに、ゲーム固有の状態で現在の入力待ちを表現します。
+- 参加・開始などもゲームの Command として扱います。
+- 旧 GameEngine の代わりに GameSimulator でコマンド列を実行します。
 
-### `T extends Map`
-これは、`タスク`を定義するための`Map`である。
+## Worker generator（5.0.1）
 
-```ts
-interface Tasks {
-    "sample": SampleTask
-    "update": UpdateTask
-}
-```
-と言った具体である。
-タスクハンドラーは、`ゲームロジック状態`とこのタスク（例えば`SampleTask`型のデータ）を受け取り、`ゲームロジック状態`を更新する処理を行う。
+Selfish で検証した Hono Worker、SQLite-backed Durable Object、waki.work JWT 認証、Hibernation WebSocket、保存・配信処理を生成します。GameDefinition の契約変更はありません。現在は timeout / Effect 実行なしの構成が対象です。
 
-### `S extends ResMap`
-これは、サーバーサイドから返却されるUI状態を定義するための`Map`である。
+server package に `def-game.worker.json` を作ります。全パスはこの設定ファイルのディレクトリ基準です。
 
-```ts
-interface Res {
-    "updated": Notify<UpdatedRes>
-    "accept": Require<AcceptRes>
+```json
+{
+  "outputDir": "src/worker",
+  "adapter": "src/worker/game-adapter.ts",
+  "entry": "src/index.ts",
+  "wranglerConfig": "wrangler.jsonc",
+  "name": "my-game",
+  "assets": "../client/public",
+  "compatibilityDate": "2026-09-12"
 }
 ```
 
-`ResMap`は、値の型として、`Notify`か`Require`のいずれかでラップすることを要請する。
-これは、UI上で、ただの情報の通知を表すか、ユーザーに対してのなんらかのアクションの要求を表している。
-`Require`は、アクションに関する制限時間を持っており、ユーザーに伝えることが可能である。
-
-### `C extends ReqMap`
-これは、クライアントサイドからイベントは発生させるためのリクエストを定義するための`Map`である。
-
-```ts
-interface Req {
-    "propose": Custom<ProposeReq>
-    "accept": Simple<AcceptReq>
-}
+```sh
+npm install --save-dev def-game@5.0.1 wrangler @cloudflare/workers-types
+npm install hono jose
+npx def-game generate-worker --config def-game.worker.json
+npx def-game generate-worker --config def-game.worker.json --check
 ```
-`ReqMap`は、値の型として、`Custom`か`Simple`のいずれかでラップすることを要請する。
-これはサーバーサイド側での実装を簡略化するために導入された型である。
-
-なんらかの`Req`を受け取ってから`Task[]`に変換する処理はしばしば冗長である。
-そこでリクエストペイロードをそのまま`タスク`として定義することができるようになっている。
-この例では、`Simple<AcceptReq>`のように`Simple`によってラップされたペイロード(`AcceptReq`)は、そのままタスクとしてキューに追加される。
-
-この仕組みは、以下の型定義により、型的にもサポートされている。
-```ts
-export type TaskMapType<A extends ReqMap, B extends Map> = Merge<SimpleOnlyPayload<A>, CustomTaskMap<B>>;
-export type Task<A extends ReqMap, B extends Map> = {
-    [K in keyof TaskMapType<A, B>]: {
-        type: K;
-        payload: TaskMapType<A, B>[K];
-    }
-}[keyof TaskMapType<A, B>];
-```
-
-
-
 
+生成対象は `outputDir` 内の `index.ts`、`session.ts`、`auth.ts`、`env.ts`、`runtime/parse.ts`、`runtime/game-adapter.ts` と、`entry`、`wranglerConfig` の計8ファイルです。Hono / jose は利用側の runtime dependency で、generator 自体に実行時依存はありません。Selfish は Hono 4.13.7、jose 6.2.12、Wrangler 4.131.1 で検証しています。
 
+ゲーム側は既存ファイルとして `adapter` を用意し、次を export します。このファイル、domain、shared は生成・上書きしません。
 
-## その他の設計
+- `gameAdapter`: 生成される `GameAdapter<State, Command, View, Error>` に適合するオブジェクト。
+- `gameAdapter.game`: ゲーム自身の GameDefinition（Effect は `never`）。
+- `parseCreate(input)` / `parseJoin(input)` / `parseCommand(input)`: 未検証入力から command を返す関数。形式不正なら null。WS の関数へ渡るのは envelope 内の command だけです。
+- `canConnect(state, actorId)`: 接続・配信を許可するかの判定。command の認可は GameDefinition が再検証します。
+- 型の export: `State`、`ActorId`（string）、`ServerMessage`、`ProtocolError`、`PublicError`、`CreateSessionResponse`、`JoinSessionResponse`。
 
-### ルームへの接続
+公開通信は `GameCommandRequest { requestId, command }`、`GameCommandResponse { requestId, ok, error? }`、`ViewStateEvent { viewState }`、`ProtocolErrorEvent { error }` の type で区別します。HTTP 応答は `CreateSessionResponse` / `JoinSessionResponse` の type と、成功時 `ok: true, sessionId`、失敗時 `ok: false, error` を持ちます。ProtocolError の code は `AuthenticationRequired` / `SessionNotFound` / `NotSessionMember` / `InvalidRequest` / `InternalError`。PublicError はそれとゲームエラーの union です。
 
-- プラットフォームAPIにより認証されたユーザーは、ルームIDを指定して入室することができる。
-- このタイミングでroomKeyと呼ばれるJWTを返す。
-`{ playerId: playerId, roomId: body.roomId }`
-- クライアントは、そのJWTをWebSocket接続時のパラメータに加える。
-- これにより、接続とplayerIdが関連づけられる。
-- WebSocket接続を通じて送られる全てのJSONデータはplayerIdプロパティを持っている。
-- サーバーサイドは、そのplayerIdプロパティがWebSocket接続に紐づいたplayerIdと一致することを確認する。
+認証は Cookie `__token` を JWKS / ES256 / issuer / audience / exp で検証し、UUID の sub を ActorId として使います。Static Assets も認証必須。ログイン誘導・refresh は client の責務です。
 
+出力が同一なら変更しません。既存ファイルと差分がある場合は書き込み前に停止します。確認後に `--force` を付けると生成対象8ファイルだけを更新します。`--check` は欠落・差分を非ゼロ終了で報告し、ファイルを変更しません。生成ファイルは Git 管理し、修正は generator / 設定側へ戻してください。Wrangler 設定も全体が生成対象なので、独自 bindings や migrations の追加には generator の対応が必要です。
 
-### 時間制限
+CLI は dependencies、package scripts、tsconfig を書き換えません。利用側で Worker の型と Hono / jose を設定し、生成された entry を Wrangler から実行します。CLI には Node.js 20 以降が必要です。
 
-`ルーム`に接続中のクライアントは、webSocketハートビートを定期的に送信する。
-これは、要求されたアクションの時間制限に関する確認処理をトリガーする。
+## 開発と公開
 
-`gameState.nextTaskExpectation`は以下のような情報を持っていて、
-```js
-{
-    expectedTaskType: "accept",
-    deadline: 1744589266,
-    defaultTask: {
-        playerId: "samplePlayer",
-        proposerId: "proposer",
-        isAccept: false,
-    }
-}
+```sh
+npm ci
+npm run typecheck
+npm test
+npm pack
 ```
-deadlineを過ぎていれば、`defaultTask`が`タスクキュー`の先頭に配置され、実行が再開するという具体である。
-
-
 
+開発時のテストには Node.js 20 以降を使用してください。npm test はビルドと Node 標準のシナリオテストを実行します。
 
+npm pack / npm publish の前に prepack で型チェック・ビルド・テストが実行されます。build は dist を作り直すため、削除した旧 API の生成物が混入しません。公開対象は dist、bin、templates、package.json、README、LICENSE です。
 
+main にレビュー済みの変更を反映した後、公開する version と認証アカウントを確認し、検証済みのパッケージを npm publish で公開します。

package/bin/def-game.cjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { version } = require('../package.json');
+
+const help = `def-game ${version}
+Usage: def-game generate-worker --config <file.json> [--force | --check]
+
+Generate a Hono Worker, SQLite Durable Object, waki.work authentication and Wrangler config.
+--force  Replace differing output files (never edits the game adapter).
+--check  Verify generated files match without writing anything.
+Node.js 20+ is required. Timeout and Effect execution are not included in this version.`;
+
+function relativeImport(from, target) {
+  let value = path.relative(path.dirname(from), target).split(path.sep).join('/').replace(/\.ts$/, '.js');
+  if (!value.startsWith('.')) value = './' + value;
+  return JSON.stringify(value);
+}
+
+function main(args) {
+  if (args.length === 0 || args[0] === '--help') return console.log(help);
+  if (args[0] === '--version') return console.log(version);
+  if (Number(process.versions.node.split('.')[0]) < 20) throw new Error('Node.js 20+ is required');
+  if (args.shift() !== 'generate-worker') throw new Error('Unknown command. Use --help.');
+  let configPath;
+  let force = false;
+  let check = false;
+  while (args.length) {
+    const arg = args.shift();
+    if (arg === '--config' && !configPath && args[0] && !args[0].startsWith('--')) configPath = args.shift();
+    else if (arg === '--force' && !force) force = true;
+    else if (arg === '--check' && !check) check = true;
+    else throw new Error(`Unknown or repeated option: ${arg}`);
+  }
+  if (!configPath || (force && check)) throw new Error('Provide --config and at most one of --force / --check');
+  configPath = path.resolve(configPath);
+  const root = path.dirname(configPath);
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  if (!config || typeof config !== 'object' || Array.isArray(config)) throw new Error('Config must be an object');
+  const allowed = new Set(['outputDir', 'adapter', 'entry', 'wranglerConfig', 'name', 'assets', 'compatibilityDate']);
+  for (const key of Object.keys(config)) if (!allowed.has(key)) throw new Error(`Unknown config key: ${key}`);
+  const required = (key) => {
+    if (typeof config[key] !== 'string' || !config[key].trim() || config[key].includes('\0')) throw new Error(`Invalid config: ${key}`);
+    return config[key];
+  };
+  const inside = (value) => {
+    if (path.isAbsolute(value)) throw new Error(`Path must be relative: ${value}`);
+    const resolved = path.resolve(root, value);
+    const relative = path.relative(root, resolved);
+    if (!relative || relative === '..' || relative.startsWith('..' + path.sep)) throw new Error(`Path must stay inside config directory: ${value}`);
+    // Do not follow existing symlinks when overwriting output or locating the adapter.
+    let current = root;
+    for (const part of relative.split(path.sep)) {
+      current = path.join(current, part);
+      if (fs.existsSync(current) && fs.lstatSync(current).isSymbolicLink()) throw new Error(`Symlink is not supported: ${current}`);
+    }
+    return resolved;
+  };
+  const outputDir = inside(required('outputDir'));
+  const adapter = inside(required('adapter'));
+  if (!/\.(ts|js)$/.test(adapter) || !fs.statSync(adapter).isFile()) throw new Error('adapter must be an existing .ts or .js file');
+  const entry = inside(required('entry'));
+  if (!entry.endsWith('.ts')) throw new Error('entry must end with .ts');
+  const wrangler = inside(required('wranglerConfig'));
+  if (!wrangler.endsWith('.jsonc')) throw new Error('wranglerConfig must end with .jsonc');
+  const name = required('name');
+  if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(name)) throw new Error('Invalid Worker name');
+  const assets = required('assets');
+  if (path.isAbsolute(assets)) throw new Error('assets must be relative to the config directory');
+  const date = required('compatibilityDate');
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || !Number.isFinite(Date.parse(date)) || new Date(date).toISOString().slice(0, 10) !== date) {
+    throw new Error('Invalid compatibilityDate');
+  }
+
+  const banner = `// Generated by def-game ${version}. Do not edit; change the generator or its config.\n`;
+  const files = new Map();
+  const add = (file, text) => {
+    if (files.has(file) || file === adapter || file === configPath) throw new Error(`Output path collision: ${file}`);
+    inside(path.relative(root, file));
+    files.set(file, banner + text);
+  };
+  for (const file of ['index.ts', 'session.ts', 'auth.ts', 'env.ts', 'runtime/parse.ts', 'runtime/game-adapter.ts']) {
+    const target = path.join(outputDir, file);
+    const source = fs.readFileSync(path.join(__dirname, '../templates/worker', file), 'utf8');
+    add(target, source.replaceAll('__ADAPTER_IMPORT__', relativeImport(target, adapter)));
+  }
+  add(entry, `export { default, SessionDurableObject } from ${relativeImport(entry, path.join(outputDir, 'index.ts'))};\n`);
+  const fromWrangler = (target) => path.relative(path.dirname(wrangler), target).split(path.sep).join('/');
+  add(wrangler, JSON.stringify({
+    name,
+    main: fromWrangler(entry),
+    compatibility_date: date,
+    assets: { directory: fromWrangler(path.resolve(root, assets)), binding: 'ASSETS', run_worker_first: true },
+    durable_objects: { bindings: [{ name: 'SESSIONS', class_name: 'SessionDurableObject' }] },
+    migrations: [{ tag: 'v1', new_sqlite_classes: ['SessionDurableObject'] }],
+    vars: {
+      AUTH_ISSUER: 'https://auth.waki.work', AUTH_AUDIENCE: 'waki.work',
+      AUTH_JWKS_URL: 'https://auth.waki.work/.well-known/jwks.json',
+    },
+  }, null, 2) + '\n');
+
+  // Preflight every output before the first write, so conflicts cannot leave half-generated code.
+  const changed = [];
+  for (const [file, contents] of files) {
+    const exists = fs.existsSync(file);
+    if (exists && !fs.statSync(file).isFile()) throw new Error(`Output is not a file: ${file}`);
+    if (exists && fs.readFileSync(file, 'utf8') === contents) continue;
+    if (exists && !force && !check) throw new Error(`Refusing to overwrite ${file}; review the changes and use --force`);
+    changed.push([file, contents]);
+  }
+  if (check) {
+    if (changed.length) throw new Error(`Generated files differ or are missing:\n${changed.map(([file]) => path.relative(root, file)).join('\n')}`);
+    return console.log(`Verified ${files.size} generated files (def-game ${version})`);
+  }
+  for (const [file, contents] of changed) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = file + `.def-game-${process.pid}.tmp`;
+    try {
+      fs.writeFileSync(temp, contents, { flag: 'wx' });
+      fs.renameSync(temp, file);
+    } finally {
+      if (fs.existsSync(temp)) fs.unlinkSync(temp);
+    }
+  }
+  console.log(`Generated ${files.size} files; changed ${changed.length} (def-game ${version})`);
+}
+
+try { main(process.argv.slice(2)); }
+catch (error) { console.error(`def-game: ${error.message}`); process.exitCode = 1; }

package/dist/game-definition.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Worker や simulator が確定したコマンドの実行元。
+ * actorId は認証済みの主体を表し、接続 ID ではない。
+ * 外部リクエストの自己申告をそのまま使わず、system は信頼できる実行側だけが指定する。
+ */
+export type CommandContext<ActorId> = {
+    readonly origin: "actor";
+    readonly actorId: ActorId;
+} | {
+    readonly origin: "system";
+};
+/**
+ * 成功時は次の安定状態と副作用の宣言、失敗時はゲーム上の拒否理由を返す。
+ * 実行側は成功した状態を保存してから Effect を処理する。
+ */
+export type TransitionResult<State, Effect, Error> = {
+    readonly ok: true;
+    readonly state: State;
+    readonly effects: readonly Effect[];
+} | {
+    readonly ok: false;
+    readonly error: Error;
+};
+/**
+ * 通信・永続化から独立したゲームそのものの契約。
+ * State の構造や入力待ちの表現は各ゲームが定義し、kernel は task queue を要求しない。
+ */
+export interface GameDefinition<State, Command, ActorId, View, Effect, Error> {
+    /** Session や接続の情報に依存しない、ゲームの初期状態を生成する。 */
+    createInitialState(): State;
+    /**
+     * 実行元とコマンドを再検証し、次の外部入力を待てる安定状態まで遷移する。
+     * 入力 state を変更せず、拒否時は error のみを返す。外部 I/O は行わない。
+     * system 起点でも、そのコマンドが現在の状態で有効かを検証する。
+     */
+    handleCommand(state: State, command: Command, context: CommandContext<ActorId>): TransitionResult<State, Effect, Error>;
+    /**
+     * state を変更せず、Actor に公開できる情報と availableActions を持つ View を生成する。
+     * availableActions は表示補助であり、コマンド実行時の検証を省略する根拠にはしない。
+     */
+    project(state: State, actorId: ActorId): View;
+}
+//# sourceMappingURL=game-definition.d.ts.map

package/dist/game-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"game-definition.d.ts","sourceRoot":"","sources":["../src/game-definition.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,cAAc,CAAC,OAAO,IAC5B;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEpC;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAC3C;IACE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC,GACC;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAEpD;;;GAGG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK;IACxE,0CAA0C;IAC1C,kBAAkB,IAAI,KAAK,CAAC;IAE5B;;;;OAIG;IACH,aAAa,CACT,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,GACjC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IAE1C;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACjD"}

package/dist/{types.js → game-definition.js}

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-;

package/dist/game-simulator.d.ts

@@ -0,0 +1,19 @@
+import type { CommandContext, GameDefinition, TransitionResult } from "./game-definition";
+/**
+ * Worker なしで同じゲーム定義にコマンドを順番に流す実行器。
+ * 状態はメモリだけに保存し、Effect は実行せず検証用に返す。
+ * ゲーム定義と呼び出し側は、受け取った状態を直接変更しない契約に従う。
+ */
+export declare class GameSimulator<State, Command, ActorId, View, Effect, Error> {
+    private readonly definition;
+    private state;
+    /** ゲーム定義が生成した初期状態から、独立した試行を開始する。 */
+    constructor(definition: GameDefinition<State, Command, ActorId, View, Effect, Error>);
+    /** コマンドが成功した場合だけ次の状態を採用し、結果をそのまま返す。 */
+    executeCommand(command: Command, context: CommandContext<ActorId>): TransitionResult<State, Effect, Error>;
+    /** シナリオの検証用に全状態を参照する。クライアント配信用ではない。 */
+    getState(): State;
+    /** 現在の状態を指定 Actor 向けに投影する。 */
+    getView(actorId: ActorId): View;
+}
+//# sourceMappingURL=game-simulator.d.ts.map

package/dist/game-simulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"game-simulator.d.ts","sourceRoot":"","sources":["../src/game-simulator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1F;;;;GAIG;AACH,qBAAa,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK;IAK/D,OAAO,CAAC,QAAQ,CAAC,UAAU;IAJ/B,OAAO,CAAC,KAAK,CAAQ;IAErB,oCAAoC;gBAEf,UAAU,EAAE,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC;IAK7F,uCAAuC;IACvC,cAAc,CACV,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,cAAc,CAAC,OAAO,CAAC,GACjC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC;IAQzC,uCAAuC;IACvC,QAAQ,IAAI,KAAK;IAIjB,8BAA8B;IAC9B,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;CAGlC"}

package/dist/game-simulator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameSimulator = void 0;
+/**
+ * Worker なしで同じゲーム定義にコマンドを順番に流す実行器。
+ * 状態はメモリだけに保存し、Effect は実行せず検証用に返す。
+ * ゲーム定義と呼び出し側は、受け取った状態を直接変更しない契約に従う。
+ */
+class GameSimulator {
+    /** ゲーム定義が生成した初期状態から、独立した試行を開始する。 */
+    constructor(definition) {
+        this.definition = definition;
+        this.state = definition.createInitialState();
+    }
+    /** コマンドが成功した場合だけ次の状態を採用し、結果をそのまま返す。 */
+    executeCommand(command, context) {
+        const result = this.definition.handleCommand(this.state, command, context);
+        if (result.ok) {
+            this.state = result.state;
+        }
+        return result;
+    }
+    /** シナリオの検証用に全状態を参照する。クライアント配信用ではない。 */
+    getState() {
+        return this.state;
+    }
+    /** 現在の状態を指定 Actor 向けに投影する。 */
+    getView(actorId) {
+        return this.definition.project(this.state, actorId);
+    }
+}
+exports.GameSimulator = GameSimulator;

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export * from './types';
-export * from './simulator';
-export * from './helper';
+export * from './game-definition';
+export * from './game-simulator';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./simulator"), exports);
-__exportStar(require("./helper"), exports);
+__exportStar(require("./game-definition"), exports);
+__exportStar(require("./game-simulator"), exports);

package/package.json

@@ -1,17 +1,31 @@
 {
   "name": "def-game",
-  "version": "4.0.0",
-  "description": "",
+  "version": "5.0.1",
+  "description": "Game definition contracts and an in-memory simulator for turn-based games",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run build && node --test test/*.test.cjs",
+    "prepack": "npm run typecheck && npm test"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "devDependencies": {
     "typescript": "^5.8.2"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "templates"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MFQWKMR4/def-game.git"
+  },
+  "bin": {
+    "def-game": "bin/def-game.cjs"
   }
-}
+}

package/templates/worker/auth.ts

@@ -0,0 +1,23 @@
+import { createRemoteJWKSet, jwtVerify } from "jose";
+import type { Env } from "./env.js";
+
+let cachedKeys: { url: string; keys: ReturnType<typeof createRemoteJWKSet> } | undefined;
+
+/** JWT は Worker 境界だけで扱う。署名・必須 claims を検証した sub だけを DO へ渡す。 */
+export async function authenticate(token: string | undefined, env: Env): Promise<string | null> {
+  if (!token) return null;
+  try {
+    if (cachedKeys?.url !== env.AUTH_JWKS_URL) {
+      // jose がキャッシュと未知 kid に対する再取得（cooldown 付き）を扱う。
+      cachedKeys = { url: env.AUTH_JWKS_URL, keys: createRemoteJWKSet(new URL(env.AUTH_JWKS_URL)) };
+    }
+    const { payload } = await jwtVerify(token, cachedKeys.keys, {
+      issuer: env.AUTH_ISSUER, audience: env.AUTH_AUDIENCE,
+      algorithms: ["ES256"], requiredClaims: ["sub", "exp", "iat"],
+    });
+    return typeof payload.sub === "string" && /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test(payload.sub)
+      ? payload.sub : null;
+  } catch {
+    return null;
+  }
+}

package/templates/worker/env.ts

@@ -0,0 +1,9 @@
+import type { SessionDurableObject } from "./session.js";
+
+export interface Env {
+  SESSIONS: DurableObjectNamespace<SessionDurableObject>;
+  ASSETS: Fetcher;
+  AUTH_ISSUER: string;
+  AUTH_AUDIENCE: string;
+  AUTH_JWKS_URL: string;
+}

package/templates/worker/index.ts

@@ -0,0 +1,84 @@
+import { Hono, type Context } from "hono";
+import { getCookie } from "hono/cookie";
+import type { ActorId, CreateSessionResponse, JoinSessionResponse, ProtocolError, PublicError } from __ADAPTER_IMPORT__;
+import type { Env } from "./env.js";
+import { authenticate } from "./auth.js";
+export { SessionDurableObject } from "./session.js";
+
+type AppEnv = { Bindings: Env; Variables: { actorId: ActorId } };
+const app = new Hono<AppEnv>();
+
+// Static Assets を含む全ルートで認証し、以後は検証済み ActorId を context から取得する。
+app.use("*", async (c, next) => {
+  const actorId = await authenticate(getCookie(c, "__token"), c.env);
+  if (!actorId) return errorResponse(c, "AuthenticationRequired", 401);
+  c.set("actorId", actorId);
+  await next();
+});
+
+app.use("*", async (c, next) => {
+  const origin = c.req.header("origin");
+  const isWebSocket = c.req.path.startsWith("/ws/");
+  if (origin && origin !== new URL(c.req.url).origin && (c.req.method !== "GET" || isWebSocket)) {
+    return errorResponse(c, "InvalidRequest", 403);
+  }
+  await next();
+});
+
+app.post("/api/sessions", (c) => joinSession(c, c.env.SESSIONS.newUniqueId(), "create"));
+
+app.post("/api/sessions/:sessionId/join", (c) => {
+  const sessionId = c.req.param("sessionId");
+  if (!/^[0-9a-f]{64}$/.test(sessionId)) return errorResponse(c, "InvalidRequest", 404);
+  return joinSession(c, c.env.SESSIONS.idFromString(sessionId), "join");
+});
+
+app.get("/ws/:sessionId", (c) => {
+  const sessionId = c.req.param("sessionId");
+  if (!/^[0-9a-f]{64}$/.test(sessionId)) return errorResponse(c, "InvalidRequest", 404);
+  if (c.req.header("upgrade")?.toLowerCase() !== "websocket") return errorResponse(c, "InvalidRequest", 426);
+  const id = c.env.SESSIONS.idFromString(sessionId);
+  // DO の Hibernation 接続をそのまま返す。token や外部のヘッダーは転送しない。
+  return c.env.SESSIONS.get(id).fetch(new Request("https://session/connect", {
+    headers: { upgrade: "websocket", "x-actor-id": c.get("actorId") },
+  }));
+});
+
+app.all("/api/*", (c) => errorResponse(c, "InvalidRequest", 404));
+app.all("/ws/*", (c) => errorResponse(c, "InvalidRequest", 404));
+app.all("*", (c) => c.env.ASSETS.fetch(c.req.raw));
+
+app.onError((_error, c) => {
+  console.error("Worker request failed");
+  return errorResponse(c, "InternalError", 500);
+});
+
+export default app;
+
+/** create と join に共通する本文検証と DO 呼び出し。本文のゲーム固有形式と参加可否は DO 内の adapter / domain が判断する。 */
+async function joinSession(c: Context<AppEnv>, id: DurableObjectId, operation: "create" | "join"): Promise<Response> {
+  if (!c.req.header("content-type")?.startsWith("application/json")) return errorResponse(c, "InvalidRequest", 400);
+  const raw = await c.req.text();
+  if (raw.length > 64 * 1024) return errorResponse(c, "InvalidRequest", 400);
+  let body: unknown;
+  try { body = JSON.parse(raw); } catch { return errorResponse(c, "InvalidRequest", 400); }
+
+  const result = await c.env.SESSIONS.get(id).fetch(new Request(`https://session/${operation}`, {
+    method: "POST", headers: { "x-actor-id": c.get("actorId"), "content-type": "application/json" },
+    body: JSON.stringify(body),
+  }));
+  const data = await result.json<{ ok: true } | { ok: false; error: PublicError }>();
+  const type = operation === "create" ? "CreateSessionResponse" : "JoinSessionResponse";
+  const response: CreateSessionResponse | JoinSessionResponse = data.ok
+    ? { type, ok: true, sessionId: id.toString() }
+    : { type, ok: false, error: data.error };
+  return Response.json(response, { status: result.status });
+}
+
+/** middleware で拒否する場合も、既存の公開レスポンス形式を維持する。 */
+function errorResponse(c: Context<AppEnv>, code: ProtocolError["code"], status: 400 | 401 | 403 | 404 | 426 | 500): Response {
+  const type = c.req.method === "POST" && c.req.path === "/api/sessions"
+    ? "CreateSessionResponse"
+    : /^\/api\/sessions\/[0-9a-f]{64}\/join$/.test(c.req.path) ? "JoinSessionResponse" : undefined;
+  return c.json({ ...(type ? { type } : {}), ok: false, error: { code } }, status);
+}

package/templates/worker/runtime/game-adapter.ts

@@ -0,0 +1,15 @@
+import type { GameDefinition } from "def-game";
+
+/**
+ * 生成対象の runtime とゲーム固有コードの接続契約。GameDefinition 自体は変更しない。
+ * decoder は未検証の本文からゲーム command を作り、形式不正なら null を返す。
+ * 参加・復帰の意味や認可は game.handleCommand が判断する。
+ * 現段階は Effect なし。timeout / Effect の生成オプションは実装時に別途追加する。
+ */
+export interface GameAdapter<State, Command, View, Error> {
+  readonly game: GameDefinition<State, Command, string, View, never, Error>;
+  readonly parseCreate: (input: unknown) => Command | null;
+  readonly parseJoin: (input: unknown) => Command | null;
+  readonly parseCommand: (input: unknown) => Command | null;
+  readonly canConnect: (state: State, actorId: string) => boolean;
+}

package/templates/worker/runtime/parse.ts

@@ -0,0 +1,14 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** 通信 envelope だけを検証する。command の名前・payload の意味は adapter が判断する。 */
+export function parseCommandRequest(raw: string | ArrayBuffer): { requestId: string; command: unknown } | null {
+  if (typeof raw !== "string" || raw.length > 64 * 1024) return null;
+  try {
+    const value: unknown = JSON.parse(raw);
+    if (!isRecord(value) || value.type !== "GameCommandRequest" || typeof value.requestId !== "string"
+      || value.requestId.length === 0 || value.requestId.length > 128 || !Object.hasOwn(value, "command")) return null;
+    return { requestId: value.requestId, command: value.command };
+  } catch { return null; }
+}

package/templates/worker/session.ts

@@ -0,0 +1,100 @@
+import { DurableObject } from "cloudflare:workers";
+import { gameAdapter, type State, type ServerMessage, type ProtocolError } from __ADAPTER_IMPORT__;
+import type { Env } from "./env.js";
+import { isRecord, parseCommandRequest } from "./runtime/parse.js";
+
+const STATE_KEY = "game-state";
+
+/** 生成対象の Session runtime。ゲーム固有の判断は gameAdapter だけを通して呼ぶ。 */
+export class SessionDurableObject extends DurableObject<Env> {
+  // State の独自キャッシュを持たない。再起動時にも Storage と attachment だけで復元する。
+  async fetch(request: Request): Promise<Response> {
+    return this.ctx.blockConcurrencyWhile(async () => {
+      const actorId = request.headers.get("x-actor-id");
+      const fail = (code: ProtocolError["code"], status: number) => Response.json({ ok: false, error: { code } }, { status });
+      if (!actorId) return fail("AuthenticationRequired", 401);
+      const path = new URL(request.url).pathname;
+      const stored = await this.ctx.storage.get<State>(STATE_KEY);
+      if (path === "/connect" && request.method === "GET") {
+        if (stored === undefined) return fail("SessionNotFound", 404);
+        if (!gameAdapter.canConnect(stored, actorId)) return fail("NotSessionMember", 403);
+        const viewState = gameAdapter.game.project(stored, actorId);
+        const pair = new WebSocketPair();
+        pair[1].serializeAttachment({ actorId });
+        this.ctx.acceptWebSocket(pair[1]);
+        this.send(pair[1], { type: "ViewStateEvent", viewState });
+        return new Response(null, { status: 101, webSocket: pair[0] });
+      }
+      if (request.method !== "POST" || (path !== "/create" && path !== "/join")) return fail("InvalidRequest", 400);
+      if (path === "/create" && stored !== undefined) return fail("InvalidRequest", 409);
+      if (path === "/join" && stored === undefined) return fail("SessionNotFound", 404);
+      let body: unknown;
+      try { body = await request.json(); } catch { return fail("InvalidRequest", 400); }
+      const command = path === "/create" ? gameAdapter.parseCreate(body) : gameAdapter.parseJoin(body);
+      if (command === null) return fail("InvalidRequest", 400);
+      const result = gameAdapter.game.handleCommand(stored === undefined ? gameAdapter.game.createInitialState() : stored, command, { origin: "actor", actorId });
+      if (!result.ok) return Response.json(result, { status: 409 });
+      // 作成と作成者の参加は、この1回の保存で確定する。
+      if (result.state !== stored) {
+        await this.ctx.storage.put(STATE_KEY, result.state);
+        this.broadcast(result.state);
+      }
+      return Response.json({ ok: true });
+    });
+  }
+
+  async webSocketMessage(socket: WebSocket, raw: string | ArrayBuffer): Promise<void> {
+    await this.ctx.blockConcurrencyWhile(async () => {
+      const parsed = parseCommandRequest(raw);
+      const command = parsed ? gameAdapter.parseCommand(parsed.command) : null;
+      if (!parsed || command === null) {
+        this.send(socket, { type: "ProtocolErrorEvent", error: { code: "InvalidRequest" } });
+        return;
+      }
+      try {
+        const attachment: unknown = socket.deserializeAttachment();
+        const state = await this.ctx.storage.get<State>(STATE_KEY);
+        if (state === undefined || !isRecord(attachment) || typeof attachment.actorId !== "string" || !gameAdapter.canConnect(state, attachment.actorId)) {
+          this.send(socket, { type: "GameCommandResponse", requestId: parsed.requestId, ok: false, error: { code: "NotSessionMember" } });
+          return;
+        }
+        const result = gameAdapter.game.handleCommand(state, command, { origin: "actor", actorId: attachment.actorId });
+        if (!result.ok) {
+          this.send(socket, { type: "GameCommandResponse", requestId: parsed.requestId, ok: false, error: result.error });
+          return;
+        }
+        await this.ctx.storage.put(STATE_KEY, result.state);
+        // Effect は現在 never。実装時もこの保存の後に実行し、配送失敗で rollback しない。
+        this.send(socket, { type: "GameCommandResponse", requestId: parsed.requestId, ok: true });
+        this.broadcast(result.state);
+      } catch {
+        console.error("Session command failed");
+        this.send(socket, { type: "GameCommandResponse", requestId: parsed.requestId, ok: false, error: { code: "InternalError" } });
+      }
+    });
+  }
+
+  private broadcast(state: State): void {
+    for (const socket of this.ctx.getWebSockets()) {
+      try {
+        const attachment: unknown = socket.deserializeAttachment();
+        if (!isRecord(attachment) || typeof attachment.actorId !== "string" || !gameAdapter.canConnect(state, attachment.actorId)) continue;
+        this.send(socket, { type: "ViewStateEvent", viewState: gameAdapter.game.project(state, attachment.actorId) });
+      } catch {
+        console.error("Session view delivery failed");
+        this.close(socket);
+      }
+    }
+  }
+
+  private send(socket: WebSocket, message: ServerMessage): void {
+    try { socket.send(JSON.stringify(message)); } catch { this.close(socket); }
+  }
+
+  private close(socket: WebSocket): void {
+    try { socket.close(1011, "Delivery failed"); } catch { /* 切断済み。確定済みの保存結果へ影響させない。 */ }
+  }
+
+  webSocketClose(socket: WebSocket, code: number, reason: string): void { socket.close(code, reason); }
+  webSocketError(socket: WebSocket): void { socket.close(1011, "Connection error"); }
+}

package/dist/example.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=example.d.ts.map

package/dist/example.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"example.d.ts","sourceRoot":"","sources":["../src/example.ts"],"names":[],"mappings":""}

package/dist/example.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const helper_1 = require("./helper");
-// A equals to SimpleOnly<Req>
-const test = {
-    type: "login",
-    payload: (0, helper_1.custom)({
-        playerId: "a",
-        name: "b",
-    }),
-};
-const customEventHander = (r) => {
-    switch (r.type) {
-        case "login":
-            return [
-                {
-                    type: "authorize",
-                    payload: {
-                        name: "a",
-                        password: "b",
-                    },
-                },
-                {
-                    type: "authenticate",
-                    payload: {
-                        name: "a",
-                        level: 1,
-                    },
-                }
-            ];
-        case "complicatedReq":
-            return [
-                {
-                    type: "task1",
-                    payload: {
-                        name: "a",
-                        password: "b",
-                    },
-                },
-                {
-                    type: "task2",
-                    payload: {
-                        name: "a",
-                        level: 1,
-                    },
-                },
-                {
-                    type: "task3",
-                    payload: {
-                        name: "a",
-                        level: 1,
-                    },
-                }
-            ];
-        default:
-            return [];
-    }
-};
-// no need to write process that handles simple requests
-const _sampleGenerateTasks = (0, helper_1.simplify)(customEventHander);
-// ------------------------------------------------------------
-// this is how you handle tasks
-// task cases are composed 
-// - keyof SimpleOnlyPayload<Req>
-// - keyof Tasks
-const _switchTask = (task) => {
-    switch (task.type) {
-        case "move":
-            return moveTaskHandler(task.payload);
-        // login is a custom request, so we need to handle it differently
-        case "authorize":
-            return authorizeTaskHandler(task.payload);
-        case "authenticate":
-            return authenticateTaskHandler(task.payload);
-        case "task1":
-            return task1Handler(task.payload);
-        case "task2":
-            return task2Handler(task.payload);
-        case "task3":
-            return task3Handler(task.payload);
-        default:
-            const _exhaustiveCheck = task;
-            console.log("unknown event", task);
-    }
-};
-const moveTaskHandler = (payload) => {
-    console.log(payload);
-};
-const authorizeTaskHandler = (payload) => {
-    console.log(payload);
-};
-const authenticateTaskHandler = (payload) => {
-    console.log(payload);
-};
-const task1Handler = (payload) => {
-    console.log(payload);
-};
-const task2Handler = (payload) => {
-    console.log(payload);
-};
-const task3Handler = (payload) => {
-    console.log(payload);
-};
-// ------------------------------------------------------------

package/dist/helper.d.ts

@@ -1,8 +0,0 @@
-import { Custom, CustomOnly, Notify, ReqMap, ReqPayload, Require, RequireSetting, Simple, Task, ToServer } from "./types";
-export declare const simple: <T extends ReqPayload>(payload: T) => Simple<T>;
-export declare const custom: <T extends ReqPayload>(payload: T) => Custom<T>;
-export declare const requiring: <T>(payload: T, setting: RequireSetting) => Require<T>;
-export declare const notifying: <T>(payload: T) => Notify<T>;
-export type CustomEventHander<A extends ReqMap, B extends Record<string, any>> = (r: ToServer<CustomOnly<A>>) => Task<A, B>[];
-export declare const simplify: <A extends ReqMap, B extends Record<string, any>>(h: CustomEventHander<A, B>) => (a: ToServer<A>) => Task<A, B>[];
-//# sourceMappingURL=helper.d.ts.map

package/dist/helper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAqB,IAAI,EAAe,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEzJ,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,UAAU,EAAE,SAAS,CAAC,KAAG,MAAM,CAAC,CAAC,CAKjE,CAAA;AAED,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,UAAU,EAAE,SAAS,CAAC,KAAG,MAAM,CAAC,CAAC,CAKjE,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,SAAS,CAAC,EAAE,SAAS,cAAc,KAAG,OAAO,CAAC,CAAC,CAM3E,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,SAAS,CAAC,KAAG,MAAM,CAAC,CAAC,CAKjD,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IACvE,CAAC,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAA;AAGlD,eAAO,MAAM,QAAQ,GAChB,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,MACvE,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAe3B,CAAA"}

package/dist/helper.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.simplify = exports.notifying = exports.requiring = exports.custom = exports.simple = void 0;
-const simple = (payload) => {
-    return {
-        kind: "simple",
-        value: payload
-    };
-};
-exports.simple = simple;
-const custom = (payload) => {
-    return {
-        kind: "custom",
-        value: payload
-    };
-};
-exports.custom = custom;
-const requiring = (payload, setting) => {
-    return {
-        kind: "require",
-        value: payload,
-        setting
-    };
-};
-exports.requiring = requiring;
-const notifying = (payload) => {
-    return {
-        kind: "notify",
-        value: payload
-    };
-};
-exports.notifying = notifying;
-const simplify = (h) => (a) => {
-    switch (a.payload.kind) {
-        case "simple":
-            const key = a.type;
-            const payload = a.payload.value;
-            return [
-                {
-                    type: key,
-                    payload,
-                }
-            ];
-        case "custom":
-            const b = a;
-            return h(b);
-    }
-};
-exports.simplify = simplify;

package/dist/simulator.d.ts

@@ -1,13 +0,0 @@
-import { DefaultGameLogicState, GameParameters, GameRule, GameState, Player, ReqMap, ToServer } from "./types";
-export declare class GameEngine<T extends Record<string, any>, S extends Record<string, any>, C extends ReqMap, L extends DefaultGameLogicState<S>, P extends GameParameters> {
-    private rules;
-    private storage;
-    constructor(rules: GameRule<T, S, C, L, P>);
-    createRoom(p: P): void;
-    join(player: Player): void;
-    startGame(): void;
-    executeAction(action: ToServer<C>): GameState<T, S, C, L, P>;
-    getState(): GameState<T, S, C, L, P>;
-    setState(state: GameState<T, S, C, L, P>): void;
-}
-//# sourceMappingURL=simulator.d.ts.map

package/dist/simulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simulator.d.ts","sourceRoot":"","sources":["../src/simulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAU,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGvH,qBAAa,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,qBAAqB,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,cAAc;IAChK,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,OAAO,CAAkC;gBAErC,KAAK,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAa1C,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI;IAMtB,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM1B,SAAS,IAAI,IAAI;IAMjB,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAc5D,QAAQ,IAAI,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAIpC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI;CAGlD"}

package/dist/simulator.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GameEngine = void 0;
-// This is a simulator
-class GameEngine {
-    constructor(rules) {
-        this.rules = rules;
-        this.storage = new InMemoryGameStateStorage();
-        // Initialize the game state
-        const gameState = {
-            gameParameters: null,
-            gameLogicState: this.rules.initialGameLogicState(),
-            taskQueue: []
-        };
-        this.storage.saveGameState(gameState);
-    }
-    createRoom(p) {
-        const state = this.storage.loadGameState();
-        const configured = this.rules.createRoom(state, p);
-        this.storage.saveGameState(configured);
-    }
-    join(player) {
-        const state = this.storage.loadGameState();
-        const joined = this.rules.onJoin(state, player);
-        this.storage.saveGameState(joined);
-    }
-    startGame() {
-        const state = this.storage.loadGameState();
-        const started = this.rules.onStartGame(state);
-        this.storage.saveGameState(started);
-    }
-    executeAction(action) {
-        const state = this.storage.loadGameState();
-        // ------ Game Logic ------
-        const tasks = this.rules.generateTasks(state, action);
-        const updatedQueueState = this.rules.prioritizeTasks(tasks, state);
-        const newState = this.rules.doTasks(updatedQueueState);
-        // ------------------------
-        this.storage.saveGameState(newState);
-        return newState; // this means that this game state is broadcasted to all players
-    }
-    getState() {
-        return this.storage.loadGameState();
-    }
-    setState(state) {
-        this.storage.saveGameState(state);
-    }
-}
-exports.GameEngine = GameEngine;
-class InMemoryGameStateStorage {
-    constructor() {
-        this.state = null;
-    }
-    loadGameState() {
-        if (this.state === null) {
-            throw new Error('Game state is not initialized');
-        }
-        return this.state;
-    }
-    saveGameState(state) {
-        this.state = state;
-    }
-}

package/dist/types.d.ts

@@ -1,123 +0,0 @@
-type Map = Record<string, any>;
-type Merge<A, B> = {
-    [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
-};
-export interface ReqPayload {
-    playerId: PlayerId;
-}
-export type Second = number;
-export type ReqMap = Record<string, Simple<ReqPayload> | Custom<ReqPayload>>;
-export interface RequireSetting {
-    limitedTime: Second;
-}
-export type ResMap = Record<string, Require<any> | Notify<any>>;
-export type Simple<T extends ReqPayload> = {
-    kind: "simple";
-    value: T;
-};
-export type Custom<T extends ReqPayload> = {
-    kind: "custom";
-    value: T;
-};
-export type Require<T> = {
-    kind: "require";
-    value: T;
-    setting: RequireSetting;
-};
-export type Notify<T> = {
-    kind: "notify";
-    value: T;
-};
-export type FromServerMap<T extends ResMap> = T;
-export type ToServerMap<T extends ReqMap> = T;
-export type CustomTaskMap<T extends Map> = T;
-export type ExtractSimplePayload<T> = T extends Simple<infer U> ? U : never;
-export type ExtractCustomPayload<T> = T extends Custom<infer U> ? U : never;
-export type SimpleOnlyPayload<T extends ReqMap> = {
-    [K in keyof T as T[K] extends Simple<any> ? K : never]: ExtractSimplePayload<T[K]>;
-};
-export type CustomOnlyPayload<T extends ReqMap> = {
-    [K in keyof T as T[K] extends Custom<any> ? K : never]: ExtractCustomPayload<T[K]>;
-};
-export type CustomOnly<T extends ReqMap> = {
-    [K in keyof T as T[K] extends Custom<any> ? K : never]: T[K];
-};
-export type RequireOnly<T extends ReqMap> = {
-    [K in keyof T as T[K] extends Require<any> ? K : never]: T[K];
-};
-export type NotifyOnly<T extends ReqMap> = {
-    [K in keyof T as T[K] extends Notify<any> ? K : never]: T[K];
-};
-export type TaskMapType<A extends ReqMap, B extends Map> = Merge<SimpleOnlyPayload<A>, CustomTaskMap<B>>;
-export type Player = {
-    id: PlayerId;
-    name: string;
-};
-export type Joiner = {
-    numberOfPlayers: number;
-    enteredPlayers: Player[];
-};
-export interface GameParameters {
-    owner: Player;
-    joiner: Joiner;
-}
-export interface DefaultGameLogicState<S extends Map> {
-    forClient: ForClient<S>;
-}
-export type FromServerDataType<T extends Map> = keyof FromServerMap<T>;
-export type ToServerDataType<T extends Map> = keyof ToServerMap<T>;
-export type FromServerData<T extends ResMap> = {
-    [K in keyof T]: {
-        type: K;
-        payload: T[K];
-    };
-}[keyof T];
-export type ToServerData<T extends ReqMap> = {
-    [K in keyof T]: {
-        type: K;
-        payload: T[K];
-    };
-}[keyof T];
-export type FromServer<S extends ResMap> = FromServerData<S>;
-export type ToServer<C extends ReqMap> = ToServerData<C>;
-export type ToServerWithNonStringKey<C extends ReqMap> = {
-    [K in keyof C]: {
-        type: K;
-        payload: C[K];
-    };
-}[keyof C];
-export type PlayerId = string;
-export type ForUI<S extends ResMap> = {
-    requiredAction: FromServer<S> | null;
-    notifications: FromServer<S>[];
-};
-export type ForClient<S extends Map> = {
-    [key: PlayerId]: ForUI<S>;
-};
-export type Task<A extends ReqMap, B extends Map> = {
-    [K in keyof TaskMapType<A, B>]: {
-        type: K;
-        payload: TaskMapType<A, B>[K];
-    };
-}[keyof TaskMapType<A, B>];
-export interface TaskResult<S extends Map, L extends DefaultGameLogicState<S>> {
-    type: string;
-    state: L;
-}
-export type GameState<T extends Map, S extends Map, C extends ReqMap, L extends DefaultGameLogicState<S>, P extends GameParameters> = {
-    gameLogicState: L;
-    taskQueue: Task<C, T>[];
-    gameParameters: P | null;
-};
-export interface GameRule<T extends Map, S extends Map, C extends ReqMap, L extends DefaultGameLogicState<S>, P extends GameParameters> {
-    initialGameLogicState: () => L;
-    createRoom: (state: GameState<T, S, C, L, P>, param: GameParameters) => GameState<T, S, C, L, P>;
-    onJoin: (state: GameState<T, S, C, L, P>, joiner: Player) => GameState<T, S, C, L, P>;
-    onStartGame: (state: GameState<T, S, C, L, P>) => GameState<T, S, C, L, P>;
-    generateTasks(state: GameState<T, S, C, L, P>, event: ToServer<C>): Task<C, T>[];
-    prioritizeTasks(newTasks: Task<C, T>[], gameState: GameState<T, S, C, L, P>): GameState<T, S, C, L, P>;
-    doTasks(state: GameState<T, S, C, L, P>): GameState<T, S, C, L, P>;
-    privaten(destinationId: PlayerId, l: L): L;
-}
-export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}