main.ts

import { HiguRenderer, type AssetManifest } from "@higu/renderer";
import "@higu/renderer/style.css";
import {
  defaultPlaybackPolicy,
  HiguSaveError,
  HiguScript,
  type HiguWarning,
  type ReadMarks,
  type ReadMarkerStorage,
  type ScriptLoader,
  SetReadMarker,
  type SkipMode,
  type StorageAdapter,
} from "@higu/script";

import { type ChapterEntry, FLOW_SCRIPT, GAME_SECTION, jumpOfScript, readChapters } from "./chapters.js";
import { HostUI } from "./host-ui.js";
import { SaveStore } from "./save.js";
import { ConfigPanel } from "./ui/config.js";
import { MenuOverlay } from "./ui/menu.js";
import { SaveLoadPanel } from "./ui/saveload.js";
import "./ui/ui.css";

/**
 * 호스트 앱 부트스트랩 (00-overview.md §2의 임베딩 스케치).
 *
 * M4 시점의 목표는 DoD 하나다 — **`_meak_001` 도입부를 텍스트+배경으로 재생**.
 * 타이틀/TIPS 등 GUI 화면(M8)은 no-op 스텁이며, 스텁이 전부 no-op이어도 완주할 수
 * 있어야 한다는 요건(03-renderer.md §11)을 그대로 만족한다.
 */

const ASSET_BASE = "/assets";
/**
 * 부팅 진입점. init.txt가 설정·창 프리셋·아트셋 폴백 체인을 세운 뒤 스스로
 * `CallScript("flow")`로 이어지므로 진입점은 이것 하나다 (02-interpreter.md §4.4).
 */
const INIT_SCRIPT = "init";
/** 07th-mod의 업데이트 오버레이 규칙 — 동명 파일은 Update/가 우선한다. */
const SCRIPT_DIRECTORIES = ["Update", "Scripts"];
/** GlobalFlags·기독 기록·세이브 슬롯이 공유하는 localStorage 이름공간. */
const STORAGE_PREFIX = "higu-ep05";
/** Q/E가 쓰는 슬롯. 슬롯 UI는 M8이므로 지금은 한 칸이면 된다. */
const QUICK_SLOT = 0;
/** 콘솔 API가 훑는 슬롯 수. */
const MAX_SLOTS = 10;

/**
 * `GLanguage` — 0=일본어(A 슬롯), 1=번역(B 슬롯). `OutputLine`이 이 값으로
 * 두 언어 슬롯 중 하나를 고른다 (04-engine-functions.md §2).
 */
const LANGUAGE = { jp: 0, ko: 1 } as const;
const DEFAULT_LANGUAGE = LANGUAGE.ko;

/** 게임 중 메뉴 (Esc / 우클릭)의 라벨. */
const MENU_KO = { save: "세이브", load: "로드", config: "설정" };
const MENU_JP = { save: "セーブ", load: "ロード", config: "設定" };

/** `.txt`를 fetch로 읽는 로더. 브라우저에는 파일 시스템이 없다. */
class HttpScriptLoader implements ScriptLoader {
  async load(name: string): Promise<string> {
    for (const directory of SCRIPT_DIRECTORIES) {
      const url = `${ASSET_BASE}/${directory}/${encodeURIComponent(name)}.txt`;
      const response = await fetch(url);
      if (response.ok) return response.text();
    }
    throw new Error(`스크립트 '${name}'을(를) 찾을 수 없습니다.`);
  }
}

/**
 * 기독 기록 영속화 (02-interpreter.md §8.1).
 *
 * GlobalFlags와 **같은 계층**이지만 값의 모양이 달라 `StorageAdapter`
 * (`Record<string, number>`)를 쓸 수 없다. Ep05 완주 기준 200 KiB대이므로
 * localStorage의 5MB 한도에 여유 있게 들어간다.
 */
class LocalStorageReadMarks implements ReadMarkerStorage {
  constructor(private readonly key: string) {}

  read(): ReadMarks {
    try {
      const raw = localStorage.getItem(this.key);
      return raw ? (JSON.parse(raw) as ReadMarks) : {};
    } catch {
      // 손상돼 있으면 기독 기록이 빈 것과 같다 — 스킵이 덜 될 뿐이다.
      return {};
    }
  }

