// package.json scripts
{
  "scripts": {
    "build": "tsc",
    "build:watch": "tsc --watch",
    "typecheck": "tsc --noEmit",
    "typecheck:watch": "tsc --noEmit --watch",
    "build:project": "tsc --build",
    "build:clean": "tsc --build --clean"
  }
}
 
// tsc の主要フラグ
// tsc                    → tsconfig.json に従ってビルド
// tsc --noEmit           → 型チェックのみ（ファイル出力なし）
// tsc --watch            → ファイル変更を監視して再ビルド
// tsc --build            → プロジェクト参照を含むインクリメンタルビルド
// tsc --declaration      → .d.ts ファイルを生成
// tsc --project tsconfig.test.json → 指定した設定ファイルを使用
// tsc --extendedDiagnostics → パフォーマンス診断情報を出力
// tsc --generateTrace ./trace → パフォーマンストレースを生成

// tsconfig.json
{
  "compilerOptions": {
    "incremental": true,
    "tsBuildInfoFile": "./.tsbuildinfo"
  }
}
// 前回のビルド情報を .tsbuildinfo に保存し、
// 変更のあったファイルのみ再コンパイル
// → 2回目以降のビルドが大幅に高速化

// パターン1: tsc (型チェック) + esbuild (トランスパイル)
{
  "scripts": {
    "typecheck": "tsc --noEmit",
    "build": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js",
    "prebuild": "npm run typecheck"
  }
}
 
// パターン2: tsc (型定義生成) + esbuild (JS生成)
{
  "scripts": {
    "build:types": "tsc --emitDeclarationOnly --declaration --declarationMap",
    "build:js": "esbuild src/index.ts --bundle --outfile=dist/index.js",
    "build": "npm run build:types && npm run build:js"
  }
}
 
// パターン3: 並列実行（concurrently を使用）
{
  "scripts": {
    "dev": "concurrently \"tsc --noEmit --watch\" \"tsx watch src/index.ts\"",
    "build": "concurrently \"tsc --noEmit\" \"esbuild src/index.ts --bundle --outfile=dist/index.js\""
  }
}

# モノレポでのビルド
tsc --build                    # 全パッケージをビルド
tsc --build packages/shared    # shared とその依存のみ
tsc --build --watch            # ウォッチモード
tsc --build --verbose          # 詳細出力
tsc --build --dry              # ドライラン
tsc --build --clean            # ビルド成果物を削除
tsc --build --force            # キャッシュを無視して全ビルド

// esbuild.config.ts
import * as esbuild from "esbuild";
 
// シンプルなビルド
await esbuild.build({
  entryPoints: ["src/index.ts"],
  bundle: true,
  outfile: "dist/index.js",
  platform: "node",
  target: "node20",
  format: "esm",
  sourcemap: true,
  minify: process.env.NODE_ENV === "production",
});
 
// 複数エントリーポイント
await esbuild.build({
  entryPoints: ["src/index.ts", "src/worker.ts"],
  bundle: true,
  outdir: "dist",
  splitting: true,  // コード分割（ESM のみ）
  format: "esm",
  platform: "node",
  target: "node20",
  external: ["pg", "redis"], // バンドルしないパッケージ
});
 
// ブラウザ向けビルド
await esbuild.build({
  entryPoints: ["src/app.ts"],
  bundle: true,
  outfile: "dist/app.js",
  platform: "browser",
  target: ["chrome100", "firefox100", "safari16"],
  format: "esm",
  sourcemap: true,
  minify: true,
  // CSS もバンドル
  loader: {
    ".png": "file",
    ".svg": "dataurl",
    ".css": "css",
  },
  // 環境変数の埋め込み
  define: {
    "process.env.NODE_ENV": '"production"',
    "import.meta.env.VITE_API_URL": '"https://api.example.com"',
  },
});

import * as esbuild from "esbuild";
import { readFile } from "fs/promises";
 
// カスタムプラグインの作成
const envPlugin: esbuild.Plugin = {
  name: "env-plugin",
  setup(build) {
    // .env ファイルを読み込んで定義に変換
    build.onResolve({ filter: /^env$/ }, (args) => ({
      path: args.path,
      namespace: "env-ns",
    }));
 
    build.onLoad({ filter: /.*/, namespace: "env-ns" }, async () => {
      const envFile = await readFile(".env", "utf-8");
      const env: Record<string, string> = {};
      for (const line of envFile.split("\n")) {
        const [key, ...valueParts] = line.split("=");
        if (key && valueParts.length > 0) {
          env[key.trim()] = valueParts.join("=").trim();
        }
      }
      return {
        contents: JSON.stringify(env),
        loader: "json",
      };
    });
  },
};
 
