bdmv2web 0.0.0-stage → 0.1.0

package/dist/runtime/app.bundle.js

@@ -0,0 +1,3515 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // ../hdmv/src/decode.ts
+  var goto = ["NOP", "GOTO", "BREAK"];
+  var jump = ["JUMP_OBJECT", "JUMP_TITLE", "CALL_OBJECT", "CALL_TITLE", "RESUME"];
+  var play = ["PLAY_PL", "PLAY_PL_PI", "PLAY_PL_PM", "TERMINATE_PL", "LINK_PI", "LINK_MK"];
+  var compare = ["", "BC", "EQ", "NE", "GE", "GT", "LE", "LT"];
+  var arithmetic = ["", "MOVE", "SWAP", "ADD", "SUB", "MUL", "DIV", "MOD", "RND", "AND", "OR", "XOR", "BITSET", "BITCLR", "SHL", "SHR"];
+  var system = ["", "SET_STREAM", "SET_NV_TIMER", "SET_BUTTON_PAGE", "ENABLE_BUTTON", "DISABLE_BUTTON", "SET_SEC_STREAM", "POPUP_OFF", "STILL_ON", "STILL_OFF", "SET_OUTPUT_MODE", "SET_STREAM_SS"];
+  function bytesFrom(input) {
+    const fallback = { path: "<raw-command>", origin: "primary", offset: "0" };
+    if (input instanceof Uint8Array) {
+      if (input.length !== 12) throw new RangeError(`HDMV command must be 12 bytes; received ${input.length}`);
+      const bytes2 = [...input].map((x) => x.toString(16).padStart(2, "0")).join("");
+      return { bytes: bytes2, words: [0, 4, 8].map((i) => new DataView(input.buffer, input.byteOffset + i, 4).getUint32(0, false)), source: fallback };
+    }
+    if (typeof input === "string") {
+      const bytes2 = input.replace(/\s|0x/gi, "").toLowerCase();
+      if (!/^[0-9a-f]{24}$/.test(bytes2)) throw new TypeError("HDMV command hex must contain exactly 24 hexadecimal characters");
+      const raw2 = Uint8Array.from(bytes2.match(/../g), (x) => Number.parseInt(x, 16));
+      return bytesFrom(raw2);
+    }
+    const bytes = input.bytes.toLowerCase();
+    if (!/^[0-9a-f]{24}$/.test(bytes)) throw new TypeError("M1 instruction bytes must contain exactly 24 hexadecimal characters");
+    const raw = Uint8Array.from(bytes.match(/../g), (x) => Number.parseInt(x, 16));
+    const words = [0, 4, 8].map((i) => new DataView(raw.buffer, i, 4).getUint32(0, false));
+    if ("words" in input && input.words.some((word, i) => word !== words[i])) throw new TypeError("M1 instruction words do not match its raw bytes");
+    return { bytes, words, source: input.source };
+  }
+  function operand(raw, immediate) {
+    if (immediate) return { kind: "immediate", value: raw >>> 0, raw: raw >>> 0 };
+    const isPsr = (raw & 2147483648) !== 0;
+    const validMask = isPsr ? 2147483775 : 4095;
+    return { kind: isPsr ? "psr" : "gpr", value: raw & (isPsr ? 127 : 4095), raw: raw >>> 0, ...raw & ~validMask ? { invalid: true } : {} };
+  }
+  function decodeInstruction(input, source2) {
+    const raw = bytesFrom(input);
+    const [w0, w1, w2] = raw.words;
+    const opCount = w0 >>> 29;
+    const group = w0 >>> 27 & 3;
+    const subGroup = w0 >>> 24 & 7;
+    const immOp1 = !!(w0 & 8388608);
+    const immOp2 = !!(w0 & 4194304);
+    const branchOption = w0 >>> 16 & 15;
+    const compareOption = w0 >>> 8 & 15;
+    const setOption = w0 & 31;
+    const issues = [];
+    if ((w0 & 3207392) !== 0) issues.push("HDMV_RESERVED_BITS_NONZERO");
+    if (opCount > 2) issues.push("HDMV_INVALID_OPERAND_COUNT");
+    const specialRegisterWords = group === 2 && subGroup === 1 && [1, 3, 6].includes(setOption);
+    const operands = [opCount > 0 ? specialRegisterWords && !immOp1 ? { kind: "encoded", value: w1 >>> 0, raw: w1 >>> 0 } : operand(w1, immOp1) : null, opCount > 1 ? specialRegisterWords && !immOp2 ? { kind: "encoded", value: w2 >>> 0, raw: w2 >>> 0 } : operand(w2, immOp2) : null];
+    const operandRecords = [operands[0], operands[1]].filter((x) => x !== null);
+    if (operandRecords.some((x) => "invalid" in x)) issues.push("HDMV_INVALID_REGISTER_ENCODING");
+    let opcode = null;
+    if (group === 0) opcode = subGroup === 0 ? goto[branchOption] ?? null : subGroup === 1 ? jump[branchOption] ?? null : subGroup === 2 ? play[branchOption] ?? null : null;
+    else if (group === 1) opcode = compare[compareOption] || null;
+    else if (group === 2) opcode = subGroup === 0 ? arithmetic[setOption] || null : subGroup === 1 ? system[setOption] ?? (setOption === 16 ? "SETSYSTEM_0x10" : null) : null;
+    else issues.push("HDMV_UNKNOWN_GROUP");
+    if (!opcode) issues.push("HDMV_UNKNOWN_OPCODE");
+    const expected = opcode === "NOP" || opcode === "BREAK" || opcode === "RESUME" || ["TERMINATE_PL", "POPUP_OFF", "STILL_ON", "STILL_OFF"].includes(opcode ?? "") ? 0 : opcode === "SETSYSTEM_0x10" ? 2 : ["SWAP", "MOVE", "ADD", "SUB", "MUL", "DIV", "MOD", "RND", "AND", "OR", "XOR", "BITSET", "BITCLR", "SHL", "SHR", "BC", "EQ", "NE", "GE", "GT", "LE", "LT", "PLAY_PL_PI", "PLAY_PL_PM", "SET_STREAM", "SET_NV_TIMER", "SET_BUTTON_PAGE", "SET_SEC_STREAM", "SET_STREAM_SS"].includes(opcode ?? "") ? 2 : 1;
+    if (opcode && opCount !== expected) issues.push("HDMV_ILLEGAL_OPERAND_COUNT");
+    if (operands.some((x) => x?.kind === "immediate") && opcode && ["MOVE", "SWAP", "ADD", "SUB", "MUL", "DIV", "MOD", "AND", "OR", "XOR", "BITSET", "BITCLR", "SHL", "SHR"].includes(opcode) && operands[0]?.kind === "immediate") issues.push("HDMV_ILLEGAL_DESTINATION");
+    if (opcode === "RND" && operands[0]?.kind !== "gpr") issues.push("HDMV_ILLEGAL_DESTINATION");
+    return { ...raw, source: source2 ?? raw.source, group, subGroup, opCount, immOp1, immOp2, branchOption, compareOption, setOption, opcode, operands, issues, status: !opcode ? "invalid" : issues.length ? "unverified" : "reference-only" };
+  }
+
+  // ../hdmv/src/registers.ts
+  var GPR_COUNT = 4096;
+  var PSR_COUNT = 128;
+  var READ_ONLY_PSRS = /* @__PURE__ */ new Set([
+    13,
+    // parental level
+    ...Array.from({ length: 7 }, (_, i) => 15 + i),
+    // player settings/capabilities
+    ...Array.from({ length: 9 }, (_, i) => 23 + i),
+    // display/profile capabilities
+    ...Array.from({ length: 14 }, (_, i) => 48 + i)
+    // player capability words
+  ]);
+  var RegisterFault = class extends Error {
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+    }
+  };
+  var RegisterFile = class {
+    constructor(profile = {}) {
+      __publicField(this, "gpr", new Uint32Array(GPR_COUNT));
+      __publicField(this, "psr", new Uint32Array(PSR_COUNT));
+      this.reset(profile);
+    }
+    reset(profile = {}) {
+      this.gpr.fill(0);
+      this.psr.fill(0);
+      const defaults = { 0: 1, 1: 255, 2: 268374015, 3: 1, 4: 65535, 5: 65535, 6: 0, 7: 0, 8: 0, 9: 0, 10: 65535, 11: 0, 12: 255, 13: 255, 14: 65535, 15: 43690, 16: 16777215, 17: 16777215, 18: 16777215, 19: 65535, 20: 2, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 3, 30: 131071, 31: 197120, 36: 65535, 37: 65535, 38: 0, 39: 0, 40: 0, 42: 65535, 43: 0, 44: 255 };
+      for (const [index, value] of Object.entries(defaults)) this.psr[Number(index)] = value;
+      if (profile.audioLanguage !== void 0) this.psr[16] = profileWord(profile.audioLanguage, 3, "audioLanguage");
+      if (profile.subtitleLanguage !== void 0) this.psr[17] = profileWord(profile.subtitleLanguage, 3, "subtitleLanguage");
+      if (profile.menuLanguage !== void 0) this.psr[18] = profileWord(profile.menuLanguage, 3, "menuLanguage");
+      if (profile.country !== void 0) this.psr[19] = profileWord(profile.country, 2, "country");
+      if (profile.region !== void 0) this.psr[20] = regionWord(profile.region);
+      this.psr[21] = uint32(profile.outputPreference ?? defaults[21], "outputPreference");
+      for (let i = 48; i <= 61; i++) this.psr[i] = 4294967295;
+      for (const [index, value] of Object.entries(profile.capabilityValues ?? {})) {
+        const psr = Number(index);
+        if (!(psr === 15 || psr >= 23 && psr <= 31 || psr >= 48 && psr <= 61)) throw new TypeError(`PSR ${psr} is not a player capability/profile register`);
+        this.psr[psr] = uint32(value, `capabilityValues[${psr}]`);
+      }
+    }
+    read(ref) {
+      const slot = ref.kind === "gpr" ? this.gpr : this.psr;
+      if (!Number.isInteger(ref.index) || ref.index < 0 || ref.index >= slot.length) throw new RegisterFault("INVALID_REGISTER_ACCESS", `${ref.kind.toUpperCase()} index ${ref.index} is out of range`);
+      return slot[ref.index];
+    }
+    write(ref, value) {
+      if (!Number.isInteger(value) || value < 0 || value > 4294967295) throw new RegisterFault("INVALID_REGISTER_VALUE", `Register value ${value} is not uint32`);
+      if (ref.kind === "psr") throw new RegisterFault("INVALID_REGISTER_ACCESS", `Program write to PSR ${ref.index} is not permitted`);
+      this.writeSlot(this.gpr, ref.index, value);
+    }
+    /** Apply a runtime/system PSR update using libbluray's writable-register policy. */
+    systemWrite(index, value) {
+      this.validateIndex(this.psr, index, "PSR");
+      if (READ_ONLY_PSRS.has(index)) throw new RegisterFault("INVALID_REGISTER_ACCESS", `System update to read-only PSR ${index} is not permitted`);
+      this.writeSlot(this.psr, index, value);
+    }
+    snapshot() {
+      return { gpr: [...this.gpr], psr: [...this.psr] };
+    }
+    writeSlot(slot, index, value) {
+      this.validateIndex(slot, index);
+      if (!Number.isInteger(value) || value < 0 || value > 4294967295) throw new RegisterFault("INVALID_REGISTER_VALUE", `Register value ${value} is not uint32`);
+      slot[index] = value >>> 0;
+    }
+    validateIndex(slot, index, kind = "Register") {
+      if (!Number.isInteger(index) || index < 0 || index >= slot.length) throw new RegisterFault("INVALID_REGISTER_ACCESS", `${kind} index ${index} is out of range`);
+    }
+  };
+  function profileWord(value, width, name) {
+    if (typeof value === "number") return uint32(value, name);
+    if (value.length !== width || !/^[A-Za-z]+$/.test(value)) throw new TypeError(`${name} must be ${width} ASCII letters or an encoded uint32 PSR word`);
+    let word = 0;
+    for (let i = 0; i < value.length; i += 1) word = word * 256 + value.charCodeAt(i) >>> 0;
+    return word;
+  }
+  function regionWord(value) {
+    if (typeof value === "number") return uint32(value, "region");
+    if (value === "A") return 1;
+    if (value === "B") return 2;
+    if (value === "C") return 4;
+    throw new TypeError("region must be A, B, C, or an encoded uint32 PSR word");
+  }
+  function uint32(value, name) {
+    if (!Number.isInteger(value) || value < 0 || value > 4294967295) throw new TypeError(`${name} must be an unsigned 32-bit integer`);
+    return value;
+  }
+
+  // ../core/dist/defaults.js
+  var DEFAULT_PLAYER_PROFILE = Object.freeze({
+    menuLanguage: "eng",
+    audioLanguage: "eng",
+    subtitleLanguage: "eng",
+    country: "US",
+    region: "A",
+    outputProfile: "portable",
+    videoProfiles: [],
+    audioProfiles: []
+  });
+
+  // ../core/dist/contract-error.js
+  var ContractError = class extends Error {
+    constructor(code, path, message) {
+      super(`${code} at ${path}: ${message}`);
+      __publicField(this, "code");
+      __publicField(this, "path");
+      this.code = code;
+      this.path = path;
+      this.name = "ContractError";
+    }
+  };
+
+  // ../core/dist/limits.js
+  var DEFAULT_LIMITS = Object.freeze({
+    maxReadWindowBytes: 8 * 1024 * 1024,
+    maxSegmentBytes: 16 * 1024 * 1024,
+    maxReassemblyBytes: 64 * 1024 * 1024,
+    maxObjectPixels: 16777216,
+    maxInstructionsPerTurn: 1e4,
+    maxQueueDepth: 1024,
+    maxCallDepth: 128,
+    maxExplorationStates: 1e5,
+    maxOutputBytes: null
+  });
+  function validateLimits(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      throw new ContractError("INVALID_LIMITS", "/", "Limits must be an object");
+    const allowedKeys = new Set(Object.keys(DEFAULT_LIMITS));
+    for (const key of Object.keys(value)) {
+      if (!allowedKeys.has(key))
+        throw new ContractError("INVALID_LIMIT", `/${key}`, "Unknown limit");
+    }
+    const merged = { ...DEFAULT_LIMITS, ...value };
+    for (const [key, v] of Object.entries(merged)) {
+      if (key === "maxOutputBytes" && v === null)
+        continue;
+      const zeroAllowed = (key === "maxCallDepth" || key === "maxQueueDepth") && v === 0;
+      if (typeof v !== "number" || !Number.isSafeInteger(v) || v < 0 || v === 0 && !zeroAllowed)
+        throw new ContractError("INVALID_LIMIT", `/${key}`, "Limit must be a non-negative safe integer for maxCallDepth/maxQueueDepth and a positive safe integer otherwise");
+    }
+    return merged;
+  }
+
+  // ../hdmv/src/vm.ts
+  var EMPTY_DELTA = { gpr: {}, psr: {} };
+  var WAIT_BY_ACTION = { PLAY_PLAYLIST: "ended", PLAY_PLAYLIST_ITEM: "ended", PLAY_PLAYLIST_MARK: "ended" };
+  var COMPARE_OPCODES = /* @__PURE__ */ new Set(["BC", "EQ", "NE", "GE", "GT", "LE", "LT"]);
+  var PSR_TIME_TICKS_PER_SECOND = 45e3;
+  var RANDOM_MULTIPLIER = 6364136223846793005n;
+  var RANDOM_MASK = 0xffffffffffffffffn;
+  function textInstruction(d) {
+    return `${d.opcode ?? "UNKNOWN"} ${d.operands.filter((x) => x !== null).map((x) => x.kind === "immediate" ? `#${x.value}` : `${x.kind}[${x.value}]`).join(",")}`.trim();
+  }
+  var HdmvVm = class {
+    constructor(programs, options = {}) {
+      __publicField(this, "limits");
+      __publicField(this, "registers");
+      __publicField(this, "trace", []);
+      __publicField(this, "actions", []);
+      __publicField(this, "diagnostics", []);
+      __publicField(this, "status", "idle");
+      __publicField(this, "programId", 0);
+      __publicField(this, "pc", 0);
+      __publicField(this, "generation", 0);
+      __publicField(this, "instructionsThisTurn", 0);
+      __publicField(this, "diagnostic", null);
+      __publicField(this, "programs", /* @__PURE__ */ new Map());
+      __publicField(this, "callStack", []);
+      __publicField(this, "continuation", null);
+      __publicField(this, "suspendedPlaylistContinuation", null);
+      __publicField(this, "suspendedPlaylistPlayback", null);
+      __publicField(this, "pendingTitleCall", null);
+      __publicField(this, "titleTransition", false);
+      __publicField(this, "menuCheckpoint", null);
+      __publicField(this, "sequence", 0);
+      __publicField(this, "opts");
+      __publicField(this, "consumedResponses", /* @__PURE__ */ new Set());
+      __publicField(this, "eventQueue", []);
+      __publicField(this, "actionQueue", []);
+      __publicField(this, "profile");
+      __publicField(this, "lastAction");
+      __publicField(this, "instructionDiagnostic", null);
+      __publicField(this, "resumeAfterPlaylistStop", false);
+      __publicField(this, "randomSeed");
+      __publicField(this, "randomState");
+      __publicField(this, "entries");
+      __publicField(this, "onTrace");
+      __publicField(this, "playback", { status: "idle", playlist: null, playItem: null, presentationTime: null, pendingActionId: null });
+      this.limits = Object.freeze(validateLimits(options.limits ?? {
+        ...DEFAULT_LIMITS,
+        ...options.maxInstructionsPerTurn === void 0 ? {} : { maxInstructionsPerTurn: options.maxInstructionsPerTurn },
+        ...options.maxCallDepth === void 0 ? {} : { maxCallDepth: options.maxCallDepth },
+        ...options.maxQueueDepth === void 0 ? {} : { maxQueueDepth: options.maxQueueDepth }
+      }));
+      this.opts = {
+        maxInstructionsPerTurn: this.limits.maxInstructionsPerTurn,
+        maxCallDepth: this.limits.maxCallDepth,
+        maxQueueDepth: this.limits.maxQueueDepth
+      };
+      this.entries = options.entries;
+      this.onTrace = options.onTrace;
+      this.profile = normalizeProfile(options.profile);
+      this.registers = new RegisterFile(this.profile);
+      if (options.limits && [options.maxInstructionsPerTurn, options.maxCallDepth, options.maxQueueDepth].some((value) => value !== void 0)) {
+        const diagnostic = { code: "VM_LIMITS_OVERRIDDEN", message: "The limits object takes precedence over scalar VM limit options.", source: null };
+        this.diagnostics.push(diagnostic);
+        this.record({ source: null, raw: null, decoded: "LIMITS", registerDelta: EMPTY_DELTA, status: "idle", diagnostic });
+      }
+      this.randomSeed = normalizeRandomSeed(options.randomSeed);
+      this.randomState = BigInt(this.randomSeed);
+      for (const p of programs) this.addProgram(p);
+      this.record({ source: null, raw: null, decoded: `RESET profile=${stableProfile(this.profile)} seed=${this.randomSeed}`, registerDelta: EMPTY_DELTA, status: "idle" });
+    }
+    addProgram(program) {
+      const p = program;
+      if (!Number.isInteger(p.id) || p.id < 0) throw new TypeError("Program id must be a non-negative integer");
+      this.programs.set(p.id, { id: p.id, instructions: p.instructions, ...p.resumeIntention !== void 0 ? { resumeIntention: p.resumeIntention } : {}, ...p.menuCallMask !== void 0 ? { menuCallMask: p.menuCallMask } : {}, ...p.titleSearchMask !== void 0 ? { titleSearchMask: p.titleSearchMask } : {} });
+    }
+    reset(programId = 0, profile = this.profile, randomSeed = this.randomSeed) {
+      const seed = normalizeRandomSeed(randomSeed);
+      this.randomSeed = seed;
+      this.randomState = BigInt(seed);
+      this.profile = normalizeProfile(profile);
+      this.registers.reset(this.profile);
+      this.programId = programId;
+      this.pc = 0;
+      this.status = "idle";
+      this.generation++;
+      this.callStack.length = 0;
+      this.continuation = null;
+      this.suspendedPlaylistContinuation = null;
+      this.suspendedPlaylistPlayback = null;
+      this.pendingTitleCall = null;
+      this.titleTransition = false;
+      this.menuCheckpoint = null;
+      this.eventQueue.length = 0;
+      this.actionQueue.length = 0;
+      this.actions.length = 0;
+      this.consumedResponses.clear();
+      this.instructionsThisTurn = 0;
+      this.diagnostic = null;
+      this.lastAction = void 0;
+      this.resumeAfterPlaylistStop = false;
+      this.playback = { status: "idle", playlist: null, playItem: null, presentationTime: null, pendingActionId: null };
+      this.record({ source: null, raw: null, decoded: `RESET profile=${stableProfile(this.profile)} seed=${seed}`, registerDelta: EMPTY_DELTA, status: "idle" });
+    }
+    snapshot() {
+      return { status: this.status, programId: this.programId, pc: this.pc, registers: this.registers.snapshot(), callStack: this.callStack.map((x) => ({ ...x })), playback: { ...this.playback }, generation: this.generation, waiting: this.continuation?.action ?? null, instructionsThisTurn: this.instructionsThisTurn, diagnostic: this.diagnostic };
+    }
+    /** Save all mutable execution state so a navigation branch can resume from this point. */
+    saveCheckpoint() {
+      return structuredClone({
+        status: this.status,
+        programId: this.programId,
+        pc: this.pc,
+        registers: this.registers.snapshot(),
+        callStack: this.callStack,
+        continuation: this.continuation,
+        suspendedPlaylistContinuation: this.suspendedPlaylistContinuation,
+        suspendedPlaylistPlayback: this.suspendedPlaylistPlayback,
+        pendingTitleCall: this.pendingTitleCall,
+        titleTransition: this.titleTransition,
+        menuCheckpoint: this.menuCheckpoint,
+        playback: this.playback,
+        generation: this.generation,
+        instructionsThisTurn: this.instructionsThisTurn,
+        diagnostic: this.diagnostic,
+        sequence: this.sequence,
+        profile: this.profile,
+        lastAction: this.lastAction,
+        resumeAfterPlaylistStop: this.resumeAfterPlaylistStop,
+        randomSeed: this.randomSeed,
+        randomState: this.randomState,
+        consumedResponses: [...this.consumedResponses],
+        eventQueue: this.eventQueue,
+        actionQueue: this.actionQueue,
+        trace: this.trace,
+        actions: this.actions,
+        diagnostics: this.diagnostics
+      });
+    }
+    /** Restore a checkpoint created by this VM's matching program set and options. */
+    restoreCheckpoint(checkpoint) {
+      if (checkpoint.registers.gpr.length !== this.registers.gpr.length || checkpoint.registers.psr.length !== this.registers.psr.length) throw new TypeError("VM checkpoint has incompatible register state");
+      normalizeRandomSeed(checkpoint.randomSeed);
+      const state = structuredClone(checkpoint);
+      this.status = state.status;
+      this.programId = state.programId;
+      this.pc = state.pc;
+      this.registers.gpr.set(state.registers.gpr);
+      this.registers.psr.set(state.registers.psr);
+      this.callStack.splice(0, this.callStack.length, ...state.callStack);
+      this.continuation = state.continuation;
+      this.suspendedPlaylistContinuation = state.suspendedPlaylistContinuation;
+      this.suspendedPlaylistPlayback = state.suspendedPlaylistPlayback;
+      this.pendingTitleCall = state.pendingTitleCall;
+      this.titleTransition = state.titleTransition;
+      this.menuCheckpoint = state.menuCheckpoint;
+      this.playback = state.playback;
+      this.generation = state.generation;
+      this.instructionsThisTurn = state.instructionsThisTurn;
+      this.diagnostic = state.diagnostic;
+      this.sequence = state.sequence;
+      this.profile = state.profile;
+      this.lastAction = state.lastAction;
+      this.resumeAfterPlaylistStop = state.resumeAfterPlaylistStop;
+      this.randomSeed = state.randomSeed;
+      this.randomState = state.randomState;
+      this.consumedResponses.clear();
+      for (const response of state.consumedResponses) this.consumedResponses.add(response);
+      this.eventQueue.splice(0, this.eventQueue.length, ...state.eventQueue);
+      this.actionQueue.splice(0, this.actionQueue.length, ...state.actionQueue);
+      this.trace.splice(0, this.trace.length, ...state.trace);
+      this.actions.splice(0, this.actions.length, ...state.actions);
+      this.diagnostics.splice(0, this.diagnostics.length, ...state.diagnostics);
+    }
+    /** Synchronize the active interactive-graphics page and focus into PSR11/PSR10. */
+    applyMenuContext(pageId, selectedButtonId) {
+      if (!Number.isInteger(pageId) || pageId < 0 || pageId > 255) throw new RangeError("Menu page ID must be an 8-bit unsigned integer");
+      if (selectedButtonId !== null && (!Number.isInteger(selectedButtonId) || selectedButtonId < 0 || selectedButtonId > 65535)) {
+        throw new RangeError("Selected button ID must be a 16-bit unsigned integer or null");
+      }
+      const before = this.registers.snapshot();
+      this.registers.systemWrite(10, selectedButtonId ?? 65535);
+      this.registers.systemWrite(11, pageId);
+      this.record({
+        source: null,
+        raw: null,
+        decoded: `MENU_CONTEXT page=${pageId} button=${selectedButtonId ?? "none"}`,
+        registerDelta: delta(before, this.registers.snapshot()),
+        status: this.status
+      });
+    }
+    /** Capture the live menu context before a user action can transfer control to a feature. */
+    beginMenuAction() {
+      if (this.status === "faulted" || this.status === "stopped") return;
+      this.menuCheckpoint = {
+        programId: this.programId,
+        pc: this.pc,
+        status: this.status,
+        registers: this.registers.snapshot(),
+        callStack: this.callStack.map((frame) => ({ ...frame })),
+        continuation: this.continuation,
+        suspendedPlaylistContinuation: this.suspendedPlaylistContinuation,
+        suspendedPlaylistPlayback: this.suspendedPlaylistPlayback ? { ...this.suspendedPlaylistPlayback } : null,
+        pendingTitleCall: this.pendingTitleCall,
+        titleTransition: this.titleTransition,
+        playback: { ...this.playback },
+        queuedActionIds: new Set(this.actionQueue.map((action) => action.id)),
+        diagnostic: this.diagnostic,
+        randomState: this.randomState,
+        firstAction: this.actions.length,
+        firstDiagnostic: this.diagnostics.length
+      };
+      this.diagnostic = null;
+    }
+    /** Restore the menu without fabricating an external player's completion event. */
+    recoverMenuAction(action) {
+      const saved = this.menuCheckpoint;
+      if (!saved || action && !this.actions.slice(saved.firstAction).some((candidate) => candidate.id === action.id)) return false;
+      this.registers.gpr.set(saved.registers.gpr);
+      this.registers.psr.set(saved.registers.psr);
+      this.programId = saved.programId;
+      this.pc = saved.pc;
+      this.status = saved.status;
+      this.callStack.splice(0, this.callStack.length, ...saved.callStack.map((frame) => ({ ...frame })));
+      this.continuation = saved.continuation;
+      this.suspendedPlaylistContinuation = saved.suspendedPlaylistContinuation;
+      this.suspendedPlaylistPlayback = saved.suspendedPlaylistPlayback ? { ...saved.suspendedPlaylistPlayback } : null;
+      this.pendingTitleCall = saved.pendingTitleCall;
+      this.playback = { ...saved.playback };
+      this.diagnostic = saved.diagnostic;
+      this.resumeAfterPlaylistStop = false;
+      this.lastAction = void 0;
+      this.titleTransition = saved.titleTransition;
+      this.randomState = saved.randomState;
+      if (this.diagnostics.length > saved.firstDiagnostic) this.diagnostics.splice(saved.firstDiagnostic);
+      if (saved.continuation) this.consumedResponses.delete(`${saved.continuation.action.generation}:${saved.continuation.action.id}`);
+      const retained = this.actionQueue.filter((queued) => saved.queuedActionIds.has(queued.id));
+      this.actionQueue.splice(0, this.actionQueue.length, ...retained);
+      this.menuCheckpoint = null;
+      this.record({ source: null, raw: null, decoded: "MENU_ACTION_RECOVERED", registerDelta: EMPTY_DELTA, status: this.status });
+      return true;
+    }
+    /** Execute one selected button's command in the current VM register/object context. Ordinary commands leave PC unchanged; object/title control transfers use the current VM context. GOTO and compare require executeButtonProgram(). The button identity is not an object ID. */
+    executeButtonCommand(command2, source2, context = "object") {
+      if (this.status === "faulted" || this.status === "stopped" || this.inputBlocked()) {
+        const diagnostic = { code: this.status === "suspended" ? "HDMV_INPUT_WHILE_SUSPENDED" : "HDMV_EVENT_AFTER_TERMINAL", message: `Button command rejected while VM is ${this.status}`, source: source2 ?? null };
+        this.record({ source: source2 ?? null, raw: null, decoded: null, registerDelta: EMPTY_DELTA, status: this.status, diagnostic });
+        return { ...this.snapshot(), buttonCommandTerminated: false };
+      }
+      this.resumeAfterPlaylistStop = false;
+      this.instructionsThisTurn = 0;
+      const savedPlaylistContinuation = this.hasPlaylistContinuation() ? this.continuation : null;
+      const before = this.registers.snapshot();
+      const from = { programId: this.programId, pc: this.pc };
+      let d;
+      try {
+        d = decodeInstruction(command2, source2);
+      } catch (error) {
+        this.failButtonProgram("HDMV_INVALID_INSTRUCTION", error instanceof Error ? error.message : String(error), source2 ?? null);
+        return { ...this.snapshot(), buttonCommandTerminated: false };
+      }
+      if (d.status === "invalid" || !d.opcode) {
+        this.failButtonProgram(d.issues[0] ?? "HDMV_UNKNOWN_OPCODE", `Cannot execute ${d.opcode ?? "unknown encoding"}: ${d.issues.join(", ") || d.bytes}`, d.source, d, before, from);
+        return { ...this.snapshot(), buttonCommandTerminated: false };
+      }
+      const program = this.programs.get(this.programId);
+      if (!program) {
+        this.failButtonProgram("HDMV_INVALID_TARGET", `No program/object ${this.programId}`, d.source, d, before, from);
+        return { ...this.snapshot(), buttonCommandTerminated: false };
+      }
+      if (this.instructionsThisTurn >= this.opts.maxInstructionsPerTurn) {
+        this.failButtonProgram("VM_EXECUTION_LIMIT", `Exceeded ${this.opts.maxInstructionsPerTurn} instructions in one turn`, d.source, d, before, from);
+        return { ...this.snapshot(), buttonCommandTerminated: false };
+      }
+      this.instructionsThisTurn++;
+      this.instructionDiagnostic = null;
+      if (d.opcode === "GOTO" || COMPARE_OPCODES.has(d.opcode)) {
+        this.noteIgnoredInstruction("HDMV_BUTTON_COMMAND_REQUIRES_PROGRAM", `${d.opcode} requires a button command sequence; use executeButtonProgram()`, d.source);
+        this.record({ programId: from.programId, pc: from.pc, source: d.source, raw: d.bytes, decoded: textInstruction(d), registerDelta: delta(before, this.registers.snapshot()), status: this.status, ...this.instructionDiagnostic ? { diagnostic: this.instructionDiagnostic } : {} });
+        this.instructionDiagnostic = null;
+        return { ...this.snapshot(), buttonCommandTerminated: false };
+      }
+      let buttonCommandTerminated;
+      if (d.opcode === "BREAK") {
+        buttonCommandTerminated = true;
+        this.record({ programId: from.programId, pc: from.pc, source: d.source, raw: d.bytes, decoded: textInstruction(d), registerDelta: EMPTY_DELTA, status: this.status });
+        return { ...this.snapshot(), buttonCommandTerminated };
+      }
+      if (this.status === "idle") this.status = "running";
+      try {
+        buttonCommandTerminated = this.execute(d, program, context) === true;
+      } catch (error) {
+        this.failButtonProgram(error instanceof RegisterFault ? error.code : "HDMV_EXECUTION_FAULT", error instanceof Error ? error.message : String(error), d.source, d, before, from);
+        return { ...this.snapshot(), buttonCommandTerminated: false };
+      }
+      this.record({ programId: from.programId, pc: from.pc, source: d.source, raw: d.bytes, decoded: textInstruction(d), ...this.lastAction ? { action: this.lastAction } : {}, registerDelta: delta(before, this.registers.snapshot()), status: this.status, ...this.instructionDiagnostic ? { diagnostic: this.instructionDiagnostic } : {} });
+      this.lastAction = void 0;
+      this.instructionDiagnostic = null;
+      if (this.resumeAfterPlaylistStop && this.status === "running") {
+        this.resumeAfterPlaylistStop = false;
+        return { ...this.runTurn(), buttonCommandTerminated };
+      }
+      if (savedPlaylistContinuation && this.continuation === savedPlaylistContinuation && this.status === "running") this.status = "suspended";
+      return { ...this.snapshot(), buttonCommandTerminated };
+    }
+    /** Execute a button's complete command array with a sequence-local PC. */
+    executeButtonProgram(commands, context = "object") {
+      const firstAction = this.actions.length;
+      if (this.status === "faulted" || this.status === "stopped" || this.inputBlocked()) {
+        const diagnostic = { code: this.status === "suspended" ? "HDMV_INPUT_WHILE_SUSPENDED" : "HDMV_EVENT_AFTER_TERMINAL", message: `Button program rejected while VM is ${this.status}`, source: null };
+        this.record({ source: null, raw: null, decoded: null, registerDelta: EMPTY_DELTA, status: this.status, diagnostic });
+        return { ...this.snapshot(), actions: [], terminated: false, buttonCommandTerminated: false, fault: this.status === "faulted" ? this.diagnostic : null };
+      }
+      const ownerProgramId = this.programId;
+      const ownerPc = this.pc;
+      const savedPlaylistContinuation = this.hasPlaylistContinuation() ? this.continuation : null;
+      if (this.status === "suspended") this.status = "running";
+      const program = this.programs.get(ownerProgramId) ?? { id: ownerProgramId, instructions: [] };
+      let pc = 0;
+      let terminated = false;
+      let buttonCommandTerminated = false;
+      this.resumeAfterPlaylistStop = false;
+      this.instructionsThisTurn = 0;
+      if (this.status === "idle") this.status = "running";
+      while (pc < commands.length && this.status === "running") {
+        if (this.instructionsThisTurn >= this.opts.maxInstructionsPerTurn) {
+          this.failButtonProgram("VM_EXECUTION_LIMIT", `Exceeded ${this.opts.maxInstructionsPerTurn} instructions in one turn`, null, void 0, void 0, { programId: ownerProgramId, pc });
+          break;
+        }
+        let d;
+        try {
+          d = decodeInstruction(commands[pc]);
+        } catch (error) {
+          this.failButtonProgram("HDMV_INVALID_INSTRUCTION", error instanceof Error ? error.message : String(error), null, void 0, void 0, { programId: ownerProgramId, pc });
+          break;
+        }
+        const instructionPc = pc;
+        pc += 1;
+        this.instructionsThisTurn++;
+        this.instructionDiagnostic = null;
+        const before = this.registers.snapshot();
+        const [a, b] = d.operands;
+        if (d.status === "invalid" || !d.opcode) {
+          this.failButtonProgram(d.issues[0] ?? "HDMV_UNKNOWN_OPCODE", `Cannot execute ${d.opcode ?? "unknown encoding"}: ${d.issues.join(", ") || d.bytes}`, d.source, d, before, { programId: ownerProgramId, pc: instructionPc });
+          break;
+        }
+        try {
+          if (d.opcode === "GOTO") {
+            pc = a ? this.value(a) : 0;
+          } else if (COMPARE_OPCODES.has(d.opcode)) {
+            const av = a ? this.value(a) : 0;
+            const bv = b ? this.value(b) : 0;
+            if (comparisonSkips(d.opcode, av, bv)) pc += 1;
+          } else if (d.opcode === "BREAK") {
+            terminated = true;
+          } else {
+            buttonCommandTerminated = this.execute(d, program, context) === true;
+            if (buttonCommandTerminated) terminated = true;
+          }
+        } catch (error) {
+          this.failButtonProgram(error instanceof RegisterFault ? error.code : "HDMV_EXECUTION_FAULT", error instanceof Error ? error.message : String(error), d.source, d, before, { programId: ownerProgramId, pc: instructionPc });
+          break;
+        }
+        this.record({ programId: ownerProgramId, pc: instructionPc, source: d.source, raw: d.bytes, decoded: textInstruction(d), ...this.lastAction ? { action: this.lastAction } : {}, registerDelta: delta(before, this.registers.snapshot()), status: this.status, ...this.instructionDiagnostic ? { diagnostic: this.instructionDiagnostic } : {} });
+        this.lastAction = void 0;
+        this.instructionDiagnostic = null;
+        if (terminated || this.status !== "running" || this.programId !== ownerProgramId || this.pc !== ownerPc) break;
+      }
+      if (!terminated && this.status === "running" && pc >= commands.length) terminated = true;
+      if (savedPlaylistContinuation && this.continuation === savedPlaylistContinuation && this.status === "running") this.status = "suspended";
+      if ((!savedPlaylistContinuation || this.continuation !== savedPlaylistContinuation) && this.status === "running" && (this.programId !== ownerProgramId || this.pc !== ownerPc)) this.runTurn();
+      if (this.resumeAfterPlaylistStop && this.status === "running") {
+        this.resumeAfterPlaylistStop = false;
+        this.runTurn();
+      }
+      const snapshot = this.snapshot();
+      return { ...snapshot, actions: this.actions.slice(firstAction), terminated, buttonCommandTerminated, fault: snapshot.status === "faulted" ? snapshot.diagnostic : null };
+    }
+    runTurn() {
+      if (this.status === "faulted" || this.status === "stopped" || this.status === "suspended") return this.snapshot();
+      this.status = "running";
+      this.instructionsThisTurn = 0;
+      while (this.status === "running") {
+        if (this.instructionsThisTurn >= this.opts.maxInstructionsPerTurn) {
+          this.fail("VM_EXECUTION_LIMIT", `Exceeded ${this.opts.maxInstructionsPerTurn} instructions in one turn`, this.currentSource());
+          break;
+        }
+        const program = this.programs.get(this.programId);
+        if (!program) {
+          this.fail("HDMV_INVALID_TARGET", `No program/object ${this.programId}`, null);
+          break;
+        }
+        const row = program.instructions[this.pc];
+        if (!row) {
+          if (this.pc >= program.instructions.length) {
+            this.status = "idle";
+            this.record({ source: null, raw: null, decoded: "PROGRAM_END", registerDelta: EMPTY_DELTA, status: this.status });
+            break;
+          }
+          this.fail("HDMV_INVALID_PC", `PC ${this.pc} is outside object ${this.programId}`, program.instructions.at(-1) ? decodeInstruction(program.instructions.at(-1)).source : null);
+          break;
+        }
+        let d;
+        try {
+          d = decodeInstruction(row);
+        } catch (error) {
+          this.fail("HDMV_INVALID_INSTRUCTION", String(error), null);
+          break;
+        }
+        this.instructionsThisTurn++;
+        const before = this.registers.snapshot();
+        const from = { programId: this.programId, pc: this.pc };
+        this.pc++;
+        this.instructionDiagnostic = null;
+        if (d.status === "invalid" || !d.opcode) {
+          this.fail(d.issues[0] ?? "HDMV_UNKNOWN_OPCODE", `Cannot execute ${d.opcode ?? "unknown encoding"}: ${d.issues.join(", ") || d.bytes}`, d.source, d, before, from);
+          break;
+        }
+        try {
+          this.execute(d, program);
+        } catch (error) {
+          this.fail(error instanceof RegisterFault ? error.code : "HDMV_EXECUTION_FAULT", error instanceof Error ? error.message : String(error), d.source, d, before, from);
+          break;
+        }
+        this.record({ programId: from.programId, pc: from.pc, source: d.source, raw: d.bytes, decoded: textInstruction(d), ...this.lastAction ? { action: this.lastAction } : {}, registerDelta: delta(before, this.registers.snapshot()), status: this.status, ...this.instructionDiagnostic ? { diagnostic: this.instructionDiagnostic } : {} });
+        this.lastAction = void 0;
+        this.instructionDiagnostic = null;
+        if (this.programId !== from.programId || this.pc !== from.pc + 1) {
+        }
+      }
+      return this.snapshot();
+    }
+    /** Resolve a title-search action using the disc index without inventing a media-ended event. */
+    selectTitle(title) {
+      if (this.pendingTitleCall !== null && this.pendingTitleCall !== title) {
+        const diagnostic = { code: "HDMV_TITLE_RESPONSE_MISMATCH", message: `CALL_TITLE is waiting for title ${this.pendingTitleCall}, received title ${title}`, source: null };
+        this.record({ source: null, raw: null, decoded: "TITLE_SEARCH_RESPONSE_IGNORED", registerDelta: EMPTY_DELTA, status: this.status, diagnostic });
+        return this.snapshot();
+      }
+      try {
+        if (!this.entries) throw new RegisterFault("HDMV_UNVERIFIED_OPCODE", "Title navigation requires the disc title table");
+        this.validateTitleTarget(title);
+        const entry = title === 0 ? this.entries.find((item) => item.kind === "topMenu") : title === 65535 ? this.entries.find((item) => item.kind === "firstPlay") : this.entries.filter((item) => item.kind === "title")[title - 1];
+        if (!entry) throw new RegisterFault("HDMV_INVALID_TARGET", `Title ${title} has no index entry`);
+        if (entry.target.objectType === "BDJ") throw new RegisterFault("HDMV_UNVERIFIED_OPCODE", `Title ${title} resolves to unsupported BD-J`);
+        if (entry.target.objectType !== "HDMV" || typeof entry.target.target !== "number") throw new RegisterFault("HDMV_INVALID_TARGET", `Title ${title} has no resolved HDMV object target`);
+        this.validateTarget(entry.target.target, 0);
+        const isCallReturn = this.pendingTitleCall !== null;
+        if (!isCallReturn && this.continuation) {
+          const action = this.continuation.action;
+          this.consumedResponses.add(`${action.generation}:${action.id}`);
+          this.removeAction(action.id);
+        }
+        if (!isCallReturn) this.continuation = null;
+        this.pendingTitleCall = null;
+        this.titleTransition = false;
+        this.playback = { status: "idle", playlist: null, playItem: null, presentationTime: null, pendingActionId: null };
+        const before = this.registers.snapshot();
+        this.registers.systemWrite(4, title);
+        this.programId = entry.target.target;
+        this.pc = 0;
+        this.status = "running";
+        this.record({ source: entry.source, raw: null, decoded: `TITLE_SELECTED title=${title} object=${entry.target.target}`, registerDelta: delta(before, this.registers.snapshot()), status: this.status });
+        return this.runTurn();
+      } catch (error) {
+        const issue = { code: error instanceof RegisterFault ? error.code : "HDMV_EXECUTION_FAULT", message: error instanceof Error ? error.message : String(error), source: null };
+        this.pendingTitleCall = null;
+        this.titleTransition = false;
+        this.diagnostic = issue;
+        this.diagnostics.push(issue);
+        if (this.status === "suspended" && !this.continuation) this.status = "idle";
+        this.record({ source: null, raw: null, decoded: "TITLE_SELECTION_REJECTED", registerDelta: EMPTY_DELTA, status: this.status, diagnostic: issue });
+        return this.snapshot();
+      }
+    }
+    /** Stop waiting for an external player whose playback state is not observable. */
+    releaseExternalPlayback(action) {
+      if (!this.continuation || this.continuation.action.id !== action.id || this.continuation.action.generation !== action.generation) return;
+      this.consumedResponses.add(`${action.generation}:${action.id}`);
+      this.removeAction(action.id);
+      this.continuation = null;
+      if (this.recoverMenuAction(action)) return;
+      this.playback = { status: "idle", playlist: null, playItem: null, presentationTime: null, pendingActionId: null };
+      this.status = "idle";
+      this.record({ source: action.source, raw: null, decoded: "EXTERNAL_PLAYER_HANDOFF", registerDelta: EMPTY_DELTA, status: this.status });
+    }
+    enqueueEvent(event) {
+      if (this.eventQueue.length >= this.opts.maxQueueDepth) {
+        this.fail("VM_QUEUE_LIMIT", `Event queue exceeds ${this.opts.maxQueueDepth}`, null);
+        return;
+      }
+      this.eventQueue.push(event);
+    }
+    drainActions() {
+      return this.actionQueue.splice(0);
+    }
+    processNextEvent() {
+      const event = this.eventQueue.shift();
+      if (event) this.handleEvent(event);
+      return this.snapshot();
+    }
+    handleEvent(event) {
+      if (this.status === "faulted" || this.status === "stopped") {
+        this.record({ source: null, raw: null, decoded: null, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: { code: "HDMV_EVENT_AFTER_TERMINAL", message: `Ignoring ${event.type} after VM entered ${this.status}`, source: null } });
+        return this.snapshot();
+      }
+      if (event.type === "MENU_INPUT" || event.type === "TOP_MENU" || event.type === "POPUP_MENU" || event.type === "RETURN") return this.handleUserEvent(event);
+      if (this.titleTransition && !this.continuation && (event.type === "MEDIA_UNAVAILABLE" || event.type === "MEDIA_ERROR")) {
+        this.titleTransition = false;
+        this.status = "idle";
+        const issue = { code: event.type === "MEDIA_ERROR" ? "HDMV_MEDIA_ERROR" : "HDMV_MEDIA_UNAVAILABLE", message: `Title transition failed: ${event.type}`, source: null };
+        this.diagnostic = issue;
+        this.diagnostics.push(issue);
+        this.record({ source: null, raw: null, decoded: "TITLE_TRANSITION_RELEASED", input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: issue });
+        return this.snapshot();
+      }
+      const pending = this.continuation;
+      const eventKey = event.responseTo ? `${event.generation}:${event.responseTo}` : "";
+      const matchesPending = !!pending && event.generation === pending.action.generation && event.responseTo === pending.action.id;
+      if (event.type === "PLAYITEM_CHANGED" || event.type === "TIME_UPDATED" || event.type === "MEDIA_SEEKED") {
+        this.applyPlaybackStatusEvent(event);
+        const resumesWait = matchesPending && eventMatches(pending.action.waitFor, event.type);
+        if (!resumesWait) {
+          this.record({ source: pending?.action.source ?? null, raw: null, decoded: pending?.action.type ?? null, input: event, event, registerDelta: EMPTY_DELTA, status: this.status });
+          return this.snapshot();
+        }
+      }
+      if (eventKey && this.consumedResponses.has(eventKey)) {
+        this.record({ source: null, raw: null, decoded: null, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: { code: "HDMV_DUPLICATE_EVENT", message: "Response already consumed", source: null } });
+        return this.snapshot();
+      }
+      if (!matchesPending) {
+        this.record({ source: null, raw: null, decoded: null, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: { code: "HDMV_IGNORED_EVENT", message: !pending ? "No continuation is waiting" : "Generation or responseTo does not match current action", source: null } });
+        return this.snapshot();
+      }
+      if (event.type === "MEDIA_STARTED" && pending.action.type.startsWith("PLAY_")) {
+        this.playback.status = "playing";
+        this.record({ source: pending.action.source, raw: null, decoded: pending.action.type, input: event, event, registerDelta: EMPTY_DELTA, status: this.status });
+        return this.snapshot();
+      }
+      if (event.type === "MEDIA_ERROR" || event.type === "MEDIA_UNAVAILABLE") {
+        this.consumedResponses.add(eventKey);
+        this.removeAction(pending.action.id);
+        this.playback.status = event.type === "MEDIA_ERROR" ? "error" : "unavailable";
+        this.playback.pendingActionId = null;
+        this.continuation = null;
+        this.status = "stopped";
+        this.diagnostic = { code: event.type === "MEDIA_ERROR" ? "HDMV_MEDIA_ERROR" : "HDMV_MEDIA_UNAVAILABLE", message: `Action ${pending.action.id} failed: ${event.type}`, source: pending.action.source };
+        this.diagnostics.push(this.diagnostic);
+        this.record({ source: pending.action.source, raw: null, decoded: pending.action.type, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: this.diagnostic });
+        this.recoverMenuAction(pending.action);
+        return this.snapshot();
+      }
+      if (!eventMatches(pending.action.waitFor, event.type)) {
+        this.record({ source: pending.action.source, raw: null, decoded: pending.action.type, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: { code: "HDMV_EVENT_NOT_READY", message: `Waiting for ${pending.action.waitFor}; received ${event.type}`, source: pending.action.source } });
+        return this.snapshot();
+      }
+      this.consumedResponses.add(eventKey);
+      this.removeAction(pending.action.id);
+      const before = this.registers.snapshot();
+      this.continuation = null;
+      this.programId = pending.nextProgramId;
+      this.pc = pending.nextPc;
+      if (event.type === "MEDIA_ENDED") this.playback.status = "ended";
+      this.playback.pendingActionId = null;
+      this.status = "running";
+      this.record({ source: pending.action.source, raw: null, decoded: pending.action.type, input: event, event, registerDelta: delta(before, this.registers.snapshot()), status: this.status });
+      return this.runTurn();
+    }
+    applyPlaybackStatusEvent(event) {
+      if (event.type === "PLAYITEM_CHANGED") {
+        const n = Number(event.payload?.playItem);
+        if (Number.isInteger(n) && n >= 0 && n <= 4294967295) {
+          this.registers.systemWrite(7, n);
+          this.playback.playItem = n;
+          this.playback.status = "playing";
+        }
+        return;
+      }
+      const ticks = playbackTicks(event);
+      if (ticks === null) return;
+      this.registers.systemWrite(8, ticks);
+      this.playback.presentationTime = ticks;
+    }
+    inputBlocked() {
+      return this.titleTransition || this.pendingTitleCall !== null;
+    }
+    handleUserEvent(event) {
+      if (this.inputBlocked()) {
+        this.record({ source: null, raw: null, decoded: null, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: { code: "HDMV_INPUT_WHILE_SUSPENDED", message: "Navigation input is rejected while a title or menu transition is pending", source: null } });
+        return this.snapshot();
+      }
+      try {
+        const program = this.programs.get(this.programId);
+        const source2 = { path: "<user-event>", origin: "primary", offset: "0" };
+        if (event.type === "MENU_INPUT") {
+          if (event.payload?.uoAllowed === false) {
+            this.record({ source: null, raw: null, decoded: null, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: { code: "HDMV_UO_BLOCKED", message: "User operation is prohibited by the current UO mask", source: null } });
+            return this.snapshot();
+          }
+          const target = Number(event.payload?.objectId);
+          if (Number.isInteger(target) && target >= 0 && this.tryTransfer(target, 0, source2)) {
+            if (this.hasPlaylistContinuation()) this.stopPlayingContinuation(this.continuation, source2);
+            this.status = "running";
+            this.runTurn();
+          }
+        } else if (event.type === "TOP_MENU") {
+          if (event.payload?.uoAllowed === false || program?.menuCallMask === true) {
+            this.record({ source: null, raw: null, decoded: null, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: { code: "HDMV_UO_BLOCKED", message: "TOP_MENU is blocked by UO/menu-call mask state", source: null } });
+            return this.snapshot();
+          }
+          this.suspendPlayingForMenuCall();
+          this.emit("TITLE_SEARCH", { title: 0 }, source2);
+          this.status = "suspended";
+          this.titleTransition = true;
+        } else if (event.type === "POPUP_MENU") {
+          if (event.payload?.uoAllowed === false) {
+            this.record({ source: null, raw: null, decoded: null, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: { code: "HDMV_UO_BLOCKED", message: "POPUP_MENU is blocked by UO mask state", source: null } });
+            return this.snapshot();
+          }
+          this.emit("MENU_CALL", {}, source2);
+        } else {
+          if (!this.replayParkedPlayback()) this.emit("MENU_RETURN", {}, source2);
+        }
+        this.record({ source: null, raw: null, decoded: null, ...this.lastAction ? { action: this.lastAction } : {}, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, ...this.instructionDiagnostic ? { diagnostic: this.instructionDiagnostic } : {} });
+        this.lastAction = void 0;
+        this.instructionDiagnostic = null;
+        return this.snapshot();
+      } catch (error) {
+        const code = error instanceof RegisterFault ? error.code : "HDMV_USER_EVENT_FAULT";
+        const message = error instanceof Error ? error.message : String(error);
+        const issue = { code, message, source: null };
+        this.fail(code, message, null);
+        this.record({ source: null, raw: null, decoded: null, input: event, event, registerDelta: EMPTY_DELTA, status: this.status, diagnostic: issue });
+        return this.snapshot();
+      }
+    }
+    execute(d, program, context = "object") {
+      const op = d.opcode;
+      const [a, b] = d.operands;
+      const av = a ? op === "SET_BUTTON_PAGE" ? this.buttonPageValue(a, d.immOp1) : this.value(a) : 0;
+      const bv = b ? op === "SET_BUTTON_PAGE" ? this.buttonPageValue(b, d.immOp2) : this.value(b) : 0;
+      switch (op) {
+        case "NOP":
+          return;
+        case "BREAK":
+          this.pc = program.instructions.length;
+          return;
+        case "GOTO":
+          this.pc = av;
+          return;
+        case "BC":
+          this.skipIf((av & ~bv) !== 0);
+          return;
+        case "EQ":
+          this.skipIf(av !== bv);
+          return;
+        case "NE":
+          this.skipIf(av === bv);
+          return;
+        case "GE":
+          this.skipIf(av < bv);
+          return;
+        case "GT":
+          this.skipIf(av <= bv);
+          return;
+        case "LE":
+          this.skipIf(av > bv);
+          return;
+        case "LT":
+          this.skipIf(av >= bv);
+          return;
+        case "MOVE":
+          this.write(a, bv);
+          return;
+        case "SWAP":
+          this.write(a, bv);
+          this.write(b, av);
+          return;
+        case "ADD":
+          this.write(a, Math.min(4294967295, av + bv));
+          return;
+        case "SUB":
+          this.write(a, av > bv ? av - bv : 0);
+          return;
+        case "MUL":
+          this.write(a, Math.min(4294967295, av * bv));
+          return;
+        case "DIV":
+          this.write(a, bv ? Math.floor(av / bv) : 4294967295);
+          return;
+        case "MOD":
+          this.write(a, bv ? av % bv : 4294967295);
+          return;
+        case "RND":
+          this.write(a, this.nextRandom(bv, d.source));
+          return;
+        case "AND":
+          this.write(a, av & bv);
+          return;
+        case "OR":
+          this.write(a, av | bv);
+          return;
+        case "XOR":
+          this.write(a, av ^ bv);
+          return;
+        case "BITSET":
+        case "BITCLR":
+          if (bv >= 32) throw new RegisterFault("HDMV_ILLEGAL_OPERAND", `Bit index ${bv} exceeds 31`);
+          this.write(a, op === "BITSET" ? av | 1 << bv : av & ~(1 << bv));
+          return;
+        case "SHL":
+        case "SHR":
+          if (bv >= 32) throw new RegisterFault("HDMV_ILLEGAL_OPERAND", `Shift count ${bv} exceeds 31`);
+          this.write(a, op === "SHL" ? av << bv : av >>> bv);
+          return;
+        case "JUMP_OBJECT":
+          if (!this.programs.has(av)) {
+            this.noteIgnoredInstruction("HDMV_INVALID_TARGET", `Target object ${av} does not exist`, d.source);
+            return;
+          }
+          if (context === "ig_object" && this.hasPlaylistContinuation()) this.stopPlayingContinuation(this.continuation, d.source);
+          this.tryTransfer(av, 0, d.source);
+          return;
+        case "CALL_OBJECT": {
+          if (!this.programs.has(av)) {
+            this.noteIgnoredInstruction("HDMV_INVALID_TARGET", `Target object ${av} does not exist`, d.source);
+            return;
+          }
+          if (this.opts.maxCallDepth < 1) throw new RegisterFault("VM_CALL_DEPTH_LIMIT", `Call depth exceeds ${this.opts.maxCallDepth}`);
+          this.saveCallPsrState();
+          const playing = context === "ig_object" && this.hasPlaylistContinuation() ? this.continuation : null;
+          if (playing) {
+            this.suspendedPlaylistContinuation = playing;
+            this.suspendedPlaylistPlayback = { ...this.playback };
+            this.stopPlayingContinuation(playing, d.source);
+            this.callStack.splice(0, this.callStack.length, { programId: playing.nextProgramId, pc: playing.nextPc });
+          } else {
+            this.callStack.splice(0, this.callStack.length, { programId: this.programId, pc: this.pc });
+          }
+          this.tryTransfer(av, 0, d.source);
+          return;
+        }
+        case "RESUME": {
+          const frame = this.callStack.pop();
+          if (!frame) {
+            if (!this.replayParkedPlayback()) this.noteIgnoredInstruction("HDMV_RESUME_WITHOUT_CALL", "RESUME has no saved call context", d.source);
+            return;
+          }
+          this.restoreCallPsrState();
+          this.programId = frame.programId;
+          this.pc = frame.pc;
+          if (this.suspendedPlaylistContinuation) {
+            this.replayParkedPlayback();
+            return;
+          }
+          return;
+        }
+        case "JUMP_TITLE": {
+          if (!this.tryValidateTitle(av, d.source)) return;
+          if (this.hasPlaylistContinuation()) this.stopPlayingContinuation(this.continuation, d.source);
+          this.callStack.length = 0;
+          this.suspendedPlaylistContinuation = null;
+          this.suspendedPlaylistPlayback = null;
+          this.resetCallPsrBackup();
+          this.emit("TITLE_SEARCH", { title: av }, d.source);
+          this.status = "suspended";
+          this.titleTransition = true;
+          return;
+        }
+        case "CALL_TITLE": {
+          if (!this.entries) {
+            this.unsupportedOperation("HDMV_UNVERIFIED_OPCODE", "CALL_TITLE requires a known HDMV title table", d.source);
+            return;
+          }
+          if (!this.tryValidateTitle(av, d.source)) return;
+          const entry = av === 0 ? this.entries.find((item) => item.kind === "topMenu") : av === 65535 ? this.entries.find((item) => item.kind === "firstPlay") : this.entries.filter((item) => item.kind === "title")[av - 1];
+          if (!entry) {
+            this.noteIgnoredInstruction("HDMV_INVALID_TARGET", `CALL_TITLE target ${av} has no index entry`, d.source);
+            return;
+          }
+          if (entry.target.objectType === "BDJ") {
+            this.unsupportedOperation("HDMV_UNVERIFIED_OPCODE", `CALL_TITLE target ${av} resolves to unsupported BD-J`, d.source);
+            return;
+          }
+          if (entry.target.objectType !== "HDMV" || typeof entry.target.target !== "number") {
+            this.noteIgnoredInstruction("HDMV_INVALID_TARGET", `CALL_TITLE target ${av} has no resolved HDMV object target`, d.source);
+            return;
+          }
+          if (!this.programs.has(entry.target.target)) {
+            this.noteIgnoredInstruction("HDMV_INVALID_TARGET", `CALL_TITLE target object ${entry.target.target} does not exist`, d.source);
+            return;
+          }
+          if (this.opts.maxCallDepth < 1) throw new RegisterFault("VM_CALL_DEPTH_LIMIT", `Call depth exceeds ${this.opts.maxCallDepth}`);
+          this.saveCallPsrState();
+          const playing = context === "ig_object" && this.hasPlaylistContinuation() ? this.continuation : null;
+          if (playing) {
+            this.suspendedPlaylistContinuation = playing;
+            this.suspendedPlaylistPlayback = { ...this.playback };
+            this.stopPlayingContinuation(playing, d.source);
+            this.callStack.splice(0, this.callStack.length, { programId: playing.nextProgramId, pc: playing.nextPc });
+          } else {
+            this.callStack.splice(0, this.callStack.length, { programId: this.programId, pc: this.pc });
+          }
+          this.pendingTitleCall = av;
+          this.status = "suspended";
+          this.emit("TITLE_SEARCH", { title: av }, d.source);
+          return;
+        }
+        case "PLAY_PL":
+          if (context !== "object") {
+            this.noteInstructionDiagnostic(op, context, d.source);
+            return;
+          }
+          this.actionAndSuspend("PLAY_PLAYLIST", { playlist: av }, d.source);
+          return;
+        case "PLAY_PL_PI":
+          if (context !== "object") {
+            this.noteInstructionDiagnostic(op, context, d.source);
+            return;
+          }
+          this.actionAndSuspend("PLAY_PLAYLIST_ITEM", { playlist: av, playItem: bv }, d.source);
+          return;
+        case "PLAY_PL_PM":
+          if (context !== "object") {
+            this.noteInstructionDiagnostic(op, context, d.source);
+            return;
+          }
+          this.actionAndSuspend("PLAY_PLAYLIST_MARK", { playlist: av, playMark: bv }, d.source);
+          return;
+        case "LINK_PI":
+          if (context !== "ig_object") {
+            this.noteInstructionDiagnostic(op, context, d.source);
+            return;
+          }
+          this.emit("LINK_PLAY_ITEM", { playItem: av }, d.source);
+          return;
+        case "LINK_MK":
+          if (context !== "ig_object") {
+            this.noteInstructionDiagnostic(op, context, d.source);
+            return;
+          }
+          this.emit("LINK_PLAY_MARK", { playMark: av }, d.source);
+          return;
+        case "TERMINATE_PL": {
+          if (context !== "ig_object") {
+            this.noteInstructionDiagnostic(op, context, d.source);
+            return;
+          }
+          if (this.hasPlaylistContinuation()) this.resumeMovieObjectAfterPlaylistStop(d.source);
+          else this.emit("PLAY_STOP", {}, d.source);
+          return true;
+        }
+        case "SET_STREAM": {
+          const destination = this.streamOperand(a, d.immOp1);
+          const source2 = this.streamOperand(b, d.immOp2);
+          const primaryAudioStream = destination & 2147483648 ? destination >>> 16 & 4095 : null;
+          const interactiveGraphicsStream = source2 & 2147483648 ? source2 >>> 16 & 255 : null;
+          const angle = source2 & 32768 ? source2 & 255 : null;
+          if (primaryAudioStream !== null) this.registers.systemWrite(1, primaryAudioStream);
+          if (interactiveGraphicsStream !== null) this.registers.systemWrite(0, interactiveGraphicsStream);
+          if (angle !== null) this.registers.systemWrite(3, angle);
+          const currentPg = this.registers.read({ kind: "psr", index: 2 });
+          const pgSubtitleStream = destination & 32768 ? destination & 4095 : null;
+          const pgSubtitleDisplay = (destination & 16384) !== 0;
+          const nextPg = ((pgSubtitleDisplay ? 2147483648 : 0) | currentPg & 2147483647 & (pgSubtitleStream === null ? 4294967295 : 4294963200) | (pgSubtitleStream ?? 0)) >>> 0;
+          this.registers.systemWrite(2, nextPg);
+          this.emit("SET_STREAM", {
+            destinationRaw: a?.raw ?? 0,
+            sourceRaw: b?.raw ?? 0,
+            destinationImmediate: d.immOp1,
+            sourceImmediate: d.immOp2,
+            destinationValue: destination,
+            sourceValue: source2,
+            primaryAudioStream,
+            interactiveGraphicsStream,
+            angle,
+            pgSubtitleStream,
+            pgSubtitleDisplay
+          }, d.source);
+          return;
+        }
+        case "SET_SEC_STREAM": {
+          const destination = this.streamOperand(a, d.immOp1);
+          const source2 = this.streamOperand(b, d.immOp2);
+          let psr14 = this.registers.read({ kind: "psr", index: 14 });
+          const secondaryVideoStream = destination & 2147483648 ? destination & 255 : null;
+          const secondaryVideoSize = destination & 8388608 ? destination >>> 16 & 15 : null;
+          const secondaryAudioStream = source2 & 2147483648 ? source2 >>> 16 & 255 : null;
+          if (secondaryVideoStream !== null) psr14 = secondaryVideoStream << 8 | psr14 & 4294902015;
+          if (secondaryVideoSize !== null) psr14 = secondaryVideoSize << 24 | psr14 & 4043309055;
+          if (secondaryAudioStream !== null) psr14 = secondaryAudioStream | psr14 & 4294967040;
+          psr14 = (destination >>> 30 & 1) << 31 | psr14 & 2147483647;
+          psr14 = (source2 >>> 30 & 1) << 30 | psr14 & 3221225471;
+          this.registers.systemWrite(14, psr14 >>> 0);
+          let psr2 = this.registers.read({ kind: "psr", index: 2 });
+          const pipPgStream = source2 & 32768 ? source2 & 4095 : null;
+          if (pipPgStream !== null) psr2 = pipPgStream << 16 | psr2 & 4026597375;
+          const textSubtitleFlags = source2 >>> 13 & 3;
+          psr2 = textSubtitleFlags << 30 | psr2 & 1073741823;
+          this.registers.systemWrite(2, psr2 >>> 0);
+          this.emit("SET_SECONDARY_STREAM", {
+            destinationRaw: a?.raw ?? 0,
+            sourceRaw: b?.raw ?? 0,
+            destinationImmediate: d.immOp1,
+            sourceImmediate: d.immOp2,
+            destinationValue: destination,
+            sourceValue: source2,
+            secondaryVideoStream,
+            secondaryVideoSize,
+            secondaryAudioStream,
+            displayVideo: (destination & 1073741824) !== 0,
+            displayAudio: (source2 & 1073741824) !== 0,
+            pipPgStream,
+            textSubtitleFlags
+          }, d.source);
+          return;
+        }
+        case "SET_NV_TIMER": {
+          const objectId = av & 65535;
+          const timeout = bv & 65535;
+          if (timeout === 0) {
+            this.registers.systemWrite(9, 0);
+            return;
+          }
+          if (timeout > 300 || !this.programs.has(objectId)) return;
+          this.registers.systemWrite(9, timeout);
+          return;
+        }
+        case "SET_BUTTON_PAGE":
+          return this.setButtonPage(av, bv, d.source, context);
+        case "ENABLE_BUTTON":
+          if (context === "ig_object") this.emit("ENABLE_BUTTON", { button: av }, d.source);
+          else this.noteInstructionDiagnostic(op, context, d.source);
+          return;
+        case "DISABLE_BUTTON":
+          if (context === "ig_object") this.emit("DISABLE_BUTTON", { button: av }, d.source);
+          else this.noteInstructionDiagnostic(op, context, d.source);
+          return;
+        case "POPUP_OFF":
+          if (context === "ig_object") this.emit("POPUP_OFF", {}, d.source);
+          else this.noteInstructionDiagnostic(op, context, d.source);
+          return;
+        case "STILL_ON":
+          if (context === "ig_object") this.emit("STILL_ON", {}, d.source);
+          else this.noteInstructionDiagnostic(op, context, d.source);
+          return;
+        case "STILL_OFF":
+          if (context === "ig_object") this.emit("STILL_OFF", {}, d.source);
+          else this.noteInstructionDiagnostic(op, context, d.source);
+          return;
+        case "SET_OUTPUT_MODE": {
+          if ((this.registers.read({ kind: "psr", index: 31 }) & 1245760) !== 1245760) return;
+          const current = this.registers.read({ kind: "psr", index: 22 });
+          this.registers.systemWrite(22, av & 1 ? current | 1 : current & ~1);
+          return;
+        }
+        case "SET_STREAM_SS": {
+          if ((this.registers.read({ kind: "psr", index: 22 }) & 1) === 0) return;
+          this.noteInstructionDiagnostic(op, context, d.source, "3D subtitle alignment is unimplemented by pinned libbluray", "HDMV_3D_SUBTITLE_ALIGNMENT_UNIMPLEMENTED");
+          return;
+        }
+        case "SETSYSTEM_0x10":
+          this.registers.systemWrite(103, av);
+          return;
+        default:
+          throw new RegisterFault("HDMV_UNVERIFIED_OPCODE", `${op} is decoded but is outside the executable subset`);
+      }
+    }
+    value(op) {
+      if (op.kind === "immediate" || op.kind === "encoded") return op.value >>> 0;
+      if (op.invalid) return 0;
+      return this.registers.read({ kind: op.kind, index: op.value });
+    }
+    streamOperand(op, immediate) {
+      if (!op) return 0;
+      if (immediate) return op.raw >>> 0;
+      const encoded = op.raw >>> 0;
+      const flags = encoded & 4026593280;
+      const lowRegister = encoded & 4095;
+      const highRegister = encoded >>> 16 & 4095;
+      const lowValue = this.registers.read({ kind: "gpr", index: lowRegister }) & 4095;
+      const highValue = this.registers.read({ kind: "gpr", index: highRegister }) & 4095;
+      return (flags | lowValue | highValue << 16) >>> 0;
+    }
+    buttonPageValue(op, immediate) {
+      if (immediate) return op.raw >>> 0;
+      const flags = op.raw & 3221225472;
+      const value = this.registers.read({ kind: "gpr", index: op.raw & 4095 }) & 1073741823;
+      return (flags | value) >>> 0;
+    }
+    setButtonPage(destination, source2, location2, context) {
+      if (context === "ig_object") {
+        const packed = (source2 & 3221225472 | (destination & 2147483648) >>> 2 | (source2 & 255) << 16 | destination & 65535) >>> 0;
+        this.emit("SET_BUTTON_PAGE", { packed }, location2);
+        return true;
+      }
+      if (destination & 2147483648) this.registers.systemWrite(10, destination & 65535);
+      if (source2 & 2147483648) this.registers.systemWrite(11, source2 & 255);
+      return false;
+    }
+    hasPlaylistContinuation() {
+      const action = this.continuation?.action;
+      return action?.waitFor === "ended" && (action.type === "PLAY_PLAYLIST" || action.type === "PLAY_PLAYLIST_ITEM" || action.type === "PLAY_PLAYLIST_MARK");
+    }
+    stopPlayingContinuation(playing, source2) {
+      this.removeAction(playing.action.id);
+      this.continuation = null;
+      this.playback = { status: "idle", playlist: null, playItem: null, presentationTime: null, pendingActionId: null };
+      this.emit("PLAY_STOP", {}, source2);
+    }
+    /** Apply bd_menu_call()/hdmv_vm_suspend_pl(): keep the playing position when the MovieObject resume-intention flag is set. */
+    suspendPlayingForMenuCall() {
+      const playing = this.hasPlaylistContinuation() ? this.continuation : null;
+      if (!playing) return;
+      const playback = { ...this.playback };
+      this.removeAction(playing.action.id);
+      this.continuation = null;
+      this.playback = { status: "idle", playlist: null, playItem: null, presentationTime: null, pendingActionId: null };
+      const program = this.programs.get(playing.nextProgramId);
+      if (program?.resumeIntention === true) {
+        this.saveCallPsrState();
+        this.suspendedPlaylistContinuation = playing;
+        this.suspendedPlaylistPlayback = playback;
+        this.callStack.splice(0, this.callStack.length, { programId: playing.nextProgramId, pc: playing.nextPc });
+      }
+      if (this.status === "suspended") this.status = "idle";
+    }
+    /** Re-issue the saved playlist action because the previous action was stopped when the title changed. */
+    replayParkedPlayback() {
+      const parked = this.suspendedPlaylistContinuation;
+      if (!parked) return false;
+      const playback = this.suspendedPlaylistPlayback;
+      this.suspendedPlaylistContinuation = null;
+      this.suspendedPlaylistPlayback = null;
+      this.playback = playback ? { ...playback } : { status: "idle", playlist: null, playItem: null, presentationTime: null, pendingActionId: null };
+      const action = this.emit(parked.action.type, parked.action.payload, parked.action.source);
+      const waitFor = WAIT_BY_ACTION[action.type];
+      if (waitFor) {
+        this.playback.status = "requested";
+        this.playback.pendingActionId = action.id;
+        this.continuation = { action: { ...action, waitFor }, nextProgramId: parked.nextProgramId, nextPc: parked.nextPc };
+        this.status = "suspended";
+      } else {
+        this.continuation = null;
+        this.status = "running";
+      }
+      return true;
+    }
+    resumeMovieObjectAfterPlaylistStop(source2) {
+      const pending = this.continuation;
+      if (!pending || !this.hasPlaylistContinuation()) throw new RegisterFault("HDMV_INVALID_CONTINUATION", "PLAY_STOP has no playlist continuation to resume");
+      this.removeAction(pending.action.id);
+      const responseKey = `${pending.action.generation}:${pending.action.id}`;
+      this.consumedResponses.add(responseKey);
+      this.emit("PLAY_STOP", {}, source2);
+      this.continuation = null;
+      this.programId = pending.nextProgramId;
+      this.pc = pending.nextPc;
+      this.playback.status = "ended";
+      this.playback.pendingActionId = null;
+      this.status = "running";
+      this.resumeAfterPlaylistStop = true;
+    }
+    noteInstructionDiagnostic(opcode, context, source2, detail, code = "HDMV_OPCODE_CONTEXT_SKIPPED") {
+      const message = detail ? `${opcode} is not implemented for ${context} context: ${detail}` : `${opcode} is not valid in ${context} context`;
+      this.instructionDiagnostic = { code, message, source: source2 };
+      this.diagnostics.push(this.instructionDiagnostic);
+    }
+    /** Record a non-fatal instruction outcome; the VM continues with the next command. */
+    noteIgnoredInstruction(code, message, source2) {
+      const issue = { code, message, source: source2 };
+      this.instructionDiagnostic = issue;
+      this.diagnostics.push(issue);
+    }
+    /** Unsupported player capability: report, stop the current run, keep the VM reusable. */
+    unsupportedOperation(code, message, source2) {
+      const issue = { code, message, source: source2 };
+      this.instructionDiagnostic = issue;
+      this.diagnostics.push(issue);
+      this.diagnostic = issue;
+    }
+    tryValidateTitle(title, source2) {
+      try {
+        this.validateTitleTarget(title);
+        return true;
+      } catch (error) {
+        this.noteIgnoredInstruction(error instanceof RegisterFault ? error.code : "HDMV_INVALID_TARGET", error instanceof Error ? error.message : String(error), source2);
+        return false;
+      }
+    }
+    tryTransfer(programId, pc, source2) {
+      const target = this.programs.get(programId);
+      if (!target) {
+        this.noteIgnoredInstruction("HDMV_INVALID_TARGET", `Target object ${programId} does not exist`, source2);
+        return false;
+      }
+      if (!Number.isInteger(pc) || pc < 0 || pc > target.instructions.length) {
+        this.noteIgnoredInstruction("HDMV_INVALID_PC", `Target PC ${pc} is invalid for object ${programId}`, source2);
+        return false;
+      }
+      this.programId = programId;
+      this.pc = pc;
+      this.record({ source: source2, raw: null, decoded: "TRANSFER", registerDelta: EMPTY_DELTA, status: this.status });
+      return true;
+    }
+    applyPlaybackPsrs(payload) {
+      const playlist = typeof payload.playlist === "number" ? payload.playlist : null;
+      if (playlist !== null) this.registers.systemWrite(6, playlist);
+      this.registers.systemWrite(5, 65535);
+      this.registers.systemWrite(7, typeof payload.playItem === "number" ? payload.playItem : 0);
+      this.registers.systemWrite(8, 0);
+    }
+    write(op, value) {
+      if (op.kind !== "gpr" || op.invalid) {
+        this.noteIgnoredInstruction("HDMV_ILLEGAL_OPERAND", `Cannot write result to ${op.kind} operand`, null);
+        return;
+      }
+      this.registers.write({ kind: "gpr", index: op.value }, value >>> 0);
+    }
+    nextRandom(range, source2) {
+      this.randomState = this.randomState * RANDOM_MULTIPLIER + 1n & RANDOM_MASK;
+      if (range === 0) {
+        this.diagnostics.push({ code: "HDMV_RND_ZERO_RANGE", message: "RND range is zero; reference behavior returns 1", source: source2 });
+        return 1;
+      }
+      return Number(this.randomState >> 32n & 0xffffffffn) % range + 1;
+    }
+    skipIf(skip) {
+      if (skip) this.pc++;
+    }
+    saveCallPsrState() {
+      for (let offset = 0; offset < 5; offset += 1) this.registers.systemWrite(36 + offset, this.registers.read({ kind: "psr", index: 4 + offset }));
+      for (let offset = 0; offset < 3; offset += 1) this.registers.systemWrite(42 + offset, this.registers.read({ kind: "psr", index: 10 + offset }));
+    }
+    restoreCallPsrState() {
+      for (let offset = 0; offset < 5; offset += 1) this.registers.systemWrite(4 + offset, this.registers.read({ kind: "psr", index: 36 + offset }));
+      for (let offset = 0; offset < 3; offset += 1) this.registers.systemWrite(10 + offset, this.registers.read({ kind: "psr", index: 42 + offset }));
+      this.resetCallPsrBackup();
+    }
+    resetCallPsrBackup() {
+      const backupDefaults = [65535, 65535, 0, 0, 0, 65535, 0, 255];
+      const backupIndices = [36, 37, 38, 39, 40, 42, 43, 44];
+      backupIndices.forEach((index, offset) => this.registers.systemWrite(index, backupDefaults[offset]));
+    }
+    validateTitleTarget(title) {
+      if (!this.entries) return;
+      const firstPlay = this.entries.find((entry) => entry.kind === "firstPlay")?.target;
+      const topMenu = this.entries.find((entry) => entry.kind === "topMenu")?.target;
+      const titleCount = this.entries.filter((entry) => entry.kind === "title").length;
+      const specialEntryAvailable = (target) => target?.objectType === "HDMV" && typeof target.target === "number" && target.target !== 65535;
+      const valid = title === 0 ? specialEntryAvailable(topMenu) : title === 65535 ? specialEntryAvailable(firstPlay) : title > 0 && title <= titleCount;
+      if (!valid) throw new RegisterFault("HDMV_INVALID_TARGET", `Title target ${title} is not present in the supplied ParsedDisc entries`);
+    }
+    validateTarget(programId, pc) {
+      const target = this.programs.get(programId);
+      if (!target) throw new RegisterFault("HDMV_INVALID_TARGET", `Target object ${programId} does not exist`);
+      if (!Number.isInteger(pc) || pc < 0 || pc > target.instructions.length) throw new RegisterFault("HDMV_INVALID_PC", `Target PC ${pc} is invalid for object ${programId}`);
+    }
+    actionAndSuspend(type, payload, source2) {
+      const action = this.emit(type, payload, source2);
+      const waitFor = WAIT_BY_ACTION[type];
+      if (type.startsWith("PLAY_")) {
+        this.applyPlaybackPsrs(payload);
+        this.playback.status = "requested";
+        this.playback.playlist = typeof payload.playlist === "number" ? payload.playlist : this.playback.playlist;
+        this.playback.playItem = typeof payload.playItem === "number" ? payload.playItem : this.playback.playItem;
+        this.playback.pendingActionId = action.id;
+      }
+      if (waitFor) {
+        this.continuation = { action: { ...action, waitFor }, nextProgramId: this.programId, nextPc: this.pc };
+        this.status = "suspended";
+      }
+    }
+    emit(type, payload, source2) {
+      if (this.actionQueue.length >= this.opts.maxQueueDepth) throw new RegisterFault("VM_QUEUE_LIMIT", `Pending action queue exceeds ${this.opts.maxQueueDepth}`);
+      const generation = ++this.generation;
+      const action = { id: `hdmv-${generation}-${this.sequence + 1}`, type, generation, payload, source: source2, ...WAIT_BY_ACTION[type] ? { waitFor: WAIT_BY_ACTION[type] } : {} };
+      this.actions.push(action);
+      this.actionQueue.push(action);
+      this.lastAction = action;
+      return action;
+    }
+    removeAction(id) {
+      const index = this.actionQueue.findIndex((action) => action.id === id);
+      if (index >= 0) this.actionQueue.splice(index, 1);
+    }
+    currentSource() {
+      const row = this.programs.get(this.programId)?.instructions[this.pc];
+      if (!row) return null;
+      try {
+        return decodeInstruction(row).source;
+      } catch {
+        return null;
+      }
+    }
+    fail(code, message, source2, d, before, location2) {
+      if (this.continuation) this.removeAction(this.continuation.action.id);
+      this.continuation = null;
+      this.pendingTitleCall = null;
+      this.titleTransition = false;
+      this.suspendedPlaylistContinuation = null;
+      this.suspendedPlaylistPlayback = null;
+      this.playback.pendingActionId = null;
+      const issue = { code, message, source: source2 };
+      this.diagnostic = issue;
+      this.diagnostics.push(issue);
+      this.status = code === "HDMV_UNVERIFIED_OPCODE" ? "idle" : "faulted";
+      this.record({ ...location2 ? { programId: location2.programId, pc: location2.pc } : {}, source: source2, raw: d?.bytes ?? null, decoded: d ? textInstruction(d) : null, registerDelta: before ? delta(before, this.registers.snapshot()) : EMPTY_DELTA, status: this.status, diagnostic: issue });
+    }
+    /** Record a fault raised while executing a button (interactive composition) program. libbluray _vm_run() clears only the faulting object (p->object = NULL); the MovieObject waiting for playlist end (playing_object) and any suspended call object stay untouched, so the pending playlist end can still resume the MovieObject. */
+    failButtonProgram(code, message, source2, d, before, location2) {
+      const issue = { code, message, source: source2 };
+      this.diagnostic = issue;
+      this.diagnostics.push(issue);
+      this.status = this.continuation ? "suspended" : "faulted";
+      this.record({ ...location2 ? { programId: location2.programId, pc: location2.pc } : {}, source: source2, raw: d?.bytes ?? null, decoded: d ? textInstruction(d) : null, registerDelta: before ? delta(before, this.registers.snapshot()) : EMPTY_DELTA, status: this.status, diagnostic: issue });
+    }
+    record(entry) {
+      const trace = { sequence: ++this.sequence, generation: this.generation, programId: entry.programId ?? this.programId, pc: entry.pc ?? this.pc, source: entry.source, raw: entry.raw, decoded: entry.decoded, ...entry.input ? { input: entry.input } : {}, ...entry.action ? { action: entry.action } : {}, ...entry.event ? { event: entry.event } : {}, registerDelta: entry.registerDelta, callDepth: this.callStack.length, callStack: this.callStack.map((x) => ({ ...x })), playback: { ...this.playback }, limits: this.limits, status: entry.status, ...entry.diagnostic ? { diagnostic: entry.diagnostic } : {} };
+      this.trace.push(trace);
+      try {
+        this.onTrace?.(trace);
+      } catch {
+      }
+    }
+  };
+  function playbackTicks(event) {
+    const presentationTime = event.payload?.presentationTime;
+    if (typeof presentationTime === "number" && Number.isFinite(presentationTime) && presentationTime >= 0) return Math.min(4294967295, Math.floor(presentationTime));
+    const seconds = event.payload?.mediaTimeSeconds;
+    if (typeof seconds === "number" && Number.isFinite(seconds) && seconds >= 0) return Math.min(4294967295, Math.round(seconds * PSR_TIME_TICKS_PER_SECOND));
+    return null;
+  }
+  function delta(before, after) {
+    const gpr = {}, psr = {};
+    before.gpr.forEach((v, i) => {
+      if (v !== after.gpr[i]) gpr[i] = after.gpr[i];
+    });
+    before.psr.forEach((v, i) => {
+      if (v !== after.psr[i]) psr[i] = after.psr[i];
+    });
+    return { gpr, psr };
+  }
+  function eventMatches(wait, event) {
+    return wait === "started" ? event === "MEDIA_STARTED" : wait === "seeked" ? event === "MEDIA_SEEKED" : wait === "ended" ? event === "MEDIA_ENDED" : wait === "still-completed" ? event === "STILL_COMPLETED" : false;
+  }
+  function comparisonSkips(opcode, a, b) {
+    switch (opcode) {
+      case "BC":
+        return (a & ~b) !== 0;
+      case "EQ":
+        return a !== b;
+      case "NE":
+        return a === b;
+      case "GE":
+        return a < b;
+      case "GT":
+        return a <= b;
+      case "LE":
+        return a > b;
+      case "LT":
+        return a >= b;
+      default:
+        return false;
+    }
+  }
+  function stableProfile(profile) {
+    const normalized = Object.fromEntries(Object.entries(profile).filter(([key]) => key !== "capabilityValues").sort(([a], [b]) => a.localeCompare(b)));
+    if (profile.capabilityValues) normalized.capabilityValues = Object.fromEntries(Object.entries(profile.capabilityValues).sort(([a], [b]) => Number(a) - Number(b)));
+    return JSON.stringify(normalized);
+  }
+  function normalizeProfile(profile) {
+    const defaults = DEFAULT_PLAYER_PROFILE;
+    return {
+      ...defaults,
+      ...profile,
+      videoProfiles: [...profile?.videoProfiles ?? defaults.videoProfiles],
+      audioProfiles: [...profile?.audioProfiles ?? defaults.audioProfiles],
+      ...profile?.capabilityValues ? { capabilityValues: { ...profile.capabilityValues } } : {}
+    };
+  }
+  function normalizeRandomSeed(value) {
+    const seed = value ?? 1;
+    if (!Number.isInteger(seed) || seed < 0 || seed > 4294967295) throw new TypeError("randomSeed must be an unsigned 32-bit integer");
+    return seed;
+  }
+
+  // ../hdmv/src/fixtures.ts
+  var source = { path: "M3-test/MovieObject.bdmv", origin: "primary", offset: "128" };
+  function command(opCount, group, subGroup, imm1, imm2, branch, compare2, set, w1, w2 = 0) {
+    const w0 = ((opCount & 7) << 29 | (group & 3) << 27 | (subGroup & 7) << 24 | Number(imm1) << 23 | Number(imm2) << 22 | (branch & 15) << 16 | (compare2 & 15) << 8 | set & 31) >>> 0;
+    const words = [w0, w1 >>> 0, w2 >>> 0];
+    const bytes = words.map((x) => x.toString(16).padStart(8, "0")).join("");
+    return { words, bytes, source };
+  }
+  var m3Fixtures = {
+    move5: command(2, 2, 0, false, true, 0, 0, 1, 0, 5),
+    add7: command(2, 2, 0, false, true, 0, 0, 3, 0, 7),
+    compareEq7: command(2, 1, 0, false, true, 0, 2, 0, 0, 7),
+    callObject1: command(1, 0, 1, true, false, 2, 0, 0, 1),
+    jumpObject1: command(1, 0, 1, true, false, 0, 0, 0, 1),
+    goto0: command(1, 0, 0, true, false, 1, 0, 0, 0),
+    playPlaylist42: command(1, 0, 2, true, false, 0, 0, 0, 42),
+    linkPlayItem3: command(1, 0, 2, true, false, 4, 0, 0, 3),
+    resume: command(0, 0, 1, false, false, 4, 0, 0, 0),
+    terminatePlaylist: command(0, 0, 2, false, false, 3, 0, 0, 0),
+    popupOff: command(0, 2, 1, false, false, 0, 0, 7, 0),
+    break: command(0, 0, 0, false, false, 2, 0, 0, 0),
+    unknown: command(1, 0, 7, true, false, 0, 0, 0, 9)
+  };
+
+  // src/igs-adapter.ts
+  function selectPopupScene(scenes, clipId, pid, time90k, timeDomain) {
+    const candidates = scenes.filter((scene) => scene.uiModel === 1 && scene.clipId?.toLocaleLowerCase("en-US") === clipId.toLocaleLowerCase("en-US") && scene.pid === pid);
+    if (!candidates.length) return { status: "not-found" };
+    if (time90k !== void 0) {
+      if (!Number.isSafeInteger(time90k) || time90k < 0) throw new RangeError("Popup selection time must be a non-negative 90 kHz timestamp.");
+      const active = candidates.filter((scene) => {
+        const pts = scene.source?.pts90k;
+        return pts !== null && pts !== void 0 && (timeDomain === void 0 || scene.source?.timeDomain === timeDomain) && BigInt(pts) <= BigInt(time90k);
+      });
+      if (!active.length) return { status: "not-found" };
+      const latestPts = active.reduce((latest2, scene) => {
+        const pts = BigInt(scene.source.pts90k);
+        return pts > latest2 ? pts : latest2;
+      }, 0n);
+      const latest = active.filter((scene) => BigInt(scene.source.pts90k) === latestPts);
+      return latest.length === 1 ? { status: "selected", scene: latest[0] } : { status: "ambiguous", scenes: latest };
+    }
+    return candidates.length === 1 ? { status: "selected", scene: candidates[0] } : { status: "ambiguous", scenes: [...candidates] };
+  }
+
+  // src/index.ts
+  var DEFAULT_MENU_INPUT_CONFIG = Object.freeze({ escapeMapping: "popup" });
+  var CanvasViewport = class {
+    constructor(width, height) {
+      this.width = width;
+      this.height = height;
+      __publicField(this, "scale", 1);
+      __publicField(this, "offsetX", 0);
+      __publicField(this, "offsetY", 0);
+    }
+    resize(canvas, cssWidth, cssHeight, dpr) {
+      const scale = Math.min(cssWidth / this.width, cssHeight / this.height);
+      this.scale = scale;
+      this.offsetX = (cssWidth - this.width * scale) / 2;
+      this.offsetY = (cssHeight - this.height * scale) / 2;
+      canvas.width = Math.round(cssWidth * dpr);
+      canvas.height = Math.round(cssHeight * dpr);
+      const context = canvas.getContext("2d");
+      if (context) {
+        context.setTransform(dpr, 0, 0, dpr, 0, 0);
+        context.clearRect(0, 0, cssWidth, cssHeight);
+      }
+    }
+    toSource(clientX, clientY, rect) {
+      const x = (clientX - rect.left - this.offsetX) / this.scale, y = (clientY - rect.top - this.offsetY) / this.scale;
+      return x < 0 || y < 0 || x >= this.width || y >= this.height ? null : { x, y };
+    }
+    toCss(context, cssWidth, cssHeight, dpr = 1) {
+      context.setTransform(dpr, 0, 0, dpr, 0, 0);
+      context.clearRect(0, 0, cssWidth, cssHeight);
+      context.setTransform(dpr * this.scale, 0, 0, dpr * this.scale, dpr * this.offsetX, dpr * this.offsetY);
+    }
+  };
+  var EventScheduler = class {
+    constructor() {
+      __publicField(this, "nowValue", 0);
+      __publicField(this, "nextId", 1);
+      __publicField(this, "events", /* @__PURE__ */ new Map());
+      __publicField(this, "pausedAt", null);
+    }
+    get now() {
+      return this.nowValue;
+    }
+    schedule(delayMs, scope, callback) {
+      if (!Number.isFinite(delayMs) || delayMs < 0) throw new RangeError("delay must be non-negative");
+      const id = this.nextId++;
+      this.events.set(id, { due: this.nowValue + delayMs, scope, callback });
+      return id;
+    }
+    cancelScope(scope) {
+      for (const [id, event] of this.events) if (event.scope === scope) this.events.delete(id);
+    }
+    advance(deltaMs) {
+      if (!Number.isFinite(deltaMs) || deltaMs < 0) throw new RangeError("delta must be non-negative");
+      this.nowValue += deltaMs;
+      while (true) {
+        const due = [...this.events].filter(([, e]) => e.due <= this.nowValue).sort((a, b) => a[1].due - b[1].due || a[0] - b[0])[0];
+        if (!due) break;
+        this.events.delete(due[0]);
+        due[1].callback();
+      }
+    }
+    pause() {
+      this.pausedAt = this.nowValue;
+    }
+    resume() {
+      this.pausedAt = null;
+    }
+    saveCheckpoint() {
+      return { now: this.nowValue, nextId: this.nextId, pausedAt: this.pausedAt, events: [...this.events].map(([id, event]) => [id, { ...event }]) };
+    }
+    restoreCheckpoint(checkpoint) {
+      this.nowValue = checkpoint.now;
+      this.nextId = checkpoint.nextId;
+      this.pausedAt = checkpoint.pausedAt;
+      this.events.clear();
+      for (const [id, event] of checkpoint.events) this.events.set(id, { ...event });
+    }
+    advanceWhileRunning(deltaMs) {
+      if (this.pausedAt === null) this.advance(deltaMs);
+    }
+  };
+  var MenuSoundPlayer = class {
+    constructor(sounds, createAudio, hooks) {
+      this.sounds = sounds;
+      this.createAudio = createAudio;
+      this.hooks = hooks;
+      __publicField(this, "requestId", 0);
+      __publicField(this, "muted", false);
+      __publicField(this, "activeAudio", /* @__PURE__ */ new Set());
+    }
+    setMuted(muted) {
+      this.muted = muted;
+      for (const audio of this.activeAudio) audio.muted = muted;
+    }
+    invalidate() {
+      this.requestId++;
+    }
+    play(soundId, buttonId) {
+      const requestId = ++this.requestId;
+      const url = this.sounds[soundId];
+      if (!url) {
+        this.hooks.report("asset", `Sound ${soundId} for button ${buttonId} has no packaged WAV asset.`);
+        return;
+      }
+      let audio;
+      try {
+        audio = this.createAudio(url);
+      } catch (error) {
+        this.hooks.report("asset", `Could not load sound ${soundId}: ${errorMessage(error)}`);
+        return;
+      }
+      audio.muted = this.muted;
+      this.trackAudio(audio);
+      audio.addEventListener?.("error", () => {
+        if (requestId === this.requestId) this.hooks.report("asset", `Sound ${soundId} asset failed to load (${url}).`);
+      }, { once: true });
+      const start = (retry) => {
+        audio.muted = this.muted;
+        let result;
+        try {
+          result = audio.play();
+        } catch (error) {
+          this.handleFailure(error, soundId, buttonId, url, requestId, audio, retry);
+          return;
+        }
+        Promise.resolve(result).catch((error) => this.handleFailure(error, soundId, buttonId, url, requestId, audio, retry));
+      };
+      start(false);
+    }
+    handleFailure(error, soundId, buttonId, url, requestId, audio, retry) {
+      this.activeAudio.delete(audio);
+      if (requestId !== this.requestId) return;
+      const name = typeof error === "object" && error !== null && "name" in error ? String(error.name) : "";
+      if (name === "NotAllowedError") {
+        if (!this.hooks.isCurrent(soundId, buttonId)) return;
+        this.hooks.report("blocked", `Browser blocked sound ${soundId}; use the retry button to play it.`);
+        this.hooks.offerRetry(() => {
+          if (requestId === this.requestId && this.hooks.isCurrent(soundId, buttonId)) this.handleRetry(audio, soundId, buttonId, url, requestId);
+        });
+      } else if (name === "NotSupportedError") this.hooks.report("unsupported", `Browser does not support packaged sound ${soundId} (${url}).`);
+      else this.hooks.report("playback", `Sound ${soundId} ${retry ? "retry" : "playback"} failed: ${errorMessage(error)}`);
+    }
+    handleRetry(audio, soundId, buttonId, url, requestId) {
+      this.trackAudio(audio);
+      audio.muted = this.muted;
+      let result;
+      try {
+        result = audio.play();
+      } catch (error) {
+        this.handleFailure(error, soundId, buttonId, url, requestId, audio, true);
+        return;
+      }
+      Promise.resolve(result).catch((error) => this.handleFailure(error, soundId, buttonId, url, requestId, audio, true));
+    }
+    trackAudio(audio) {
+      if (!audio.addEventListener) return;
+      this.activeAudio.add(audio);
+      const release = () => this.activeAudio.delete(audio);
+      audio.addEventListener("ended", release, { once: true });
+      audio.addEventListener("error", release, { once: true });
+    }
+  };
+  function errorMessage(error) {
+    return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  }
+  var MenuController = class {
+    constructor(scene, vm, hooks = {}, schedulerOrConfig = new EventScheduler()) {
+      this.scene = scene;
+      this.vm = vm;
+      this.hooks = hooks;
+      __publicField(this, "pageIndex", 0);
+      __publicField(this, "selectedButtonId", null);
+      __publicField(this, "activatedButtonId", null);
+      __publicField(this, "disabled", /* @__PURE__ */ new Set());
+      __publicField(this, "bogSelections", /* @__PURE__ */ new Map());
+      __publicField(this, "scheduler");
+      __publicField(this, "invalidUoMaskPages", /* @__PURE__ */ new Set());
+      __publicField(this, "unsupportedTimeoutActivationPages", /* @__PURE__ */ new Set());
+      __publicField(this, "started", false);
+      __publicField(this, "autoActionDepth", 0);
+      __publicField(this, "inputConfig");
+      __publicField(this, "animationIndices", /* @__PURE__ */ new Map());
+      __publicField(this, "animationElapsedMs", 0);
+      __publicField(this, "paused", false);
+      __publicField(this, "activeEffect", null);
+      if (!scene.pages.length) throw new TypeError("menu scene must contain a page");
+      const scheduler = isMenuScheduler(schedulerOrConfig);
+      this.scheduler = scheduler ? schedulerOrConfig : new EventScheduler();
+      const inputConfig = scheduler ? DEFAULT_MENU_INPUT_CONFIG : { ...DEFAULT_MENU_INPUT_CONFIG, ...schedulerOrConfig };
+      if (!["popup", "topMenu", "custom", "none"].includes(inputConfig.escapeMapping)) throw new TypeError(`Invalid Escape mapping '${String(inputConfig.escapeMapping)}'.`);
+      this.inputConfig = inputConfig;
+      this.selectPageDefault(false);
+    }
+    get page() {
+      return this.scene.pages[this.pageIndex];
+    }
+    get button() {
+      return this.page.buttons.find((b) => b.id === this.selectedButtonId) ?? null;
+    }
+    saveCheckpoint() {
+      if (!this.scheduler.saveCheckpoint || !this.scheduler.restoreCheckpoint) throw new TypeError("Menu scheduler does not support checkpoints");
+      return {
+        pageIndex: this.pageIndex,
+        selectedButtonId: this.selectedButtonId,
+        activatedButtonId: this.activatedButtonId,
+        disabled: [...this.disabled],
+        bogSelections: [...this.bogSelections],
+        invalidUoMaskPages: [...this.invalidUoMaskPages],
+        unsupportedTimeoutActivationPages: [...this.unsupportedTimeoutActivationPages],
+        started: this.started,
+        animationIndices: [...this.animationIndices],
+        animationElapsedMs: this.animationElapsedMs,
+        paused: this.paused,
+        activeEffect: this.activeEffect ? { ...this.activeEffect, frames: [...this.activeEffect.frames], next: [...this.activeEffect.next] } : null,
+        autoActionDepth: this.autoActionDepth,
+        scheduler: this.scheduler.saveCheckpoint()
+      };
+    }
+    restoreCheckpoint(checkpoint) {
+      if (!Number.isInteger(checkpoint.pageIndex) || checkpoint.pageIndex < 0 || checkpoint.pageIndex >= this.scene.pages.length) throw new TypeError("Menu checkpoint has an invalid page index");
+      if (!this.scheduler.restoreCheckpoint) throw new TypeError("Menu scheduler does not support checkpoints");
+      const { scheduler: schedulerCheckpoint, ...state } = checkpoint;
+      this.pageIndex = state.pageIndex;
+      this.selectedButtonId = state.selectedButtonId;
+      this.activatedButtonId = state.activatedButtonId;
+      this.disabled.clear();
+      for (const id of state.disabled) this.disabled.add(id);
+      this.bogSelections.clear();
+      for (const [key, button] of state.bogSelections) this.bogSelections.set(key, button);
+      this.animationIndices = new Map(state.animationIndices);
+      this.animationElapsedMs = state.animationElapsedMs;
+      this.paused = state.paused;
+      this.activeEffect = state.activeEffect ? { ...state.activeEffect, frames: [...state.activeEffect.frames], next: [...state.activeEffect.next] } : null;
+      this.invalidUoMaskPages.clear();
+      for (const page of state.invalidUoMaskPages) this.invalidUoMaskPages.add(page);
+      this.unsupportedTimeoutActivationPages.clear();
+      for (const page of state.unsupportedTimeoutActivationPages) this.unsupportedTimeoutActivationPages.add(page);
+      this.started = state.started;
+      this.autoActionDepth = state.autoActionDepth;
+      this.scheduler.restoreCheckpoint(schedulerCheckpoint);
+    }
+    schedulePageEffect(delayMs, callback) {
+      return this.scheduler.schedule(delayMs, `page:${this.page.id}`, callback);
+    }
+    pause() {
+      this.paused = true;
+      this.scheduler.pause();
+    }
+    resume() {
+      this.paused = false;
+      this.scheduler.resume();
+    }
+    advanceWhileRunning(deltaMs) {
+      this.scheduler.advanceWhileRunning(deltaMs);
+      if (!this.started || this.paused || !Number.isFinite(deltaMs) || deltaMs < 0) return;
+      if (this.activeEffect) {
+        this.advanceEffect(deltaMs);
+        return;
+      }
+      const interval = animationFrameIntervalMs(this.scene.frameRateCode ?? 0, this.page.animationFrameRateCode ?? 0);
+      if (!this.hasActiveAnimation()) return;
+      this.animationElapsedMs += deltaMs;
+      let steps = 0;
+      while ((interval === 0 ? steps === 0 : this.animationElapsedMs >= interval) && steps < 256) {
+        if (interval > 0) this.animationElapsedMs -= interval;
+        this.advanceButtonAnimations();
+        steps++;
+      }
+      if (steps) this.hooks.render?.();
+    }
+    get effectFrame() {
+      return this.activeEffect?.frames[this.activeEffect.index] ?? null;
+    }
+    get isAnimating() {
+      return !!this.activeEffect || this.hasActiveAnimation();
+    }
+    visualState(button) {
+      const state = !button.enabled ? button.states.normal : button.id === this.activatedButtonId ? button.states.activated : button.id === this.selectedButtonId ? button.states.selected : button.states.normal;
+      if (!state || state.startObjectId === void 0 || state.endObjectId === void 0) return state;
+      const index = this.animationIndices.get(button.bog) ?? 0;
+      const objectId = index < 0 && state.endObjectId < 65534 ? state.endObjectId : state.startObjectId + Math.max(0, index);
+      const object = this.page.objects?.get(objectId);
+      if (!object) {
+        const { image: _image, ...withoutImage } = state;
+        return this.page.objects ? withoutImage : state;
+      }
+      return { ...state, image: object.image, bounds: { x: state.bounds.x, y: state.bounds.y, width: object.width, height: object.height } };
+    }
+    start() {
+      if (this.started) return;
+      this.started = true;
+      this.syncMenuContext();
+      this.beginPageEffects([], this.page.effects?.enter ?? [], this.button?.autoAction === true);
+      if (!this.activeEffect && this.button?.autoAction) this.runAutomaticAction(this.button);
+    }
+    syncVmContext() {
+      this.syncMenuContext();
+    }
+    setPage(index) {
+      this.changePage(index, true);
+    }
+    applySetButtonPage(packed) {
+      if (!Number.isInteger(packed) || packed < 0 || packed > 4294967295) {
+        this.hooks.diagnostic?.("VM emitted an invalid SET_BUTTON_PAGE value.");
+        return;
+      }
+      const pageFlag = (packed & 2147483648) !== 0;
+      const effectsFlag = (packed & 1073741824) !== 0;
+      const buttonFlag = (packed & 536870912) !== 0;
+      const pageId = packed >>> 16 & 255;
+      const buttonId = packed & 65535;
+      if (pageFlag) {
+        if (pageId === this.page.id) return;
+        const pageIndex = this.scene.pages.findIndex((page) => page.id === pageId);
+        if (pageIndex < 0) {
+          this.hooks.diagnostic?.(`SET_BUTTON_PAGE references missing page ${pageId}.`);
+          return;
+        }
+        this.changePage(pageIndex, !buttonFlag, !effectsFlag);
+      }
+      if (!buttonFlag) return;
+      if (buttonId === 65535) {
+        this.selectedButtonId = null;
+        this.activatedButtonId = null;
+        this.syncMenuContext();
+        this.hooks.invalidateSound?.();
+        this.hooks.render?.();
+        return;
+      }
+      const target = this.page.buttons.find((button) => button.id === buttonId);
+      if (!target) {
+        this.hooks.diagnostic?.(`SET_BUTTON_PAGE references unusable button ${buttonId} on page ${this.page.id}.`);
+        return;
+      }
+      this.activateBogButton(target);
+    }
+    changePage(index, runAutoAction, playOutEffects = true) {
+      if (!Number.isInteger(index) || index < 0 || index >= this.scene.pages.length) throw new RangeError("page index out of range");
+      const oldPage = this.page;
+      this.scheduler.cancelScope(`page:${oldPage.id}`);
+      this.hooks.invalidateSound?.();
+      this.pageIndex = index;
+      this.activatedButtonId = null;
+      this.selectPageDefault(false);
+      const out = playOutEffects ? oldPage.effects?.exit ?? [] : [];
+      const enter = this.page.effects?.enter ?? [];
+      this.beginPageEffects(out, enter, runAutoAction && this.started);
+      if (!this.activeEffect && runAutoAction && this.started && this.button?.autoAction) this.runAutomaticAction(this.button);
+      this.hooks.render?.();
+    }
+    beginPageEffects(out, enter, pendingAutoAction) {
+      const frames = out.length ? out : enter;
+      this.activeEffect = frames.length ? {
+        frames: [...frames],
+        index: 0,
+        remainingMs: frames[0].duration90k / 90,
+        next: out.length ? [...enter] : [],
+        pendingAutoAction
+      } : null;
+    }
+    advanceEffect(deltaMs) {
+      let remainingDelta = deltaMs;
+      let transitions = 0;
+      while (this.activeEffect && transitions < 512) {
+        const active = this.activeEffect;
+        if (active.remainingMs > remainingDelta) {
+          active.remainingMs -= remainingDelta;
+          break;
+        }
+        remainingDelta = Math.max(0, remainingDelta - active.remainingMs);
+        if (active.index + 1 < active.frames.length) {
+          active.index++;
+          active.remainingMs = active.frames[active.index].duration90k / 90;
+        } else if (active.next.length) {
+          active.frames = active.next;
+          active.next = [];
+          active.index = 0;
+          active.remainingMs = active.frames[0].duration90k / 90;
+        } else {
+          const runAutoAction = active.pendingAutoAction;
+          this.activeEffect = null;
+          if (runAutoAction && this.button?.autoAction) this.runAutomaticAction(this.button);
+        }
+        transitions++;
+        if (remainingDelta === 0 && this.activeEffect?.remainingMs !== 0) break;
+      }
+      this.hooks.render?.();
+    }
+    hasActiveAnimation() {
+      return this.page.buttons.some((button) => {
+        if (!this.isDisplayed(button)) return false;
+        const state = !button.enabled ? button.states.normal : button.id === this.activatedButtonId ? button.states.activated : button.id === this.selectedButtonId ? button.states.selected : button.states.normal;
+        return !!state && (this.animationIndices.get(button.bog) ?? 0) >= 0 && state.endObjectId !== void 0 && state.startObjectId !== void 0 && state.endObjectId > state.startObjectId;
+      });
+    }
+    advanceButtonAnimations() {
+      const visibleBogs = new Set(this.page.buttons.filter((button) => this.isDisplayed(button)).map((button) => button.bog));
+      for (const bog of visibleBogs) {
+        const button = this.page.buttons.find((candidate) => candidate.bog === bog && this.isDisplayed(candidate));
+        if (!button) continue;
+        const state = !button.enabled ? button.states.normal : button.id === this.activatedButtonId ? button.states.activated : button.id === this.selectedButtonId ? button.states.selected : button.states.normal;
+        if (!state || state.startObjectId === void 0 || state.endObjectId === void 0) continue;
+        const range = state.endObjectId - state.startObjectId;
+        if (range <= 0 || state.startObjectId >= 65535 || state.endObjectId >= 65535) continue;
+        const current = this.animationIndices.get(bog) ?? 0;
+        if (current < 0) continue;
+        const next = current + 1;
+        if (state.repeat) this.animationIndices.set(bog, next % (range + 1));
+        else this.animationIndices.set(bog, next > range ? -1 : next);
+      }
+    }
+    setButtonEnabled(id, enabled) {
+      const target = this.page.buttons.find((button) => button.id === id);
+      if (!target) return;
+      if (!this.page.bogDefaults) {
+        enabled ? this.disabled.delete(id) : this.disabled.add(id);
+        if (!enabled && this.selectedButtonId === id) {
+          this.hooks.invalidateSound?.();
+          this.activatedButtonId = null;
+          this.selectedButtonId = null;
+          this.syncMenuContext();
+        }
+        this.hooks.render?.();
+        return;
+      }
+      const key = this.bogSelectionKey(this.page.id, target.bog);
+      const current = this.bogSelections.get(key);
+      if (enabled) {
+        this.animationIndices.set(target.bog, 0);
+        this.bogSelections.set(key, id);
+        if (current === this.selectedButtonId) this.selectButton(id);
+        else if (!this.isUsable(this.button)) {
+          const fallback = this.firstUsablePageButton();
+          if (fallback) this.selectButton(fallback.id);
+        }
+      } else if (current === id) {
+        this.bogSelections.set(key, 65535);
+        if (this.selectedButtonId === id) {
+          this.hooks.invalidateSound?.();
+          this.activatedButtonId = null;
+          this.selectedButtonId = this.firstUsablePageButton()?.id ?? null;
+          this.syncMenuContext();
+        }
+      }
+      this.hooks.render?.();
+    }
+    handle(kind) {
+      if (this.activeEffect) return;
+      if (kind === "escape") {
+        if (!this.isUoAllowed(25)) return;
+        const current = this.button;
+        const hiddenAutoActions = current ? [...new Set(Object.values(current.neighbors))].map((id) => this.page.buttons.find((button2) => button2.id === id)).filter((button2) => !!button2 && this.isUsable(button2) && button2.autoAction === true && button2.commands.length > 0 && button2.states.selected?.bounds === void 0) : [];
+        if (hiddenAutoActions.length === 1) {
+          this.selectButton(hiddenAutoActions[0].id);
+          return;
+        }
+        if (this.inputConfig.escapeMapping === "popup") this.handle("popup");
+        else if (this.inputConfig.escapeMapping === "topMenu") this.handle("topMenu");
+        else if (this.inputConfig.escapeMapping === "custom") this.hooks.escape?.();
+        return;
+      }
+      if (kind === "popup" || kind === "topMenu") {
+        const permission = kind === "popup" ? "popup" : "topMenu";
+        if (this.page.allowedActions?.[permission] === false || !this.isUoAllowed(kind === "popup" ? 24 : 0)) return;
+        this.vm.beginMenuAction?.();
+        if (kind === "popup") {
+          this.hooks.popup?.();
+          this.vm.handleEvent({ type: "POPUP_MENU", channel: "keyboard" });
+        } else {
+          this.hooks.topMenu?.();
+          this.vm.handleEvent({ type: "TOP_MENU", channel: "keyboard" });
+        }
+        this.hooks.dispatchActions?.();
+        return;
+      }
+      if (["up", "down", "left", "right"].includes(kind)) {
+        this.move(kind);
+        return;
+      }
+      if (this.page.allowedActions?.activate === false || !this.isUoAllowed(19)) return;
+      const button = this.button;
+      if (!this.isUsable(button)) return;
+      const activatedPageId = this.page.id;
+      this.syncMenuContext();
+      this.vm.beginMenuAction?.();
+      this.activatedButtonId = button.id;
+      const state = button.states.selected;
+      if (state?.soundId !== void 0 && state.soundId !== 255) this.hooks.playSound?.(state.soundId, button.id);
+      if (this.vm.executeButtonProgram) {
+        try {
+          const commands = button.commands.map(({ bytes, source: source2 }) => {
+            const decoded = decodeInstruction(bytes, source2);
+            return { bytes: decoded.bytes, words: decoded.words, source: decoded.source };
+          });
+          const result = this.vm.executeButtonProgram(commands, "ig_object");
+          if (result.fault?.message) {
+            this.hooks.diagnostic?.(result.fault.message);
+            this.recoverMenuAction();
+          } else if (result.diagnostic?.message) {
+            this.hooks.diagnostic?.(result.diagnostic.message);
+            this.recoverMenuAction();
+          } else this.hooks.dispatchActions?.();
+        } catch (error) {
+          this.recoverMenuAction();
+          this.hooks.diagnostic?.(error instanceof Error ? error.message : String(error));
+        }
+        this.hooks.activateButton?.(activatedPageId, button);
+      } else if (this.vm.executeButtonCommand) {
+        for (const command2 of button.commands) {
+          const result = this.vm.executeButtonCommand(command2.bytes, command2.source, "ig_object");
+          if (result.diagnostic?.message) this.hooks.diagnostic?.(result.diagnostic.message);
+          if (result.status === "faulted" || result.diagnostic?.message) this.recoverMenuAction();
+          else this.hooks.dispatchActions?.();
+          if (result.buttonCommandTerminated || result.status === "faulted" || result.status === "suspended" || result.status === "stopped") break;
+        }
+        this.hooks.activateButton?.(activatedPageId, button);
+      } else if (button.commands.length) this.hooks.diagnostic?.(`Button ${button.id} has commands, but no HDMV button-command executor is connected.`);
+      this.hooks.render?.();
+    }
+    hit(x, y) {
+      const orderedButtons = this.page.bogDefaults ? this.page.bogDefaults.flatMap(({ bog }) => this.page.buttons.filter((button) => button.bog === bog)) : this.page.buttons;
+      return orderedButtons.find((button) => this.isUsable(button) && contains(button.states.selected?.bounds, x, y))?.id ?? null;
+    }
+    selectFromPointer(x, y) {
+      if (!this.isUoAllowed(18)) return false;
+      const id = this.hit(x, y);
+      if (id === null) return false;
+      this.selectButton(id, false);
+      return this.selectedButtonId === id;
+    }
+    activatePointer(x, y) {
+      if (!this.isUoAllowed(20)) return;
+      const hit = this.hit(x, y);
+      if (hit === null) return;
+      const selectionChanged = this.selectedButtonId !== hit;
+      if (selectionChanged && (!this.selectFromPointer(x, y) || this.selectedButtonId !== hit)) return;
+      this.handle("activate");
+    }
+    move(direction) {
+      const fieldIndex = { up: 14, down: 15, left: 16, right: 17 }[direction];
+      if (this.page.allowedActions?.move === false || !this.isUoAllowed(fieldIndex)) return;
+      const current = this.button;
+      if (!this.isUsable(current)) return;
+      const targetId = current.neighbors[direction];
+      const target = this.page.buttons.find((b) => b.id === targetId);
+      if (this.isUsable(target)) this.selectButton(targetId);
+    }
+    isUsable(button) {
+      if (!button || !button.enabled || this.disabled.has(button.id) || !this.isBogEnabled(button)) return false;
+      return !this.page.bogDefaults || this.page.bogDefaults.some((entry) => entry.bog === button.bog);
+    }
+    isBogEnabled(button) {
+      return !this.page.bogDefaults || this.bogSelections.get(this.bogSelectionKey(this.page.id, button.bog)) === button.id;
+    }
+    isDisplayed(button) {
+      return this.isBogEnabled(button);
+    }
+    activateBogButton(button) {
+      this.bogSelections.set(this.bogSelectionKey(this.page.id, button.bog), button.id);
+      this.selectButton(button.id, false);
+      if (button.autoAction && this.selectedButtonId === button.id) this.runAutomaticAction(button);
+      this.hooks.render?.();
+    }
+    firstUsablePageButton() {
+      const declaredDefault = this.page.buttons.find((button) => button.id === this.page.defaultButtonId && this.isUsable(button));
+      return declaredDefault ?? this.page.buttons.find((button) => this.isUsable(button));
+    }
+    bogSelectionKey(pageId, bog) {
+      return `${pageId}:${bog}`;
+    }
+    recoverMenuAction() {
+      if (this.vm.recoverMenuAction?.()) this.syncMenuContext();
+    }
+    isUoAllowed(fieldIndex) {
+      const serialized = this.page.uoMask;
+      if (serialized === void 0) return true;
+      if (!/^(0|[1-9][0-9]*)$/.test(serialized)) {
+        if (!this.invalidUoMaskPages.has(this.page.id)) {
+          this.invalidUoMaskPages.add(this.page.id);
+          this.hooks.diagnostic?.(`Page ${this.page.id} has an invalid decimal UO mask; menu input is blocked.`);
+        }
+        return false;
+      }
+      const sourceBit = 63 - fieldIndex;
+      return (BigInt(serialized) >> BigInt(sourceBit) & 1n) === 0n;
+    }
+    selectButton(id, runAutoAction = true) {
+      const target = this.page.buttons.find((button) => button.id === id);
+      if (!this.isUsable(target)) return;
+      const changed = this.selectedButtonId !== id;
+      if (changed) {
+        this.hooks.invalidateSound?.();
+        this.activatedButtonId = null;
+        this.selectedButtonId = id;
+        this.animationIndices.set(target.bog, 0);
+        this.syncMenuContext();
+        this.hooks.render?.();
+        if (runAutoAction && target.autoAction) this.runAutomaticAction(target);
+      }
+    }
+    selectPageDefault(runAutoAction) {
+      const page = this.page;
+      this.animationIndices = new Map((page.bogDefaults ?? [...new Set(page.buttons.map((button) => button.bog))].map((bog) => ({ bog }))).map(({ bog }) => [bog, 0]));
+      this.animationElapsedMs = 0;
+      const previousSelection = this.selectedButtonId;
+      for (const key of [...this.bogSelections.keys()]) if (key.startsWith(`${page.id}:`)) this.bogSelections.delete(key);
+      for (const entry of page.bogDefaults ?? []) {
+        const member = page.buttons.find((candidate) => candidate.id === entry.defaultButtonId && candidate.bog === entry.bog);
+        if (member) {
+          this.bogSelections.set(this.bogSelectionKey(page.id, entry.bog), member.id);
+          const inertPlaceholder = !member.enabled && !member.autoAction && !member.states.normal && !member.states.selected && !member.commands.length;
+          if (!member.enabled && !inertPlaceholder) this.hooks.diagnostic?.(`Page ${page.id} BOG ${entry.bog} default button ${entry.defaultButtonId} belongs to the BOG but is disabled or has no usable hit geometry.`);
+        } else if (entry.defaultButtonId !== 65535) {
+          this.hooks.diagnostic?.(`Page ${page.id} BOG ${entry.bog} default button ${entry.defaultButtonId} is not a member of that BOG.`);
+        }
+      }
+      const declaredDefault = page.defaultButtonId === 65535 ? void 0 : page.buttons.find((b) => b.id === page.defaultButtonId && this.isUsable(b));
+      const psrSelection = this.vm.snapshot?.().registers.psr[10];
+      const preservedSelection = psrSelection === void 0 ? previousSelection : psrSelection === 65535 ? null : psrSelection;
+      const priorEnabled = preservedSelection === null ? void 0 : page.buttons.find((b) => b.id === preservedSelection && this.isUsable(b));
+      const firstEnabled = page.bogDefaults ? page.buttons.find((b) => this.isUsable(b)) : void 0;
+      const initialSelection = declaredDefault ?? priorEnabled ?? firstEnabled;
+      this.selectedButtonId = initialSelection?.id ?? null;
+      this.activatedButtonId = null;
+      this.syncMenuContext();
+      const defaultActivatedButtonId = page.defaultActivatedButtonId;
+      if (defaultActivatedButtonId !== void 0 && defaultActivatedButtonId !== 65534 && defaultActivatedButtonId !== 65535) {
+        this.hooks.diagnostic?.(`Page ${page.id} declares default activated button ${defaultActivatedButtonId}, but its runtime semantics are unverified.`);
+      }
+      if (defaultActivatedButtonId === 65534 && this.hasSelectionTimeout() && !this.unsupportedTimeoutActivationPages.has(page.id)) {
+        this.unsupportedTimeoutActivationPages.add(page.id);
+        this.hooks.diagnostic?.(`Page ${page.id} requests activation of the selected button after the selection timeout, but timeout activation is not implemented.`);
+      }
+      if (initialSelection) this.bogSelections.set(this.bogSelectionKey(page.id, initialSelection.bog), initialSelection.id);
+      if (runAutoAction && initialSelection?.autoAction) this.runAutomaticAction(initialSelection);
+    }
+    runAutomaticAction(button) {
+      if (this.activeEffect) {
+        this.activeEffect.pendingAutoAction = true;
+        return;
+      }
+      if (this.autoActionDepth >= 32) {
+        this.hooks.diagnostic?.("Menu auto-action chain exceeded 32 nested activations and was stopped.");
+        return;
+      }
+      this.autoActionDepth++;
+      try {
+        this.handle("activate");
+      } finally {
+        this.autoActionDepth--;
+      }
+    }
+    hasSelectionTimeout() {
+      return this.scene.selectionTimeout90k !== null && this.scene.selectionTimeout90k !== void 0 && this.scene.selectionTimeout90k !== "0";
+    }
+    syncMenuContext() {
+      this.vm.applyMenuContext?.(this.page.id, this.selectedButtonId);
+    }
+  };
+  function isMenuScheduler(value) {
+    return typeof value.schedule === "function" && typeof value.cancelScope === "function" && typeof value.pause === "function" && typeof value.resume === "function" && typeof value.advanceWhileRunning === "function" && typeof value.now === "number";
+  }
+  function drawMenu(context, scene, controller, viewport, cssWidth, cssHeight, dpr = 1) {
+    const output = context.canvas;
+    const pageLayer = output?.ownerDocument ? menuPageLayer(output, scene.width, scene.height) : null;
+    const layerContext = pageLayer?.getContext("2d") ?? null;
+    if (layerContext) {
+      layerContext.setTransform(1, 0, 0, 1, 0, 0);
+      layerContext.clearRect(0, 0, scene.width, scene.height);
+      const effect = controller.effectFrame;
+      if (effect) drawEffectFrame(layerContext, effect);
+      else for (const button of controller.page.buttons) {
+        if (!controller.isDisplayed(button)) continue;
+        const state = controller.visualState(button);
+        if (state?.image) layerContext.drawImage(state.image, state.bounds.x, state.bounds.y, state.bounds.width, state.bounds.height);
+      }
+    }
+    viewport.toCss(context, cssWidth, cssHeight, dpr);
+    context.save();
+    context.beginPath();
+    context.rect(0, 0, scene.width, scene.height);
+    context.clip();
+    if (layerContext && pageLayer) context.drawImage(pageLayer, 0, 0, scene.width, scene.height);
+    else if (controller.effectFrame) drawEffectFrame(context, controller.effectFrame);
+    else for (const button of controller.page.buttons) {
+      if (!controller.isDisplayed(button)) continue;
+      const state = controller.visualState(button);
+      if (state?.image) context.drawImage(state.image, state.bounds.x, state.bounds.y, state.bounds.width, state.bounds.height);
+    }
+    context.restore();
+  }
+  function drawEffectFrame(context, frame) {
+    context.clearRect(0, 0, context.canvas.width, context.canvas.height);
+    for (const object of frame.objects) {
+      if (object.crop) context.drawImage(object.image, object.crop.x, object.crop.y, object.crop.width, object.crop.height, object.x, object.y, object.crop.width, object.crop.height);
+      else context.drawImage(object.image, object.x, object.y, object.width, object.height);
+    }
+  }
+  function animationFrameIntervalMs(videoFrameRateCode, animationFrameRateCode) {
+    const frameTicks = [0, 9e4 / 1001 * 24, 9e4 / 1e3 * 24, 9e4 / 1e3 * 25, 9e4 / 1001 * 30, 9e4 / 1e3 * 50, 9e4 / 1001 * 60, 0][videoFrameRateCode] ?? 0;
+    return frameTicks * (animationFrameRateCode + 1) / 90;
+  }
+  var menuPageLayers = /* @__PURE__ */ new WeakMap();
+  function menuPageLayer(output, width, height) {
+    let layer = menuPageLayers.get(output);
+    if (!layer) {
+      layer = output.ownerDocument.createElement("canvas");
+      menuPageLayers.set(output, layer);
+    }
+    if (layer.width !== width) layer.width = width;
+    if (layer.height !== height) layer.height = height;
+    return layer;
+  }
+  function contains(b, x, y) {
+    return !!b && x >= b.x && y >= b.y && x < b.x + b.width && y < b.y + b.height;
+  }
+  var PreviewPlaybackBridge = class {
+    constructor(vm, report) {
+      this.vm = vm;
+      this.report = report;
+      __publicField(this, "currentGeneration", 0);
+    }
+    dispatch(action) {
+      this.currentGeneration = Math.max(this.currentGeneration, action.generation);
+      if (["PLAY_PLAYLIST", "PLAY_PLAYLIST_ITEM", "PLAY_PLAYLIST_MARK", "LINK_PLAY_ITEM", "LINK_PLAY_MARK", "TITLE_SEARCH"].includes(action.type)) {
+        this.report(`Playback unavailable in menu preview (${action.type}).`);
+        this.vm.handleEvent({ type: "MEDIA_UNAVAILABLE", generation: action.generation, responseTo: action.id });
+      } else if (action.type === "MENU_CALL") {
+        this.report("Popup composition is unavailable because this package does not have an in-browser title overlay context.");
+      } else if (["STILL_ON", "STILL_OFF", "MENU_RETURN"].includes(action.type)) {
+        this.report(`${action.type} is not available in menu preview.`);
+      }
+    }
+    isCurrent(generation) {
+      return generation === this.currentGeneration;
+    }
+  };
+  var MenuLoopPlaybackBridge = class {
+    constructor(vm, video, audio, media, report, hooks = {}, playlistMedia = []) {
+      this.vm = vm;
+      this.video = video;
+      this.audio = audio;
+      this.media = media;
+      this.report = report;
+      this.hooks = hooks;
+      __publicField(this, "currentGeneration", 0);
+      __publicField(this, "selectedAudioStream");
+      __publicField(this, "confirmedPrimaryAudioStream");
+      __publicField(this, "switchSequence", 0);
+      __publicField(this, "mediaSequence", 0);
+      __publicField(this, "started", false);
+      __publicField(this, "startPromise", null);
+      __publicField(this, "retryGeneration", 0);
+      __publicField(this, "activePlaylistResponse", null);
+      __publicField(this, "lastTimeUpdateSecond", -1);
+      __publicField(this, "activeMedia");
+      __publicField(this, "playlistMedia");
+      this.playlistMedia = playlistMedia;
+      this.activeMedia = media ?? null;
+      this.confirmedPrimaryAudioStream = vm.registers.read({ kind: "psr", index: 1 });
+      this.selectedAudioStream = media ? this.pickAudioStream(media) : 0;
+      this.video.addEventListener?.("ended", () => {
+        if (this.activeMedia?.background.loop) return;
+        const response = this.activePlaylistResponse;
+        if (!response) return;
+        this.activePlaylistResponse = null;
+        this.vm.handleEvent({ type: "MEDIA_ENDED", generation: response.generation, responseTo: response.id });
+      });
+      this.video.addEventListener?.("timeupdate", () => {
+        const response = this.activePlaylistResponse;
+        if (!response) return;
+        const second = Math.floor(this.video.currentTime);
+        if (second === this.lastTimeUpdateSecond) return;
+        this.lastTimeUpdateSecond = second;
+        this.vm.handleEvent({ type: "TIME_UPDATED", generation: response.generation, responseTo: response.id, payload: { presentationTime: Math.max(0, Math.round(this.video.currentTime * 45e3)) } });
+      });
+    }
+    async dispatch(action) {
+      if (action.generation < this.currentGeneration) return;
+      if (action.generation > this.currentGeneration) this.switchSequence++;
+      this.currentGeneration = Math.max(this.currentGeneration, action.generation);
+      if (action.type === "SET_STREAM") {
+        const stream = action.payload?.primaryAudioStream;
+        if (typeof stream === "number" && stream > 0) await this.selectAudioStream(stream, action.generation);
+        return;
+      }
+      if (action.type === "PLAY_STOP") {
+        this.stopMedia();
+        return;
+      }
+      if (["LINK_PLAY_ITEM", "LINK_PLAY_MARK", "STILL_ON", "STILL_OFF", "MENU_RETURN"].includes(action.type)) {
+        const target2 = action.type === "LINK_PLAY_ITEM" ? action.payload?.playItem : action.type === "LINK_PLAY_MARK" ? action.payload?.playMark : void 0;
+        this.report(`${action.type}${typeof target2 === "number" ? ` ${target2}` : ""} is not available in the packaged menu loop.`);
+        return;
+      }
+      if (action.type !== "PLAY_PLAYLIST" && action.type !== "PLAY_PLAYLIST_ITEM" && action.type !== "PLAY_PLAYLIST_MARK") return;
+      const playlist = action.payload?.playlist;
+      if (typeof playlist !== "number") {
+        this.report("Playback unavailable in menu preview (PLAY_PLAYLIST without a numeric playlist).");
+        this.vm.handleEvent({ type: "MEDIA_UNAVAILABLE", generation: action.generation, responseTo: action.id });
+        return;
+      }
+      const target = this.findMedia(playlist, this.playItemFor(playlist, action));
+      if (!target) {
+        this.report(`Playback unavailable in menu preview (PLAY_PLAYLIST ${String(playlist)}).`);
+        this.vm.handleEvent({ type: "MEDIA_UNAVAILABLE", generation: action.generation, responseTo: action.id });
+        return;
+      }
+      if (!target.background.path) {
+        this.report("Menu background playback assets are unavailable.");
+        this.vm.handleEvent({ type: "MEDIA_UNAVAILABLE", generation: action.generation, responseTo: action.id });
+        return;
+      }
+      const response = { id: action.id, generation: action.generation };
+      if (target !== this.activeMedia) {
+        await this.switchMedia(target, response);
+        return;
+      }
+      this.activePlaylistResponse = response;
+      const started = await this.startMedia(response);
+      if (!started && this.activePlaylistResponse === response) this.activePlaylistResponse = null;
+    }
+    isCurrent(generation) {
+      return generation === this.currentGeneration;
+    }
+    get selectedPrimaryAudioStream() {
+      const track = this.findAudioTrack(this.selectedAudioStream);
+      return track ? this.psrStreamNumber(track) : null;
+    }
+    /** Starts the local menu loop from the Start gesture when Top Menu emits no matching PLAY_PL action. */
+    async startMenuBackground() {
+      if (!this.media?.background.path) {
+        this.report("Menu background playback assets are unavailable.");
+        return false;
+      }
+      if (this.activeMedia !== this.media) {
+        this.mediaSequence++;
+        this.activeMedia = this.media;
+        this.selectedAudioStream = this.pickAudioStream(this.media);
+        this.started = false;
+        this.startPromise = null;
+        this.activePlaylistResponse = null;
+      }
+      return this.startMedia();
+    }
+    async startMedia(response) {
+      const mediaSequence = this.mediaSequence;
+      const media = this.activeMedia;
+      if (this.started) {
+        this.hooks.clearRetry?.();
+        const audioTrack = this.findAudioTrack(this.selectedAudioStream);
+        if (this.video.paused || audioTrack && this.audio.paused) {
+          try {
+            await Promise.all([this.video.play(), ...audioTrack ? [this.audio.play()] : []]);
+          } catch (error) {
+            const name = typeof error === "object" && error !== null && "name" in error ? String(error.name) : "";
+            const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+            if (name === "NotAllowedError") {
+              this.report(`Browser blocked menu media playback; use the retry button to start it. (${message})`);
+              const retryGeneration = ++this.retryGeneration;
+              this.hooks.offerRetry?.(() => {
+                if (retryGeneration !== this.retryGeneration || response && !this.isPending(response)) return;
+                void this.startMedia(response);
+              });
+              return false;
+            }
+            this.report(`Menu media could not resume: ${message}`);
+            if (response) this.vm.handleEvent({ type: "MEDIA_ERROR", generation: response.generation, responseTo: response.id, payload: { message } });
+            return false;
+          }
+        }
+        if (response) {
+          this.activePlaylistResponse = response;
+          this.vm.handleEvent({ type: "MEDIA_STARTED", generation: response.generation, responseTo: response.id });
+        }
+        return true;
+      }
+      if (!this.startPromise) {
+        if (!media) return false;
+        const audioTrack = this.findAudioTrack(this.selectedAudioStream);
+        this.video.loop = media.background.loop;
+        this.video.src = media.background.path;
+        if (audioTrack) {
+          this.audio.loop = media.background.loop;
+          this.audio.src = audioTrack.path;
+        }
+        const attempt2 = Promise.resolve().then(() => Promise.all([this.video.play(), ...audioTrack ? [this.audio.play()] : []])).then(() => {
+          if (this.mediaSequence !== mediaSequence || this.activeMedia !== media) return false;
+          this.started = true;
+          this.retryGeneration++;
+          this.hooks.clearRetry?.();
+          return true;
+        }).catch((error) => {
+          if (this.mediaSequence !== mediaSequence || this.activeMedia !== media) return false;
+          const name = typeof error === "object" && error !== null && "name" in error ? String(error.name) : "";
+          const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+          if (name === "NotAllowedError") {
+            this.report(`Browser blocked menu media playback; use the retry button to start it. (${message})`);
+            const retryGeneration = ++this.retryGeneration;
+            this.hooks.offerRetry?.(() => {
+              if (retryGeneration !== this.retryGeneration || response && !this.isPending(response)) return;
+              void this.startMedia(response);
+            });
+            return false;
+          }
+          this.retryGeneration++;
+          this.hooks.clearRetry?.();
+          this.report(name === "NotSupportedError" ? `Menu media format is not supported: ${message}` : `Menu media could not start: ${message}`);
+          if (response) this.vm.handleEvent({ type: "MEDIA_ERROR", generation: response.generation, responseTo: response.id, payload: { message } });
+          return false;
+        });
+        this.startPromise = attempt2;
+      }
+      const attempt = this.startPromise;
+      const started = await attempt;
+      if (this.startPromise === attempt && !started) this.startPromise = null;
+      if (started && response) {
+        this.activePlaylistResponse = response;
+        this.vm.handleEvent({ type: "MEDIA_STARTED", generation: response.generation, responseTo: response.id });
+      }
+      return started;
+    }
+    /** Swap the local video/audio source while the VM keeps its current generation. */
+    async switchMedia(target, response) {
+      this.switchSequence++;
+      this.mediaSequence++;
+      this.activeMedia = target;
+      this.selectedAudioStream = this.pickAudioStream(target);
+      this.started = false;
+      this.startPromise = null;
+      this.activePlaylistResponse = response;
+      this.lastTimeUpdateSecond = -1;
+      this.video.pause();
+      this.audio.pause();
+      try {
+        this.video.currentTime = 0;
+        this.audio.currentTime = 0;
+      } catch {
+      }
+      const started = await this.startMedia(response);
+      if (!started && this.activePlaylistResponse === response) this.activePlaylistResponse = null;
+    }
+    findMedia(playlist, playItem = 0) {
+      const candidates = [this.media, ...this.playlistMedia].filter((candidate) => !!candidate && candidate.playlist === playlist);
+      const exact = candidates.find((candidate) => (candidate.playItem ?? 0) === playItem);
+      if (exact) return exact;
+      const playlistLevel = candidates.find((candidate) => candidate.playItem === void 0);
+      if (playlistLevel) return playlistLevel;
+      return candidates.length === 1 ? candidates[0] : void 0;
+    }
+    /** The PlayItem a playlist request addresses; `LinkPI` and play marks are
+     * resolved by the caller, which owns the package's mark table. */
+    playItemFor(playlist, action) {
+      const resolved = this.hooks.resolvePlayItem?.(playlist, action);
+      if (typeof resolved === "number" && Number.isSafeInteger(resolved) && resolved >= 0) return resolved;
+      const payload = action.payload;
+      return typeof payload?.playItem === "number" ? payload.playItem : 0;
+    }
+    /** Switch the background for a `LinkPI`/`LinkMK` jump. No VM response is
+     * expected: those actions move inside the playlist the VM is already playing,
+     * so the menu keeps its current playback wait. */
+    async showMenuItem(playlist, playItem) {
+      const target = this.findMedia(playlist, playItem);
+      if (!target?.background.path) return false;
+      if (target === this.activeMedia) return this.startMedia();
+      this.switchSequence++;
+      this.mediaSequence++;
+      this.activeMedia = target;
+      this.selectedAudioStream = this.pickAudioStream(target);
+      this.started = false;
+      this.startPromise = null;
+      this.activePlaylistResponse = null;
+      this.lastTimeUpdateSecond = -1;
+      this.video.pause();
+      this.audio.pause();
+      try {
+        this.video.currentTime = 0;
+        this.audio.currentTime = 0;
+      } catch {
+      }
+      return this.startMedia();
+    }
+    pickAudioStream(media) {
+      return this.pickAudioTrackForPsr(media, this.confirmedPrimaryAudioStream)?.streamNumber ?? [...media.audioTracks].sort((left, right) => left.streamNumber - right.streamNumber)[0]?.streamNumber ?? 0;
+    }
+    pickAudioTrackForPsr(media, psrStreamNumber) {
+      const matches = media.audioTracks.filter((track) => this.psrStreamNumber(track) === psrStreamNumber);
+      return matches.length === 1 ? matches[0] : void 0;
+    }
+    stopMedia() {
+      this.activePlaylistResponse = null;
+      this.video.pause();
+      this.audio.pause();
+    }
+    isPending(response) {
+      const waiting = this.vm.snapshot().waiting;
+      return waiting?.id === response.id && waiting.generation === response.generation;
+    }
+    findAudioTrack(streamNumber) {
+      if (!this.activeMedia) return void 0;
+      const matches = this.activeMedia.audioTracks.filter((track) => track.streamNumber === streamNumber);
+      return matches.length === 1 ? matches[0] : void 0;
+    }
+    findAudioTrackForPsrStream(psrStreamNumber) {
+      if (!this.activeMedia) return void 0;
+      const matches = this.activeMedia.audioTracks.filter((track) => this.psrStreamNumber(track) === psrStreamNumber);
+      return matches.length === 1 ? matches[0] : void 0;
+    }
+    psrStreamNumber(track) {
+      return track.psrStreamNumber ?? track.streamNumber + 1;
+    }
+    async selectAudioStream(psrStreamNumber, generation) {
+      if (!this.activeMedia || this.activeMedia.audioTracks.length === 0) {
+        this.rollbackPrimaryAudioStream(this.confirmedPrimaryAudioStream);
+        return;
+      }
+      const sequence = ++this.switchSequence;
+      const previousTrack = this.findAudioTrack(this.selectedAudioStream);
+      const previousPsr = this.confirmedPrimaryAudioStream;
+      const track = this.findAudioTrackForPsrStream(psrStreamNumber);
+      if (!track) {
+        this.rollbackPrimaryAudioStream(previousPsr);
+        this.report(`Primary audio stream ${psrStreamNumber} is not included in this menu package.`);
+        return;
+      }
+      if (track.streamNumber === this.selectedAudioStream && this.audio.src.endsWith(track.path)) {
+        this.confirmedPrimaryAudioStream = psrStreamNumber;
+        return;
+      }
+      const shouldPlay = this.started && !this.video.paused;
+      const logicalTime = this.video.currentTime;
+      try {
+        await this.applyAudioTrack(track, logicalTime, shouldPlay, generation, sequence);
+        if (!this.isCurrentTrackSwitch(generation, sequence)) return;
+        this.selectedAudioStream = track.streamNumber;
+        this.confirmedPrimaryAudioStream = psrStreamNumber;
+        this.hooks.audioTrackChanged?.(track);
+      } catch (error) {
+        if (!this.isCurrentTrackSwitch(generation, sequence)) return;
+        this.rollbackPrimaryAudioStream(previousPsr);
+        let rollbackError;
+        if (previousTrack) {
+          try {
+            await this.applyAudioTrack(previousTrack, logicalTime, shouldPlay, generation, sequence);
+          } catch (restoreError) {
+            rollbackError = restoreError;
+          }
+        }
+        if (!this.isCurrentTrackSwitch(generation, sequence)) return;
+        const failure = error instanceof Error ? error.message : String(error);
+        const restoreMessage = rollbackError ? ` Previous audio restore failed: ${rollbackError instanceof Error ? rollbackError.message : typeof rollbackError === "string" ? rollbackError : "non-Error value"}` : "";
+        this.report(`Primary audio stream ${psrStreamNumber} could not be confirmed: ${failure}.${restoreMessage}`);
+      }
+    }
+    async applyAudioTrack(track, logicalTime, shouldPlay, generation, sequence) {
+      this.audio.pause();
+      this.audio.src = track.path;
+      const expectedSrc = this.audio.src;
+      const metadataWait = waitAudioMetadata(this.audio, this.hooks.trackSwitchTimeoutMs ?? 15e3, expectedSrc);
+      this.audio.load();
+      await metadataWait;
+      this.assertCurrentTrackSwitch(generation, sequence);
+      const duration = track.durationSeconds ?? this.activeMedia?.background.durationSeconds;
+      if (typeof duration !== "number" || !Number.isFinite(duration) || duration <= 0) throw new Error("Menu package is missing a valid generated audio duration.");
+      const targetTime = logicalTime % duration;
+      if (Math.abs(this.audio.currentTime - targetTime) > 1e-6) {
+        const seekWait = waitAudioEvent(this.audio, "seeked", this.hooks.trackSwitchTimeoutMs ?? 15e3);
+        try {
+          this.audio.currentTime = targetTime;
+        } catch (error) {
+          seekWait.cancel();
+          throw error;
+        }
+        await seekWait.promise;
+      }
+      this.assertCurrentTrackSwitch(generation, sequence);
+      if (this.audio.readyState < 2) {
+        await waitAudioReady(this.audio, this.hooks.trackSwitchTimeoutMs ?? 15e3);
+        this.assertCurrentTrackSwitch(generation, sequence);
+      }
+      if (shouldPlay) {
+        await this.audio.play();
+        this.assertCurrentTrackSwitch(generation, sequence);
+      }
+    }
+    isCurrentTrackSwitch(generation, sequence) {
+      return this.currentGeneration === generation && this.switchSequence === sequence;
+    }
+    assertCurrentTrackSwitch(generation, sequence) {
+      if (!this.isCurrentTrackSwitch(generation, sequence)) throw new Error("Audio selection belongs to a stale generation.");
+    }
+    rollbackPrimaryAudioStream(streamNumber) {
+      this.confirmedPrimaryAudioStream = streamNumber;
+      this.vm.registers.systemWrite(1, streamNumber);
+    }
+  };
+  function waitAudioEvent(audio, eventName, timeoutMs) {
+    let cancel = () => {
+    };
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+      let settled = false;
+      const cleanup = () => {
+        clearTimeout(timer);
+        audio.removeEventListener(eventName, onReady);
+        audio.removeEventListener("error", onFailure);
+        audio.removeEventListener("abort", onFailure);
+      };
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        if (error) rejectPromise(error);
+        else resolvePromise();
+      };
+      const onReady = () => finish();
+      const onFailure = () => finish(new Error("Audio seek failed."));
+      const timer = setTimeout(() => finish(new Error(`Timed out waiting for audio ${eventName}.`)), timeoutMs);
+      cancel = () => finish(new Error(`Audio ${eventName} was superseded.`));
+      audio.addEventListener(eventName, onReady, { once: true });
+      audio.addEventListener("error", onFailure, { once: true });
+      audio.addEventListener("abort", onFailure, { once: true });
+    });
+    return { promise, cancel: () => cancel() };
+  }
+  function waitAudioMetadata(audio, timeoutMs, expectedSrc) {
+    return new Promise((resolvePromise, rejectPromise) => {
+      let settled = false;
+      const cleanup = () => {
+        clearTimeout(timer);
+        audio.removeEventListener("loadedmetadata", onMetadata);
+        audio.removeEventListener("error", onFailure);
+        audio.removeEventListener("abort", onFailure);
+      };
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        if (error) rejectPromise(error);
+        else resolvePromise();
+      };
+      const onMetadata = () => {
+        if (audio.currentSrc === expectedSrc && audio.readyState >= 1) finish();
+      };
+      const onFailure = () => finish(new Error(`Audio metadata failed (media error ${audio.error?.code ?? "unknown"}).`));
+      const timer = setTimeout(() => finish(new Error("Timed out waiting for target audio metadata.")), timeoutMs);
+      audio.addEventListener("loadedmetadata", onMetadata);
+      audio.addEventListener("error", onFailure, { once: true });
+      audio.addEventListener("abort", onFailure, { once: true });
+    });
+  }
+  function waitAudioReady(audio, timeoutMs) {
+    if (audio.readyState >= 2) return Promise.resolve();
+    return new Promise((resolvePromise, rejectPromise) => {
+      let settled = false;
+      const cleanup = () => {
+        clearTimeout(timer);
+        audio.removeEventListener("loadeddata", onReady);
+        audio.removeEventListener("canplay", onReady);
+        audio.removeEventListener("error", onFailure);
+        audio.removeEventListener("abort", onFailure);
+      };
+      const finish = (error) => {
+        if (!settled) {
+          settled = true;
+          cleanup();
+          error ? rejectPromise(error) : resolvePromise();
+        }
+      };
+      const onReady = () => {
+        if (audio.readyState >= 2) finish();
+      };
+      const onFailure = () => finish(new Error("Audio track could not decode the selected position."));
+      const timer = setTimeout(() => finish(new Error("Timed out waiting for decoded audio data.")), timeoutMs);
+      audio.addEventListener("loadeddata", onReady);
+      audio.addEventListener("canplay", onReady);
+      audio.addEventListener("error", onFailure);
+      audio.addEventListener("abort", onFailure);
+    });
+  }
+  function installKeyboardInput(target, controller) {
+    const held = /* @__PURE__ */ new Set();
+    const onDown = (event) => {
+      if (held.has(event.code)) return;
+      held.add(event.code);
+      const mapped = { ArrowUp: "up", ArrowDown: "down", ArrowLeft: "left", ArrowRight: "right", Enter: "activate", Space: "activate", Escape: "escape", KeyT: "topMenu", KeyP: "popup" };
+      const kind = mapped[event.code];
+      if (kind) {
+        event.preventDefault();
+        controller.handle(kind);
+      }
+    };
+    const onUp = (event) => held.delete(event.code);
+    const onBlur = () => held.clear();
+    target.addEventListener("keydown", onDown);
+    target.addEventListener("keyup", onUp);
+    target.addEventListener("blur", onBlur);
+    return () => {
+      held.clear();
+      target.removeEventListener("keydown", onDown);
+      target.removeEventListener("keyup", onUp);
+      target.removeEventListener("blur", onBlur);
+    };
+  }
+  function installCanvasPointerInput(canvas, viewport, controller, cssSize) {
+    const point = (event) => {
+      const position = viewport.toSource(event.clientX, event.clientY, canvas.getBoundingClientRect());
+      if (position) controller.selectFromPointer(position.x, position.y);
+    };
+    const activate = (event) => {
+      const rect = canvas.getBoundingClientRect();
+      const position = viewport.toSource(event.clientX, event.clientY, rect);
+      if (!position) return;
+      controller.activatePointer(position.x, position.y);
+    };
+    const resize = () => {
+      const size = cssSize();
+      viewport.resize(canvas, size.width, size.height, window.devicePixelRatio || 1);
+      controller.hooks.render?.();
+    };
+    canvas.addEventListener("pointermove", point);
+    canvas.addEventListener("pointerdown", activate);
+    window.addEventListener("resize", resize);
+    resize();
+    return () => {
+      canvas.removeEventListener("pointermove", point);
+      canvas.removeEventListener("pointerdown", activate);
+      window.removeEventListener("resize", resize);
+    };
+  }
+
+  // ../media-export/src/external-targets.ts
+  function resolveExternalPlayTarget(targets, request) {
+    const unavailable = (code, message) => ({ status: "unavailable", code, message });
+    if (!Number.isInteger(request.playlist) || request.playlist < 0 || request.playlist > 99999) return unavailable("EXTERNAL_PLAYLIST_INVALID", "Playlist number is invalid.");
+    const playlistId = String(request.playlist).padStart(5, "0");
+    const playlist = targets.playlists.find((item2) => item2.id === playlistId);
+    if (!playlist) return unavailable("EXTERNAL_PLAYLIST_UNKNOWN", `Playlist ${playlistId} is not mapped.`);
+    const mark = request.type === "PLAY_PLAYLIST_MARK" ? playlist.marks.find((item2) => item2.index === request.playMark) : void 0;
+    if (request.type === "PLAY_PLAYLIST_MARK" && !mark) return unavailable("EXTERNAL_MARK_UNKNOWN", `Playlist ${playlistId} does not contain mark ${request.playMark}.`);
+    const itemIndex = request.type === "PLAY_PLAYLIST_ITEM" ? request.playItem : mark?.playItemIndex ?? 0;
+    const position = playlist.items.findIndex((item2) => item2.index === itemIndex);
+    if (position < 0) return unavailable("EXTERNAL_PLAYITEM_UNKNOWN", `Playlist ${playlistId} does not contain PlayItem ${itemIndex}.`);
+    const item = playlist.items[position];
+    const start = BigInt(mark?.sourceTime90k ?? item.sourceIn90k);
+    const end = BigInt(item.sourceOut90k);
+    if (end <= BigInt(item.sourceIn90k) || start < BigInt(item.sourceIn90k) || start >= end) return unavailable("EXTERNAL_TIME_INVALID", `Playlist ${playlistId} PlayItem ${itemIndex} has an invalid interval or mark.`);
+    if (!item.present) return unavailable("EXTERNAL_STREAM_MISSING", `Source ${item.streamPath} is missing.`);
+    const remainingItems = playlist.items.slice(position + 1);
+    const sourceOrigin = item.sourceOrigin90k === null ? null : BigInt(item.sourceOrigin90k);
+    if (sourceOrigin !== null && start < sourceOrigin) return unavailable("EXTERNAL_TIME_BEFORE_STC", `Playlist ${playlistId} target time precedes the selected Clip STC start time.`);
+    return { status: "available", playlistId, item, clipTime90k: start.toString(), seekTime90k: sourceOrigin === null ? null : (start - sourceOrigin).toString(), remainingItems };
+  }
+
+  // src/browser.ts
+  function createMenuVm(data, onTrace) {
+    if (data.profile !== void 0 && (typeof data.profile !== "object" || data.profile === null || Array.isArray(data.profile))) throw new Error("Embedded player profile must be a JSON object.");
+    return new HdmvVm(data.vmPrograms ?? [], { ...onTrace ? { onTrace } : {}, ...data.vmEntries ? { entries: data.vmEntries } : {}, ...data.profile ? { profile: data.profile } : {}, ...data.limits ? { limits: data.limits } : {} });
+  }
+  function createStatusToast(host, timeoutMs = 4500, messageHost = host) {
+    let timer;
+    return (message, options = {}) => {
+      messageHost.textContent = message;
+      host.classList?.add("is-visible");
+      host.classList?.toggle("is-error", options.error === true);
+      host.classList?.toggle("is-persistent", options.persist === true);
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+      if (options.persist) return;
+      timer = setTimeout(() => {
+        timer = void 0;
+        host.classList?.remove("is-visible");
+      }, timeoutMs);
+    };
+  }
+  var statusToast;
+  var statusCopyButton;
+  var statusMessage = "";
+  function showStatus(message, options) {
+    const element = document.getElementById("runtime-status");
+    if (!element) return;
+    statusMessage = message;
+    statusCopyButton?.setAttribute?.("data-copied", "false");
+    const messageElement = document.getElementById("runtime-status-message");
+    statusToast ?? (statusToast = createStatusToast(element, void 0, messageElement ?? element));
+    statusToast(message, options);
+    if (!statusCopyButton) {
+      const button = document.getElementById("runtime-status-copy");
+      if (button) {
+        statusCopyButton = button;
+        attachStatusCopy(button, () => statusMessage, () => {
+          if (statusMessage) showStatus(statusMessage);
+        });
+      }
+    }
+  }
+  function attachStatusCopy(button, message, afterCopy) {
+    let reset;
+    button.addEventListener?.("click", () => {
+      const text = message();
+      if (!text) return;
+      void copyText(text).then((copied) => {
+        if (!copied) return;
+        afterCopy?.();
+        button.setAttribute?.("data-copied", "true");
+        if (reset !== void 0) clearTimeout(reset);
+        reset = setTimeout(() => {
+          reset = void 0;
+          button.setAttribute?.("data-copied", "false");
+        }, 1600);
+      });
+    });
+  }
+  async function copyText(text) {
+    const clipboard = globalThis.navigator?.clipboard;
+    if (clipboard && typeof clipboard.writeText === "function") {
+      try {
+        await clipboard.writeText(text);
+        return true;
+      } catch {
+      }
+    }
+    if (typeof document.createElement !== "function" || typeof document.body?.appendChild !== "function") return false;
+    const area = document.createElement("textarea");
+    area.value = text;
+    area.setAttribute("readonly", "");
+    area.style.position = "fixed";
+    area.style.top = "-1000px";
+    area.style.opacity = "0";
+    document.body.appendChild(area);
+    area.select();
+    try {
+      return document.execCommand("copy") === true;
+    } catch {
+      return false;
+    } finally {
+      if (typeof document.body.removeChild === "function") document.body.removeChild(area);
+    }
+  }
+  function visibleError(error) {
+    const status = document.getElementById("runtime-status");
+    const detail = document.getElementById("runtime-diagnostics");
+    if (status) status.role = "alert";
+    showStatus("Menu preview could not start.", { persist: true, error: true });
+    if (detail) {
+      detail.hidden = false;
+      detail.textContent = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    }
+  }
+  function vmConsoleLogger(context) {
+    let pending = [];
+    let scheduled = false;
+    return (entry) => {
+      if (entry.decoded?.startsWith("RESET ")) return;
+      pending.push(entry);
+      if (scheduled) return;
+      scheduled = true;
+      queueMicrotask(() => {
+        scheduled = false;
+        const batch = pending;
+        pending = [];
+        const commands = batch.filter((item) => item.decoded && !item.decoded.startsWith("MENU_CONTEXT")).map((item) => `${item.programId}:${item.pc} ${item.decoded}`);
+        const actions = summarizeLabels(batch.flatMap((item) => item.action ? [item.action.type] : []));
+        const events = summarizeLabels(batch.flatMap((item) => {
+          const type = item.event?.type ?? item.input?.type;
+          return type ? [type] : [];
+        }));
+        const diagnostics = summarizeLabels(batch.flatMap((item) => item.diagnostic ? [item.diagnostic.code] : []));
+        const faulted = batch.some((item) => item.status === "faulted");
+        const heartbeatOnly = !actions && !diagnostics && !faulted && !!events && events.split(",").every((label) => label.startsWith("TIME_UPDATED"));
+        if (heartbeatOnly) return;
+        if (!commands.length && !actions && !events && !diagnostics) return;
+        const shownCommands = commands.length <= 6 ? commands.join(" \u2192 ") : `${commands.slice(0, 2).join(" \u2192 ")} \u2192 \u2026 ${commands.length - 4} more \u2192 ${commands.slice(-2).join(" \u2192 ")}`;
+        const where = context?.();
+        const fields = where ? [where] : [];
+        fields.push(`${commands.length} step${commands.length === 1 ? "" : "s"}`);
+        if (shownCommands) fields.push(shownCommands);
+        if (actions) fields.push(`actions=${actions}`);
+        if (events) fields.push(`events=${events}`);
+        if (diagnostics) fields.push(`diag=${diagnostics}`);
+        const status = batch.at(-1)?.status;
+        if (status) fields.push(`status=${status}`);
+        console.info(`[VM] ${fields.join(" | ")}`);
+      });
+    };
+  }
+  function menuLog(message) {
+    console.info(`[menu] ${message}`);
+  }
+  function sceneLabel(scene) {
+    const clip = scene.clipId ?? scene.id ?? "?";
+    const pid = typeof scene.pid === "number" ? `0x${scene.pid.toString(16)}` : "?";
+    return `clip ${clip} pid ${pid}`;
+  }
+  function backgroundLabel(path) {
+    if (!path) return "none";
+    const parts = path.split("/");
+    return parts.length >= 2 ? parts[parts.length - 2] : path;
+  }
+  function summarizeLabels(values) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const value of values) counts.set(value, (counts.get(value) ?? 0) + 1);
+    return [...counts].map(([value, count]) => count === 1 ? value : `${value} x${count}`).join(",");
+  }
+  function fileUrlFromBdmvPath(bdmvPath, streamPath) {
+    const normalize = (path) => path.replace(/\\/g, "/").split("/").map((part, index) => index === 0 && /^[A-Za-z]:$/.test(part) ? part : encodeURIComponent(part)).join("/");
+    const base = bdmvPath.replace(/\\/g, "/");
+    let bdmvUrl;
+    if (/^[A-Za-z]:\//.test(base)) bdmvUrl = new URL(`file:///${normalize(base)}/`);
+    else if (base.startsWith("/")) bdmvUrl = new URL(`file://${normalize(base)}/`);
+    else bdmvUrl = new URL(`${normalize(base.replace(/\/$/, ""))}/`, location.href);
+    return new URL(normalize(streamPath), bdmvUrl).href;
+  }
+  function format90kSeconds(ticks) {
+    const value = BigInt(ticks);
+    if (value < 0n) throw new RangeError("Playback offset cannot be negative.");
+    const whole = value / 90000n;
+    const fraction = (value % 90000n * 1000000n / 90000n).toString().padStart(6, "0").replace(/0+$/, "");
+    return fraction ? `${whole}.${fraction}` : whole.toString();
+  }
+  function openExternalVideo(bdmvPath, streamPath, seekTime90k) {
+    const videoUrl = fileUrlFromBdmvPath(bdmvPath, streamPath);
+    const platform = navigator.userAgent;
+    if (/Macintosh|Mac OS X/i.test(platform)) {
+      if (seekTime90k === null) throw new Error("The selected chapter position is unavailable.");
+      return `iina://open?url=${encodeURIComponent(videoUrl)}&mpv_start=${format90kSeconds(seekTime90k)}`;
+    }
+    if (/Windows/i.test(platform)) return `potplayer://${videoUrl}`;
+    throw new Error("External playback is available on macOS and Windows.");
+  }
+  async function boot() {
+    try {
+      const data = globalThis.__BDMV_MENU_DATA__;
+      if (!data || typeof data !== "object" || !("ir" in data)) throw new Error("Missing or invalid embedded menu data.");
+      validateEmbeddedDiscIR(data.ir);
+      const assetMap = /* @__PURE__ */ new Map();
+      for (const batch of globalThis.__BDMV_MENU_ASSETS__ ?? []) {
+        if (!Array.isArray(batch)) throw new Error("Invalid embedded image batch.");
+        await Promise.all(batch.map(async (asset) => {
+          if (!asset || typeof asset.id !== "string" || typeof asset.dataUrl !== "string") throw new Error("Invalid embedded image record.");
+          const image = new Image();
+          image.src = asset.dataUrl;
+          try {
+            await image.decode();
+          } catch {
+            throw new Error(`Could not decode embedded PNG '${asset.id}'.`);
+          }
+          assetMap.set(asset.id, image);
+        }));
+      }
+      if (!data.scene) throw new Error("The package contains no supported menu scene.");
+      let scene = normalizeScene(data.scene, assetMap);
+      let activeMenuSceneKey = menuSceneKey(data.scene);
+      const status = document.getElementById("runtime-status");
+      const start = document.getElementById("start-menu");
+      const muteToggle = document.getElementById("audio-mute-toggle");
+      const canvas = document.getElementById("menu-canvas");
+      const popupCanvas = document.getElementById("popup-canvas");
+      const video = document.getElementById("menu-background");
+      const audio = document.getElementById("menu-audio");
+      if (!status || !start || !muteToggle || !canvas) throw new Error("The menu page is missing required runtime elements.");
+      let viewport = new CanvasViewport(scene.width, scene.height);
+      const logState = { scene: sceneLabel(data.scene), button: "" };
+      const vm = createMenuVm(data, vmConsoleLogger(() => {
+        const button = logState.button;
+        logState.button = "";
+        return button ? `${logState.scene} \xB7 ${button}` : logState.scene;
+      }));
+      if (data.vmInitialProgramId !== void 0) {
+        if (!Number.isSafeInteger(data.vmInitialProgramId) || !(data.vmPrograms ?? []).some((program) => program.id === data.vmInitialProgramId)) throw new Error(`Invalid initial MovieObject ${String(data.vmInitialProgramId)}.`);
+        vm.reset(data.vmInitialProgramId);
+      }
+      let retrySound = null;
+      let retryMedia = null;
+      const menuMedia = (data.menuMedia ?? []).filter((item) => item.playlist !== data.media?.playlist || (item.playItem ?? 0) !== (data.media?.playItem ?? 0));
+      const playlistHasMedia = (playlist) => data.media?.playlist === playlist || menuMedia.some((item) => item.playlist === playlist);
+      const packagedMenuMedia = (playlist, playItem) => {
+        const candidates = [data.media, ...menuMedia].filter((item) => !!item && item.playlist === playlist);
+        return candidates.find((item) => (item.playItem ?? 0) === playItem) ?? (candidates.length === 1 ? candidates[0] : void 0);
+      };
+      const requestedPlayItem = (playlist, action) => {
+        if ((action.type === "PLAY_PLAYLIST_ITEM" || action.type === "LINK_PLAY_ITEM") && typeof action.payload.playItem === "number") return action.payload.playItem;
+        if ((action.type === "PLAY_PLAYLIST_MARK" || action.type === "LINK_PLAY_MARK") && typeof action.payload.playMark === "number") {
+          return data.menuPlaylistMarks?.find((item) => item.playlistId === playlist)?.marks.find((mark) => mark.index === action.payload.playMark)?.playItemRef ?? 0;
+        }
+        return 0;
+      };
+      const playbackBridge = (data.media || data.menuMedia?.length) && video && audio ? new MenuLoopPlaybackBridge(vm, video, audio, data.media, (message) => {
+        showStatus(message);
+      }, {
+        offerRetry: (retry) => {
+          retryMedia = retry;
+          start.textContent = "Retry menu media";
+          start.hidden = false;
+          start.disabled = false;
+        },
+        clearRetry: () => {
+          retryMedia = null;
+          if (!retrySound) start.hidden = true;
+        },
+        resolvePlayItem: (playlist, action) => requestedPlayItem(playlist, action)
+      }, menuMedia) : new PreviewPlaybackBridge(vm, (message) => {
+        showStatus(message);
+      });
+      let controller = null;
+      let popupController = null;
+      let popupViewport = null;
+      let removePopupPointer;
+      let removeKeyboard;
+      let inputStarted = false;
+      let animationFrameHandle;
+      let lastAnimationFrameTime;
+      const animateMenus = (time) => {
+        animationFrameHandle = void 0;
+        const delta2 = lastAnimationFrameTime === void 0 ? 0 : Math.max(0, time - lastAnimationFrameTime);
+        lastAnimationFrameTime = time;
+        controller?.advanceWhileRunning(delta2);
+        popupController?.advanceWhileRunning(delta2);
+        if (controller?.isAnimating || popupController?.isAnimating) animationFrameHandle = requestAnimationFrame(animateMenus);
+        else lastAnimationFrameTime = void 0;
+      };
+      const ensureAnimationLoop = () => {
+        if (animationFrameHandle === void 0 && (controller?.isAnimating || popupController?.isAnimating)) animationFrameHandle = requestAnimationFrame(animateMenus);
+      };
+      const closePopup = () => {
+        const wasOpen = popupController !== null;
+        if (!wasOpen) return;
+        popupController?.pause();
+        popupController = null;
+        popupViewport = null;
+        removePopupPointer?.();
+        removePopupPointer = void 0;
+        if (popupCanvas) {
+          popupCanvas.hidden = true;
+          popupCanvas.getContext("2d")?.clearRect(0, 0, popupCanvas.width, popupCanvas.height);
+        }
+        if (inputStarted && controller) queueMicrotask(() => {
+          removeKeyboard?.();
+          removeKeyboard = installKeyboardInput(window, controller);
+        });
+        if (controller) {
+          controller.syncVmContext();
+          redraw();
+        }
+      };
+      const pendingActions = [];
+      let activeMenuPlaylist = data.media?.playlist ?? data.menuPlaylistIds?.[0] ?? null;
+      const missingMenuMedia = /* @__PURE__ */ new Set();
+      const activateMenuScene = (target) => {
+        const targetSceneKey = menuSceneKey(target.scene);
+        if (activeMenuSceneKey === targetSceneKey) return;
+        closePopup();
+        removePointer?.();
+        scene = normalizeScene(target.scene, assetMap);
+        activeMenuSceneKey = targetSceneKey;
+        logState.scene = sceneLabel(target.scene);
+        viewport = new CanvasViewport(scene.width, scene.height);
+        controller = new MenuController(scene, vm, { render: redraw, dispatchActions, diagnostic: (message) => showStatus(message), playSound: (soundId, buttonId) => soundPlayer.play(soundId, buttonId), invalidateSound: () => {
+          soundPlayer.invalidate();
+          retrySound = null;
+          start.hidden = true;
+        }, activateButton: (pageId, button) => {
+          logState.button = `button ${button.id} (page ${pageId})`;
+        } }, data.inputConfig);
+        const rect = canvas.getBoundingClientRect();
+        viewport.resize(canvas, rect.width, rect.height, window.devicePixelRatio || 1);
+        controller.start();
+        if (inputStarted) {
+          removeKeyboard?.();
+          removePointer = installCanvasPointerInput(canvas, viewport, controller, () => {
+            const size = canvas.getBoundingClientRect();
+            return { width: size.width, height: size.height };
+          });
+          removeKeyboard = installKeyboardInput(window, controller);
+        }
+        redraw();
+      };
+      const dispatchActions = () => {
+        pendingActions.push(...vm.drainActions());
+        if (!controller) return { menuPlaylistRequested: false, completion: Promise.resolve() };
+        const mediaActions = [];
+        let menuPlaylistRequested = false;
+        const source2 = popupController?.activatedButtonId != null ? popupController : controller;
+        const pressed = source2?.activatedButtonId != null ? `button ${source2.activatedButtonId} (page ${source2.page.id}) ` : "";
+        const report = (message) => menuLog(`${pressed}${message}`);
+        while (pendingActions.length) {
+          const action = pendingActions.shift();
+          const inputController = popupController ?? controller;
+          if (action.type === "SET_BUTTON_PAGE") {
+            const packed = action.payload.packed;
+            if (typeof packed === "number") {
+              const before = inputController ? `${inputController.page.id}:${inputController.selectedButtonId ?? "none"}` : "";
+              inputController?.applySetButtonPage(packed);
+              const after = inputController ? `${inputController.page.id}:${inputController.selectedButtonId ?? "none"}` : "";
+              if (before !== after && inputController) report(`SET_BUTTON_PAGE #${packed.toString(16)} \u2192 page ${inputController.page.id} button ${inputController.selectedButtonId ?? "none"}`);
+            } else showStatus("VM emitted SET_BUTTON_PAGE without its packed operand.");
+          } else if ((action.type === "ENABLE_BUTTON" || action.type === "DISABLE_BUTTON") && typeof action.payload.button === "number") {
+            inputController?.setButtonEnabled(action.payload.button, action.type === "ENABLE_BUTTON");
+          } else if (action.type === "POPUP_OFF") {
+            closePopup();
+          } else if (action.type === "MENU_CALL") {
+            const selected = data.scene?.clipId && data.scene.pid !== void 0 ? selectPopupScene(data.popupScenes ?? [], data.scene.clipId, data.scene.pid) : { status: "not-found" };
+            if (selected.status !== "selected" || !popupCanvas) {
+              showStatus("No unambiguous popup IGS composition matches the active menu clip and PID.");
+            } else {
+              closePopup();
+              const popupScene = normalizeScene(selected.scene, assetMap);
+              popupViewport = new CanvasViewport(popupScene.width, popupScene.height);
+              popupCanvas.hidden = false;
+              const drawPopup = () => {
+                if (!popupController || !popupViewport || !popupCanvas) return;
+                const rect2 = popupCanvas.getBoundingClientRect();
+                const context = popupCanvas.getContext("2d");
+                if (context) drawMenu(context, popupScene, popupController, popupViewport, rect2.width, rect2.height, window.devicePixelRatio || 1);
+                ensureAnimationLoop();
+              };
+              popupController = new MenuController(popupScene, vm, { render: drawPopup, dispatchActions, diagnostic: (message) => showStatus(message), playSound: (soundId, buttonId) => soundPlayer.play(soundId, buttonId), invalidateSound: () => soundPlayer.invalidate(), activateButton: (pageId, button) => {
+                logState.button = `popup button ${button.id} (page ${pageId})`;
+              } }, data.inputConfig);
+              const rect = popupCanvas.getBoundingClientRect();
+              popupViewport.resize(popupCanvas, rect.width, rect.height, window.devicePixelRatio || 1);
+              removePopupPointer = installCanvasPointerInput(popupCanvas, popupViewport, popupController, () => {
+                const size = popupCanvas.getBoundingClientRect();
+                return { width: size.width, height: size.height };
+              });
+              popupController.start();
+              if (inputStarted) queueMicrotask(() => {
+                removeKeyboard?.();
+                if (popupController) removeKeyboard = installKeyboardInput(window, popupController);
+              });
+              drawPopup();
+            }
+          } else if (action.type === "TITLE_SEARCH" && typeof action.payload.title === "number") {
+            closePopup();
+            const selected = vm.selectTitle(action.payload.title);
+            if (selected.diagnostic) {
+              showStatus(selected.diagnostic.message);
+              if (vm.recoverMenuAction()) {
+                controller.syncVmContext();
+                pendingActions.length = 0;
+                continue;
+              }
+            }
+            pendingActions.push(...vm.drainActions());
+          } else if (["PLAY_PLAYLIST", "PLAY_PLAYLIST_ITEM", "PLAY_PLAYLIST_MARK"].includes(action.type) && typeof action.payload.playlist === "number" && data.menuPlaylistIds?.includes(action.payload.playlist)) {
+            const playlist = action.payload.playlist;
+            const playItem = requestedPlayItem(playlist, action);
+            const menuScenesForPlaylist = data.menuScenes?.filter((item) => item.playlistId === playlist) ?? [];
+            const target = menuScenesForPlaylist.find((item) => (item.playItem ?? 0) === playItem) ?? menuScenesForPlaylist[0];
+            if (!target) {
+              report(`${action.type} playlist ${playlist} has no packaged IGS composition; released the VM wait`);
+              showStatus(`Menu playlist ${playlist} has no packaged IGS composition.`);
+              vm.releaseExternalPlayback(action);
+              continue;
+            }
+            activeMenuPlaylist = playlist;
+            activateMenuScene(target);
+            report(`${action.type} playlist ${playlist}${playItem ? ` PlayItem ${playItem}` : ""} \u2192 ${sceneLabel(target.scene)} \xB7 background ${backgroundLabel(packagedMenuMedia(playlist, playItem)?.background.path)}`);
+            if (playlistHasMedia(playlist)) mediaActions.push(Promise.resolve(playbackBridge.dispatch(action)));
+            else {
+              vm.handleEvent({ type: "MEDIA_STARTED", generation: action.generation, responseTo: action.id });
+              mediaActions.push(Promise.resolve(playbackBridge.startMenuBackground?.() ?? false).then(() => void 0));
+            }
+            menuPlaylistRequested = true;
+          } else if (["LINK_PLAY_ITEM", "LINK_PLAY_MARK"].includes(action.type) && activeMenuPlaylist !== null) {
+            const playlist = activeMenuPlaylist;
+            const playItem = requestedPlayItem(playlist, action);
+            const jump2 = `${action.type === "LINK_PLAY_MARK" ? `LINK_MK ${action.payload.playMark}` : `LINK_PI ${playItem}`} \u2192 playlist ${playlist} PlayItem ${playItem}`;
+            const entry = (data.menuScenes ?? []).find((item) => item.playlistId === playlist && (item.playItem ?? 0) === playItem);
+            if (!entry) {
+              report(`${jump2} is not packaged; stayed on ${logState.scene}`);
+              showStatus(`Menu playlist ${playlist} PlayItem ${playItem} is not packaged; the menu stayed on the current page.`, { persist: true });
+              continue;
+            }
+            activateMenuScene(entry);
+            const shown = playbackBridge.showMenuItem?.(playlist, playItem);
+            if (!shown) {
+              report(`${jump2} \u2192 ${sceneLabel(entry.scene)} \xB7 no packaged background, the current one keeps playing`);
+              if (!missingMenuMedia.has(`${playlist}:${playItem}`)) {
+                missingMenuMedia.add(`${playlist}:${playItem}`);
+                showStatus(`Menu PlayItem ${playItem} has no packaged background; the current one keeps playing.`);
+              }
+              continue;
+            }
+            report(`${jump2} \u2192 ${sceneLabel(entry.scene)} \xB7 background ${backgroundLabel(packagedMenuMedia(playlist, playItem)?.background.path)}`);
+            mediaActions.push(shown.then((ok) => {
+              if (!ok) showStatus(`Menu PlayItem ${playItem} background could not start.`);
+            }));
+          } else if (["PLAY_PLAYLIST", "PLAY_PLAYLIST_ITEM", "PLAY_PLAYLIST_MARK"].includes(action.type) && typeof action.payload.playlist === "number" && data.preMenuPlaylistIds?.includes(action.payload.playlist)) {
+            report(`${action.type} playlist ${action.payload.playlist} \u2192 intro completed in the VM`);
+            vm.handleEvent({ type: "MEDIA_ENDED", generation: action.generation, responseTo: action.id });
+            pendingActions.push(...vm.drainActions());
+            continue;
+          } else if (data.externalTargets && ["PLAY_PLAYLIST", "PLAY_PLAYLIST_ITEM", "PLAY_PLAYLIST_MARK"].includes(action.type) && !(action.type === "PLAY_PLAYLIST" && typeof action.payload.playlist === "number" && playlistHasMedia(action.payload.playlist))) {
+            closePopup();
+            const result = resolveExternalPlayTarget(data.externalTargets, { type: action.type, ...action.payload });
+            if (result.status === "unavailable") {
+              report(`${action.type} ${action.payload.playlist ?? action.payload.playMark ?? "?"} has no external target: ${result.message}`);
+              showStatus(result.message, { persist: true });
+              vm.releaseExternalPlayback(action);
+              continue;
+            }
+            const bdmvPath = globalThis.__BDMV_BDMV_PATH__;
+            if (!bdmvPath) {
+              showStatus("The package is missing runtime/bdmv-config.js; set the BDMV path and reload.", { persist: true, error: true });
+              vm.releaseExternalPlayback(action);
+              continue;
+            }
+            try {
+              const protocolUrl = openExternalVideo(bdmvPath, result.item.streamPath, result.seekTime90k);
+              setMenuMuted(true);
+              report(`${action.type} ${action.payload.playlist ?? action.payload.playMark ?? "?"} \u2192 external player ${result.item.streamPath}${typeof result.seekTime90k === "number" ? ` at ${format90kSeconds(String(result.seekTime90k))}s` : ""}`);
+              showStatus(`Requested ${result.item.streamPath} in the external player.`);
+              location.href = protocolUrl;
+            } catch (error) {
+              showStatus(error instanceof Error ? error.message : String(error), { persist: true, error: true });
+            }
+            vm.releaseExternalPlayback(action);
+          } else {
+            if (["PLAY_PLAYLIST", "PLAY_PLAYLIST_ITEM", "PLAY_PLAYLIST_MARK", "TOP_MENU", "MENU_RETURN"].includes(action.type)) closePopup();
+            if (["LINK_PLAY_ITEM", "LINK_PLAY_MARK"].includes(action.type)) report(`${action.type} ${action.payload.playItem ?? action.payload.playMark ?? "?"} \u2192 no packaged menu playlist is active; handed to the fallback bridge`);
+            if (action.type === "PLAY_PLAYLIST" && action.payload.playlist === data.media?.playlist) menuPlaylistRequested = true;
+            mediaActions.push(Promise.resolve(playbackBridge.dispatch(action)));
+          }
+        }
+        return { menuPlaylistRequested, completion: Promise.all(mediaActions).then(() => void 0) };
+      };
+      const soundPlayer = new MenuSoundPlayer(data.sounds ?? {}, (url) => new Audio(url), {
+        report: (kind, message) => {
+          showStatus(message);
+          if (kind === "blocked") {
+            start.textContent = "Retry sound";
+            start.hidden = false;
+            start.disabled = false;
+          } else if (kind === "unsupported" || kind === "asset") {
+            start.hidden = true;
+            retrySound = null;
+          }
+        },
+        offerRetry: (retry) => {
+          retrySound = retry;
+          start.textContent = "Retry sound";
+          start.hidden = false;
+          start.disabled = false;
+        },
+        isCurrent: (_soundId, buttonId) => !!controller && controller.button?.id === buttonId && controller.activatedButtonId === buttonId
+      });
+      let menuMuted = false;
+      let manualMuted = false;
+      let removeAutoMuteRestore = null;
+      let armAutoMuteTimer;
+      const applyMenuMuted = (muted) => {
+        menuMuted = muted;
+        if (video) video.muted = muted;
+        if (audio) audio.muted = muted;
+        soundPlayer.setMuted(muted);
+        muteToggle.setAttribute("aria-pressed", String(muted));
+        muteToggle.setAttribute("aria-label", muted ? "Unmute menu audio" : "Mute menu audio");
+        muteToggle.title = muted ? "Unmute menu audio" : "Mute menu audio";
+      };
+      const disarmAutoMuteRestore = () => {
+        if (armAutoMuteTimer !== void 0) clearTimeout(armAutoMuteTimer);
+        armAutoMuteTimer = void 0;
+        removeAutoMuteRestore?.();
+        removeAutoMuteRestore = null;
+      };
+      const isMuteControl = (event) => {
+        const target = event.target;
+        if (target === muteToggle) return true;
+        return !!target && typeof target.closest === "function" && target.closest("#audio-mute-toggle") !== null;
+      };
+      const restoreAutoMutedMenu = (event) => {
+        if (manualMuted || !menuMuted || isMuteControl(event)) return;
+        applyMenuMuted(false);
+        disarmAutoMuteRestore();
+      };
+      const armAutoMuteRestore = () => {
+        if (removeAutoMuteRestore) return;
+        window.addEventListener("keydown", restoreAutoMutedMenu, true);
+        window.addEventListener("pointerdown", restoreAutoMutedMenu, true);
+        window.addEventListener("click", restoreAutoMutedMenu, true);
+        removeAutoMuteRestore = () => {
+          window.removeEventListener("keydown", restoreAutoMutedMenu, true);
+          window.removeEventListener("pointerdown", restoreAutoMutedMenu, true);
+          window.removeEventListener("click", restoreAutoMutedMenu, true);
+        };
+      };
+      const setMenuMuted = (muted, manual = false) => {
+        if (manual) {
+          manualMuted = muted;
+          disarmAutoMuteRestore();
+        }
+        applyMenuMuted(muted);
+        if (muted && !manual && !manualMuted) {
+          if (armAutoMuteTimer !== void 0) clearTimeout(armAutoMuteTimer);
+          armAutoMuteTimer = setTimeout(() => {
+            armAutoMuteTimer = void 0;
+            if (menuMuted && !manualMuted) armAutoMuteRestore();
+          }, 0);
+        } else if (!muted) disarmAutoMuteRestore();
+      };
+      muteToggle.addEventListener("click", () => setMenuMuted(!menuMuted, true));
+      const redraw = () => {
+        if (!controller) return;
+        const rect = canvas.getBoundingClientRect();
+        const context = canvas.getContext("2d");
+        if (context) drawMenu(context, scene, controller, viewport, rect.width, rect.height, window.devicePixelRatio || 1);
+        ensureAnimationLoop();
+      };
+      controller = new MenuController(scene, vm, { render: redraw, dispatchActions, diagnostic: (message) => {
+        showStatus(message);
+      }, playSound: (soundId, buttonId) => soundPlayer.play(soundId, buttonId), invalidateSound: () => {
+        soundPlayer.invalidate();
+        retrySound = null;
+        start.hidden = true;
+      }, activateButton: (pageId, button) => {
+        logState.button = `button ${button.id} (page ${pageId})`;
+      } }, data.inputConfig);
+      start.hidden = false;
+      start.disabled = false;
+      showStatus("Images decoded. Select Start menu preview to enable input.");
+      let removePointer;
+      start.addEventListener("click", async () => {
+        if (retrySound) {
+          const retry = retrySound;
+          retrySound = null;
+          start.disabled = true;
+          start.hidden = true;
+          retry();
+          return;
+        }
+        if (retryMedia) {
+          const retry = retryMedia;
+          retryMedia = null;
+          start.disabled = true;
+          start.hidden = true;
+          retry();
+          return;
+        }
+        if (inputStarted) return;
+        inputStarted = true;
+        start.disabled = true;
+        start.hidden = true;
+        let menuMediaStarted;
+        let pending = { menuPlaylistRequested: false, completion: Promise.resolve() };
+        if (data.vmInitialProgramId !== void 0 && (data.media || data.menuMedia?.length) && video && audio) {
+          if (data.vmFirstPlayProgramId !== void 0 && data.vmEntries?.some((entry) => entry.kind === "topMenu" && entry.target.objectType === "HDMV")) {
+            vm.reset(data.vmFirstPlayProgramId);
+            const initial = vm.runTurn();
+            if (initial.status === "faulted") {
+              showStatus(initial.diagnostic?.message ?? "First Play initialization failed.");
+              return;
+            }
+            if (initial.waiting) vm.releaseExternalPlayback(initial.waiting);
+            vm.drainActions();
+            vm.selectTitle(0);
+          } else vm.runTurn();
+          pending = dispatchActions();
+        }
+        if (!pending.menuPlaylistRequested && playbackBridge.startMenuBackground && !["faulted", "stopped"].includes(vm.snapshot().status)) {
+          const backgroundStart = playbackBridge.startMenuBackground();
+          const [, started] = await Promise.all([pending.completion, backgroundStart]);
+          menuMediaStarted = started;
+        } else {
+          await pending.completion;
+        }
+        if (retryMedia) return;
+        const vmStatus = vm.snapshot().status;
+        if (vmStatus === "faulted" || vmStatus === "stopped" || vmStatus === "suspended" && !pending.menuPlaylistRequested) return;
+        if (menuMediaStarted !== false) showStatus("Menu preview ready. Use arrow keys and Enter, or select a visible button.");
+        const initialRect = canvas.getBoundingClientRect();
+        viewport.resize(canvas, initialRect.width, initialRect.height, window.devicePixelRatio || 1);
+        controller.start();
+        void dispatchActions().completion;
+        removeKeyboard?.();
+        removePointer?.();
+        removeKeyboard = installKeyboardInput(window, popupController ?? controller);
+        removePointer = installCanvasPointerInput(canvas, viewport, controller, () => {
+          const rect = canvas.getBoundingClientRect();
+          return { width: rect.width, height: rect.height };
+        });
+        redraw();
+      });
+      window.addEventListener("pagehide", () => {
+        removeKeyboard?.();
+        removePointer?.();
+        disarmAutoMuteRestore();
+      }, { once: true });
+    } catch (error) {
+      visibleError(error);
+    }
+  }
+  function validateEmbeddedDiscIR(value) {
+    if (!isRecord(value)) throw new Error("Embedded DiscIR must be a JSON object.");
+    if (value.schemaVersion !== "1.0") throw new Error(`Unsupported DiscIR schema version '${typeof value.schemaVersion === "string" ? value.schemaVersion : "missing"}'. Expected 1.0.`);
+    for (const key of ["entries", "programs", "menus", "playlists", "mediaAssets", "diagnostics"]) if (!Array.isArray(value[key])) throw new Error(`Embedded DiscIR is invalid: '${key}' must be an array.`);
+  }
+  function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function normalizeScene(source2, assets) {
+    if (!source2 || !Number.isSafeInteger(source2.width) || source2.width <= 0 || !Number.isSafeInteger(source2.height) || source2.height <= 0 || !Array.isArray(source2.pages) || source2.pages.length === 0) throw new Error("Invalid menu scene dimensions or pages.");
+    return {
+      width: source2.width,
+      height: source2.height,
+      ...source2.frameRateCode !== void 0 ? { frameRateCode: source2.frameRateCode } : {},
+      compositionTimeout90k: source2.compositionTimeout90k,
+      selectionTimeout90k: source2.selectionTimeout90k,
+      pages: source2.pages.map((page) => ({
+        id: page.id,
+        uoMask: page.uoMask,
+        defaultButtonId: page.defaultButtonId,
+        ...page.defaultActivatedButtonId !== void 0 ? { defaultActivatedButtonId: page.defaultActivatedButtonId } : {},
+        ...page.bogDefaults ? { bogDefaults: page.bogDefaults } : {},
+        animationFrameRateCode: page.animationFrameRateCode,
+        ...page.objects ? { objects: new Map(page.objects.flatMap((object) => {
+          const image = assets.get(object.assetId);
+          return image ? [[object.id, { image, width: object.width, height: object.height }]] : [];
+        })) } : {},
+        ...page.effects ? { effects: {
+          enter: normalizeEffects(page.effects.enter, assets),
+          exit: normalizeEffects(page.effects.exit, assets)
+        } } : {},
+        ...page.allowedActions ? { allowedActions: page.allowedActions } : {},
+        buttons: page.buttons.map((button) => ({
+          id: button.id,
+          bog: button.bog ?? 0,
+          enabled: button.enabled ?? true,
+          ...button.autoAction !== void 0 ? { autoAction: button.autoAction } : {},
+          neighbors: button.neighbors,
+          states: {
+            ...button.states.normal ? { normal: normalizeState(button.states.normal, assets) } : {},
+            ...button.states.selected ? { selected: normalizeState(button.states.selected, assets) } : {},
+            ...button.states.activated ? { activated: normalizeState(button.states.activated, assets) } : {}
+          },
+          commands: button.commands ?? []
+        }))
+      }))
+    };
+  }
+  function menuSceneKey(scene) {
+    return `${scene.clipId ?? scene.id ?? ""}:${scene.pid ?? ""}`;
+  }
+  function normalizeEffects(effects, assets) {
+    return effects.map((effect) => ({
+      duration90k: effect.duration90k,
+      objects: effect.objects.flatMap((object) => {
+        const image = assets.get(object.assetId);
+        return image ? [{ ...object, image }] : [];
+      })
+    }));
+  }
+  function normalizeState(state, assets) {
+    const { x, y, width, height } = state.bounds;
+    if (![x, y, width, height].every(Number.isFinite) || width <= 0 || height <= 0) throw new Error("Invalid button state bounds.");
+    const image = state.assetId === void 0 ? void 0 : assets.get(state.assetId);
+    if (state.assetId !== void 0 && !image) throw new Error(`Button state references missing image '${state.assetId}'.`);
+    return {
+      bounds: { x, y, width, height },
+      ...image ? { image } : {},
+      ...state.soundId !== void 0 ? { soundId: state.soundId } : {},
+      startObjectId: state.startObjectId,
+      endObjectId: state.endObjectId,
+      ...state.repeat !== void 0 ? { repeat: state.repeat } : {}
+    };
+  }
+  if (typeof document !== "undefined") void boot();
+})();