miaoda-game-devkit 0.2.17 → 0.2.19

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/phaser-headless-host.ts
-import * as Phaser3 from "phaser";
+import * as Phaser4 from "phaser";
 
 // src/phaser-engine-warnings.ts
 var originalWarn;
@@ -70,8 +70,248 @@ function matchesEngineWarning(message, matcher) {
   return matcher.test(message);
 }
 
-// src/phaser-text-assertions.ts
+// src/headless-evidence-scene-plugin.ts
 import * as Phaser from "phaser";
+function createHeadlessEvidenceTracker() {
+  return {
+    engine: {
+      sceneStarts: {},
+      sceneCreates: {},
+      sceneUpdates: {},
+      sceneShutdowns: {},
+      processedPointerEvents: 0,
+      processedGameObjectEvents: 0,
+      processedKeyboardEvents: 0,
+      arcadeWorldSteps: 0
+    },
+    registeredScenes: [],
+    visitedScenes: [],
+    restartedScenes: [],
+    restartRequests: [],
+    transitionRequests: [],
+    transitions: [],
+    pendingRestarts: [],
+    pendingTransitions: []
+  };
+}
+function requestHeadlessTransition(tracker, transition) {
+  tracker.transitionRequests.push(transition);
+  tracker.pendingTransitions.push(transition);
+}
+function requestHeadlessRestart(tracker, sceneKey) {
+  if (!sceneKey) return;
+  appendUnique(tracker.restartRequests, sceneKey);
+  tracker.pendingRestarts.push({
+    scene: sceneKey,
+    startCount: tracker.engine.sceneStarts[sceneKey] ?? 0,
+    createCount: tracker.engine.sceneCreates[sceneKey] ?? 0,
+    shutdownCount: tracker.engine.sceneShutdowns[sceneKey] ?? 0
+  });
+}
+var pluginSequence = 0;
+function createHeadlessEvidenceScenePluginConfig(tracker) {
+  pluginSequence += 1;
+  const key = `__headlessEvidenceScenePlugin${pluginSequence}`;
+  const Plugin = class HeadlessEvidenceScenePlugin extends Phaser.Plugins.ScenePlugin {
+    currentInput;
+    currentKeyboard;
+    currentWorld;
+    /** 在 Scene BOOT 时注册一次生命周期监听；重启只会触发 START，不会重复注册。 */
+    boot() {
+      const scene = this.scene;
+      if (!scene) return;
+      const events = scene.sys.events;
+      events.once(Phaser.Scenes.Events.DESTROY, this.destroy, this);
+      if (scene.sys.settings.key === "__SYSTEM") return;
+      appendUnique(tracker.registeredScenes, scene.sys.settings.key);
+      events.on(Phaser.Scenes.Events.START, this.onStart, this);
+      events.on(Phaser.Scenes.Events.CREATE, this.onCreate, this);
+      events.on(Phaser.Scenes.Events.UPDATE, this.onUpdate, this);
+      events.on(Phaser.Scenes.Events.SLEEP, this.onSleep, this);
+      events.on(Phaser.Scenes.Events.WAKE, this.onWake, this);
+      events.on(Phaser.Scenes.Events.SHUTDOWN, this.onShutdown, this);
+    }
+    /** START 是 Scene 真正进入活动生命周期的证据，并在此时绑定本轮输入和物理实例。 */
+    onStart() {
+      const scene = this.scene;
+      if (!scene) return;
+      const sceneKey = scene.sys.settings.key;
+      increment(tracker.engine.sceneStarts, sceneKey);
+      appendUnique(tracker.visitedScenes, sceneKey);
+      this.bindInput(scene);
+      this.bindArcadeWorld(scene);
+    }
+    /** CREATE 由 SceneManager 在生产 create 调用返回后发布，比“调用过 create”更强。 */
+    onCreate() {
+      const scene = this.scene;
+      if (!scene) return;
+      const sceneKey = scene.sys.settings.key;
+      increment(tracker.engine.sceneCreates, sceneKey);
+      this.completeTransition(sceneKey, ["start", "launch", "switch"]);
+      const restartIndex = tracker.pendingRestarts.findIndex(
+        (request) => request.scene === sceneKey && (tracker.engine.sceneStarts[sceneKey] ?? 0) > request.startCount && (tracker.engine.sceneCreates[sceneKey] ?? 0) > request.createCount && (tracker.engine.sceneShutdowns[sceneKey] ?? 0) > request.shutdownCount
+      );
+      if (restartIndex >= 0) {
+        tracker.pendingRestarts.splice(restartIndex, 1);
+        appendUnique(tracker.restartedScenes, sceneKey);
+      }
+    }
+    /** UPDATE 证明目标 Scene 确实参与了游戏帧，而不只是 host 调用了 loop.step。 */
+    onUpdate() {
+      const scene = this.scene;
+      if (scene) increment(tracker.engine.sceneUpdates, scene.sys.settings.key);
+    }
+    onSleep() {
+      const sceneKey = this.scene?.sys.settings.key;
+      if (sceneKey) this.completeTransition(sceneKey, ["sleep"]);
+    }
+    onWake() {
+      const sceneKey = this.scene?.sys.settings.key;
+      if (sceneKey) this.completeTransition(sceneKey, ["wake", "switch"]);
+    }
+    /** SHUTDOWN 表示本轮生命周期结束；解绑外部 emitter，避免重启后重复计数。 */
+    onShutdown() {
+      const scene = this.scene;
+      if (scene) increment(tracker.engine.sceneShutdowns, scene.sys.settings.key);
+      this.unbindRuntimeEvents();
+    }
+    /** 将转场请求与目标 Scene 的真实生命周期结果配对。 */
+    completeTransition(sceneKey, methods) {
+      const index = tracker.pendingTransitions.findIndex(
+        (transition2) => transition2.to === sceneKey && methods.includes(transition2.method)
+      );
+      if (index < 0) return;
+      const [transition] = tracker.pendingTransitions.splice(index, 1);
+      if (transition) tracker.transitions.push(transition);
+    }
+    /** 监听 Phaser 已完成的输入分发；DOM dispatch 本身不计为引擎已消费。 */
+    bindInput(scene) {
+      this.currentInput = scene.input;
+      for (const event of [
+        Phaser.Input.Events.POINTER_DOWN,
+        Phaser.Input.Events.POINTER_DOWN_OUTSIDE,
+        Phaser.Input.Events.POINTER_MOVE,
+        Phaser.Input.Events.POINTER_UP,
+        Phaser.Input.Events.POINTER_UP_OUTSIDE
+      ]) {
+        this.currentInput.on(event, this.onPointerInput, this);
+      }
+      for (const event of [
+        Phaser.Input.Events.GAMEOBJECT_DOWN,
+        Phaser.Input.Events.GAMEOBJECT_MOVE,
+        Phaser.Input.Events.GAMEOBJECT_UP,
+        Phaser.Input.Events.DRAG_START,
+        Phaser.Input.Events.DRAG,
+        Phaser.Input.Events.DRAG_END
+      ]) {
+        this.currentInput.on(event, this.onGameObjectInput, this);
+      }
+      const keyboard = scene.input.keyboard;
+      if (keyboard) {
+        this.currentKeyboard = keyboard;
+        keyboard.on(
+          Phaser.Input.Keyboard.Events.ANY_KEY_DOWN,
+          this.onKeyboardInput,
+          this
+        );
+        keyboard.on(
+          Phaser.Input.Keyboard.Events.ANY_KEY_UP,
+          this.onKeyboardInput,
+          this
+        );
+      }
+    }
+    /** WORLD_STEP 由 Arcade World 在实际 step 末尾发布，可验证物理推进并非只被请求。 */
+    bindArcadeWorld(scene) {
+      const world = scene.physics?.world;
+      if (!world) return;
+      this.currentWorld = world;
+      world.on(
+        Phaser.Physics.Arcade.Events.WORLD_STEP,
+        this.onArcadeWorldStep,
+        this
+      );
+    }
+    onPointerInput() {
+      tracker.engine.processedPointerEvents += 1;
+    }
+    onGameObjectInput() {
+      tracker.engine.processedGameObjectEvents += 1;
+    }
+    onKeyboardInput() {
+      tracker.engine.processedKeyboardEvents += 1;
+    }
+    onArcadeWorldStep() {
+      tracker.engine.arcadeWorldSteps += 1;
+    }
+    /** 仅移除本插件拥有的监听，不触碰游戏注册的输入和物理回调。 */
+    unbindRuntimeEvents() {
+      if (this.currentInput) {
+        for (const event of [
+          Phaser.Input.Events.POINTER_DOWN,
+          Phaser.Input.Events.POINTER_DOWN_OUTSIDE,
+          Phaser.Input.Events.POINTER_MOVE,
+          Phaser.Input.Events.POINTER_UP,
+          Phaser.Input.Events.POINTER_UP_OUTSIDE
+        ]) {
+          this.currentInput.off(event, this.onPointerInput, this);
+        }
+        for (const event of [
+          Phaser.Input.Events.GAMEOBJECT_DOWN,
+          Phaser.Input.Events.GAMEOBJECT_MOVE,
+          Phaser.Input.Events.GAMEOBJECT_UP,
+          Phaser.Input.Events.DRAG_START,
+          Phaser.Input.Events.DRAG,
+          Phaser.Input.Events.DRAG_END
+        ]) {
+          this.currentInput.off(event, this.onGameObjectInput, this);
+        }
+      }
+      this.currentKeyboard?.off(
+        Phaser.Input.Keyboard.Events.ANY_KEY_DOWN,
+        this.onKeyboardInput,
+        this
+      );
+      this.currentKeyboard?.off(
+        Phaser.Input.Keyboard.Events.ANY_KEY_UP,
+        this.onKeyboardInput,
+        this
+      );
+      this.currentWorld?.off(
+        Phaser.Physics.Arcade.Events.WORLD_STEP,
+        this.onArcadeWorldStep,
+        this
+      );
+      this.currentInput = void 0;
+      this.currentKeyboard = void 0;
+      this.currentWorld = void 0;
+    }
+    destroy() {
+      this.unbindRuntimeEvents();
+      const scene = this.scene;
+      if (scene) {
+        const events = scene.sys.events;
+        events.off(Phaser.Scenes.Events.START, this.onStart, this);
+        events.off(Phaser.Scenes.Events.CREATE, this.onCreate, this);
+        events.off(Phaser.Scenes.Events.UPDATE, this.onUpdate, this);
+        events.off(Phaser.Scenes.Events.SLEEP, this.onSleep, this);
+        events.off(Phaser.Scenes.Events.WAKE, this.onWake, this);
+        events.off(Phaser.Scenes.Events.SHUTDOWN, this.onShutdown, this);
+      }
+      super.destroy();
+    }
+  };
+  return { key, plugin: Plugin, mapping: key };
+}
+function appendUnique(values, value) {
+  if (value && !values.includes(value)) values.push(value);
+}
+function increment(values, key) {
+  if (key) values[key] = (values[key] ?? 0) + 1;
+}
+
+// src/phaser-text-assertions.ts
+import * as Phaser2 from "phaser";
 function describeText(label) {
   const name = label.name ? ` name=${JSON.stringify(label.name)}` : "";
   const value = label.text.length > 80 ? `${label.text.slice(0, 77)}...` : label.text;
@@ -87,7 +327,7 @@ function isEffectivelyRenderable(label) {
     if (state.visible === false || state.alpha === 0 || state.scaleX === 0 || state.scaleY === 0) {
       return false;
     }
-    current = state.parentContainer ?? (state.displayList instanceof Phaser.GameObjects.Layer ? state.displayList : null);
+    current = state.parentContainer ?? (state.displayList instanceof Phaser2.GameObjects.Layer ? state.displayList : null);
   }
   return true;
 }