// リビルド通知プラグイン
const notifyPlugin: esbuild.Plugin = {
  name: "notify-plugin",
  setup(build) {
    let start: number;
 
    build.onStart(() => {
      start = Date.now();
      console.log("Build started...");
    });
 
    build.onEnd((result) => {
      const elapsed = Date.now() - start;
      if (result.errors.length > 0) {
        console.error(`Build failed in ${elapsed}ms with ${result.errors.length} errors`);
      } else {
        console.log(`Build completed in ${elapsed}ms`);
        if (result.warnings.length > 0) {
          console.warn(`  ${result.warnings.length} warnings`);
        }
      }
    });
  },
};
 
// Node.js の外部パッケージを自動検出するプラグイン
const nodeExternalsPlugin: esbuild.Plugin = {
  name: "node-externals",
  setup(build) {
    // node_modules のパッケージを全て external にする
    build.onResolve({ filter: /^[^./]/ }, (args) => ({
      path: args.path,
      external: true,
    }));
  },
};
 
// プラグインの使用
await esbuild.build({
  entryPoints: ["src/index.ts"],
  bundle: true,
  outfile: "dist/index.js",
  platform: "node",
  format: "esm",
  plugins: [envPlugin, notifyPlugin, nodeExternalsPlugin],
});

// esbuild の watch + serve
const ctx = await esbuild.context({
  entryPoints: ["src/index.ts"],
  bundle: true,
  outdir: "dist",
  platform: "node",
  format: "esm",
  sourcemap: true,
  plugins: [
    {
      name: "rebuild-notify",
      setup(build) {
        build.onEnd((result) => {
          console.log(
            `Build finished: ${result.errors.length} errors`
          );
        });
      },
    },
  ],
});
 
await ctx.watch(); // ファイル変更を監視して自動リビルド
 
// フロントエンド用の開発サーバー
const serveCtx = await esbuild.context({
  entryPoints: ["src/app.ts"],
  bundle: true,
  outdir: "public/dist",
  platform: "browser",
  format: "esm",
  sourcemap: true,
});
 
// 開発サーバーを起動
const { host, port } = await serveCtx.serve({
  servedir: "public",
  port: 3000,
});
console.log(`Dev server running at http://${host}:${port}`);

{
  "scripts": {
    "build": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js --format=esm",
    "build:prod": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js --format=esm --minify --sourcemap",
    "dev": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js --format=esm --watch",
    "typecheck": "tsc --noEmit"
  }
}

// .swcrc
{
  "$schema": "https://swc.rs/schema.json",
  "jsc": {
    "parser": {
      "syntax": "typescript",
      "tsx": false,
      "decorators": true,
      "dynamicImport": true
    },
    "target": "es2022",
    "transform": {
      "decoratorVersion": "2022-03"
    },
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"]
    }
  },
  "module": {
    "type": "es6",
    "strict": true,
    "noInterop": false
  },
  "sourceMaps": true,
  "minify": false
}

// package.json
{
  "scripts": {
    "build": "swc src -d dist --strip-leading-paths",
    "build:watch": "swc src -d dist --strip-leading-paths --watch",
    "dev": "swc src -d dist --strip-leading-paths --watch",
    "typecheck": "tsc --noEmit"
  }
}

// @swc-node/register で直接 .ts を実行
{
  "scripts": {
    "start": "node --import @swc-node/register/esm src/index.ts",
    "dev": "node --import @swc-node/register/esm --watch src/index.ts"
  }
}

// .swcrc に minify 設定を追加
{
  "jsc": {
    "parser": { "syntax": "typescript" },
    "target": "es2022",
    "minify": {
      "compress": {
        "dead_code": true,
        "drop_console": true,
        "drop_debugger": true,
        "passes": 2,
        "unused": true
      },
      "mangle": {
        "toplevel": true,
        "keep_classnames": false,
        "keep_fnames": false
      }
    }
  },
  "minify": true
}

// vite.config.ts
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react-swc"; // SWC 版 React プラグイン
 