  write(marks: ReadMarks): void {
    try {
      localStorage.setItem(this.key, JSON.stringify(marks));
    } catch {
      /* 용량 초과나 접근 거부. 기독 기록이 안 남을 뿐 진행을 막지 않는다. */
    }
  }
}

/** GlobalFlags 영속화 (02-interpreter.md §5). */
class LocalStorageAdapter implements StorageAdapter {
  constructor(private readonly key: string) {}

  read(): Record<string, number> {
    try {
      const raw = localStorage.getItem(this.key);
      return raw ? (JSON.parse(raw) as Record<string, number>) : {};
    } catch {
      // 사파리의 프라이빗 모드 등에서 읽기가 막힐 수 있다 — 설정이 날아갈 뿐이다.
      return {};
    }
  }

  write(flags: Readonly<Record<string, number>>): void {
    try {
      localStorage.setItem(this.key, JSON.stringify(flags));
    } catch {
      /* 영속화 실패는 재생을 막을 이유가 아니다. */
    }
  }
}

async function boot(): Promise<void> {
  const root = document.querySelector<HTMLElement>("#game-area");
  if (!root) throw new Error("#game-area를 찾을 수 없습니다.");

  const manifestResponse = await fetch("/assets-manifest.json");
  if (!manifestResponse.ok) {
    throw new Error("에셋 매니페스트를 읽을 수 없습니다. HIGU_ASSETS 경로를 확인하세요.");
  }
  const manifest = (await manifestResponse.json()) as AssetManifest;

  const warnings: HiguWarning[] = [];
  // 기독 마커는 영속 계층을 물려야 하므로 정책을 직접 만들어 넘긴다 (§8.1).
  const readMarker = new SetReadMarker(new LocalStorageReadMarks(`${STORAGE_PREFIX}:read`));
  const policy = { ...defaultPlaybackPolicy(), readMarker };

  const higu = new HiguScript({
    loader: new HttpScriptLoader(),
    storage: new LocalStorageAdapter(STORAGE_PREFIX),
    policy,
    onWarning: (warning) => {
      warnings.push(warning);
      console.warn(`[higu] ${warning.loc.file}:${warning.loc.line}:${warning.loc.col} ${warning.message}`);
    },
  });

  const saves = new SaveStore(STORAGE_PREFIX);

  /**
   * `S` 키가 켜는 스킵의 종류 (원본 `GSkipUnread` → `SkipUnreadMessages`).
   * 기본 `"read"`가 원본의 기본값이다 — 미독에서 멈추는 스킵(§8.1). 설정 UI가 바꾼다.
   */
  let skipToggleMode: SkipMode = "read";
  // `mark()`는 문장마다 불려 메모리만 건드린다 — 창을 닫기 전에 한 번 흘린다 (§8.1).
  window.addEventListener("beforeunload", () => readMarker.flush());

  // 렌더러는 인터프리터와 **같은** 정책/스케줄러를 공유한다 (02-interpreter.md §8).
  const renderer = new HiguRenderer({
    rootElement: root,
    policy: higu.policy,
    scheduler: higu.scheduler,
    flags: higu.flags,
    validity: () => higu.validity,
    assets: { baseUrl: ASSET_BASE, manifest },
    onQuickSave: () => void quickSave(QUICK_SLOT),
    onQuickLoad: () => void quickLoad(QUICK_SLOT),
    onMenu: () => void openGameMenu(),
    skipToggleMode: () => skipToggleMode,
    onWarning: (message) => console.warn(`[higu:renderer] ${message}`),
  });
  renderer.start();

  /** 진행 중인 `run()`/`resume()`. 퀵로드가 이것이 끝나기를 기다린다. */
  let currentRun: Promise<void> = Promise.resolve();

  /**
   * 세이브/로드 직렬화 게이트.
   *
   * 퀵로드는 `stop()` → `await currentRun` → `restore()` → `resume()`의 4단계인데,
   * 두 호출이 겹치면 뒤의 것이 **이미 resolve된 옛 `currentRun`**을 기다리게 되어
   * 그대로 통과한다. 그 사이 앞의 것이 `resume()`을 시작했으면 뒤의 `restore()`가
   * "VM이 이미 실행 중입니다"로 죽고, 화면은 복원되지 않은 채 남는다 — 퀵로드 키를
   * 연타하면 재현된다.
   *
   * 실패는 게이트에서 삼킨다. 한 번의 로드 실패가 이후의 세이브/로드를 영영 막으면
   * 안 된다 — 실패 보고는 각 작업이 반환값으로 한다.
   */
  let gate: Promise<unknown> = Promise.resolve();
  function serialized<T>(task: () => Promise<T>): Promise<T> {
    const run = gate.then(task, task);
    gate = run.then(
      () => {},
      () => {},
    );
    return run;
  }

  /**
   * 세이브 (02-interpreter.md §7.2).
   *
   * `canSave`는 **호스트가 거는 게이트**다 — `snapshot()` 자신은 강제하지 않는다
   * (§7.2). `input`/`choice` 서스펜션이면서 스크립트가 세이브를 금지하지 않은
   * 구간에서만 참이다.
   */
  async function saveNow(slot: number): Promise<boolean> {
    if (!higu.canSave) {
      console.warn(`[higu] 지금은 세이브할 수 없습니다 (${higu.status} / ${higu.suspendedOn ?? "-"}).`);
      return false;
    }
    try {
      saves.write(slot, {
        savedAt: new Date().toISOString(),
        ...(higu.savePointLabel && { label: higu.savePointLabel }),
        exec: higu.snapshot(),
        scene: renderer.snapshot(),
      });
    } catch (error: unknown) {
      // 용량 초과가 대표적이다. 삼키면 저장됐다고 믿고 진행하게 된다.
      console.error("[higu] 세이브에 실패했습니다.", error);
      return false;
    }
    // 세이브 시점에 기독 기록도 함께 흘린다 — 원본이 `SaveGlobals()`에 묶는 것과
    // 같은 자리다 (§8.1).
    readMarker.flush();
    console.info(`[higu] 슬롯 ${slot}에 세이브했습니다.`);
    return true;
  }

  /**
   * 로드 (02-interpreter.md §7.3).
   *
   * `restore()`는 VM이 실행 중이 아닐 것을 요구하는데 `stop()`은 협조적이라
   * 진행 중인 서스펜션이 resolve된 뒤에야 루프를 빠져나온다 — 클릭 대기는 클릭이
   * 없으면 영영 안 풀리므로 호스트가 대신 풀어 준다. 어차피 곧 화면 전체를
   * 복원하므로 그 진행이 화면에 남기는 것은 의미가 없다.
   *
   * **`forceAdvance()` 한 번으로는 부족하다.** `OutputLine`의 대기는 한 덩어리로
   * 보이지만 실제로는 **둘**이다 (`text-window.ts`의 `waitForClick`) — 타이핑 완료
   * 대기를 풀고 나서야 진행 대기가 등록된다. 한 번만 쏘면 타이핑만 끝나고 그
   * 다음에 걸리는 진행 대기에 그대로 눌러앉아, **사용자가 실제로 클릭할 때까지
   * 로드가 시작되지 않는다.** 오토 모드면 한 번 더 필요하다 — 오토 중 첫 진행
   * 입력은 오토만 끄고 진행하지 않는다(원본 `StateNormal`의 순서).
   *
   * 그래서 VM이 실제로 멈출 때까지 계속 쏜다. `stop()`을 이미 걸어 두었으므로
   * VM은 다음 문장 경계에서 멈추고, 펌프는 몇 번 돌지 않는다.
   *
   * **선택지도 함께 풀어야 한다** (M8). `choice` 서스펜션은 진행 입력으로
   * 풀리지 않으므로 `forceAdvance()`가 닿지 않는데, `input`과 마찬가지로
   * **세이브 가능 지점**이라(02-interpreter.md §4.1) 선택지에서 저장하고
   * 선택지에서 로드하는 것이 정상 경로다. 놔두면 `await currentRun`이 영영
   * 끝나지 않아 게이트가 막히고 이후의 세이브/로드가 전부 죽는다.
   */
  const unblock = (): void => {
    renderer.input.forceAdvance();
    renderer.choices.destroy();
  };

  async function loadNow(slot: number): Promise<boolean> {
    const data = saves.read(slot);
    if (!data) {
      console.warn(`[higu] 슬롯 ${slot}에 세이브가 없습니다.`);
      return false;
    }

    higu.stop();
    unblock();
    const pump = setInterval(unblock, 16);
    try {
      await currentRun;
    } finally {
      clearInterval(pump);
    }

    try {
      // 인터프리터를 먼저 되돌린다 — 검증에 실패하면 화면을 건드리지 않은 채로
      // 끝나야 한다(§7.3: 로드 실패가 진행 중인 플레이를 깨뜨리지 않는다).
      await higu.restore(data.exec);
    } catch (error: unknown) {
      if (error instanceof HiguSaveError) {
        console.error(
          `[higu] 세이브를 읽을 수 없습니다: ${error.message}` +
            (error.savePointLabel ? ` (마지막 지점: ${error.savePointLabel.local})` : ""),
        );
      } else {
        console.error("[higu] 로드에 실패했습니다.", error);
      }
      currentRun = higu.resume();
      return false;
    }

    /*
     * 화면 복원이 실패해도 **재개는 반드시 시킨다.** 여기까지 왔으면 인터프리터는
     * 이미 되돌아가 있어 되돌릴 수단이 없다 — 던지고 나가면 VM이 복원된 채로
     * 영영 재개되지 않아 게임이 멈춘다. 화면이 어긋난 채로라도 진행하면 다음
     * `DrawScene`/`OutputLine`이 덮어쓴다.
     *
     * 정상 경로에서는 오지 않는다 — 구조가 바뀐 옛 슬롯은 `SaveStore`의 버전에서
     * 이미 걸러진다(save.ts). 손상된 슬롯을 위한 보험이다.
     */
    try {
      renderer.restore(data.scene);
    } catch (error: unknown) {
      console.error("[higu] 화면 복원에 실패했습니다 — 진행은 계속합니다.", error);
    }
    console.info(`[higu] 슬롯 ${slot}을(를) 로드했습니다.`);
    currentRun = higu.resume();
    return true;
  }

  /**
   * 바깥에 내보내는 세이브/로드. **반드시 게이트를 거친다** — 퀵세이브/퀵로드는
   * 키 입력에 매여 있어 사용자가 얼마든지 겹쳐 부를 수 있다.
   */
  const quickSave = (slot: number): Promise<boolean> => serialized(() => saveNow(slot));
  const quickLoad = (slot: number): Promise<boolean> => serialized(() => loadNow(slot));

  const params = new URLSearchParams(location.search);
  const language = params.get("lang") === "jp" ? LANGUAGE.jp : DEFAULT_LANGUAGE;

  /**
   * `?chapter=`/`?jump=` 지름길 (개발 편의 — M7까지의 유일한 진입 방식이었다).
   *
   * 값이 있으면 `TitleScreen()`이 타이틀을 띄우지 않고 VM을 멈추고, 호스트가
   * 그 챕터로 직행한다. **한 번 쓰고 지운다** — 챕터가 끝나면 flow가
   * `JumpSection("Title")`로 돌아오는데, 그때도 세워져 있으면 타이틀이 영영
   * 뜨지 않는다.
   */
  let bootJump: number | undefined;

  higu.useAll(renderer.commands());
  const hostUI = new HostUI({
    // 메뉴는 스테이지에 붙는다 — 게임 화면의 일부이므로 창과 함께 축소돼야 한다.
    host: renderer.stage.root,
    // 챕터 목록은 `flow:Game`의 AST에서 뽑는다 (`chapters.ts`).
    chapters: readChapters(await higu.load(FLOW_SCRIPT)),
    onSound: (name) => renderer.playSystemSound(name),
    bootJump: () => bootJump,
  });
  higu.useAll(hostUI.commands());

  // GlobalFlags는 localStorage에 남으므로(02-interpreter.md §5) 이전 실행의
  // 언어가 그대로 살아난다. flow.txt의 LanguagePrompt는 첫 플레이에만 불리니
  // (GFlag_FirstPlay) 여기서 매번 세워야 `?lang=`이 실제로 듣는다.
  higu.flags.set("GLanguage", language);

  const japanese = () => higu.flags.get("GLanguage") === LANGUAGE.jp;
  const saveLoadPanel = new SaveLoadPanel({ host: renderer.stage.viewport, slots: MAX_SLOTS, japanese: japanese() });

  /**
   * 게임 중 메뉴 (Esc / 우클릭) — 03-renderer.md §10, §11.
   *
   * 세이브/설정 화면은 **호스트의 책임**이므로 렌더러는 부르기만 하고 여기서 연다.
   * 열려 있는 동안 VM은 그대로 서스펜션에 머문다 — 메뉴는 스크립트의 문장이 아니라
   * 그 위에 뜨는 UI이므로 실행을 건드릴 이유가 없다.
   *
   * 겹쳐 열지 않는다. Esc가 키에 매여 있어 사용자가 얼마든지 연타할 수 있다.
   */
  let menuOpen = false;
  async function openGameMenu(): Promise<void> {
    if (menuOpen) return;
    menuOpen = true;
    try {
      const l = japanese() ? MENU_JP : MENU_KO;
      const picked = await gameMenu.show(
        [
          { value: "save", label: l.save },
          { value: "load", label: l.load },
          { value: "config", label: l.config },
        ],
        { armMs: 0, cancellable: true },
      );

      if (picked === "save") {
        // 지금 저장할 수 없는 구간이면 칸을 잠근다 — 눌러 봐야 실패하는 버튼을
        // 보여 줄 이유가 없다 (§7.2).
        const slot = await saveLoadPanel.open("save", saves.list(MAX_SLOTS), higu.canSave);
        if (slot !== undefined) await quickSave(slot);
      } else if (picked === "load") {
        const slot = await saveLoadPanel.open("load", saves.list(MAX_SLOTS));
        if (slot !== undefined) await quickLoad(slot);
      } else if (picked === "config") {
        await configPanel.open();
      }
    } finally {
      menuOpen = false;
    }
  }

  const gameMenu = new MenuOverlay({
    host: renderer.stage.root,
    onSound: (name) => renderer.playSystemSound(name),
  });

  const configPanel = new ConfigPanel({
    host: renderer.stage.viewport,
    policy: higu.policy,
    flags: higu.flags,
    skipToggleMode: {
      get: () => skipToggleMode,
      set: (mode) => (skipToggleMode = mode),
    },
    // 창 불투명도는 렌더러가 즉시 반영해야 한다 — 플래그만 바꾸면 다음 줄까지 안 변한다.
    onOpacity: (percent) => renderer.text.setOpacity(percent),
    japanese: japanese(),
  });

  // 콘솔 API — 세이브 슬롯 UI는 M8의 범위다 (03-renderer.md §11).
  Object.assign(window, {
    higu,
    renderer,
    warnings,
    save: quickSave,
    load: quickLoad,
    saves: () => saves.list(MAX_SLOTS),
  });

  /*
   * `?chapter=`/`?jump=`이 있으면 타이틀을 건너뛴다. `TitleScreen()`이 이 값을
   * 보고 VM을 멈추고(host-ui.ts), 아래에서 호스트가 그 챕터로 잇는다.
   *
   * **한 번 쓰고 지운다** — 챕터가 끝나면 flow는 `JumpSection("Title")`로 돌아오는데,
   * 그때도 세워져 있으면 타이틀이 영영 뜨지 않고 같은 챕터를 다시 시작한다.
   */
  bootJump = resolveJump(params, hostUI.chapters);

  /*
   * **세이브를 로드하더라도 init은 반드시 먼저 돌린다.**
   *
   * init.txt가 세우는 것 중 상당수가 RendererState에 없기 때문이다 — 창 프리셋
   * (`ModADVModeSettingLoad` 등 모드별로), 아트셋/BGM셋 폴백 체인(`ModAddArtset`),
   * GUI 오프셋(`SetGUIPosition`), 화면비(`SetScreenAspect`). RendererState는 "지금
   * 화면에 있는 것"이지 "엔진의 설정"이 아니다(§9).
   *
   * 원본도 같은 순서다 — `BurikoScriptSystem`이 init을 돌린 뒤 세이브를 읽는다.
   *
   * init.txt는 설정 플래그와 창 프리셋을 세운 뒤 스스로 `CallScript("flow")`로
   * 이어진다(§4.4). **타이틀이 실물이 된 뒤로는 여기서 멈추지 않는다** — flow가
   * 타이틀 → 본편 → 타이틀의 루프를 스스로 돌므로 `run()`을 그대로 둔다.
   *
   * **진입점을 명시한다.** 인자 없는 `run()`은 *최초로 `load()`한* 스크립트를
   * 도는데(`HiguScript.entry`는 `??=`로 정해진다), 그러면 부팅 순서가 조용한
   * 결합이 된다 — M8에서 챕터 목록을 읽으려고 flow를 먼저 로드했더니 진입점이
   * flow가 되어 **init이 통째로 건너뛰어졌고**, 화면이 4:3으로 떨어졌다
   * (`SetScreenAspect("0.5625")`가 init에 있다). 이름을 박아 두면 로드 순서가
   * 바뀌어도 안전하다.
   */
  await higu.load(INIT_SCRIPT);
  currentRun = higu.run(INIT_SCRIPT);
  await currentRun;

  const bootSlot = params.get("load");
  // `?load=` 만 있고 값이 없으면 퀵슬롯. `Number(x) || QUICK_SLOT`으로 쓰면 0이
  // falsy라 `?load=0`이 폴백을 타고 넘어간다 — 지금은 값이 같아 안 드러날 뿐이다.
  if (bootSlot !== null && (await quickLoad(bootSlot === "" ? QUICK_SLOT : Number(bootSlot)))) {
    await currentRun;
  } else if (bootJump !== undefined) {
    // 지름길로 왔다 — `TitleScreen()`이 VM을 멈춘 자리에서 이어받는다.
    const jump = bootJump;
    bootJump = undefined;
    currentRun = startChapter(jump);
    await currentRun;
  }
  console.info(`[higu] 종료 (status: ${higu.status})`);

  /**
   * `?chapter=` / `?jump=`을 `Game()`의 `s_jump` 값으로 푼다. 없으면 `undefined` —
   * 그 경우 타이틀이 뜬다.
   *
   * 목록은 `flow:Game`의 AST에서 뽑은 것을 쓴다(`chapters.ts`) — 표로 복사해 두면
   * 원본이 바뀌었을 때 조용히 어긋나고, 타이틀의 챕터 선택과 같은 목록을 봐야 한다.
   */
  function resolveJump(search: URLSearchParams, chapters: readonly ChapterEntry[]): number | undefined {
    const jump = search.get("jump");
    if (jump !== null) {
      const value = Number(jump);
      if (chapters.some((c) => c.jump === value)) return value;
      console.warn(`[higu] ?jump=${jump}은(는) 없는 챕터입니다 — 타이틀로 시작합니다.`);
      return undefined;
    }

    const chapter = search.get("chapter");
    if (chapter === null) return undefined;

    const found = jumpOfScript(chapters, chapter);
    if (found !== undefined) return found;
    console.warn(`[higu] ?chapter=${chapter}은(는) flow:${GAME_SECTION}에 없습니다 — 타이틀로 시작합니다.`);
    return undefined;
  }

  /**
   * 본편 진입 — **`flow`의 `Game()`을 경유한다** (M8).
   *
   * M7까지는 `run("_meak_001")`로 챕터 스크립트에 직행했다. 그러면 `Game()`이
   * 세우는 것을 통째로 건너뛴다:
   *
   * - `SetValidityOfSaving(TRUE)` — **이것 때문에 M7의 세이브/로드 DoD를 목시
   *   검증할 수 없었다.** `flow`는 `main()`/`Title()`에서 세이브를 잠그고
   *   `Game()`이 챕터를 돌리기 직전에야 연다. 직행하면 잠긴 채로 남아 `canSave`가
   *   끝내 열리지 않는다 — 엔진이 아니라 앱의 지름길이 원인이었다.
   * - `SetValidityOfInput(TRUE)`, TIPS 카운터(`NewTipsStart`/`NewTipsCount`/
   *   `TipsCount`) 초기화, BGM 0~3 페이드아웃.
   *
   * `Game()`은 `s_jump <= N` 분기로 재생 시작점을 고르므로(§6), 값을 세우고
   * 섹션째로 부르면 된다. 끝나면 스스로 `JumpSection("Title")`로 돌아간다.
   */
  function startChapter(jump: number): Promise<void> {
    higu.localWork.set("s_jump", jump);
    console.info(`[higu] init 완료 — s_jump=${jump}에서 시작합니다.`);
    return higu.run(FLOW_SCRIPT, GAME_SECTION);
  }
}

boot().catch((error: unknown) => {
  console.error(error);
  const box = document.querySelector<HTMLElement>("#boot-error");
  if (box) {
    box.style.display = "block";
    box.textContent = `부팅에 실패했습니다.\n\n${String(error instanceof Error ? error.stack : error)}`;
  }
});