@@ -104,15 +344,15 @@ function collectSceneTexts(scene) {
   const visit = (child) => {
     if (visited.has(child)) return;
     visited.add(child);
-    if (child instanceof Phaser.GameObjects.Text) {
+    if (child instanceof Phaser2.GameObjects.Text) {
       labels.push(child);
       return;
     }
-    if (child instanceof Phaser.GameObjects.Container) {
+    if (child instanceof Phaser2.GameObjects.Container) {
       child.list.forEach(visit);
       return;
     }
-    if (child instanceof Phaser.GameObjects.Layer) {
+    if (child instanceof Phaser2.GameObjects.Layer) {
       child.getChildren().forEach(visit);
     }
   };
@@ -125,15 +365,15 @@ function collectSceneBitmapTexts(scene) {
   const visit = (child) => {
     if (visited.has(child)) return;
     visited.add(child);
-    if (child instanceof Phaser.GameObjects.BitmapText) {
+    if (child instanceof Phaser2.GameObjects.BitmapText) {
       labels.push(child);
       return;
     }
-    if (child instanceof Phaser.GameObjects.Container) {
+    if (child instanceof Phaser2.GameObjects.Container) {
       child.list.forEach(visit);
       return;
     }
-    if (child instanceof Phaser.GameObjects.Layer) {
+    if (child instanceof Phaser2.GameObjects.Layer) {
       child.getChildren().forEach(visit);
     }
   };
@@ -242,7 +482,7 @@ function assertSceneTextHealth(scene) {
 }
 
 // src/phaser-runtime-assertions.ts
-import * as Phaser2 from "phaser";
+import * as Phaser3 from "phaser";
 function collectObjects(scene) {
   const objects = [];
   const visited = /* @__PURE__ */ new Set();
@@ -250,9 +490,9 @@ function collectObjects(scene) {
     if (visited.has(object)) return;
     visited.add(object);
     objects.push(object);
-    if (object instanceof Phaser2.GameObjects.Container)
+    if (object instanceof Phaser3.GameObjects.Container)
       object.list.forEach(visit);
-    if (object instanceof Phaser2.GameObjects.Layer)
+    if (object instanceof Phaser3.GameObjects.Layer)
       object.getChildren().forEach(visit);
   };
   scene.children.getChildren().forEach(visit);
@@ -271,7 +511,7 @@ function isEffectivelyVisible(object) {
     if (state.visible === false || state.alpha === 0 || state.scaleX === 0 || state.scaleY === 0) {
       return false;
     }
-    current = state.parentContainer ?? (state.displayList instanceof Phaser2.GameObjects.Layer ? state.displayList : null);
+    current = state.parentContainer ?? (state.displayList instanceof Phaser3.GameObjects.Layer ? state.displayList : null);
   }
   return true;
 }
@@ -480,12 +720,9 @@ async function createHeadlessGame(scene, options = {}) {
     }
     engineDiagnostics.push(diagnostic);
   });
-  const transitions = [];
-  const registeredScenes = [];
-  const visitedScenes = [];
-  const restartedScenes = [];
+  const tracker = createHeadlessEvidenceTracker();
   const checkpoints = [];
-  const appendUnique = (values, value) => {
+  const appendUnique2 = (values, value) => {
     if (value && !values.includes(value)) values.push(value);
   };
   const assertStepCount = (value, name) => {
@@ -497,17 +734,23 @@ async function createHeadlessGame(scene, options = {}) {
   };
   const evidence = {
     frames: 0,
+    observedFrames: 0,
     physicsSteps: 0,
+    observedPhysicsSteps: 0,
     mouseEvents: 0,
     keyboardEvents: 0,
     touchEvents: 0,
     clicks: 0,
-    registeredScenes,
-    visitedScenes,
-    restartedScenes,
+    consumedInputEvents: 0,
+    engine: tracker.engine,
+    registeredScenes: tracker.registeredScenes,
+    visitedScenes: tracker.visitedScenes,
+    restartRequests: tracker.restartRequests,
+    restartedScenes: tracker.restartedScenes,
     checkpoints,
     destroyed: false,
-    transitions
+    transitionRequests: tracker.transitionRequests,
+    transitions: tracker.transitions
   };
   const created = new Promise((resolve, reject) => {
     const guardedScenes = /* @__PURE__ */ new WeakSet();
@@ -575,12 +818,12 @@ async function createHeadlessGame(scene, options = {}) {
         });
       };
       currentScene.load.on(
-        Phaser3.Loader.Events.FILE_LOAD_ERROR,
+        Phaser4.Loader.Events.FILE_LOAD_ERROR,
         onFileLoadError
       );
       restoreGuards.push(() => {
         currentScene.load.off(
-          Phaser3.Loader.Events.FILE_LOAD_ERROR,
+          Phaser4.Loader.Events.FILE_LOAD_ERROR,
           onFileLoadError
         );
       });
@@ -604,7 +847,9 @@ async function createHeadlessGame(scene, options = {}) {
           guardScene(target);
           const from = currentScene.sys.settings.key;
           const to = key === void 0 ? from : typeof key === "string" ? key : key.sys.settings.key;
-          if (from && to) transitions.push({ from, to, method });
+          if (from && to) {
+            requestHeadlessTransition(tracker, { from, to, method });
+          }
           const callArgs = key === void 0 && args.length === 0 ? [] : [key, ...args];
           return Reflect.apply(original, currentScene.scene, callArgs);
         };
@@ -615,7 +860,7 @@ async function createHeadlessGame(scene, options = {}) {
       const originalRestart = scenePlugin.restart;
       if (typeof originalRestart === "function") {
         scenePlugin.restart = (...args) => {
-          appendUnique(restartedScenes, currentScene.sys.settings.key);
+          requestHeadlessRestart(tracker, currentScene.sys.settings.key);
           return Reflect.apply(originalRestart, currentScene.scene, args);
         };
         restoreGuards.push(() => {
@@ -676,17 +921,26 @@ async function createHeadlessGame(scene, options = {}) {
       ...config.audio,
       noAudio: true
     };
+    const evidencePlugin = createHeadlessEvidenceScenePluginConfig(tracker);
+    const configuredPlugins = config.plugins;
+    const plugins = Array.isArray(
+      configuredPlugins
+    ) ? { global: configuredPlugins, scene: [evidencePlugin] } : {
+      ...configuredPlugins,
+      scene: [...configuredPlugins?.scene ?? [], evidencePlugin]
+    };
     try {
-      game = new Phaser3.Game({
+      game = new Phaser4.Game({
         width: 320,
         height: 180,
         banner: false,
         autoFocus: false,
         seed: ["phaser-headless-test"],
         ...config,
-        type: Phaser3.HEADLESS,
+        type: Phaser4.HEADLESS,
         fps,
         audio,
+        plugins,
         callbacks: {
           preBoot(bootedGame) {
             const manager = bootedGame.scene;
@@ -706,10 +960,10 @@ async function createHeadlessGame(scene, options = {}) {
                 finish();
               }
             };
-            bootedGame.events.on(Phaser3.Core.Events.POST_STEP, checkReadiness);
+            bootedGame.events.on(Phaser4.Core.Events.POST_STEP, checkReadiness);
             removeReadinessCheck = () => {
               bootedGame.events.off(
-                Phaser3.Core.Events.POST_STEP,
+                Phaser4.Core.Events.POST_STEP,
                 checkReadiness
               );
             };
@@ -830,10 +1084,8 @@ async function createHeadlessGame(scene, options = {}) {
   };
   const assertHealth = () => {
     for (const currentScene of readyGame.scene.getScenes(false)) {
-      appendUnique(registeredScenes, currentScene.sys.settings.key);
       if (!currentScene.sys.isActive() && !currentScene.sys.isPaused())
         continue;
-      appendUnique(visitedScenes, currentScene.sys.settings.key);
       if (!allowIdleLoaderQueues.includes(currentScene.sys.settings.key) && !currentScene.load.isLoading() && currentScene.load.list.size > 0) {
         const queuedFiles = [...currentScene.load.list].map(
           (file) => `${file.type}:${String(file.key)}`
@@ -860,7 +1112,9 @@ async function createHeadlessGame(scene, options = {}) {
     }
     return target;
   };
+  const getProcessedInputEvents = () => evidence.engine.processedPointerEvents + evidence.engine.processedKeyboardEvents;
   const dispatchMouse = async (type, x, y, buttons) => {
+    const processedBefore = getProcessedInputEvents();
     const { clientX, clientY } = gameToClient(x, y);
     const mouseTarget = getEventTarget(readyGame.input.mouse?.target, "mouse");
     mouseTarget.dispatchEvent(
@@ -874,6 +1128,10 @@ async function createHeadlessGame(scene, options = {}) {
       })
     );
     evidence.mouseEvents += 1;
+    evidence.consumedInputEvents += Math.max(
+      0,
+      getProcessedInputEvents() - processedBefore
+    );
     await settleRuntime();
   };
   const keyIdentity = (keyCode) => {
@@ -887,25 +1145,26 @@ async function createHeadlessGame(scene, options = {}) {
     }
     const identities = /* @__PURE__ */ new Map([
       [
-        Phaser3.Input.Keyboard.KeyCodes.LEFT,
+        Phaser4.Input.Keyboard.KeyCodes.LEFT,
         { key: "ArrowLeft", code: "ArrowLeft" }
       ],
       [
-        Phaser3.Input.Keyboard.KeyCodes.RIGHT,
+        Phaser4.Input.Keyboard.KeyCodes.RIGHT,
         { key: "ArrowRight", code: "ArrowRight" }
       ],
-      [Phaser3.Input.Keyboard.KeyCodes.UP, { key: "ArrowUp", code: "ArrowUp" }],
+      [Phaser4.Input.Keyboard.KeyCodes.UP, { key: "ArrowUp", code: "ArrowUp" }],
       [
-        Phaser3.Input.Keyboard.KeyCodes.DOWN,
+        Phaser4.Input.Keyboard.KeyCodes.DOWN,
         { key: "ArrowDown", code: "ArrowDown" }
       ],
-      [Phaser3.Input.Keyboard.KeyCodes.SPACE, { key: " ", code: "Space" }],
-      [Phaser3.Input.Keyboard.KeyCodes.ENTER, { key: "Enter", code: "Enter" }],
-      [Phaser3.Input.Keyboard.KeyCodes.ESC, { key: "Escape", code: "Escape" }]
+      [Phaser4.Input.Keyboard.KeyCodes.SPACE, { key: " ", code: "Space" }],
+      [Phaser4.Input.Keyboard.KeyCodes.ENTER, { key: "Enter", code: "Enter" }],
+      [Phaser4.Input.Keyboard.KeyCodes.ESC, { key: "Escape", code: "Escape" }]
     ]);
     return identities.get(keyCode) ?? { key: "", code: "" };
   };
   const dispatchKeyboard = async (type, keyCode, options2 = {}) => {
+    const processedBefore = getProcessedInputEvents();
     if (!Number.isInteger(keyCode) || keyCode < 0) {
       throw new Error(
         `HEADLESS keyboard keyCode must be a non-negative integer; received ${keyCode}`
@@ -934,6 +1193,10 @@ async function createHeadlessGame(scene, options = {}) {
     );
     keyboardTarget.dispatchEvent(event);
     evidence.keyboardEvents += 1;
+    evidence.consumedInputEvents += Math.max(
+      0,
+      getProcessedInputEvents() - processedBefore
+    );
     await settleRuntime();
   };
   const activeTouches = /* @__PURE__ */ new Map();
@@ -960,6 +1223,7 @@ async function createHeadlessGame(scene, options = {}) {
     };
   };
   const dispatchTouch = async (type, x, y, identifier) => {
+    const processedBefore = getProcessedInputEvents();
     if (type === "touchstart" && activeTouches.has(identifier)) {
       throw new Error(
         `HEADLESS touch identifier ${identifier} is already active`
@@ -1001,6 +1265,10 @@ async function createHeadlessGame(scene, options = {}) {
     try {
       touchTarget.dispatchEvent(event);
       evidence.touchEvents += 1;
+      evidence.consumedInputEvents += Math.max(
+        0,
+        getProcessedInputEvents() - processedBefore
+      );
     } finally {
       if (originalElementFromPointDescriptor) {
         Object.defineProperty(
@@ -1051,8 +1319,17 @@ async function createHeadlessGame(scene, options = {}) {
   };
   const frameDurationMs = 1e3 / (config.fps?.target ?? 60);
   const stepFrame = () => {
+    const updatesBefore = Object.values(evidence.engine.sceneUpdates).reduce(
+      (total, count) => total + count,
+      0
+    );
     readyGame.loop.step(readyGame.loop.lastTime + frameDurationMs);
     evidence.frames += 1;
+    const updatesAfter = Object.values(evidence.engine.sceneUpdates).reduce(
+      (total, count) => total + count,
+      0
+    );
+    if (updatesAfter > updatesBefore) evidence.observedFrames += 1;
   };
   const stepFrames = (count = 1) => {
     assertStepCount(count, "stepFrames count");
@@ -1081,19 +1358,19 @@ async function createHeadlessGame(scene, options = {}) {
     evidence,
     assertGameplayEvidence(requirements = {}) {
       const inputEvents = evidence.mouseEvents + evidence.keyboardEvents + evidence.touchEvents;
-      if (requirements.requireInput && inputEvents === 0) {
+      if (requirements.requireInput && (inputEvents === 0 || evidence.consumedInputEvents === 0)) {
         throw new Error(
-          "Gameplay evidence is missing real HEADLESS input events."
+          "Gameplay evidence is missing DOM input consumed by Phaser InputPlugin."
         );
       }
-      if (requirements.requireFrameAdvance && evidence.frames === 0) {
+      if (requirements.requireFrameAdvance && (evidence.frames === 0 || evidence.observedFrames === 0)) {
         throw new Error(
-          "Gameplay evidence is missing complete Phaser frame advancement."
+          "Gameplay evidence is missing a complete frame observed by an active Phaser Scene."
         );
       }
-      if (requirements.requirePhysicsStep && evidence.physicsSteps === 0) {
+      if (requirements.requirePhysicsStep && (evidence.physicsSteps === 0 || evidence.observedPhysicsSteps === 0)) {
         throw new Error(
-          "Gameplay evidence is missing Arcade Physics advancement."
+          "Gameplay evidence is missing an Arcade Physics step observed through WORLD_STEP."
         );
       }
       const requiredTransitions = requirements.requireTransition === void 0 ? [] : typeof requirements.requireTransition === "string" ? [requirements.requireTransition] : requirements.requireTransition;
@@ -1168,8 +1445,12 @@ async function createHeadlessGame(scene, options = {}) {
         );
       }
       for (let step = 0; step < steps; step += 1) {
+        const worldStepsBefore = evidence.engine.arcadeWorldSteps;
         scene.physics.world.singleStep();
         evidence.physicsSteps += 1;
+        if (evidence.engine.arcadeWorldSteps > worldStepsBefore) {
+          evidence.observedPhysicsSteps += 1;
+        }
       }
       throwRuntimeError();
       assertHealth();
@@ -1181,7 +1462,7 @@ async function createHeadlessGame(scene, options = {}) {
           "Gameplay checkpoint id must contain 1 to 120 non-whitespace characters."
         );
       }
-      appendUnique(checkpoints, normalizedId);
+      appendUnique2(checkpoints, normalizedId);
     },
     assertTextHealth() {
       assertSceneTextHealth(scene);
@@ -1252,16 +1533,33 @@ function createGameplayContractMetadata(contract) {
 function snapshotEvidence(evidence) {
   return {
     frames: evidence.frames,
+    observedFrames: evidence.observedFrames,
     physicsSteps: evidence.physicsSteps,
+    observedPhysicsSteps: evidence.observedPhysicsSteps,
     mouseEvents: evidence.mouseEvents,
     keyboardEvents: evidence.keyboardEvents,
     touchEvents: evidence.touchEvents,
     clicks: evidence.clicks,
+    consumedInputEvents: evidence.consumedInputEvents,
+    engine: {
+      sceneStarts: { ...evidence.engine.sceneStarts },
+      sceneCreates: { ...evidence.engine.sceneCreates },
+      sceneUpdates: { ...evidence.engine.sceneUpdates },
+      sceneShutdowns: { ...evidence.engine.sceneShutdowns },
+      processedPointerEvents: evidence.engine.processedPointerEvents,
+      processedGameObjectEvents: evidence.engine.processedGameObjectEvents,
+      processedKeyboardEvents: evidence.engine.processedKeyboardEvents,
+      arcadeWorldSteps: evidence.engine.arcadeWorldSteps
+    },
     registeredScenes: [...evidence.registeredScenes],
     visitedScenes: [...evidence.visitedScenes],
+    restartRequests: [...evidence.restartRequests],
     restartedScenes: [...evidence.restartedScenes],
     checkpoints: [...evidence.checkpoints],
     destroyed: evidence.destroyed,
+    transitionRequests: evidence.transitionRequests.map((transition) => ({
+      ...transition
+    })),
     transitions: evidence.transitions.map((transition) => ({ ...transition }))
   };
 }
@@ -1336,7 +1634,7 @@ function gameplayTest(name, options, run) {
 }
 
 // src/game-telemetry.ts
-import * as Phaser4 from "phaser";
+import * as Phaser5 from "phaser";
 var GAME_TELEMETRY_GLOBAL = "gameTelemetry";
 function telemetryGlobal() {
   return globalThis;
@@ -1357,7 +1655,7 @@ function installGameTelemetry(owner, telemetry) {
     );
   }
   const events = owner.events;
-  const lifecycleEvents = owner instanceof Phaser4.Game ? [Phaser4.Core.Events.DESTROY] : [Phaser4.Scenes.Events.SHUTDOWN, Phaser4.Scenes.Events.DESTROY];
+  const lifecycleEvents = owner instanceof Phaser5.Game ? [Phaser5.Core.Events.DESTROY] : [Phaser5.Scenes.Events.SHUTDOWN, Phaser5.Scenes.Events.DESTROY];
   let installed = true;
   const cleanup = () => {
     if (!installed) return;