export default defineConfig({
  plugins: [react()],
  build: {
    target: "es2022",
    outDir: "dist",
    sourcemap: true,
    // Rollup のオプション
    rollupOptions: {
      output: {
        // 手動チャンク分割
        manualChunks: {
          vendor: ["react", "react-dom"],
          ui: ["@radix-ui/react-dialog", "@radix-ui/react-dropdown-menu"],
        },
        // チャンクファイル名のフォーマット
        chunkFileNames: "assets/[name]-[hash].js",
        entryFileNames: "assets/[name]-[hash].js",
        assetFileNames: "assets/[name]-[hash].[ext]",
      },
    },
    // チャンクサイズ警告の閾値
    chunkSizeWarningLimit: 500,
    // CSS のコード分割
    cssCodeSplit: true,
  },
  resolve: {
    alias: {
      "@": "/src",
      "@components": "/src/components",
      "@hooks": "/src/hooks",
      "@utils": "/src/utils",
    },
  },
  server: {
    port: 3000,
    strictPort: true,
    // プロキシ設定
    proxy: {
      "/api": {
        target: "http://localhost:8080",
        changeOrigin: true,
        rewrite: (path) => path.replace(/^\/api/, ""),
      },
    },
  },
  // 環境変数のプレフィックス
  envPrefix: "VITE_",
});

// よく使われる Vite プラグイン
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react-swc";
import tsconfigPaths from "vite-tsconfig-paths";
import checker from "vite-plugin-checker";
import { compression } from "vite-plugin-compression2";
import { visualizer } from "rollup-plugin-visualizer";
 
export default defineConfig({
  plugins: [
    // React (SWC ベース、高速)
    react(),
 
    // tsconfig.json の paths を自動解決
    tsconfigPaths(),
 
    // 開発中にリアルタイム型チェック + ESLint
    checker({
      typescript: true,
      eslint: {
        lintCommand: 'eslint "./src/**/*.{ts,tsx}"',
      },
    }),
 
    // Gzip / Brotli 圧縮
    compression({
      algorithm: "gzip",
      threshold: 1024,
    }),
    compression({
      algorithm: "brotliCompress",
      threshold: 1024,
    }),
 
    // バンドルサイズの可視化
    visualizer({
      filename: "dist/stats.html",
      open: false,
      gzipSize: true,
      brotliSize: true,
    }),
  ],
});

// vite.config.ts -- ライブラリとしてビルド
import { defineConfig } from "vite";
import dts from "vite-plugin-dts";
 
export default defineConfig({
  plugins: [
    dts({
      rollupTypes: true,           // 型定義を1ファイルにバンドル
      insertTypesEntry: true,      // package.json の types を自動設定
      tsconfigPath: "./tsconfig.build.json",
    }),
  ],
  build: {
    lib: {
      entry: "src/index.ts",
      name: "MyLib",
      formats: ["es", "cjs"],
      fileName: (format) => `index.${format === "es" ? "mjs" : "cjs"}`,
    },
    rollupOptions: {
      // ピア依存はバンドルしない
      external: ["react", "react-dom", "react/jsx-runtime"],
      output: {
        globals: {
          react: "React",
          "react-dom": "ReactDOM",
        },
      },
    },
    // ソースマップ生成
    sourcemap: true,
    // minify しない（ライブラリの場合）
    minify: false,
  },
});

// vite.config.ts -- Node.js バックエンド
import { defineConfig } from "vite";
 
export default defineConfig({
  build: {
    ssr: true,
    target: "node20",
    outDir: "dist",
    rollupOptions: {
      input: "src/server.ts",
      output: {
        format: "esm",
        entryFileNames: "server.js",
      },
    },
  },
  ssr: {
    noExternal: true, // 全ての依存をバンドル
    // noExternal: ["specific-pkg"], // 特定のみバンドル
  },
});
 
// Vite + Express の SSR 設定例
// vite.config.ts
export default defineConfig({
  build: {
    ssr: true,
    rollupOptions: {
      input: {
        server: "src/server.ts",
        entry: "src/entry-server.tsx",
      },
    },
  },
});

// .env ファイルの読み込み順序:
// .env                # 常に読み込み
// .env.local          # 常に読み込み（.gitignore 推奨）
// .env.[mode]         # 指定モードで読み込み
// .env.[mode].local   # 指定モードで読み込み（.gitignore 推奨）
 
// .env
VITE_API_URL=https://api.example.com
VITE_APP_TITLE=My App
 
// .env.development
VITE_API_URL=http://localhost:8080
VITE_DEBUG=true
 
// .env.production
VITE_API_URL=https://api.production.com
VITE_DEBUG=false
 
// src/vite-env.d.ts -- 型定義
/// <reference types="vite/client" />
 
interface ImportMetaEnv {
  readonly VITE_API_URL: string;
  readonly VITE_APP_TITLE: string;
  readonly VITE_DEBUG: string;
}
 
interface ImportMeta {
  readonly env: ImportMetaEnv;
}
 
// 使用例
const apiUrl = import.meta.env.VITE_API_URL; // 型: string
const isDev = import.meta.env.DEV;            // 型: boolean
const isProd = import.meta.env.PROD;          // 型: boolean
const mode = import.meta.env.MODE;            // 型: string

# インストール
npm install -D tsx
 
# TypeScript ファイルを直接実行
npx tsx src/index.ts
 
# ウォッチモード
npx tsx watch src/index.ts
 
# ESM として実行
npx tsx --esm src/index.ts
 
# REPL
npx tsx

// package.json
{
  "scripts": {
    "start": "tsx src/index.ts",
    "dev": "tsx watch src/index.ts",
    "script": "tsx scripts/seed.ts"
  }
}

// tsup.config.ts
import { defineConfig } from "tsup";
 
export default defineConfig({
  // エントリーポイント
  entry: ["src/index.ts", "src/utils/index.ts"],
 
  // 出力形式（ESM + CJS）
  format: ["esm", "cjs"],
 
  // 型定義ファイル生成
  dts: true,
 
  // ソースマップ
  sourcemap: true,
 
  // クリーンビルド
  clean: true,
 
  // 外部パッケージ（バンドルしない）
  external: ["react", "react-dom"],
 
  // Tree-shaking
  treeshake: true,
 
  // TypeScript のターゲット
  target: "es2020",
 
  // 出力ディレクトリ
  outDir: "dist",
 
  // コード分割
  splitting: true,
 
  // minify
  minify: false,
});

// package.json（デュアル ESM/CJS パッケージ）
{
  "name": "my-lib",
  "version": "1.0.0",
  "type": "module",
  "main": "./dist/index.cjs",
  "module": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "import": {
        "types": "./dist/index.d.ts",
        "default": "./dist/index.js"
      },
      "require": {
        "types": "./dist/index.d.cts",
        "default": "./dist/index.cjs"
      }
    },
    "./utils": {
      "import": {
        "types": "./dist/utils/index.d.ts",
        "default": "./dist/utils/index.js"
      },
      "require": {
        "types": "./dist/utils/index.d.cts",
        "default": "./dist/utils/index.cjs"
      }
    }
  },
  "files": ["dist"],
  "scripts": {
    "build": "tsup",
    "dev": "tsup --watch",
    "typecheck": "tsc --noEmit",
    "prepublishOnly": "npm run build"
  }
}

// build.config.ts
import { defineBuildConfig } from "unbuild";
 
export default defineBuildConfig({
  entries: ["src/index"],
  declaration: true,
  clean: true,
  rollup: {
    emitCJS: true,
    inlineDependencies: true,
  },
  // 自動 externals 検出
  externals: ["react"],
});

// turbo.json
{
  "$schema": "https://turbo.build/schema.json",
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".next/**"],
      "inputs": ["src/**", "tsconfig.json"]
    },
    "typecheck": {
      "dependsOn": ["^build"]
    },
    "lint": {},
    "test": {
      "dependsOn": ["build"]
    },
    "dev": {
      "cache": false,
      "persistent": true
    }
  }
}

# Turborepo でのビルド
turbo build           # 全パッケージをビルド（キャッシュ活用）
turbo build --filter=web  # web パッケージのみ
turbo build --force   # キャッシュを無視
turbo dev             # 全パッケージの開発サーバー
 
# リモートキャッシュ（チーム間でキャッシュ共有）
turbo login
turbo link
turbo build  # リモートキャッシュを使用

// NG: tsc だけで全てをやろうとする
{
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  }
}
// 問題:
// - バンドルされない（ファイルが分散）
// - Tree-shaking なし
// - パス解決が壊れることがある（paths）
// - ビルドが遅い
// - node_modules から直接 import が必要
 
// OK: 型チェックとビルドを分離
{
  "scripts": {
    "typecheck": "tsc --noEmit",
    "build": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js",
    "prebuild": "npm run typecheck"
  }
}

// NG: 毎回手動でビルド→実行
{
  "scripts": {
    "dev": "tsc && node dist/index.js"
  }
}
 
// OK: ファイル監視で自動再起動
{
  "scripts": {
    "dev": "tsx watch src/index.ts"
  }
}
// もしくは
{
  "scripts": {
    "dev": "node --import @swc-node/register/esm --watch src/index.ts"
  }
}

// NG: ビルドと型チェックを直列実行
{
  "scripts": {
    "build": "tsc --noEmit && esbuild src/index.ts --bundle --outfile=dist/index.js"
  }
}
 
// OK: CI で並列実行
// .github/workflows/ci.yml
// jobs:
//   typecheck:
//     run: npm run typecheck
//   build:
//     run: npm run build:js
//   lint:
//     run: npm run lint
//   test:
//     run: npm test

// NG: バンドル分析なしでデプロイ
// → 不要な依存が含まれ、パフォーマンス悪化
 
// OK: バンドル分析を定期的に実施
// vite.config.ts
import { visualizer } from "rollup-plugin-visualizer";
 
export default defineConfig({
  plugins: [
    visualizer({
      filename: "dist/stats.html",
      gzipSize: true,
      brotliSize: true,
    }),
  ],
});
// npm run build 後に dist/stats.html を確認

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# ---- Builder ステージ ----
FROM node:20-slim AS builder
 
WORKDIR /app
 
# 依存のインストール（キャッシュ効率化）
COPY package.json package-lock.json ./
RUN npm ci
 
# ソースコピー & ビルド
COPY tsconfig.json ./
COPY src/ ./src/
RUN npm run build
 
# ---- Production ステージ ----
FROM node:20-slim AS production
 
WORKDIR /app
 
# 本番依存のみインストール
COPY package.json package-lock.json ./
RUN npm ci --omit=dev
 
# ビルド成果物のみコピー
COPY --from=builder /app/dist ./dist
 
# Node.js で直接実行
CMD ["node", "dist/index.js"]

# esbuild でバンドルすると node_modules が不要になる
FROM node:20-slim AS builder
 
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY tsconfig.json ./
COPY src/ ./src/
RUN npx esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js --format=esm --minify
 
# ---- 軽量な Production ステージ ----
FROM node:20-slim AS production
WORKDIR /app
 
# バンドル済みファイルのみコピー（node_modules 不要）
COPY --from=builder /app/dist/index.js ./index.js
 
CMD ["node", "index.js"]
# → イメージサイズが大幅に削減される

# 詳細な診断情報
tsc --extendedDiagnostics --noEmit
 
# 出力例:
# Files:               1,234
# Lines of Library:    35,678
# Lines of Definitions: 89,012
# Lines of TypeScript:  67,890
# Nodes:               345,678
# Identifiers:         123,456
# Symbols:              67,890
# Types:                34,567
# Instantiations:      234,567  ← これが大きいと遅い
# Memory used:         456,789K
# Assignability cache size: 12,345
# Identity cache size:  1,234
# Subtype cache size:   2,345
# Strict subtype cache: 3,456
# I/O Read time:        0.12s
# Parse time:           1.23s
# ResolveModule time:   0.34s
# ResolveTypeRef time:  0.05s
# Bind time:            0.45s
# Check time:           5.67s   ← 通常最大
# printTime time:       0.89s
# Emit time:            0.89s
# Total time:           8.36s
 
# Instantiations が大きい場合の対処:
# 1. 複雑なジェネリクス型を簡素化
# 2. 条件型のネストを減らす
# 3. 型の再計算を避ける（type alias でキャッシュ）

// NG: 深くネストされた条件型（Instantiations が爆発）
type DeepPick<T, K extends string> =
  K extends `${infer First}.${infer Rest}`
    ? First extends keyof T
      ? { [P in First]: DeepPick<T[First], Rest> }
      : never
    : K extends keyof T
      ? { [P in K]: T[P] }
      : never;
 
// OK: interface で中間型を定義してキャッシュ
interface CachedDeepPick<T, First extends keyof T, Rest extends string> {
  [P in First]: DeepPick<T[First], Rest>;
}
 
// NG: 大量のユニオン型（チェックが O(n^2)）
type AllEvents = Event1 | Event2 | ... | Event100;
 
// OK: 判別共用体でマップ型を使用
interface EventMap {
  event1: Event1;
  event2: Event2;
  // ...
}
type AllEvents = EventMap[keyof EventMap];