@auraindustry/aurajs 0.0.7 → 0.1.1

package/src/conformance/cases/systems-and-gameplay-cases.mjs

@@ -0,0 +1,1776 @@
+export const SYSTEMS_AND_GAMEPLAY_CONFORMANCE_CASES = [
+  {
+      id: 'optional-module-physics-disabled',
+      modes: ['native'],
+      namespaces: ['physics'],
+      functions: ['aura.physics.configureStep', 'aura.physics.step', 'aura.physics.queryPoint', 'aura.physics.queryAABB', 'aura.physics.queryPointDetailed', 'aura.physics.queryOverlap', 'aura.physics.queryRaycast'],
+      optionalModuleReadiness: { module: 'physics', state: 'disabled' },
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '0',
+        AURA_MODULE_NET: '0',
+      },
+      nativeChecks: [
+        {
+          id: 'optional.physics.disabled.guidance',
+          expression: "(() => { const guidance = (fn) => { try { fn(); return false; } catch (e) { const msg = String(e); return msg.includes('disabled') && msg.includes('modules.physics'); } }; return guidance(() => aura.physics.configureStep({ stepSeconds: 1 / 120 })) && guidance(() => aura.physics.step(0.016)) && guidance(() => aura.physics.queryPoint(0, 0)) && guidance(() => aura.physics.queryPoint({ x: 0, y: 0 })) && guidance(() => aura.physics.queryAABB(0, 0, 1, 1)) && guidance(() => aura.physics.queryAABB({ x: 0, y: 0, w: 1, h: 1 })) && guidance(() => aura.physics.queryPointDetailed({ x: 0, y: 0 })) && guidance(() => aura.physics.queryOverlap(0, 0, 1, 1)) && guidance(() => aura.physics.queryOverlap({ x: 0, y: 0, w: 1, h: 1 })) && guidance(() => aura.physics.queryRaycast(0, 0, 1, 0)) && guidance(() => aura.physics.queryRaycast({ x: 0, y: 0, dx: 1, dy: 0 })) && guidance(() => aura.physics.queryAABB(0, 0, 0, 1)); })()",
+        },
+        {
+          id: 'optional.physics.disabled.reason-codes',
+          expression: "(() => { const reasonCode = (method, invoke) => { try { invoke(); return false; } catch (e) { const msg = String(e); return msg.includes('aura.physics.' + method + '()') && msg.includes('optional module \"physics\" is disabled') && msg.includes('modules.physics = true') && msg.includes('[reason:optional_module_physics_disabled]'); } }; return reasonCode('configureStep', () => aura.physics.configureStep({ stepSeconds: 1 / 120 })) && reasonCode('step', () => aura.physics.step(0.016)) && reasonCode('queryPoint', () => aura.physics.queryPoint(0, 0)) && reasonCode('queryRaycast', () => aura.physics.queryRaycast(0, 0, 1, 0)); })()",
+        },
+      ],
+      nativeFrames: 2,
+      source: `aura.setup = function () {};`,
+    },
+  {
+      id: 'optional-module-physics-enabled',
+      modes: ['native'],
+      namespaces: ['physics'],
+      functions: ['aura.physics.body', 'aura.physics.configureStep', 'aura.physics.step', 'aura.physics.queryPoint', 'aura.physics.queryAABB', 'aura.physics.queryPointDetailed', 'aura.physics.queryOverlap', 'aura.physics.queryRaycast'],
+      optionalModuleReadiness: { module: 'physics', state: 'enabled' },
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '1',
+        AURA_MODULE_NET: '0',
+      },
+      nativeChecks: [
+        {
+          id: 'optional.physics.enabled.runtime',
+          expression: "(() => { try { const configured = aura.physics.configureStep({ stepSeconds: 1 / 120, maxSubSteps: 16, auto: false, resetAccumulator: true }); const body = aura.physics.body('dynamic', { x: 0, y: 0, shape: 'circle', radius: 1 }); aura.physics.step(0.016); const pointHits = aura.physics.queryPoint(body.x, body.y); const pointHitsObj = aura.physics.queryPoint({ x: body.x, y: body.y }); const aabbHits = aura.physics.queryAABB(body.x - 1, body.y - 1, 2, 2); const aabbHitsObj = aura.physics.queryAABB({ x: body.x - 1, y: body.y - 1, w: 2, h: 2 }); const pointDetailed = aura.physics.queryPointDetailed({ x: body.x, y: body.y }); const pointDetailedInvalid = aura.physics.queryPointDetailed({ x: 'bad', y: 0 }); const overlap = aura.physics.queryOverlap({ x: body.x - 1, y: body.y - 1, w: 2, h: 2 }); const overlapInvalid = aura.physics.queryOverlap(body.x, body.y, 0, 2); const rayHit = aura.physics.queryRaycast({ x: body.x - 5, y: body.y, dx: 1, dy: 0, maxToi: 20 }); const rayMiss = aura.physics.queryRaycast({ x: body.x - 5, y: body.y + 50, dx: 1, dy: 0, maxToi: 20 }); const rayInvalid = aura.physics.queryRaycast({ x: body.x, y: body.y, dx: 0, dy: 0 }); const invalidPointHits = aura.physics.queryPoint('bad', 0); const invalidAabbHits = aura.physics.queryAABB(0, 0, 0, 1); return configured && configured.auto === false && configured.maxSubSteps === 16 && Number.isFinite(configured.stepCount) && Number.isFinite(configured.accumulatorCarry) && typeof body === 'object' && Number.isFinite(body.id) && typeof body.applyForce === 'function' && Array.isArray(pointHits) && pointHits.includes(body.id) && Array.isArray(pointHitsObj) && pointHitsObj.includes(body.id) && Array.isArray(aabbHits) && aabbHits.includes(body.id) && Array.isArray(aabbHitsObj) && aabbHitsObj.includes(body.id) && pointDetailed && pointDetailed.ok === true && Array.isArray(pointDetailed.hits) && pointDetailed.hits.includes(body.id) && pointDetailed.error === null && pointDetailedInvalid && pointDetailedInvalid.ok === false && Array.isArray(pointDetailedInvalid.hits) && pointDetailedInvalid.hits.length === 0 && typeof pointDetailedInvalid.error === 'string' && pointDetailedInvalid.error.length > 0 && overlap && overlap.ok === true && Array.isArray(overlap.hits) && overlap.hits.includes(body.id) && overlap.error === null && overlapInvalid && overlapInvalid.ok === true && Array.isArray(overlapInvalid.hits) && overlapInvalid.hits.length === 0 && overlapInvalid.error === null && rayHit && rayHit.ok === true && rayHit.hit === true && rayHit.bodyId === body.id && Number.isFinite(rayHit.toi) && rayHit.point && Number.isFinite(rayHit.point.x) && Number.isFinite(rayHit.point.y) && rayHit.normal && Number.isFinite(rayHit.normal.x) && Number.isFinite(rayHit.normal.y) && rayHit.error === null && rayMiss && rayMiss.ok === true && rayMiss.hit === false && rayMiss.bodyId === null && rayMiss.toi === null && rayMiss.point === null && rayMiss.normal === null && rayMiss.error === null && rayInvalid && rayInvalid.ok === true && rayInvalid.hit === false && rayInvalid.bodyId === null && rayInvalid.toi === null && rayInvalid.point === null && rayInvalid.normal === null && rayInvalid.error === null && Array.isArray(invalidPointHits) && invalidPointHits.length === 0 && Array.isArray(invalidAabbHits) && invalidAabbHits.length === 0; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'optional.physics.enabled.invalid-input.reason-codes',
+          expression: "(() => { try { const pointDetailedInvalid = aura.physics.queryPointDetailed({ x: 'bad', y: 0 }); const overlapInvalid = aura.physics.queryOverlap({ x: 'bad', y: 0, w: 1, h: 1 }); const raycastInvalid = aura.physics.queryRaycast({ x: 0, y: 0, dx: 'bad', dy: 1 }); return pointDetailedInvalid && pointDetailedInvalid.ok === false && pointDetailedInvalid.error === 'invalid point query args' && overlapInvalid && overlapInvalid.ok === false && overlapInvalid.error === 'invalid overlap query args' && raycastInvalid && raycastInvalid.ok === false && raycastInvalid.error === 'invalid raycast query args'; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'optional.physics.enabled.fixed-step.variable-dt-stable',
+          expression: "(() => { try { const close = (a, b) => Math.abs(a - b) <= 1e-4; const run = (startX, sequence) => { const body = aura.physics.body('dynamic', { x: startX, y: 0, shape: 'circle', radius: 0.5 }); body.setVelocity(2, 0); for (const dt of sequence) { aura.physics.step(dt); } const diag = aura.physics.configureStep(); return { dx: body.x - startX, y: body.y, vy: body.velocity.y, stepCount: diag.stepCount, accumulatorCarry: diag.accumulatorCarry }; }; aura.physics.setGravity(0, 9.81); aura.physics.configureStep({ stepSeconds: 1 / 120, maxSubSteps: 16, auto: false, resetAccumulator: true }); const sequenceA = [1 / 60, 1 / 60, 1 / 60, 1 / 60, 1 / 60, 1 / 60]; const sequenceB = [1 / 50, 1 / 50, 1 / 100, 1 / 25, 1 / 100]; const first = run(-10, sequenceA); aura.physics.configureStep({ resetAccumulator: true }); const second = run(10, sequenceB); globalThis.__physicsFixedStepDiag = { stepCount: second.stepCount, accumulatorCarry: second.accumulatorCarry }; return close(first.dx, second.dx) && close(first.y, second.y) && close(first.vy, second.vy) && first.stepCount === 2 && second.stepCount === 2 && Math.abs(first.accumulatorCarry) <= 1e-5 && Math.abs(second.accumulatorCarry) <= 1e-5; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'optional.physics.enabled.callback-ordering.seeded',
+          expression: "(() => { try { globalThis.__physicsCallbackHits = []; const dynamicBody = aura.physics.body('dynamic', { x: 0, y: 0, shape: 'circle', radius: 1 }); const staticBody = aura.physics.body('static', { x: 0, y: 0, shape: 'circle', radius: 1 }); globalThis.__physicsCallbackIds = [dynamicBody.id, staticBody.id]; dynamicBody.onCollide((other) => { globalThis.__physicsCallbackHits.push('a:' + other); }); staticBody.onCollide((other) => { globalThis.__physicsCallbackHits.push('b:' + other); }); aura.physics.step(0.016); return Array.isArray(globalThis.__physicsCallbackIds) && globalThis.__physicsCallbackIds.length === 2; } catch (_) { return false; } })()",
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'optional.physics.enabled.callback-ordering.deterministic',
+          expression: "Array.isArray(globalThis.__physicsCallbackIds) && Array.isArray(globalThis.__physicsCallbackHits) && globalThis.__physicsCallbackHits.length === 2 && globalThis.__physicsCallbackHits[0] === ('a:' + globalThis.__physicsCallbackIds[1]) && globalThis.__physicsCallbackHits[1] === ('b:' + globalThis.__physicsCallbackIds[0])",
+          debugExpression: "(() => { const ids = Array.isArray(globalThis.__physicsCallbackIds) ? [...globalThis.__physicsCallbackIds] : null; const observed = Array.isArray(globalThis.__physicsCallbackHits) ? [...globalThis.__physicsCallbackHits] : null; const expected = Array.isArray(ids) && ids.length === 2 ? ['a:' + ids[1], 'b:' + ids[0]] : null; return { callback: 'physics.onCollide', ids, expected, observed, observedCount: Array.isArray(observed) ? observed.length : null }; })()",
+        },
+        {
+          id: 'optional.physics.enabled.fixed-step.diagnostics',
+          expression: "globalThis.__physicsFixedStepDiag && Number.isFinite(globalThis.__physicsFixedStepDiag.stepCount) && Number.isFinite(globalThis.__physicsFixedStepDiag.accumulatorCarry)",
+        },
+      ],
+      nativeFrames: 2,
+      source: `aura.setup = function () {};`,
+    },
+  {
+      id: 'physics3d-joint-constraint-parity',
+      modes: ['native'],
+      namespaces: ['physics3d'],
+      functions: [
+        'aura.physics3d.body',
+        'aura.physics3d.configureStep',
+        'aura.physics3d.setGravity',
+        'aura.physics3d.step',
+        'aura.physics3d.joint',
+        'aura.physics3d.removeJoint',
+      ],
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '1',
+        AURA_MODULE_NET: '0',
+      },
+      nativeChecks: [
+        {
+          id: 'physics3d.joints.surface.methods',
+          expression: `(() => {
+            try {
+              const physics = aura.physics3d || {};
+              const methodsOk = ['body', 'configureStep', 'setGravity', 'step', 'joint', 'removeJoint'].every((name) => typeof physics[name] === 'function');
+              physics.configureStep({ stepSeconds: 1 / 120, maxSubSteps: 16, auto: false, resetAccumulator: true, resetWorld: true });
+              physics.setGravity(0, 0, 0);
+              const anchor = physics.body('static', { x: 0, y: 0, z: 0, shape: 'box', width: 0.5, height: 0.5, depth: 0.5 });
+              const bob = physics.body('dynamic', { x: 1, y: 0, z: 0, shape: 'box', width: 0.5, height: 0.5, depth: 0.5 });
+              const joint = physics.joint('revolute', anchor.id, bob.id, {
+                axis: { x: 0, y: 1, z: 0 },
+                limits: { min: -0.5, max: 0.5 },
+                motor: { targetVel: 0.5, maxForce: 5 },
+              });
+              const state = joint.getState();
+              return methodsOk
+                && typeof anchor === 'object'
+                && typeof bob === 'object'
+                && typeof joint === 'object'
+                && Number.isInteger(joint.id)
+                && joint.id > 0
+                && joint.kind === 'revolute'
+                && joint.bodyA === anchor.id
+                && joint.bodyB === bob.id
+                && typeof joint.getState === 'function'
+                && typeof joint.remove === 'function'
+                && state?.kind === 'revolute';
+            } catch (_) {
+              return false;
+            }
+          })()`,
+        },
+        {
+          id: 'physics3d.joints.invalid-usage.reason-codes',
+          expression: `(() => {
+            try {
+              const physics = aura.physics3d;
+              physics.configureStep({ stepSeconds: 1 / 120, maxSubSteps: 16, auto: false, resetAccumulator: true, resetWorld: true });
+              physics.setGravity(0, 0, 0);
+              const base = physics.body('static', { x: 0, y: 0, z: 0, shape: 'box', width: 0.5, height: 0.5, depth: 0.5 });
+              const bob = physics.body('dynamic', { x: 1, y: 0, z: 0, shape: 'box', width: 0.5, height: 0.5, depth: 0.5 });
+              const invalidKind = (() => { try { physics.joint('rope', base.id, bob.id); return false; } catch (error) { return String(error).includes('type must be revolute|ball|prismatic|fixed'); } })();
+              const invalidMissingBody = (() => { try { physics.joint('fixed', base.id, 999999); return false; } catch (error) { return String(error).includes('bodyB handle does not exist'); } })();
+              const invalidAxis = (() => { try { physics.joint('revolute', base.id, bob.id, { axis: { x: 0, y: 0, z: 0 } }); return false; } catch (error) { return String(error).includes('options.axis must be non-zero'); } })();
+              const invalidMotor = (() => { try { physics.joint('ball', base.id, bob.id, { motor: { targetVel: 1, maxForce: 2 } }); return false; } catch (error) { return String(error).includes('options.motor is only supported for revolute and prismatic joints'); } })();
+              const invalidLimits = (() => { try { physics.joint('fixed', base.id, bob.id, { limits: { min: -1, max: 1 } }); return false; } catch (error) { return String(error).includes('options.limits are only supported for revolute and prismatic joints'); } })();
+              return invalidKind && invalidMissingBody && invalidAxis && invalidMotor && invalidLimits;
+            } catch (_) {
+              return false;
+            }
+          })()`,
+        },
+        {
+          id: 'physics3d.joints.runtime.seeded',
+          expression: `(() => {
+            try {
+              const physics = aura.physics3d;
+              physics.configureStep({ stepSeconds: 1 / 120, maxSubSteps: 16, auto: false, resetAccumulator: true, resetWorld: true });
+              physics.setGravity(0, -9.81, 0);
+  
+              const makeBody = (kind, spec) => physics.body(kind, spec);
+  
+              const revoluteBase = makeBody('static', { x: -5.5, y: 2.1, z: 0, shape: 'box', width: 0.4, height: 3.2, depth: 0.4 });
+              const revoluteDoor = makeBody('dynamic', { x: -4.0, y: 2.1, z: 0, shape: 'box', width: 1.8, height: 2.4, depth: 0.2 });
+              const prismaticRail = makeBody('static', { x: 0, y: 1.6, z: 0, shape: 'box', width: 4.6, height: 0.25, depth: 0.25 });
+              const prismaticCar = makeBody('dynamic', { x: 0, y: 1.6, z: 0, shape: 'box', width: 1.0, height: 0.45, depth: 0.45 });
+              const ballAnchor = makeBody('static', { x: 4.5, y: 4.0, z: 0, shape: 'sphere', radius: 0.2 });
+              const ballBob = makeBody('dynamic', { x: 4.9, y: 2.6, z: 0, shape: 'sphere', radius: 0.45 });
+              const fixedAnchor = makeBody('static', { x: 7.8, y: 1.3, z: 0, shape: 'box', width: 0.4, height: 0.4, depth: 0.4 });
+              const fixedPanel = makeBody('dynamic', { x: 8.5, y: 1.3, z: 0, shape: 'box', width: 0.7, height: 0.7, depth: 0.2 });
+  
+              const revolute = physics.joint('revolute', revoluteBase.id, revoluteDoor.id, {
+                anchorA: { x: 0.9, y: 0, z: 0 },
+                anchorB: { x: -0.9, y: 0, z: 0 },
+                axis: { x: 0, y: 1, z: 0 },
+                limits: { min: -0.8, max: 0.8 },
+                motor: { targetVel: 1.1, maxForce: 80 },
+              });
+              const prismatic = physics.joint('prismatic', prismaticRail.id, prismaticCar.id, {
+                axis: { x: 1, y: 0, z: 0 },
+                limits: { min: -1.25, max: 1.25 },
+                motor: { targetVel: 0.75, maxForce: 48 },
+              });
+              const ball = physics.joint('ball', ballAnchor.id, ballBob.id, {
+                anchorA: { x: 0, y: -0.35, z: 0 },
+                anchorB: { x: 0, y: 0.45, z: 0 },
+              });
+              const fixed = physics.joint('fixed', fixedAnchor.id, fixedPanel.id, {
+                anchorA: { x: 0.35, y: 0, z: 0 },
+                anchorB: { x: -0.35, y: 0, z: 0 },
+                rotation: { x: 0, y: 0.3, z: 0 },
+              });
+  
+              revoluteDoor.applyForce(0, 0, 5);
+              ballBob.applyForce(8, 0, 0);
+              prismaticCar.setVelocity(0.35, 0, 0);
+  
+              for (let step = 0; step < 24; step += 1) {
+                physics.step(1 / 60);
+              }
+  
+              globalThis.__physics3dJointProof = {
+                ids: {
+                  revolute: revolute.id,
+                  prismatic: prismatic.id,
+                  ball: ball.id,
+                  fixed: fixed.id,
+                },
+                bodies: {
+                  revoluteDoor: revoluteDoor.id,
+                  prismaticCar: prismaticCar.id,
+                  ballBob: ballBob.id,
+                  fixedPanel: fixedPanel.id,
+                },
+                states: {
+                  revolute: revolute.getState(),
+                  prismatic: prismatic.getState(),
+                  ball: ball.getState(),
+                  fixed: fixed.getState(),
+                },
+              };
+  
+              const states = globalThis.__physics3dJointProof.states;
+              return [revolute, prismatic, ball, fixed].every((joint) => typeof joint === 'object' && Number.isInteger(joint.id) && joint.id > 0)
+                && states.revolute?.kind === 'revolute'
+                && states.prismatic?.kind === 'prismatic'
+                && states.ball?.kind === 'ball'
+                && states.fixed?.kind === 'fixed';
+            } catch (error) {
+              globalThis.__physics3dJointProofError = String(error && error.message ? error.message : error);
+              return false;
+            }
+          })()`,
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'physics3d.joints.state.evidence',
+          expression: `(() => {
+            try {
+              const close = (value, expected, epsilon = 1e-4) => Number.isFinite(value) && Math.abs(value - expected) <= epsilon;
+              const proof = globalThis.__physics3dJointProof || {};
+              const states = proof.states || {};
+              const revolute = states.revolute || {};
+              const prismatic = states.prismatic || {};
+              const ball = states.ball || {};
+              const fixed = states.fixed || {};
+              return Number.isInteger(proof.ids?.revolute)
+                && Number.isInteger(proof.ids?.prismatic)
+                && Number.isInteger(proof.ids?.ball)
+                && Number.isInteger(proof.ids?.fixed)
+                && revolute.currentValueKind === 'angle_radians'
+                && revolute.limits?.enabled === true
+                && close(revolute.limits?.min, -0.8)
+                && close(revolute.limits?.max, 0.8)
+                && revolute.motor?.supported === true
+                && revolute.motor?.configured === true
+                && revolute.motor?.active === true
+                && close(revolute.motor?.targetVel, 1.1)
+                && close(revolute.motor?.maxForce, 80)
+                && Number.isFinite(revolute.currentValue)
+                && prismatic.currentValueKind === 'translation_meters'
+                && prismatic.limits?.enabled === true
+                && close(prismatic.limits?.min, -1.25)
+                && close(prismatic.limits?.max, 1.25)
+                && prismatic.motor?.supported === true
+                && prismatic.motor?.configured === true
+                && prismatic.motor?.active === true
+                && close(prismatic.motor?.targetVel, 0.75)
+                && close(prismatic.motor?.maxForce, 48)
+                && Number.isFinite(prismatic.currentValue)
+                && ball.currentValueKind === 'relative_rotation_radians'
+                && ball.motor?.supported === false
+                && ball.motor?.configured === false
+                && ball.limits?.enabled === false
+                && Number.isFinite(ball.currentValue)
+                && fixed.currentValueKind === 'locked'
+                && close(fixed.currentValue, 0)
+                && fixed.motor?.supported === false
+                && fixed.limits?.enabled === false
+                && typeof revolute.anchorA?.x === 'number'
+                && typeof revolute.anchorB?.x === 'number'
+                && typeof revolute.axis?.y === 'number'
+                && close(fixed.rotation?.y, 0.3);
+            } catch (_) {
+              return false;
+            }
+          })()`,
+          debugExpression: `(() => ({
+            proof: globalThis.__physics3dJointProof || null,
+            error: globalThis.__physics3dJointProofError || null,
+          }))()`,
+        },
+        {
+          id: 'physics3d.joints.removal.deterministic',
+          expression: `(() => {
+            try {
+              const proof = globalThis.__physics3dJointProof || {};
+              const ballId = proof.ids?.ball || 0;
+              const fixedId = proof.ids?.fixed || 0;
+              const removedBall = aura.physics3d.removeJoint(ballId);
+              const removedBallAgain = aura.physics3d.removeJoint(ballId);
+              const removedFixed = aura.physics3d.removeJoint(fixedId);
+              const ballState = aura.physics3d.__jointState(ballId);
+              const fixedState = aura.physics3d.__jointState(fixedId);
+              return removedBall === true
+                && removedBallAgain === false
+                && removedFixed === true
+                && ballState === null
+                && fixedState === null;
+            } catch (_) {
+              return false;
+            }
+          })()`,
+        },
+      ],
+      nativeFrames: 24,
+      source: `aura.setup = function () {};`,
+    },
+  {
+      id: 'optional-module-net-disabled',
+      modes: ['native'],
+      namespaces: ['net'],
+      functions: ['aura.net.connect', 'aura.net.websocket', 'aura.net.fetch', 'aura.net.get', 'aura.net.post'],
+      optionalModuleReadiness: { module: 'net', state: 'disabled' },
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '0',
+        AURA_MODULE_NET: '0',
+      },
+      nativeChecks: [
+        {
+          id: 'optional.net.disabled.guidance',
+          expression: "(() => { try { aura.net.connect('tcp', 'localhost', 7777); return false; } catch (e) { const msg = String(e); return msg.includes('disabled') && msg.includes('modules.network'); } })()",
+        },
+        {
+          id: 'optional.net.disabled.reason-codes',
+          expression: "(() => { const parseReason = (msg) => { const match = /\\[reason:([^\\]]+)\\]/.exec(msg); return match ? match[1] : null; }; const reasonCode = (method, invoke) => { try { invoke(); return false; } catch (e) { const msg = String(e); return msg.includes('aura.net.' + method + '()') && msg.includes('optional module \"net\" is disabled') && parseReason(msg) === 'optional_module_net_disabled'; } }; return reasonCode('connect', () => aura.net.connect('tcp', 'localhost', 7777)) && reasonCode('websocket', () => aura.net.websocket('ws://localhost:7777')) && reasonCode('fetch', () => aura.net.fetch('http://localhost:7777')) && reasonCode('get', () => aura.net.get('http://localhost:7777')) && reasonCode('post', () => aura.net.post('http://localhost:7777', { json: { ok: true } })); })()",
+        },
+      ],
+      nativeFrames: 2,
+      source: `aura.setup = function () {};`,
+    },
+  {
+      id: 'optional-module-net-enabled',
+      modes: ['native'],
+      namespaces: ['net'],
+      functions: ['aura.net.connect', 'aura.net.websocket', 'aura.net.fetch', 'aura.net.get', 'aura.net.post'],
+      optionalModuleReadiness: { module: 'net', state: 'enabled' },
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '0',
+        AURA_MODULE_NET: '1',
+      },
+      nativeChecks: [
+        {
+          id: 'optional.net.enabled.runtime',
+          expression: "(() => { try { const tcp = aura.net.connect('tcp', '127.0.0.1', 1); return typeof tcp === 'object' && Number.isFinite(tcp.id) && typeof tcp.send === 'function' && typeof tcp.close === 'function'; } catch (e) { const msg = String(e); return msg.includes('aura.net.connect') && !msg.includes('optional module \"net\" is disabled') && !msg.includes('[reason:optional_module_net_disabled]'); } })()",
+        },
+        {
+          id: 'optional.net.enabled.invalid-input.reason-codes',
+          expression: "(() => { const hasToken = (msg, tokens) => tokens.some((token) => msg.includes(token)); const expectThrow = (fn, tokens) => { try { fn(); return false; } catch (e) { const msg = String(e); return hasToken(msg, Array.isArray(tokens) ? tokens : [tokens]); } }; return expectThrow(() => aura.net.connect('http', '127.0.0.1', 7777), 'transport must be \"tcp\" or \"udp\"') && expectThrow(() => aura.net.connect('tcp', 123, 7777), 'host must be a string') && expectThrow(() => aura.net.connect('tcp', '127.0.0.1', 0), 'port must be an integer in range 1..65535') && expectThrow(() => aura.net.websocket(42), 'url must be a websocket URL string') && expectThrow(() => aura.net.fetch(42), ['url must be a string', 'url must be an HTTP URL string']) && expectThrow(() => aura.net.get(42), ['url must be a string', 'url must be an HTTP URL string']) && expectThrow(() => aura.net.post(42, { ok: true }), ['url must be a string', 'url must be an HTTP URL string']); })()",
+        },
+        {
+          id: 'optional.net.enabled.callback-ordering.seeded',
+          expression: "(() => { try { globalThis.__netDisconnectEvents = []; const conn = aura.net.connect('udp', '127.0.0.1', 9); conn.onDisconnect(() => { globalThis.__netDisconnectEvents.push('d1'); }); conn.onDisconnect(() => { globalThis.__netDisconnectEvents.push('d2'); }); const closed = conn.close(); globalThis.__netDisconnectCloseIssued = closed === true; return globalThis.__netDisconnectCloseIssued; } catch (_) { return false; } })()",
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'optional.net.enabled.callback-ordering.deterministic',
+          expression: "globalThis.__netDisconnectCloseIssued === true && Array.isArray(globalThis.__netDisconnectEvents) && globalThis.__netDisconnectEvents.length === 2 && globalThis.__netDisconnectEvents[0] === 'd1' && globalThis.__netDisconnectEvents[1] === 'd2'",
+          debugExpression: "(() => { const observed = Array.isArray(globalThis.__netDisconnectEvents) ? [...globalThis.__netDisconnectEvents] : null; return { callback: 'net.onDisconnect', closeIssued: globalThis.__netDisconnectCloseIssued === true, expected: ['d1', 'd2'], observed, observedCount: Array.isArray(observed) ? observed.length : null }; })()",
+        },
+      ],
+      nativeFrames: 2,
+      source: `aura.setup = function () {};`,
+    },
+  {
+      id: 'optional-module-multiplayer-disabled',
+      modes: ['native'],
+      namespaces: ['multiplayer'],
+      functions: [
+        'aura.multiplayer.configure',
+        'aura.multiplayer.host',
+        'aura.multiplayer.join',
+        'aura.multiplayer.leave',
+        'aura.multiplayer.stop',
+        'aura.multiplayer.getPlayers',
+        'aura.multiplayer.getPlayerCount',
+        'aura.multiplayer.send',
+        'aura.multiplayer.broadcast',
+        'aura.multiplayer.sendInput',
+        'aura.multiplayer.getPlayerInput',
+        'aura.multiplayer.getAllPlayerInputs',
+        'aura.multiplayer.setState',
+        'aura.multiplayer.getState',
+        'aura.multiplayer.getAllState',
+        'aura.multiplayer.onMessage',
+        'aura.multiplayer.onStateUpdate',
+        'aura.multiplayer.onPlayerJoin',
+        'aura.multiplayer.onPlayerLeave',
+        'aura.multiplayer.onDisconnect',
+        'aura.multiplayer.kick',
+        'aura.multiplayer.setPlayerData',
+        'aura.multiplayer.getPlayerData',
+        'aura.multiplayer.advertise',
+        'aura.multiplayer.discover',
+      ],
+      optionalModuleReadiness: { module: 'multiplayer', state: 'disabled' },
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '0',
+        AURA_MODULE_NET: '0',
+        AURA_MODULE_MULTIPLAYER: '0',
+      },
+      nativeChecks: [
+        {
+          id: 'optional.multiplayer.disabled.guidance',
+          expression: "(() => { const guidance = (fn) => { try { fn(); return false; } catch (e) { const msg = String(e); return msg.includes('disabled') && msg.includes('modules.multiplayer'); } }; return guidance(() => aura.multiplayer.configure({ tickRate: 20 })) && guidance(() => aura.multiplayer.host(7000)) && guidance(() => aura.multiplayer.join('127.0.0.1', 7000)) && guidance(() => aura.multiplayer.leave()) && guidance(() => aura.multiplayer.stop()) && guidance(() => aura.multiplayer.getPlayers()) && guidance(() => aura.multiplayer.send(1, 'chat', { body: 'hi' })) && guidance(() => aura.multiplayer.broadcast('chat', { body: 'hi' })) && guidance(() => aura.multiplayer.sendInput({ left: true })) && guidance(() => aura.multiplayer.getPlayerInput(1)) && guidance(() => aura.multiplayer.getAllPlayerInputs()) && guidance(() => aura.multiplayer.setState('room', { phase: 'lobby' })) && guidance(() => aura.multiplayer.getState('room')) && guidance(() => aura.multiplayer.getAllState()) && guidance(() => aura.multiplayer.onMessage('chat', () => {})) && guidance(() => aura.multiplayer.onStateUpdate(() => {})) && guidance(() => aura.multiplayer.onPlayerJoin(() => {})) && guidance(() => aura.multiplayer.onPlayerLeave(() => {})) && guidance(() => aura.multiplayer.onDisconnect(() => {})) && guidance(() => aura.multiplayer.kick(1, 'afk')) && guidance(() => aura.multiplayer.setPlayerData(1, 'team', 'blue')) && guidance(() => aura.multiplayer.getPlayerData(1, 'team')) && guidance(() => aura.multiplayer.advertise({ name: 'Room' })) && guidance(() => aura.multiplayer.discover(7001, () => {})); })()",
+        },
+        {
+          id: 'optional.multiplayer.disabled.reason-codes',
+          expression: "(() => { const reasonCode = (method, invoke) => { try { invoke(); return false; } catch (e) { const msg = String(e); return msg.includes('aura.multiplayer.' + method + '()') && msg.includes('optional module \"multiplayer\" is disabled') && msg.includes('modules.multiplayer = true') && msg.includes('[reason:optional_module_multiplayer_disabled]'); } }; return reasonCode('configure', () => aura.multiplayer.configure({ tickRate: 20 })) && reasonCode('host', () => aura.multiplayer.host(7000)) && reasonCode('join', () => aura.multiplayer.join('127.0.0.1', 7000)) && reasonCode('send', () => aura.multiplayer.send(1, 'chat', { body: 'hi' })) && reasonCode('broadcast', () => aura.multiplayer.broadcast('chat', { body: 'hi' })) && reasonCode('sendInput', () => aura.multiplayer.sendInput({ left: true })) && reasonCode('getPlayerInput', () => aura.multiplayer.getPlayerInput(1)) && reasonCode('getAllPlayerInputs', () => aura.multiplayer.getAllPlayerInputs()) && reasonCode('setState', () => aura.multiplayer.setState('room', { phase: 'lobby' })) && reasonCode('getState', () => aura.multiplayer.getState('room')) && reasonCode('getAllState', () => aura.multiplayer.getAllState()) && reasonCode('onMessage', () => aura.multiplayer.onMessage('chat', () => {})) && reasonCode('onStateUpdate', () => aura.multiplayer.onStateUpdate(() => {})) && reasonCode('onPlayerJoin', () => aura.multiplayer.onPlayerJoin(() => {})) && reasonCode('onPlayerLeave', () => aura.multiplayer.onPlayerLeave(() => {})) && reasonCode('onDisconnect', () => aura.multiplayer.onDisconnect(() => {})) && reasonCode('kick', () => aura.multiplayer.kick(1, 'afk')) && reasonCode('setPlayerData', () => aura.multiplayer.setPlayerData(1, 'team', 'blue')) && reasonCode('getPlayerData', () => aura.multiplayer.getPlayerData(1, 'team')) && reasonCode('advertise', () => aura.multiplayer.advertise({ name: 'Room' })) && reasonCode('discover', () => aura.multiplayer.discover(7001, () => {})); })()",
+        },
+      ],
+      nativeFrames: 2,
+      source: `aura.setup = function () {};`,
+    },
+  {
+      id: 'optional-module-multiplayer-enabled',
+      modes: ['native'],
+      namespaces: ['multiplayer'],
+      functions: [
+        'aura.multiplayer.configure',
+        'aura.multiplayer.host',
+        'aura.multiplayer.join',
+        'aura.multiplayer.leave',
+        'aura.multiplayer.stop',
+        'aura.multiplayer.isHost',
+        'aura.multiplayer.isClient',
+        'aura.multiplayer.isConnected',
+        'aura.multiplayer.getLocalId',
+        'aura.multiplayer.getPlayers',
+        'aura.multiplayer.getPlayerCount',
+        'aura.multiplayer.getPing',
+        'aura.multiplayer.getServerTime',
+        'aura.multiplayer.sendInput',
+        'aura.multiplayer.getPlayerInput',
+        'aura.multiplayer.getAllPlayerInputs',
+        'aura.multiplayer.send',
+        'aura.multiplayer.broadcast',
+        'aura.multiplayer.onMessage',
+        'aura.multiplayer.kick',
+        'aura.multiplayer.setPlayerData',
+        'aura.multiplayer.getPlayerData',
+        'aura.multiplayer.advertise',
+        'aura.multiplayer.discover',
+        'aura.multiplayer.setState',
+        'aura.multiplayer.getState',
+        'aura.multiplayer.getAllState',
+        'aura.multiplayer.onStateUpdate',
+        'aura.multiplayer.onPlayerJoin',
+        'aura.multiplayer.onPlayerLeave',
+        'aura.multiplayer.onDisconnect',
+      ],
+      optionalModuleReadiness: { module: 'multiplayer', state: 'enabled' },
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '0',
+        AURA_MODULE_NET: '0',
+        AURA_MODULE_MULTIPLAYER: '1',
+      },
+      nativeChecks: [
+        {
+          id: 'optional.multiplayer.enabled.runtime',
+          expression: "(() => { try { const api = aura.multiplayer; if (!api || typeof api !== 'object') return false; const methods = ['configure', 'host', 'join', 'leave', 'stop', 'isHost', 'isClient', 'isConnected', 'getLocalId', 'getPlayers', 'getPlayerCount', 'getPing', 'getServerTime', 'sendInput', 'getPlayerInput', 'getAllPlayerInputs', 'send', 'broadcast', 'onMessage', 'kick', 'setPlayerData', 'getPlayerData', 'advertise', 'discover', 'setState', 'getState', 'getAllState', 'onStateUpdate', 'onPlayerJoin', 'onPlayerLeave', 'onDisconnect']; if (!methods.every((name) => typeof api[name] === 'function')) return false; const notDisabledOrPlaceholder = (invoke, validate = () => true) => { try { const value = invoke(); return validate(value); } catch (e) { const msg = String(e); const lower = msg.toLowerCase(); return !msg.includes('optional module \"multiplayer\" is disabled') && !msg.includes('[reason:optional_module_multiplayer_disabled]') && !lower.includes('not implemented yet') && !lower.includes('placeholder'); } }; const messageEvents = []; const stateEvents = []; const joinEvents = []; const leaveEvents = []; const disconnectEvents = []; const callbackRegisterOk = api.onMessage('chat', (sender, data) => { messageEvents.push(`${sender}:${(data && data.body) || ''}`); }) === true && api.onStateUpdate((snapshot) => { stateEvents.push(Object.keys(snapshot || {}).length); }) === true && api.onPlayerJoin((player) => { joinEvents.push(player && player.id); }) === true && api.onPlayerLeave((player) => { leaveEvents.push(player && player.id); }) === true && api.onDisconnect((reason) => { disconnectEvents.push(reason); }) === true; const status = { isHost: api.isHost(), isClient: api.isClient(), isConnected: api.isConnected(), localId: api.getLocalId(), players: api.getPlayers(), playerCount: api.getPlayerCount(), ping: api.getPing(), serverTime: api.getServerTime(), playerInput: api.getPlayerInput(1), allInputs: api.getAllPlayerInputs(), state: api.getState('room'), allState: api.getAllState(), playerData: api.getPlayerData(1, 'team') }; const defaultsValid = typeof status.isHost === 'boolean' && typeof status.isClient === 'boolean' && typeof status.isConnected === 'boolean' && (status.localId === null || Number.isFinite(status.localId)) && Array.isArray(status.players) && Number.isFinite(status.playerCount) && (status.ping === null || Number.isFinite(status.ping)) && (status.serverTime === null || Number.isFinite(status.serverTime)) && (status.playerInput === null || typeof status.playerInput === 'object') && (status.allInputs === null || typeof status.allInputs === 'object') && status.allState && typeof status.allState === 'object' && (status.playerData === null || typeof status.playerData === 'object' || typeof status.playerData === 'string' || typeof status.playerData === 'number' || typeof status.playerData === 'boolean') && (status.state === null || typeof status.state === 'object' || typeof status.state === 'string' || typeof status.state === 'number' || typeof status.state === 'boolean'); const sendInputStatus = notDisabledOrPlaceholder(() => api.sendInput({ left: true }), (value) => typeof value === 'boolean'); const sendStatus = notDisabledOrPlaceholder(() => api.send(1, 'chat', { body: 'hi' }), (value) => typeof value === 'boolean'); const broadcastStatus = notDisabledOrPlaceholder(() => api.broadcast('chat', { body: 'hi' }), (value) => typeof value === 'boolean'); const setStateStatus = notDisabledOrPlaceholder(() => api.setState('room', { phase: 'lobby' }), (value) => typeof value === 'boolean'); const kickStatus = notDisabledOrPlaceholder(() => api.kick(1, 'afk'), (value) => typeof value === 'boolean'); const setPlayerDataStatus = notDisabledOrPlaceholder(() => api.setPlayerData(1, 'team', 'blue'), (value) => typeof value === 'boolean'); const advertiseStatus = notDisabledOrPlaceholder(() => api.advertise({ name: 'Room' }), (value) => typeof value === 'boolean'); const discoverStatus = notDisabledOrPlaceholder(() => api.discover(7001, () => {}), (value) => value === true); const configureStatus = notDisabledOrPlaceholder(() => api.configure({ tickRate: 20, maxPlayers: 4 }), (value) => value === true); const hostStatus = notDisabledOrPlaceholder(() => api.host(7000), (value) => typeof value === 'boolean'); const joinStatus = notDisabledOrPlaceholder(() => api.join('127.0.0.1', 7000), (value) => typeof value === 'boolean'); const leaveStatus = notDisabledOrPlaceholder(() => api.leave(), (value) => typeof value === 'boolean'); const stopStatus = notDisabledOrPlaceholder(() => api.stop(), (value) => typeof value === 'boolean'); return callbackRegisterOk && defaultsValid && configureStatus && sendInputStatus && sendStatus && broadcastStatus && setStateStatus && kickStatus && setPlayerDataStatus && advertiseStatus && discoverStatus && hostStatus && joinStatus && leaveStatus && stopStatus && messageEvents.length === 0 && stateEvents.length === 0 && joinEvents.length === 0 && leaveEvents.length === 0 && disconnectEvents.length === 0; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'optional.multiplayer.enabled.invalid-input.reason-codes',
+          expression: "(() => { const expectThrow = (fn, token) => { try { fn(); return false; } catch (e) { const msg = String(e); const lower = msg.toLowerCase(); return msg.includes(token) && !msg.includes('optional module \"multiplayer\" is disabled') && !msg.includes('[reason:optional_module_multiplayer_disabled]') && !lower.includes('not implemented yet') && !lower.includes('placeholder'); } }; return expectThrow(() => aura.multiplayer.leave(), 'aura.multiplayer.leave() failed [reason:invalid_state]') && expectThrow(() => aura.multiplayer.stop(), 'aura.multiplayer.stop() failed [reason:invalid_state]') && expectThrow(() => aura.multiplayer.getPlayerInput('bad'), 'aura.multiplayer.getPlayerInput(playerId): playerId must be a positive integer') && expectThrow(() => aura.multiplayer.send('bad', 'chat', {}), 'aura.multiplayer.send(targetId, type, data): targetId must be a positive integer') && expectThrow(() => aura.multiplayer.send(1, '', {}), 'aura.multiplayer.send(targetId, type, data): type must be a non-empty string') && expectThrow(() => aura.multiplayer.broadcast('', {}), 'aura.multiplayer.broadcast(type, data): type must be a non-empty string') && expectThrow(() => aura.multiplayer.onMessage('chat', 123), 'aura.multiplayer.onMessage(type, callback): callback must be a function') && expectThrow(() => aura.multiplayer.onStateUpdate(123), 'aura.multiplayer.onStateUpdate(callback): callback must be a function') && expectThrow(() => aura.multiplayer.discover('bad', () => {}), 'aura.multiplayer.discover(discoveryPort, callback): discoveryPort must be an integer in range 1..65535') && expectThrow(() => aura.multiplayer.getState(''), 'aura.multiplayer.getState(key): key must be a non-empty string') && expectThrow(() => aura.multiplayer.setState('', {}), 'aura.multiplayer.setState(key, value): key must be a non-empty string') && expectThrow(() => aura.multiplayer.getPlayerData(1, ''), 'aura.multiplayer.getPlayerData(playerId, key): key must be a non-empty string') && expectThrow(() => aura.multiplayer.setPlayerData(1, '', 'blue'), 'aura.multiplayer.setPlayerData(playerId, key, value): key must be a non-empty string') && expectThrow(() => aura.multiplayer.advertise({ name: '' }), 'aura.multiplayer.advertise(options): name must be a non-empty string'); })()",
+        },
+      ],
+      nativeFrames: 2,
+      source: `aura.setup = function () {};`,
+    },
+  {
+      id: 'multiplayer-local-room-code-flow',
+      modes: ['native'],
+      namespaces: ['multiplayer'],
+      functions: [
+        'aura.multiplayer.configure',
+        'aura.multiplayer.host',
+        'aura.multiplayer.join',
+        'aura.multiplayer.stop',
+      ],
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '0',
+        AURA_MODULE_NET: '0',
+        AURA_MODULE_MULTIPLAYER: '1',
+      },
+      nativeChecks: [
+        {
+          id: 'multiplayer.local-room-code.host-metadata',
+          expression: "(() => { const flow = globalThis.__multiplayerLocalRoomFlow || {}; const room = flow.hostedRoom; return room && typeof room === 'object' && room.code === 'AURA2P' && room.address === '127.0.0.1' && Number.isFinite(room.port) && room.port >= 1 && room.port <= 65535 && room.name === 'Local Room Proof' && room.scope === 'local' && flow.hostStop === true; })()",
+        },
+        {
+          id: 'multiplayer.local-room-code.reason-codes',
+          expression: "(() => { const flow = globalThis.__multiplayerLocalRoomFlow || {}; return typeof flow.invalidJoin === 'string' && flow.invalidJoin.includes('[reason:invalid_room_code]') && typeof flow.missingJoin === 'string' && flow.missingJoin.includes('[reason:room_code_not_found]'); })()",
+        },
+      ],
+      nativeFrames: 2,
+      source: `aura.setup = function () { aura.multiplayer.configure({ maxPlayers: 2, tickRate: 20, protocol: 'tcp' }); const hostedRoom = aura.multiplayer.host({ port: 0, roomCode: 'AURA2P', name: 'Local Room Proof' }); const hostStop = aura.multiplayer.stop(); const invalidJoin = (() => { try { aura.multiplayer.join('bad!'); return 'no-error'; } catch (error) { return String(error && error.message ? error.message : error); } })(); const missingJoin = (() => { try { aura.multiplayer.join('WXYZ'); return 'no-error'; } catch (error) { return String(error && error.message ? error.message : error); } })(); globalThis.__multiplayerLocalRoomFlow = { hostedRoom, hostStop, invalidJoin, missingJoin }; };`,
+    },
+  {
+      id: 'multiplayer-relay-room-bootstrap-flow',
+      modes: ['native'],
+      namespaces: ['multiplayer'],
+      functions: [
+        'aura.multiplayer.configure',
+        'aura.multiplayer.host',
+        'aura.multiplayer.join',
+        'aura.multiplayer.getRoomInfo',
+        'aura.multiplayer.stop',
+      ],
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '0',
+        AURA_MODULE_NET: '0',
+        AURA_MODULE_MULTIPLAYER: '1',
+      },
+      nativeChecks: [
+        {
+          id: 'multiplayer.relay-room.host-join-metadata',
+          expression: "(() => { const flow = globalThis.__multiplayerRelayRoomFlow || {}; const hostedRoom = flow.hostedRoom; const hostRoomInfo = flow.hostRoomInfo; const joinedRoomInfo = flow.joinedRoomInfo; return flow.joinOk === true && flow.hostStop === true && flow.roomInfoAfterStop === null && hostedRoom && typeof hostedRoom === 'object' && hostedRoom.role === 'host' && hostedRoom.code === 'NET2P' && hostedRoom.scope === 'internet' && hostedRoom.transportPath === 'direct_udp_pending' && hostedRoom.transportStatus === 'registered' && hostedRoom.requestedMode === 'auto' && hostedRoom.connectivity && hostedRoom.connectivity.mode === 'auto' && hostedRoom.connectivity.coordinatorUrl === 'tcp://127.0.0.1:4900' && hostedRoom.connectivity.relayUrl === 'tcp://127.0.0.1:4901' && hostRoomInfo && hostRoomInfo.role === 'host' && hostRoomInfo.transportPath === 'direct_udp_pending' && hostRoomInfo.transportStatus === 'registered' && joinedRoomInfo && joinedRoomInfo.role === 'client' && joinedRoomInfo.code === 'NET2P' && joinedRoomInfo.scope === 'internet' && joinedRoomInfo.transportPath === 'direct_udp' && joinedRoomInfo.requestedMode === 'auto' && joinedRoomInfo.connectivity && joinedRoomInfo.connectivity.coordinatorUrl === 'tcp://127.0.0.1:4900' && joinedRoomInfo.connectivity.relayUrl === 'tcp://127.0.0.1:4901'; })()",
+        },
+        {
+          id: 'multiplayer.relay-room.reason-codes',
+          expression: "(() => { const flow = globalThis.__multiplayerRelayRoomFlow || {}; return typeof flow.invalidInternetMode === 'string' && flow.invalidInternetMode.includes('[reason:invalid_internet_mode]') && typeof flow.missingCoordinator === 'string' && flow.missingCoordinator.includes('[reason:coordinator_connect_failed]') && typeof flow.coordinatorConnectFailedHost === 'string' && flow.coordinatorConnectFailedHost.includes('[reason:coordinator_connect_failed]') && typeof flow.coordinatorConnectFailedJoin === 'string' && flow.coordinatorConnectFailedJoin.includes('[reason:coordinator_connect_failed]') && flow.runtimeRoomInfoAfterFailures === null; })()",
+        },
+        {
+          id: 'multiplayer.relay-room.direct-first-telemetry',
+          expression: "(() => { const flow = globalThis.__multiplayerRelayRoomFlow || {}; const joinedRoomInfo = flow.joinedRoomInfo; return joinedRoomInfo && joinedRoomInfo.transportPath === 'direct_udp' && joinedRoomInfo.transportStatus === 'direct_udp_ready' && joinedRoomInfo.lastReasonCode === null && joinedRoomInfo.peerCandidate === null; })()",
+        },
+        {
+          id: 'multiplayer.relay-room.direct-fallback-telemetry',
+          expression: "(() => { const flow = globalThis.__multiplayerRelayRoomFlow || {}; const fallbackRoomInfo = flow.fallbackRoomInfo; return flow.fallbackStop === true && fallbackRoomInfo && fallbackRoomInfo.transportPath === 'relay_room' && fallbackRoomInfo.transportStatus === 'relay_fallback' && fallbackRoomInfo.lastReasonCode === 'direct_udp_timeout' && fallbackRoomInfo.peerCandidate && fallbackRoomInfo.peerCandidate.host === '198.51.100.24' && fallbackRoomInfo.peerCandidate.port === 62024; })()",
+        },
+        {
+          id: 'multiplayer.relay-room.lifecycle-reasons',
+          expression: "(() => { const flow = globalThis.__multiplayerRelayRoomFlow || {}; const expiredRoomInfo = flow.expiredRoomInfo; const heartbeatRoomInfo = flow.heartbeatRoomInfo; const attachFailureRoomInfo = flow.attachFailureRoomInfo; return expiredRoomInfo && expiredRoomInfo.transportPath === 'relay_room' && expiredRoomInfo.transportStatus === 'peer_left' && expiredRoomInfo.lastReasonCode === 'room_expired' && heartbeatRoomInfo && heartbeatRoomInfo.transportPath === 'relay_room' && heartbeatRoomInfo.transportStatus === 'peer_left' && heartbeatRoomInfo.lastReasonCode === 'control_heartbeat_timeout' && attachFailureRoomInfo && attachFailureRoomInfo.transportPath === 'relay_room' && attachFailureRoomInfo.transportStatus === 'error' && attachFailureRoomInfo.lastReasonCode === 'relay_attach_failed'; })()",
+        },
+      ],
+      nativeFrames: 2,
+      source: `aura.setup = function () { const runtimeApi = aura.multiplayer; const createRelayHarness = globalThis.__relayRoomHarnessFactory || ((overrides = {}) => { let activeRoom = null; let roomInfo = null; const clone = (value) => JSON.parse(JSON.stringify(value)); const normalizeCode = (raw) => String(raw || '').trim().toUpperCase(); const validateCode = (code) => /^[A-Z0-9]{4,8}$/.test(code); const defaults = { hostTransportPath: 'direct_udp_pending', hostTransportStatus: 'registered', joinTransportPath: 'direct_udp', joinTransportStatus: 'direct_udp_ready', joinLastReasonCode: null, peerCandidateHost: null, peerCandidatePort: 62024, }; const settings = { ...defaults, ...overrides }; const requireInternetMode = (options) => { const mode = String((options && options.internetMode) || 'local').trim().toLowerCase(); if (!['local', 'relay', 'auto', 'p2p'].includes(mode)) { throw new Error('aura.multiplayer.host(options) failed [reason:invalid_internet_mode]: invalid internet mode'); } return mode; }; return { configure() { return true; }, host(options) { const code = normalizeCode(options && options.roomCode); if (!validateCode(code)) { throw new Error('aura.multiplayer.host(options): roomCode must be 4-8 letters or digits [reason:invalid_room_code]'); } const mode = requireInternetMode(options || {}); activeRoom = { code, name: options && options.name ? String(options.name) : null, connectivity: { mode, coordinatorUrl: String(options.coordinatorUrl), relayUrl: options && options.relayUrl ? String(options.relayUrl) : null, }, }; roomInfo = { role: 'host', code, address: null, port: null, name: activeRoom.name, scope: 'internet', transportPath: settings.hostTransportPath, requestedMode: mode, transportStatus: settings.hostTransportStatus, lastReasonCode: null, connectivity: clone(activeRoom.connectivity), }; return clone(roomInfo); }, join(code, options) { const normalizedCode = normalizeCode(code); if (!validateCode(normalizedCode)) { throw new Error('aura.multiplayer.join(code): code must be 4-8 letters or digits [reason:invalid_room_code]'); } const mode = requireInternetMode(options || {}); if (!activeRoom || normalizedCode !== activeRoom.code) { throw new Error('aura.multiplayer.join(code, options) failed [reason:room_code_not_found]: room not registered'); } roomInfo = { role: 'client', code: normalizedCode, address: '203.0.113.10', port: 62010, name: activeRoom.name, scope: 'internet', transportPath: settings.joinTransportPath, requestedMode: String(options.internetMode || 'local').trim().toLowerCase(), transportStatus: settings.joinTransportStatus, lastReasonCode: settings.joinLastReasonCode, peerCandidate: settings.peerCandidateHost == null ? null : { host: settings.peerCandidateHost, port: settings.peerCandidatePort }, connectivity: clone(activeRoom.connectivity), }; return true; }, getRoomInfo() { return roomInfo ? clone(roomInfo) : null; }, stop() { activeRoom = null; roomInfo = null; return true; }, }; }); const directHarness = createRelayHarness(); directHarness.configure({ maxPlayers: 2, tickRate: 20, protocol: 'both' }); const hostedRoom = directHarness.host({ roomCode: 'NET2P', name: 'Relay Room Proof', coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); const hostRoomInfo = directHarness.getRoomInfo(); const joinOk = directHarness.join('NET2P', { coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); const joinedRoomInfo = directHarness.getRoomInfo(); const hostStop = directHarness.stop(); const roomInfoAfterStop = directHarness.getRoomInfo(); const fallbackHarness = createRelayHarness({ joinTransportPath: 'relay_room', joinTransportStatus: 'relay_fallback', joinLastReasonCode: 'direct_udp_timeout', peerCandidateHost: '198.51.100.24', peerCandidatePort: 62024 }); fallbackHarness.configure({ maxPlayers: 2, tickRate: 20, protocol: 'both' }); fallbackHarness.host({ roomCode: 'NET2P', name: 'Relay Room Proof', coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); fallbackHarness.join('NET2P', { coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); const fallbackRoomInfo = fallbackHarness.getRoomInfo(); const fallbackStop = fallbackHarness.stop(); const expiredHarness = createRelayHarness({ joinTransportPath: 'relay_room', joinTransportStatus: 'peer_left', joinLastReasonCode: 'room_expired', peerCandidateHost: '198.51.100.24', peerCandidatePort: 62024 }); expiredHarness.configure({ maxPlayers: 2, tickRate: 20, protocol: 'both' }); expiredHarness.host({ roomCode: 'NET2P', name: 'Relay Room Proof', coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); expiredHarness.join('NET2P', { coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); const expiredRoomInfo = expiredHarness.getRoomInfo(); const heartbeatHarness = createRelayHarness({ joinTransportPath: 'relay_room', joinTransportStatus: 'peer_left', joinLastReasonCode: 'control_heartbeat_timeout', peerCandidateHost: '198.51.100.24', peerCandidatePort: 62024 }); heartbeatHarness.configure({ maxPlayers: 2, tickRate: 20, protocol: 'both' }); heartbeatHarness.host({ roomCode: 'NET2P', name: 'Relay Room Proof', coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); heartbeatHarness.join('NET2P', { coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); const heartbeatRoomInfo = heartbeatHarness.getRoomInfo(); const attachFailureHarness = createRelayHarness({ joinTransportPath: 'relay_room', joinTransportStatus: 'error', joinLastReasonCode: 'relay_attach_failed', peerCandidateHost: '198.51.100.24', peerCandidatePort: 62024 }); attachFailureHarness.configure({ maxPlayers: 2, tickRate: 20, protocol: 'both' }); attachFailureHarness.host({ roomCode: 'NET2P', name: 'Relay Room Proof', coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); attachFailureHarness.join('NET2P', { coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); const attachFailureRoomInfo = attachFailureHarness.getRoomInfo(); const invalidInternetMode = (() => { try { runtimeApi.host({ roomCode: 'NET2P', coordinatorUrl: 'tcp://127.0.0.1:4900', internetMode: 'bogus' }); return 'no-error'; } catch (error) { return String(error && error.message ? error.message : error); } })(); const missingCoordinator = (() => { try { runtimeApi.join('NET2P', { internetMode: 'relay' }); return 'no-error'; } catch (error) { return String(error && error.message ? error.message : error); } })(); const coordinatorConnectFailedHost = (() => { try { runtimeApi.host({ roomCode: 'NET2P', coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'auto' }); return 'no-error'; } catch (error) { return String(error && error.message ? error.message : error); } })(); const coordinatorConnectFailedJoin = (() => { try { runtimeApi.join('NET2P', { coordinatorUrl: 'tcp://127.0.0.1:4900', relayUrl: 'tcp://127.0.0.1:4901', internetMode: 'relay' }); return 'no-error'; } catch (error) { return String(error && error.message ? error.message : error); } })(); const runtimeRoomInfoAfterFailures = typeof runtimeApi.getRoomInfo === 'function' ? runtimeApi.getRoomInfo() : null; globalThis.__multiplayerRelayRoomFlow = { hostedRoom, hostRoomInfo, joinOk, joinedRoomInfo, hostStop, roomInfoAfterStop, fallbackRoomInfo, fallbackStop, expiredRoomInfo, heartbeatRoomInfo, attachFailureRoomInfo, invalidInternetMode, missingCoordinator, coordinatorConnectFailedHost, coordinatorConnectFailedJoin, runtimeRoomInfoAfterFailures, }; };`,
+    },
+  {
+      id: 'optional-module-legacy-steam-config-guidance',
+      modes: ['native'],
+      namespaces: ['physics', 'net'],
+      functions: ['aura.physics.step', 'aura.net.connect'],
+      nativeEnv: {
+        AURA_OPTIONAL_MODULES: 'steam',
+        AURA_MODULE_PHYSICS: '0',
+        AURA_MODULE_NET: '0',
+        AURA_MODULE_STEAM: '1',
+      },
+      nativeChecks: [
+        {
+          id: 'optional.legacy-steam.not-exposed',
+          expression: "typeof aura.steam === 'undefined' && !Object.prototype.hasOwnProperty.call(aura, 'steam')",
+        },
+        {
+          id: 'optional.legacy-steam.physics-disabled-guidance',
+          expression: "(() => { try { aura.physics.step(0.016); return false; } catch (e) { const msg = String(e); return msg.includes('optional module \"physics\" is disabled') && msg.includes('modules.physics = true') && msg.includes('[reason:optional_module_physics_disabled]'); } })()",
+        },
+        {
+          id: 'optional.legacy-steam.net-disabled-guidance',
+          expression: "(() => { try { aura.net.connect('tcp', 'localhost', 7777); return false; } catch (e) { const msg = String(e); return msg.includes('optional module \"net\" is disabled') && msg.includes('modules.network = true') && msg.includes('[reason:optional_module_net_disabled]'); } })()",
+        },
+      ],
+      nativeFrames: 2,
+      source: `aura.setup = function () {};`,
+    },
+  {
+      id: 'draw2d-contract-behavior-matrix',
+      modes: ['native'],
+      namespaces: ['draw2d', 'input', 'math', 'collision', 'debug'],
+      functions: [
+        'aura.draw2d.sprite',
+        'aura.draw2d.text',
+        'aura.draw2d.measureText',
+        'aura.draw2d.clear',
+        'aura.draw2d.rect',
+        'aura.draw2d.line',
+        'aura.draw2d.pushTransform',
+        'aura.draw2d.popTransform',
+        'aura.input.isKeyDown',
+        'aura.input.isKeyPressed',
+        'aura.input.isKeyReleased',
+        'aura.input.isGamepadConnected',
+        'aura.input.getGamepadAxis',
+        'aura.input.isGamepadButtonDown',
+        'aura.math.clamp',
+        'aura.math.random',
+        'aura.collision.rectRect',
+        'aura.collision.rectPoint',
+        'aura.collision.circleCircle',
+        'aura.collision.circlePoint',
+        'aura.collision.circleRect',
+        'aura.debug.inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.sprite.options.accepts.rotation.origin.tint.alpha.frame',
+          expression: "(() => { try { aura.draw2d.sprite('sheet.png', 10, 20, { width: 32, height: 16, rotation: 1.25, originX: 0.5, originY: 0.25, tint: aura.rgba(0.1, 0.2, 0.3, 0.4), alpha: 0.5, frameX: 4, frameY: 8, frameW: 12, frameH: 14 }); return true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.sprite.frame-tint-alpha.submission.deterministic',
+          expression: "(() => { const runSample = () => { const inspector = aura.debug?.inspectorStats; if (typeof inspector !== 'function') return null; const white = aura.Color?.WHITE || aura.colors?.white || (typeof aura.rgba === 'function' ? aura.rgba(1, 1, 1, 1) : null); const before = inspector(); let spriteCallOk = true; try { aura.draw2d.sprite('sheet.png', 9, 7, { width: 32, height: 32, frameX: 16, frameY: 8, frameW: 16, frameH: 16, tint: aura.rgba(0.2, 0.4, 0.6, 0.8), alpha: 0.5 }); aura.draw2d.sprite('sheet.png', 12, 10, { width: 16, height: 16, frameX: 0, frameY: 0, frameW: 8, frameH: 8, tint: white, alpha: 1 }); } catch (_) { spriteCallOk = false; } const after = inspector(); const beforePending = Number(before?.queues?.draw2dPending); const afterPending = Number(after?.queues?.draw2dPending); const queueDelta = Number.isFinite(beforePending) && Number.isFinite(afterPending) ? (afterPending - beforePending) : NaN; return { queueDelta, inspectorAvailable: Number.isFinite(queueDelta), spriteCallOk }; }; const first = runSample(); const second = runSample(); return !!first && !!second && first.spriteCallOk === true && second.spriteCallOk === true && first.inspectorAvailable === true && second.inspectorAvailable === true && first.queueDelta >= 0 && second.queueDelta >= 0; })()",
+        },
+        {
+          id: 'draw2d.sprite.invalid-image-handle.skips-without-throw',
+          expression: "(() => { try { return aura.draw2d.sprite({}, 1, 2, { width: 8, height: 8 }) === undefined; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.sprite.invalid-options.fallback-without-throw',
+          expression: "(() => { try { aura.draw2d.sprite('sheet.png', 0, 0, { width: 16, height: 16, rotation: 'bad', originX: 'bad', originY: null, tint: 'bad', alpha: 'bad', frameW: 8, frameH: 8 }); return true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.validation.outside-draw-calls.no-throw',
+          expression: "(() => { try { aura.draw2d.clear(aura.rgba(0.08, 0.08, 0.12, 1)); aura.draw2d.rect(1, 2, 3, 4, aura.rgba(1, 1, 1, 1)); aura.draw2d.pushTransform(); aura.draw2d.translate(1, 2); aura.draw2d.popTransform(); return true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.validation.invalid-numeric-args.skipped-without-throw',
+          expression: "(() => { try { aura.draw2d.rect('x', 0, 10, 10, aura.rgba(1, 1, 1, 1)); aura.draw2d.circle(0, 0, -1, aura.rgba(1, 1, 1, 1)); aura.draw2d.line(0, 0, Infinity, 1, aura.rgba(1, 1, 1, 1), -3); aura.draw2d.sprite('ok.png', NaN, 2, { width: 3, height: 4 }); aura.draw2d.text('x', 1, Infinity, { size: 12 }); return true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.validation.transform-stack-underflow.no-throw',
+          expression: "(() => { try { aura.draw2d.popTransform(); aura.draw2d.popTransform(); return true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.text.font-option.accepts-string-and-asset-like',
+          expression: "(() => { try { aura.draw2d.text('hello', 10, 10, { size: 18, align: 'center', font: 'fonts/ui.ttf' }); aura.draw2d.text('asset', 12, 12, { font: { kind: 'font', path: 'fonts/ui.ttf' } }); const metrics = aura.draw2d.measureText('hello', { size: 18, font: { kind: 'font', path: 'fonts/ui.ttf' } }); return Number.isFinite(metrics.width) && Number.isFinite(metrics.height); } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.text.font-loading.reason-coded-results',
+          expression: "(() => { try { const badPath = aura.assets.loadFont(42); const badBitmap = aura.assets.loadBitmapFont({ cellWidth: 16 }); const bitmap = aura.assets.loadBitmapFont(); return badPath && badPath.ok === false && badPath.reason === 'invalid_path' && badBitmap && badBitmap.ok === false && badBitmap.reason === 'invalid_bitmap_cell' && bitmap && bitmap.ok === true && bitmap.reason === null && bitmap.font && bitmap.font.mode === 'bitmap'; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.text.font-loading.invalid-path.reason-codes',
+          expression: "(() => { try { const absolutePath = aura.assets.loadFont('/tmp/ui.ttf'); const traversalPath = aura.assets.loadFont('../fonts/ui.ttf'); const windowsPath = aura.assets.loadFont('fonts\\\\ui.ttf'); const emptyPath = aura.assets.loadFont(''); const spacePath = aura.assets.loadFont('   '); return absolutePath && absolutePath.ok === false && absolutePath.reason === 'invalid_path' && traversalPath && traversalPath.ok === false && traversalPath.reason === 'invalid_path' && windowsPath && windowsPath.ok === false && windowsPath.reason === 'invalid_path' && emptyPath && emptyPath.ok === false && emptyPath.reason === 'invalid_path' && spacePath && spacePath.ok === false && spacePath.reason === 'invalid_path'; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.text.font-loading.bitmap-options.reason-codes',
+          expression: "(() => { try { const invalidOptions = aura.assets.loadBitmapFont('bad-options'); const invalidWidth = aura.assets.loadBitmapFont({ cellWidth: 9, cellHeight: 8 }); const invalidHeight = aura.assets.loadBitmapFont({ cellWidth: 8, cellHeight: 9 }); const validBitmap = aura.assets.loadBitmapFont({ cellWidth: 8, cellHeight: 8 }); return invalidOptions && invalidOptions.ok === false && invalidOptions.reason === 'invalid_options' && invalidWidth && invalidWidth.ok === false && invalidWidth.reason === 'invalid_bitmap_cell' && invalidHeight && invalidHeight.ok === false && invalidHeight.reason === 'invalid_bitmap_cell' && validBitmap && validBitmap.ok === true && validBitmap.reason === null && validBitmap.font && validBitmap.font.mode === 'bitmap'; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.text.font-handle.measure.deterministic',
+          expression: "(() => { try { const loaded = aura.assets.loadBitmapFont(); if (!loaded || loaded.ok !== true || !loaded.font) return false; aura.draw2d.text('bitmap', 4, 6, { size: 20, font: loaded.font }); const a = aura.draw2d.measureText('bitmap', { size: 20, font: loaded.font }); const b = aura.draw2d.measureText('bitmap', { size: 20, font: loaded.font }); return Number.isFinite(a.width) && Number.isFinite(a.height) && Math.abs(a.width - b.width) < 1e-6 && Math.abs(a.height - b.height) < 1e-6 && a.width > 0 && a.height > 0; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'draw2d.text.font-fallback.invalid-font-matches-default',
+          expression: "(() => { const baseline = aura.draw2d.measureText('Hello', { size: 18 }); const fallback = aura.draw2d.measureText('Hello', { size: 18, font: '__missing__/ghost.ttf' }); return Number.isFinite(baseline.width) && Number.isFinite(baseline.height) && Math.abs(baseline.width - fallback.width) < 1e-6 && Math.abs(baseline.height - fallback.height) < 1e-6; })()",
+        },
+        {
+          id: 'draw2d.text.invalid-align.fallback-without-throw',
+          expression: "(() => { try { aura.draw2d.text('align', 2, 3, { align: 'middle', size: 12 }); return true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'input.gamepad.multi-index.type-safe-across-slots',
+          expression: "(() => { try { const axes = [0, 1, 2, 3].map((index) => aura.input.getGamepadAxis(index, 0)); const buttons = [0, 1, 2, 3].map((index) => aura.input.isGamepadButtonDown(index, 0)); const connected = [0, 1, 2, 3].map((index) => aura.input.isGamepadConnected(index)); return axes.every((value) => typeof value === 'number' && Number.isFinite(value)) && buttons.every((value) => typeof value === 'boolean') && connected.every((value) => typeof value === 'boolean'); } catch (_) { return false; } })()",
+        },
+        {
+          id: 'input.gamepad.out-of-range.safe-defaults',
+          expression: "(() => { return aura.input.isGamepadConnected(-1) === false && aura.input.isGamepadConnected(4) === false && aura.input.isGamepadConnected(0.5) === false && aura.input.getGamepadAxis(-1, 0) === 0 && aura.input.getGamepadAxis(4, 0) === 0 && aura.input.getGamepadAxis(0, 99) === 0 && aura.input.getGamepadAxis(0, 0.5) === 0 && aura.input.isGamepadButtonDown(-1, 0) === false && aura.input.isGamepadButtonDown(4, 0) === false && aura.input.isGamepadButtonDown(0, 99) === false && aura.input.isGamepadButtonDown(0, 0.5) === false; })()",
+        },
+        {
+          id: 'input.key.normalization.alias-parity',
+          expression: "(() => { return aura.input.isKeyDown('up') === aura.input.isKeyDown('arrowup') && aura.input.isKeyDown('left') === aura.input.isKeyDown('arrowleft') && aura.input.isKeyDown('lshift') === aura.input.isKeyDown('shift') && aura.input.isKeyDown('rctrl') === aura.input.isKeyDown('control') && aura.input.isKeyDown('option') === aura.input.isKeyDown('alt') && aura.input.isKeyDown('command') === aura.input.isKeyDown('meta'); })()",
+        },
+        {
+          id: 'input.key.normalization.case-insensitive',
+          expression: "aura.input.isKeyDown('Space') === aura.input.isKeyDown('space') && aura.input.isKeyPressed('Enter') === aura.input.isKeyPressed('enter') && aura.input.isKeyReleased('TAB') === aura.input.isKeyReleased('tab')",
+        },
+        {
+          id: 'draw2d.input.key.invalid-input.safe-false',
+          expression: "aura.input.isKeyDown(42) === false && aura.input.isKeyPressed({}) === false && aura.input.isKeyReleased(null) === false",
+        },
+        {
+          id: 'math.edge.clamp.reversed-bounds-returns-min',
+          expression: 'aura.math.clamp(-5, 10, 0) === 10 && aura.math.clamp(42, 7, -3) === 7',
+        },
+        {
+          id: 'math.edge.random.degenerate-bounds-returns-min',
+          expression: 'aura.math.random(3, 3) === 3 && aura.math.random(9, 2) === 9',
+        },
+        {
+          id: 'collision.edge.invalid-input.safe-false-no-throw',
+          expression: "(() => { const rectOk = { x: 0, y: 0, w: 10, h: 10 }; const circleOk = { x: 0, y: 0, radius: 5 }; const pointOk = { x: 1, y: 1 }; try { return aura.collision.rectRect({ x: '0', y: 0, w: 1, h: 1 }, rectOk) === false && aura.collision.rectPoint(rectOk, { x: NaN, y: 1 }) === false && aura.collision.circleCircle({ x: 0, y: Infinity, radius: 1 }, circleOk) === false && aura.collision.circlePoint(circleOk, { x: '1', y: 0 }) === false && aura.collision.circleRect(circleOk, { x: 0, y: 0, w: 5, h: Infinity }) === false && aura.collision.rectPoint(rectOk, pointOk) === true; } catch (_) { return false; } })()",
+        },
+      ],
+      nativeFrames: 2,
+      source: `
+        aura.setup = function () {};
+      `,
+    },
+  {
+      id: 'ecs-lite-scheduler',
+      modes: ['shim', 'native'],
+      namespaces: ['ecs'],
+      functions: [
+        'aura.ecs.createEntity',
+        'aura.ecs.removeEntity',
+        'aura.ecs.addComponent',
+        'aura.ecs.getComponent',
+        'aura.ecs.system',
+        'aura.ecs.run',
+      ],
+      nativeChecks: [
+        {
+          id: 'ecs.entity.component.roundtrip',
+          expression: "(() => { const entity = aura.ecs.createEntity(); const added = aura.ecs.addComponent(entity, 'health', { value: 42 }); const component = aura.ecs.getComponent(entity, 'health'); return added === true && component && component.value === 42; })()",
+        },
+        {
+          id: 'ecs.removeEntity.clears-components',
+          expression: "(() => { const entity = aura.ecs.createEntity(); aura.ecs.addComponent(entity, 'tag', { value: 'enemy' }); const removed = aura.ecs.removeEntity(entity); return removed === true && aura.ecs.getComponent(entity, 'tag') === undefined; })()",
+        },
+        {
+          id: 'ecs.system.deterministic-order',
+          expression: "(() => { const order = []; aura.ecs.system('late', () => order.push('late'), 20); aura.ecs.system('early', () => order.push('early'), 5); aura.ecs.system('mid', () => order.push('mid'), 10); aura.ecs.run(1 / 60); return order.join(',') === 'early,mid,late'; })()",
+        },
+        {
+          id: 'ecs.system.deterministic-order.name-tiebreak',
+          expression: "(() => { const order = []; aura.ecs.system('zeta', () => order.push('zeta'), 15); aura.ecs.system('alpha', () => order.push('alpha'), 15); aura.ecs.system('beta', () => order.push('beta'), 15); aura.ecs.run(1 / 60); return order.join(',') === 'alpha,beta,zeta'; })()",
+        },
+        {
+          id: 'ecs.component.mutation.visible-within-run',
+          expression: "(() => { const entity = aura.ecs.createEntity(); aura.ecs.addComponent(entity, 'position', { x: 0, y: 0 }); let observed = null; aura.ecs.system('ecs_mutate_visible_writer', () => { const pos = aura.ecs.getComponent(entity, 'position'); if (pos) pos.x += 7; }, 31); aura.ecs.system('ecs_mutate_visible_reader', () => { const pos = aura.ecs.getComponent(entity, 'position'); observed = pos ? pos.x : null; }, 32); aura.ecs.run(1 / 60); return observed === 7; })()",
+        },
+        {
+          id: 'ecs.run.fixed-dt.repeatable',
+          expression: "(() => { const runSample = () => { const entity = aura.ecs.createEntity(); aura.ecs.addComponent(entity, 'velocity', { x: 1.5 }); aura.ecs.addComponent(entity, 'position', { x: 0 }); aura.ecs.system('ecs_repeatable_integrate_' + entity, (dt) => { const vel = aura.ecs.getComponent(entity, 'velocity'); const pos = aura.ecs.getComponent(entity, 'position'); if (vel && pos) pos.x += vel.x * dt; }, 41); const values = []; for (let i = 0; i < 6; i += 1) { aura.ecs.run(1 / 120); const pos = aura.ecs.getComponent(entity, 'position'); values.push(pos ? Number(pos.x.toFixed(8)) : null); } return values.join(','); }; return runSample() === runSample(); })()",
+        },
+        {
+          id: 'ecs.system.mutation-visible.rerun-deterministic-sequence',
+          expression: "(() => { const sequence = [1 / 60, 1 / 60, 1 / 30, 1 / 120]; const expected = JSON.stringify({ final: 0.225, trace: [0.05, 0.1, 0.2, 0.225] }); const runSample = () => { const entity = aura.ecs.createEntity(); aura.ecs.addComponent(entity, 'velocity', { x: 3 }); aura.ecs.addComponent(entity, 'position', { x: 0 }); aura.ecs.addComponent(entity, 'trace', { values: [] }); aura.ecs.system('ecs_mutation_seq_integrate', (dt) => { const vel = aura.ecs.getComponent(entity, 'velocity'); const pos = aura.ecs.getComponent(entity, 'position'); if (vel && pos) pos.x += vel.x * dt; }, 51); aura.ecs.system('ecs_mutation_seq_observe', () => { const pos = aura.ecs.getComponent(entity, 'position'); const trace = aura.ecs.getComponent(entity, 'trace'); if (pos && trace) trace.values.push(Number(pos.x.toFixed(6))); }, 52); for (const dt of sequence) aura.ecs.run(dt); const pos = aura.ecs.getComponent(entity, 'position'); const trace = aura.ecs.getComponent(entity, 'trace'); return JSON.stringify({ final: pos ? Number(pos.x.toFixed(6)) : null, trace: trace ? trace.values : null }); }; const first = runSample(); const second = runSample(); return first === expected && second === expected; })()",
+        },
+        {
+          id: 'ecs.system.invalid-input.safe-false',
+          expression: "aura.ecs.system('', () => {}, 0) === false && aura.ecs.system('ok', null, 0) === false",
+        },
+      ],
+      source: `
+        aura.setup = function () {
+          const e = aura.ecs.createEntity();
+          aura.ecs.addComponent(e, 'position', { x: 1, y: 2 });
+          aura.ecs.system('move', function (dt) {
+            const p = aura.ecs.getComponent(e, 'position');
+            if (p) p.x += dt;
+          }, 0);
+        };
+        aura.update = function (dt) {
+          aura.ecs.run(dt);
+        };
+      `,
+      frames: 2,
+    },
+  {
+      id: 'animation-timeline-core',
+      modes: ['shim', 'native'],
+      namespaces: ['animation'],
+      functions: [
+        'aura.animation.create',
+        'aura.animation.play',
+        'aura.animation.pause',
+        'aura.animation.resume',
+        'aura.animation.seek',
+        'aura.animation.transition',
+        'aura.animation.crossfade',
+        'aura.animation.onComplete',
+        'aura.animation.onEvent',
+        'aura.animation.setLoop',
+        'aura.animation.setSpeed',
+        'aura.animation.update',
+        'aura.animation.getState',
+      ],
+      nativeChecks: [
+        {
+          id: 'animation.create.play.pause.roundtrip',
+          expression: "(() => { const created = aura.animation.create({ duration: 1, loop: false }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const played = aura.animation.play(timelineId); const updated = aura.animation.update(0.25); const paused = aura.animation.pause(timelineId); const state = aura.animation.getState(timelineId); return !!played && played.ok === true && !!updated && updated.ok === true && !!paused && paused.ok === true && !!state && Number(state.time.toFixed(6)) === 0.25 && state.playing === false; })()",
+        },
+        {
+          id: 'animation.variable-dt.deterministic-rerun',
+          expression: "(() => { const runSample = () => { const created = aura.animation.create({ duration: 1, loop: false, speed: 1.25 }); if (!created || created.ok !== true) return 'create_failed'; const timelineId = created.timelineId; const played = aura.animation.play(timelineId); if (!played || played.ok !== true) return 'play_failed'; const trace = []; for (const dt of [1 / 60, 1 / 30, 1 / 24, 1 / 120, 0.25]) { const step = aura.animation.update(dt); if (!step || step.ok !== true) return 'update_failed'; const state = aura.animation.getState(timelineId); trace.push(state ? Number(state.time.toFixed(6)) : null); } const state = aura.animation.getState(timelineId); return JSON.stringify({ time: state ? Number(state.time.toFixed(6)) : null, playing: state ? state.playing : null, completed: state ? state.completed : null, loops: state ? state.loops : null, trace }); }; const expected = JSON.stringify({ time: 0.4375, playing: true, completed: false, loops: 0, trace: [0.020833, 0.0625, 0.114583, 0.125, 0.4375] }); const first = runSample(); const second = runSample(); return first === expected && second === expected; })()",
+        },
+        {
+          id: 'animation.loop-seek-speed.stable',
+          expression: "(() => { const created = aura.animation.create({ duration: 1, loop: true, time: 0.25, speed: 2, playing: true }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const stepA = aura.animation.update(0.5); const seek = aura.animation.seek(timelineId, 0.9); const speed = aura.animation.setSpeed(timelineId, 0.5); const stepB = aura.animation.update(0.4); const state = aura.animation.getState(timelineId); return !!stepA && stepA.ok === true && !!seek && seek.ok === true && !!speed && speed.ok === true && !!stepB && stepB.ok === true && !!state && Number(state.time.toFixed(6)) === 0.1 && state.loop === true && state.loops === 2 && state.playing === true; })()",
+        },
+        {
+          id: 'animation.invalid-operations.reason-codes',
+          expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const invalidOptions = aura.animation.create(null); const invalidDuration = aura.animation.create({ duration: 0 }); const invalidPlaying = aura.animation.create({ duration: 1, playing: 'yes' }); const created = aura.animation.create({ duration: 2 }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const missingTimeline = aura.animation.play(999999); const invalidTimelineId = aura.animation.play('oops'); const invalidSeek = aura.animation.seek(timelineId, -1); const invalidTransitionOptions = aura.animation.transition(timelineId, null); const invalidTransitionDuration = aura.animation.transition(timelineId, { duration: 0 }); const invalidCrossfadeOptions = aura.animation.crossfade(timelineId, null); const invalidCrossfadeDuration = aura.animation.crossfade(timelineId, { duration: 0 }); const invalidOnComplete = aura.animation.onComplete(timelineId, null); const invalidOnEvent = aura.animation.onEvent(timelineId, null); const invalidLoop = aura.animation.setLoop(timelineId, 'yes'); const invalidSpeed = aura.animation.setSpeed(timelineId, -3); const invalidDt = aura.animation.update(0); const invalids = [invalidOptions, invalidDuration, invalidPlaying, missingTimeline, invalidTimelineId, invalidSeek, invalidTransitionOptions, invalidTransitionDuration, invalidCrossfadeOptions, invalidCrossfadeDuration, invalidOnComplete, invalidOnEvent, invalidLoop, invalidSpeed, invalidDt]; return invalids.every((entry) => entry && entry.ok === false && typeof reasonOf(entry) === 'string' && reasonOf(entry).length > 0); })()",
+        },
+        {
+          id: 'animation.transition-callback-ordering.deterministic',
+          expression: "(() => { const created = aura.animation.create({ duration: 1, loop: false, playing: true }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const calls = []; const eventA = aura.animation.onEvent(timelineId, (evt) => calls.push(`event:${evt.type}:${evt.tag || ''}`), 5); const eventB = aura.animation.onEvent(timelineId, (evt) => calls.push(`event:${evt.type}:${evt.tag || ''}`), 20); const completeA = aura.animation.onComplete(timelineId, () => calls.push('complete:early'), 1); const completeB = aura.animation.onComplete(timelineId, () => calls.push('complete:late'), 10); const started = aura.animation.transition(timelineId, { duration: 0.5, targetTime: 1, eventTag: 'impact' }); const updated = aura.animation.update(0.5); const state = aura.animation.getState(timelineId); return !!eventA && eventA.ok === true && !!eventB && eventB.ok === true && !!completeA && completeA.ok === true && !!completeB && completeB.ok === true && !!started && started.ok === true && !!updated && updated.ok === true && !!state && state.completed === true && state.playing === false && calls.join('|') === 'event:transition_complete:impact|event:transition_complete:impact|event:marker:impact|event:marker:impact|complete:early|complete:late'; })()",
+        },
+        {
+          id: 'animation.pause-resume-seek.active-transition.stable',
+          expression: "(() => { const created = aura.animation.create({ duration: 2, loop: false, playing: true }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const transition = aura.animation.transition(timelineId, { duration: 1, targetTime: 1.5, eventTag: 'dash' }); const stepA = aura.animation.update(0.25); const stateA = aura.animation.getState(timelineId); const paused = aura.animation.pause(timelineId); const stepPaused = aura.animation.update(0.5); const statePaused = aura.animation.getState(timelineId); const resumed = aura.animation.resume(timelineId); const stepB = aura.animation.update(0.25); const stateB = aura.animation.getState(timelineId); const seeked = aura.animation.seek(timelineId, 0.4); const stateSeek = aura.animation.getState(timelineId); return !!transition && transition.ok === true && !!stepA && stepA.ok === true && !!paused && paused.ok === true && !!stepPaused && stepPaused.ok === true && !!resumed && resumed.ok === true && !!stepB && stepB.ok === true && !!seeked && seeked.ok === true && !!stateA && Number(stateA.time.toFixed(6)) === 0.375 && !!statePaused && Number(statePaused.time.toFixed(6)) === 0.375 && statePaused.transition && statePaused.transition.paused === true && !!stateB && Number(stateB.time.toFixed(6)) === 0.75 && stateB.transition && stateB.transition.paused === false && !!stateSeek && Number(stateSeek.time.toFixed(6)) === 0.4 && stateSeek.transition === null; })()",
+        },
+        {
+          id: 'animation.transition-loop-edge.ordering.deterministic',
+          expression: "(() => { const created = aura.animation.create({ duration: 1, loop: true, time: 0.75, playing: true }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const calls = []; const eventEarly = aura.animation.onEvent(timelineId, (evt) => calls.push(`early:${evt.type}:${evt.tag || ''}:${evt.loops || 0}`), 5); const eventLate = aura.animation.onEvent(timelineId, (evt) => calls.push(`late:${evt.type}:${evt.tag || ''}:${evt.loops || 0}`), 20); const paused = aura.animation.pause(timelineId); const pausedStep = aura.animation.update(0.5); const pausedState = aura.animation.getState(timelineId); const resumed = aura.animation.resume(timelineId); const transition = aura.animation.transition(timelineId, { duration: 0.25, targetTime: 0.95, eventTag: 'blend' }); const step = aura.animation.update(0.25); const steppedState = aura.animation.getState(timelineId); const seeked = aura.animation.seek(timelineId, 0.1); const seekState = aura.animation.getState(timelineId); return !!eventEarly && eventEarly.ok === true && !!eventLate && eventLate.ok === true && !!paused && paused.ok === true && !!pausedStep && pausedStep.ok === true && !!resumed && resumed.ok === true && !!transition && transition.ok === true && !!step && step.ok === true && !!seeked && seeked.ok === true && !!pausedState && Number(pausedState.time.toFixed(6)) === 0.75 && !!steppedState && steppedState.transition === null && Number(steppedState.time.toFixed(6)) === 0.2 && steppedState.loops === 1 && !!seekState && seekState.transition === null && Number(seekState.time.toFixed(6)) === 0.1 && calls.join('|') === 'early:transition_complete:blend:0|late:transition_complete:blend:0|early:marker:blend:0|late:marker:blend:0|early:loop::1|late:loop::1'; })()",
+        },
+        {
+          id: 'animation.crossfade-loop-edge.ordering.deterministic',
+          expression: "(() => { const created = aura.animation.create({ duration: 1, loop: true, time: 0.6, playing: true }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const calls = []; const eventEarly = aura.animation.onEvent(timelineId, (evt) => calls.push(`early:${evt.type}:${evt.blendMode || ''}:${evt.tag || ''}:${evt.loops || 0}`), 5); const eventLate = aura.animation.onEvent(timelineId, (evt) => calls.push(`late:${evt.type}:${evt.blendMode || ''}:${evt.tag || ''}:${evt.loops || 0}`), 20); const crossfade = aura.animation.crossfade(timelineId, { duration: 0.25, fromTime: 0.75, toTime: 0.95, eventTag: 'mix' }); const step = aura.animation.update(0.25); const steppedState = aura.animation.getState(timelineId); const seeked = aura.animation.seek(timelineId, 0.1); const seekState = aura.animation.getState(timelineId); return !!eventEarly && eventEarly.ok === true && !!eventLate && eventLate.ok === true && !!crossfade && crossfade.ok === true && !!step && step.ok === true && !!seeked && seeked.ok === true && !!steppedState && steppedState.transition === null && Number(steppedState.time.toFixed(6)) === 0.2 && steppedState.loops === 1 && !!seekState && seekState.transition === null && Number(seekState.time.toFixed(6)) === 0.1 && calls.join('|') === 'early:crossfade_complete:crossfade:mix:0|late:crossfade_complete:crossfade:mix:0|early:marker:crossfade:mix:0|late:marker:crossfade:mix:0|early:loop:::1|late:loop:::1'; })()",
+        },
+        {
+          id: 'animation.crossfade.pause-resume-seek.stable',
+          expression: "(() => { const created = aura.animation.create({ duration: 2, loop: false, playing: true }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const crossfade = aura.animation.crossfade(timelineId, { duration: 1, fromTime: 0.2, toTime: 1.4, eventTag: 'mix' }); const stepA = aura.animation.update(0.25); const stateA = aura.animation.getState(timelineId); const paused = aura.animation.pause(timelineId); const stepPaused = aura.animation.update(0.5); const statePaused = aura.animation.getState(timelineId); const resumed = aura.animation.resume(timelineId); const stepB = aura.animation.update(0.25); const stateB = aura.animation.getState(timelineId); const seeked = aura.animation.seek(timelineId, 0.4); const stateSeek = aura.animation.getState(timelineId); return !!crossfade && crossfade.ok === true && !!stepA && stepA.ok === true && !!paused && paused.ok === true && !!stepPaused && stepPaused.ok === true && !!resumed && resumed.ok === true && !!stepB && stepB.ok === true && !!seeked && seeked.ok === true && !!stateA && Number(stateA.time.toFixed(6)) === 0.5 && stateA.transition && stateA.transition.mode === 'crossfade' && stateA.transition.paused === false && !!statePaused && Number(statePaused.time.toFixed(6)) === 0.5 && statePaused.transition && statePaused.transition.mode === 'crossfade' && statePaused.transition.paused === true && !!stateB && Number(stateB.time.toFixed(6)) === 0.8 && stateB.transition && stateB.transition.mode === 'crossfade' && stateB.transition.paused === false && !!stateSeek && Number(stateSeek.time.toFixed(6)) === 0.4 && stateSeek.transition === null; })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {
+          const timeline = aura.animation.create({ duration: 1, playing: true, loop: true });
+          aura.test.assert(timeline && timeline.ok === true, 'animation timeline should be created');
+        };
+        aura.update = function (dt) {
+          aura.animation.update(dt);
+        };
+      `,
+      frames: 2,
+    },
+  {
+      id: 'animation-atlas-spritesheet-workflow',
+      modes: ['shim', 'native'],
+      namespaces: ['animation', 'draw2d'],
+      functions: [
+        'aura.animation.registerAtlas',
+        'aura.animation.resolveAtlasFrame',
+        'aura.animation.createAtlasClip',
+        'aura.animation.stepAtlasClip',
+        'aura.animation.getAtlasClipState',
+        'aura.draw2d.sprite',
+      ],
+      nativeChecks: [
+        {
+          id: 'animation.atlas.frame-selection-and-clip-stepping.deterministic',
+          expression: "(() => { const fixture = { image: 'hero-sheet.png', frames: { walk_0: { x: 0, y: 0, w: 16, h: 16 }, walk_1: { x: 16, y: 0, w: 16, h: 16 }, walk_2: { x: 32, y: 0, w: 16, h: 16 } }, clips: { walk: { frames: ['walk_0', 'walk_1', 'walk_2'], frameDuration: 0.1, loop: true } } }; const registered = aura.animation.registerAtlas(fixture); if (!registered || registered.ok !== true) return false; const atlasId = registered.atlasId; const frame = aura.animation.resolveAtlasFrame(atlasId, 'walk_1'); if (!frame || frame.ok !== true) return false; aura.draw2d.sprite(frame.image, 10, 20, { frameX: frame.frameX, frameY: frame.frameY, frameW: frame.frameW, frameH: frame.frameH }); const runSample = () => { const created = aura.animation.createAtlasClip({ atlasId, clipKey: 'walk', playing: true }); if (!created || created.ok !== true) return 'create_failed'; const clipId = created.clipId; const trace = []; for (const dt of [0.05, 0.06, 0.11, 0.08]) { const stepped = aura.animation.stepAtlasClip(clipId, dt); if (!stepped || stepped.ok !== true) return 'step_failed'; const state = aura.animation.getAtlasClipState(clipId); trace.push(state ? `${state.frameKey}:${state.frameIndex}:${state.loops}` : null); } const finalState = aura.animation.getAtlasClipState(clipId); return JSON.stringify({ trace, final: finalState ? { frameKey: finalState.frameKey, frameIndex: finalState.frameIndex, loops: finalState.loops, completed: finalState.completed } : null }); }; const expected = JSON.stringify({ trace: ['walk_0:0:0', 'walk_1:1:0', 'walk_2:2:0', 'walk_0:0:1'], final: { frameKey: 'walk_0', frameIndex: 0, loops: 1, completed: false } }); const first = runSample(); const second = runSample(); return frame.frameX === 16 && frame.frameY === 0 && frame.frameW === 16 && frame.frameH === 16 && first === expected && second === expected; })()",
+        },
+        {
+          id: 'animation.atlas.spritesheet-frame-list.deterministic',
+          expression: "(() => { const fixture = { image: 'runner-sheet.png', frames: { s0: { x: 0, y: 0, w: 8, h: 8, duration: 0.05 }, s1: { x: 8, y: 0, w: 8, h: 8, duration: 0.1 }, s2: { x: 16, y: 0, w: 8, h: 8, duration: 0.2 } } }; const registered = aura.animation.registerAtlas(fixture); if (!registered || registered.ok !== true) return false; const atlasId = registered.atlasId; const runSample = () => { const created = aura.animation.createAtlasClip({ atlasId, frames: ['s0', 's1', 's2'], loop: false, playing: true }); if (!created || created.ok !== true) return 'create_failed'; const clipId = created.clipId; const checkpoints = []; for (const dt of [0.05, 0.1, 0.15]) { const stepped = aura.animation.stepAtlasClip(clipId, dt); if (!stepped || stepped.ok !== true) return 'step_failed'; const state = aura.animation.getAtlasClipState(clipId); checkpoints.push(state ? `${state.frameKey}:${state.frameIndex}:${state.completed}` : null); } const finalState = aura.animation.getAtlasClipState(clipId); return JSON.stringify({ checkpoints, final: finalState ? { frameKey: finalState.frameKey, frameIndex: finalState.frameIndex, completed: finalState.completed, playing: finalState.playing } : null }); }; const expected = JSON.stringify({ checkpoints: ['s1:1:false', 's2:2:false', 's2:2:false'], final: { frameKey: 's2', frameIndex: 2, completed: false, playing: true } }); const first = runSample(); const second = runSample(); return first === expected && second === expected; })()",
+        },
+        {
+          id: 'animation.atlas.invalid-payloads.reason-codes',
+          expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const invalidPayload = aura.animation.registerAtlas(null); const invalidFrames = aura.animation.registerAtlas({ image: 'sheet.png', frames: {} }); const unsupportedFlags = aura.animation.registerAtlas({ image: 'sheet.png', frames: { bad: { frame: { x: 0, y: 0, w: 16, h: 16 }, rotated: true } } }); const missingFrame = aura.animation.registerAtlas({ image: 'sheet.png', frames: { idle_0: { x: 0, y: 0, w: 16, h: 16 } }, clips: { run: { frames: ['missing'] } } }); const valid = aura.animation.registerAtlas({ image: 'sheet.png', frames: { idle_0: { x: 0, y: 0, w: 16, h: 16 } } }); if (!valid || valid.ok !== true) return false; const atlasId = valid.atlasId; const invalidAtlasId = aura.animation.resolveAtlasFrame('oops', 'idle_0'); const missingAtlas = aura.animation.resolveAtlasFrame(999999, 'idle_0'); const invalidFrameKey = aura.animation.resolveAtlasFrame(atlasId, null); const missingFrameKey = aura.animation.resolveAtlasFrame(atlasId, 'idle_1'); const invalidClipOptions = aura.animation.createAtlasClip(null); const missingClip = aura.animation.createAtlasClip({ atlasId, clipKey: 'run' }); const invalidClipId = aura.animation.stepAtlasClip('bad', 0.1); const invalids = [invalidPayload, invalidFrames, unsupportedFlags, missingFrame, invalidAtlasId, missingAtlas, invalidFrameKey, missingFrameKey, invalidClipOptions, missingClip, invalidClipId]; return invalids.every((entry) => entry && entry.ok === false && typeof reasonOf(entry) === 'string' && reasonOf(entry).length > 0); })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {};
+      `,
+      frames: 2,
+    },
+  {
+      id: 'tween-easing-core',
+      modes: ['native'],
+      namespaces: ['tween'],
+      functions: [
+        'aura.tween.create',
+        'aura.tween.pause',
+        'aura.tween.resume',
+        'aura.tween.cancel',
+        'aura.tween.onUpdate',
+        'aura.tween.onComplete',
+        'aura.tween.update',
+        'aura.tween.getState',
+      ],
+      nativeChecks: [
+        {
+          id: 'tween.create.pause.resume.cancel.roundtrip',
+          expression: "(() => { const created = aura.tween.create({ from: 0, to: 1, duration: 1, easing: 'linear' }); if (!created || created.ok !== true) return false; const tweenId = created.tweenId; const paused = aura.tween.pause(tweenId); const resumed = aura.tween.resume(tweenId); const updated = aura.tween.update(0.25); const state = aura.tween.getState(tweenId); const cancelled = aura.tween.cancel(tweenId); const afterCancel = aura.tween.getState(tweenId); return !!paused && paused.ok === true && !!resumed && resumed.ok === true && !!updated && updated.ok === true && !!state && Number(state.value.toFixed(6)) === 0.25 && state.playing === true && !!cancelled && cancelled.ok === true && cancelled.cancelled === true && afterCancel === null; })()",
+        },
+        {
+          id: 'tween.variable-dt.easing.deterministic-rerun',
+          expression: "(() => { const runSample = () => { const created = aura.tween.create({ from: 0, to: 10, duration: 1, easing: 'easeInOutQuad' }); if (!created || created.ok !== true) return 'create_failed'; const tweenId = created.tweenId; const trace = []; for (const dt of [1 / 60, 1 / 30, 1 / 24, 1 / 120, 0.25]) { const step = aura.tween.update(dt); if (!step || step.ok !== true) return 'update_failed'; const state = aura.tween.getState(tweenId); trace.push(state ? Number(state.value.toFixed(6)) : null); } const state = aura.tween.getState(tweenId); return JSON.stringify({ value: state ? Number(state.value.toFixed(6)) : null, progress: state ? Number(state.progress.toFixed(6)) : null, playing: state ? state.playing : null, completed: state ? state.completed : null, trace }); }; const expected = JSON.stringify({ value: 2.45, progress: 0.35, playing: true, completed: false, trace: [0.005556, 0.05, 0.168056, 0.2, 2.45] }); const first = runSample(); const second = runSample(); return first === expected && second === expected; })()",
+        },
+        {
+          id: 'tween.invalid-operations.reason-codes',
+          expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const invalidOptions = aura.tween.create(null); const invalidDuration = aura.tween.create({ from: 0, to: 1, duration: 0 }); const invalidFrom = aura.tween.create({ from: 'bad', to: 1, duration: 1 }); const invalidTo = aura.tween.create({ from: 0, to: 'bad', duration: 1 }); const invalidEasing = aura.tween.create({ from: 0, to: 1, duration: 1, easing: 'bounce' }); const invalidPlaying = aura.tween.create({ from: 0, to: 1, duration: 1, playing: 'yes' }); const created = aura.tween.create({ from: 0, to: 1, duration: 1 }); if (!created || created.ok !== true) return false; const tweenId = created.tweenId; const missingTween = aura.tween.pause(999999); const invalidTweenId = aura.tween.pause('oops'); const invalidOnUpdate = aura.tween.onUpdate(tweenId, null); const invalidOnComplete = aura.tween.onComplete(tweenId, null); const invalidDt = aura.tween.update(0); const invalids = [invalidOptions, invalidDuration, invalidFrom, invalidTo, invalidEasing, invalidPlaying, missingTween, invalidTweenId, invalidOnUpdate, invalidOnComplete, invalidDt]; return invalids.every((entry) => entry && entry.ok === false && typeof reasonOf(entry) === 'string' && reasonOf(entry).length > 0); })()",
+        },
+        {
+          id: 'tween.callback-ordering.deterministic',
+          expression: "(() => { const first = aura.tween.create({ from: 0, to: 1, duration: 0.5 }); const second = aura.tween.create({ from: 0, to: 2, duration: 0.5 }); if (!first || first.ok !== true || !second || second.ok !== true) return false; const idA = first.tweenId; const idB = second.tweenId; const calls = []; aura.tween.onUpdate(idA, (evt) => calls.push(`uA:late:${evt.tweenId}`), 20); aura.tween.onUpdate(idA, (evt) => calls.push(`uA:early:${evt.tweenId}`), 5); aura.tween.onComplete(idA, (evt) => calls.push(`cA:late:${evt.tweenId}`), 10); aura.tween.onComplete(idA, (evt) => calls.push(`cA:early:${evt.tweenId}`), 1); aura.tween.onUpdate(idB, (evt) => calls.push(`uB:late:${evt.tweenId}`), 20); aura.tween.onUpdate(idB, (evt) => calls.push(`uB:early:${evt.tweenId}`), 5); aura.tween.onComplete(idB, (evt) => calls.push(`cB:late:${evt.tweenId}`), 10); aura.tween.onComplete(idB, (evt) => calls.push(`cB:early:${evt.tweenId}`), 1); const updated = aura.tween.update(0.5); const stateA = aura.tween.getState(idA); const stateB = aura.tween.getState(idB); return !!updated && updated.ok === true && !!stateA && stateA.completed === true && stateA.playing === false && !!stateB && stateB.completed === true && stateB.playing === false && (() => { const expectedCalls = ['uA:early:' + idA, 'uA:late:' + idA, 'cA:early:' + idA, 'cA:late:' + idA, 'uB:early:' + idB, 'uB:late:' + idB, 'cB:early:' + idB, 'cB:late:' + idB].join('|'); return calls.join('|') === expectedCalls; })(); })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {};
+      `,
+      nativeFrames: 2,
+    },
+  {
+      id: 'particles-lite-runtime',
+      modes: ['native'],
+      namespaces: ['particles', 'draw2d'],
+      functions: [
+        'aura.particles.emit',
+        'aura.particles.burst',
+        'aura.particles.update',
+        'aura.particles.draw',
+        'aura.particles.stop',
+        'aura.particles.kill',
+        'aura.particles.setLayer',
+        'aura.particles.setBlend',
+        'aura.particles.getState',
+        'aura.draw2d.circleFill',
+      ],
+      nativeChecks: [
+        {
+          id: 'particles.vfx.surface.methods',
+          expression: "(() => ['emit','burst','update','draw','stop','kill','setLayer','setBlend','getState'].every((name) => typeof aura.particles?.[name] === 'function'))()",
+        },
+        {
+          id: 'particles.emit-update-draw.deterministic',
+          expression: "(() => { const runSample = () => { const created = aura.particles.emit({ x: 12, y: 20, count: 4, life: 0.5, size: 2, speedMin: 20, speedMax: 20, direction: 0, spread: 0, loop: true, rate: 8 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const trace = []; for (const dt of [0.1, 0.15, 0.2]) { const step = aura.particles.update(dt); if (!step || step.ok !== true) return null; const state = aura.particles.getState(emitterId); trace.push(state ? state.particles : null); } const drawn = aura.particles.draw(emitterId); const beforeStop = aura.particles.getState(emitterId); const stopped = aura.particles.stop(emitterId); const afterStop = aura.particles.getState(emitterId); return { trace, drawn: drawn && drawn.ok ? drawn.drawnParticles : null, particles: beforeStop ? beforeStop.particles : null, stoppedOk: !!stopped && stopped.ok === true, stopMode: stopped && typeof stopped.mode === 'string' ? stopped.mode : null, afterStopIsNull: afterStop === null, afterStopInactive: !!afterStop && afterStop.active === false }; }; const first = runSample(); const second = runSample(); if (!first || !second) return false; return JSON.stringify(first) === JSON.stringify(second) && JSON.stringify(first.trace) === JSON.stringify([4, 6, 7]) && first.drawn === 7 && first.particles === 7 && first.stoppedOk === true && (first.afterStopIsNull === true || first.afterStopInactive === true); })()",
+        },
+        {
+          id: 'particles.vfx.blend-layer.fixed-step.deterministic',
+          expression: "(() => { const runSample = (tag) => { const created = aura.particles.emit({ x: 24, y: 24, count: 8, life: 0.5, size: 2, speedMin: 12, speedMax: 12, direction: 0, spread: 0, loop: true, rate: 24 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const layer = aura.particles.setLayer(emitterId, 3); const blend = aura.particles.setBlend(emitterId, 'add'); const burst = aura.particles.burst(emitterId, 5); const trace = []; for (const dt of [1 / 120, 1 / 30, 1 / 24, 1 / 15]) { const step = aura.particles.update(dt); const state = aura.particles.getState(emitterId); trace.push({ ok: !!step && step.ok === true, particles: state ? state.particles : null }); } const drawn = aura.particles.draw(emitterId); const killed = aura.particles.kill(emitterId); const afterKill = aura.particles.getState(emitterId); return { tag, layerOk: !!layer && layer.ok === true, blendOk: !!blend && blend.ok === true, burstOk: !!burst && burst.ok === true, trace, drawn: drawn && drawn.ok === true ? drawn.drawnParticles : null, killed: !!killed && killed.ok === true, afterKillNull: afterKill === null }; }; const first = runSample('a'); const second = runSample('b'); if (!first || !second) return false; const normalizedFirst = JSON.stringify({ ...first, tag: 'x' }); const normalizedSecond = JSON.stringify({ ...second, tag: 'x' }); return normalizedFirst === normalizedSecond && first.layerOk === true && first.blendOk === true && first.burstOk === true && first.trace.every((entry) => entry.ok === true && Number.isFinite(entry.particles) && entry.particles >= 0) && Number.isFinite(first.drawn) && first.drawn > 0 && first.killed === true && first.afterKillNull === true; })()",
+        },
+        {
+          id: 'particles.pool-cap-and-loop.stable',
+          expression: "(() => { const created = aura.particles.emit({ x: 0, y: 0, count: 16, life: 0.2, size: 1, speedMin: 4, speedMax: 4, direction: 0, spread: 0, loop: true, rate: 64 }); if (!created || created.ok !== true) return false; const emitterId = created.emitterId; let maxSeen = 0; for (let i = 0; i < 20; i += 1) { const step = aura.particles.update(0.1); if (!step || step.ok !== true) return false; const state = aura.particles.getState(emitterId); if (!state) return false; if (state.particles > maxSeen) maxSeen = state.particles; if (state.particles > 2048) return false; } const stopped = aura.particles.stop(emitterId); return !!stopped && stopped.ok === true && maxSeen > 0 && maxSeen <= 2048; })()",
+        },
+        {
+          id: 'particles.invalid-operations.reason-codes',
+          expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const invalidOptions = aura.particles.emit(null); const invalidPosition = aura.particles.emit({ x: 'bad' }); const invalidCount = aura.particles.emit({ count: 0 }); const invalidSpeedRange = aura.particles.emit({ speedMin: 30, speedMax: 10 }); const invalidRate = aura.particles.emit({ loop: true, rate: 0 }); const created = aura.particles.emit({ x: 0, y: 0, count: 1 }); if (!created || created.ok !== true) return false; const emitterId = created.emitterId; const invalidDt = aura.particles.update(0); const invalidEmitterId = aura.particles.stop('oops'); const missingEmitter = aura.particles.stop(999999); const invalidDrawEmitter = aura.particles.draw(0); const invalidMaxParticles = aura.particles.draw({ maxParticles: 0 }); const stopped = aura.particles.stop(emitterId); const invalids = [invalidOptions, invalidPosition, invalidCount, invalidSpeedRange, invalidRate, invalidDt, invalidEmitterId, missingEmitter, invalidDrawEmitter, invalidMaxParticles]; return invalids.every((entry) => entry && entry.ok === false && typeof reasonOf(entry) === 'string' && reasonOf(entry).length > 0) && stopped && stopped.ok === true; })()",
+        },
+        {
+          id: 'particles.vfx.reason-codes.stable',
+          expression: "(() => { const reasonOf = (entry) => (entry && (entry.reasonCode || entry.reason)) || null; const runSample = () => { const created = aura.particles.emit({ x: 0, y: 0, count: 1 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const invalidBurstCount = aura.particles.burst(emitterId, 0); const invalidLayer = aura.particles.setLayer(emitterId, -1); const invalidBlendMode = aura.particles.setBlend(emitterId, 'unsupported'); const invalidKillId = aura.particles.kill('bad-id'); const missingKill = aura.particles.kill(999999); const cleaned = aura.particles.kill(emitterId); return { invalidBurstCount: reasonOf(invalidBurstCount), invalidLayer: reasonOf(invalidLayer), invalidBlendMode: reasonOf(invalidBlendMode), invalidKillId: reasonOf(invalidKillId), missingKill: reasonOf(missingKill), cleaned: !!cleaned && cleaned.ok === true }; }; const first = runSample(); const second = runSample(); const reasonsPresent = !!first && typeof first.invalidBurstCount === 'string' && typeof first.invalidLayer === 'string' && typeof first.invalidBlendMode === 'string' && typeof first.invalidKillId === 'string' && typeof first.missingKill === 'string'; return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && reasonsPresent && first.cleaned === true; })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {};
+      `,
+      nativeFrames: 2,
+    },
+  {
+      id: 'phaser-particles-vfx-blend-parity',
+      modes: ['native'],
+      namespaces: ['particles', 'draw2d'],
+      functions: [
+        'aura.particles.emit',
+        'aura.particles.burst',
+        'aura.particles.update',
+        'aura.particles.draw',
+        'aura.particles.stop',
+        'aura.particles.kill',
+        'aura.particles.setLayer',
+        'aura.particles.setBlend',
+        'aura.particles.getState',
+        'aura.draw2d.circleFill',
+      ],
+      nativeChecks: [
+        {
+          id: 'particles.vfx.surface.methods',
+          expression: "(() => ['emit','burst','update','draw','stop','kill','setLayer','setBlend','getState'].every((name) => typeof aura.particles?.[name] === 'function'))()",
+        },
+        {
+          id: 'particles.vfx.blend-layer.fixed-step.deterministic',
+          expression: "(() => { const runSample = (tag) => { const createdA = aura.particles.emit({ x: 24, y: 24, count: 5, life: 0.5, size: 2, speedMin: 12, speedMax: 12, direction: 0, spread: 0, loop: true, rate: 24, layer: 3, blend: 'add' }); const createdB = aura.particles.emit({ x: 40, y: 24, count: 5, life: 0.5, size: 2, speedMin: 8, speedMax: 8, direction: 0, spread: 0, loop: true, rate: 12, layer: 1, blend: 'screen' }); if (!createdA || createdA.ok !== true || !createdB || createdB.ok !== true) return null; const emitterIdA = createdA.emitterId; const emitterIdB = createdB.emitterId; const layer = aura.particles.setLayer(emitterIdA, 3); const blend = aura.particles.setBlend(emitterIdA, 'add'); const burstA = aura.particles.burst(emitterIdA, { count: 4 }); const burstB = aura.particles.burst(emitterIdB); const trace = []; for (const dt of [1 / 120, 1 / 30, 1 / 24, 1 / 15]) { const step = aura.particles.update(dt); const stateA = aura.particles.getState(emitterIdA); const stateB = aura.particles.getState(emitterIdB); trace.push({ ok: !!step && step.ok === true, particlesA: stateA ? stateA.particles : null, particlesB: stateB ? stateB.particles : null }); } const drawn = aura.particles.draw({ maxParticles: 64 }); const order = Array.isArray(drawn?.drawOrder) ? drawn.drawOrder.map((entry) => `${entry.layer}:${entry.blend}:${entry.drawnParticles}`).join('|') : null; const killedA = aura.particles.kill(emitterIdA); const killedB = aura.particles.kill(emitterIdB); const afterKillA = aura.particles.getState(emitterIdA); const afterKillB = aura.particles.getState(emitterIdB); return { tag, layerOk: !!layer && layer.ok === true, blendOk: !!blend && blend.ok === true, burstASpawned: burstA?.spawned ?? null, burstBSpawned: burstB?.spawned ?? null, trace, drawn: drawn && drawn.ok === true ? drawn.drawnParticles : null, order, killedA: !!killedA && killedA.ok === true, killedB: !!killedB && killedB.ok === true, afterKillNull: afterKillA === null && afterKillB === null }; }; const first = runSample('a'); const second = runSample('b'); if (!first || !second) return false; const normalizedFirst = JSON.stringify({ ...first, tag: 'x' }); const normalizedSecond = JSON.stringify({ ...second, tag: 'x' }); return normalizedFirst === normalizedSecond && first.layerOk === true && first.blendOk === true && first.burstASpawned === 4 && first.burstBSpawned === 5 && first.trace.every((entry) => entry.ok === true && Number.isFinite(entry.particlesA) && Number.isFinite(entry.particlesB) && entry.particlesA >= 0 && entry.particlesB >= 0) && Number.isFinite(first.drawn) && first.drawn > 0 && (first.order === null || (typeof first.order === 'string' && first.order.length > 0)) && first.killedA === true && first.killedB === true && first.afterKillNull === true; })()",
+        },
+        {
+          id: 'particles.vfx.stop-vs-kill.fixed-step.deterministic',
+          expression: "(() => { const runSample = () => { const drainedEmitter = aura.particles.emit({ x: 0, y: 0, count: 3, life: 0.2, size: 1, speedMin: 6, speedMax: 6, direction: 0, spread: 0, loop: false }); const killedEmitter = aura.particles.emit({ x: 0, y: 0, count: 3, life: 0.2, size: 1, speedMin: 6, speedMax: 6, direction: 0, spread: 0, loop: true, rate: 30 }); if (!drainedEmitter?.ok || !killedEmitter?.ok) return null; const drainedId = drainedEmitter.emitterId; const killedId = killedEmitter.emitterId; const drained = aura.particles.stop(drainedId, { mode: 'drain' }); const drainedAfterStop = aura.particles.getState(drainedId); const killed = aura.particles.kill(killedId); const killedAfterKill = aura.particles.getState(killedId); for (const dt of [0.05, 0.05, 0.05, 0.05]) { aura.particles.update(dt); } const drainedAfterTick = aura.particles.getState(drainedId); const killedAfterTick = aura.particles.getState(killedId); return { drainedOk: !!drained && drained.ok === true, drainedRemovedAfterStop: drainedAfterStop === null, drainedPersistedAfterStop: drainedAfterStop !== null, killedOk: !!killed && killed.ok === true, killedRemovedAfterKill: killedAfterKill === null, drainedRemovedAfterTick: drainedAfterTick === null, killedRemovedAfterTick: killedAfterTick === null }; }; const first = runSample(); const second = runSample(); return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && first.drainedOk === true && (first.drainedRemovedAfterStop === true || first.drainedPersistedAfterStop === true) && first.killedOk === true && first.killedRemovedAfterKill === true && first.drainedRemovedAfterTick === true && first.killedRemovedAfterTick === true; })()",
+        },
+        {
+          id: 'particles.vfx.reason-codes.stable',
+          expression: "(() => { const reasonOf = (entry) => (entry && (entry.reasonCode || entry.reason)) || null; const collect = () => { const created = aura.particles.emit({ x: 0, y: 0, count: 1 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const invalidLayerId = aura.particles.setLayer('bad-id', 1); const invalidBlendId = aura.particles.setBlend('bad-id', 'add'); const invalidLayer = aura.particles.setLayer(emitterId, -1); const invalidBlendMode = aura.particles.setBlend(emitterId, 'unsupported'); const invalidBurstArgs = aura.particles.burst(emitterId, 'bad'); const invalidBurstCount = aura.particles.burst(emitterId, { count: 0 }); const invalidStopMode = aura.particles.stop(emitterId, { mode: 'pause' }); const invalidKillId = aura.particles.kill('bad-id'); const missingKill = aura.particles.kill(999999); const cleaned = aura.particles.kill(emitterId); return { invalidLayerId: reasonOf(invalidLayerId), invalidBlendId: reasonOf(invalidBlendId), invalidLayer: reasonOf(invalidLayer), invalidBlendMode: reasonOf(invalidBlendMode), invalidBurstArgs: reasonOf(invalidBurstArgs), invalidBurstCount: reasonOf(invalidBurstCount), invalidStopMode: reasonOf(invalidStopMode), invalidKillId: reasonOf(invalidKillId), missingKill: reasonOf(missingKill), cleaned: !!cleaned && cleaned.ok === true }; }; const first = collect(); const second = collect(); const requiredReasonKeys = ['invalidLayerId','invalidBlendId','invalidLayer','invalidBlendMode','invalidBurstArgs','invalidBurstCount','invalidKillId','missingKill']; const reasonsPresent = !!first && requiredReasonKeys.every((key) => typeof first[key] === 'string' && first[key].length > 0); return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && reasonsPresent && (first.invalidStopMode === null || typeof first.invalidStopMode === 'string') && (first.cleaned === true || first.invalidStopMode === null); })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {};
+      `,
+      nativeFrames: 2,
+    },
+  {
+      id: 'threejs-draw3d-postfx-composer-parity',
+      modes: ['native'],
+      namespaces: ['draw3d', 'scene3d', 'mesh', 'material', 'camera3d', 'debug'],
+      functions: [
+        'aura.draw3d.setPostFXPass',
+        'aura.draw3d.setPostFXEnabled',
+        'aura.draw3d.removePostFXPass',
+        'aura.draw3d.getPostFXState',
+        'aura.draw3d.clear3d',
+        'aura.scene3d.createNode',
+        'aura.scene3d.bindRenderNode',
+        'aura.scene3d.submitRenderBindings',
+        'aura.scene3d.getRenderSubmissionState',
+        'aura.mesh.createBox',
+        'aura.mesh.unload',
+        'aura.material.create',
+        'aura.material.unload',
+        'aura.camera3d.perspective',
+        'aura.camera3d.setPosition',
+        'aura.camera3d.lookAt',
+        'aura.debug.enableInspector',
+        'aura.debug.inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw3d.postfx.surface.methods',
+          expression: "(() => ['setPostFXPass','setPostFXEnabled','removePostFXPass','getPostFXState'].every((name) => typeof aura.draw3d?.[name] === 'function'))()",
+        },
+        {
+          id: 'draw3d.postfx.chain-mutation.deterministic',
+          expression: "(() => { const runSample = () => { const baseline = aura.draw3d.getPostFXState(); aura.draw3d.removePostFXPass('bloom'); aura.draw3d.removePostFXPass('colorGrade'); aura.draw3d.removePostFXPass('vignette'); aura.draw3d.removePostFXPass('fxaa'); const setBloom = aura.draw3d.setPostFXPass('bloom', { strength: 1.25, radius: 0.6, threshold: 0.7 }); const setFxaa = aura.draw3d.setPostFXPass('fxaa', { enabled: true, strength: 1.0 }); const setColorGrade = aura.draw3d.setPostFXPass('colorGrade', { strength: 0.8 }); const disableBloom = aura.draw3d.setPostFXEnabled('bloom', false); const enableBloom = aura.draw3d.setPostFXEnabled('bloom', true); const removeFxaa = aura.draw3d.removePostFXPass('fxaa'); const setVignette = aura.draw3d.setPostFXPass('vignette', { strength: 0.4, radius: 0.9 }); const state = aura.draw3d.getPostFXState(); return { status: [setBloom?.reasonCode, setFxaa?.reasonCode, setColorGrade?.reasonCode, disableBloom?.reasonCode, enableBloom?.reasonCode, removeFxaa?.reasonCode, setVignette?.reasonCode].join('|'), order: Array.isArray(state?.passes) ? state.passes.map((pass) => pass.pass).join('|') : '', enabled: state?.enabledPasses, total: state?.totalPasses, fingerprint: state?.orderFingerprint, mutationDelta: Number(state?.mutationCount || 0) - Number(baseline?.mutationCount || 0), lastReasonCode: state?.lastReasonCode, lastOk: state?.lastOk }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.status === 'postfx_ok|postfx_ok|postfx_ok|postfx_ok|postfx_ok|postfx_ok|postfx_ok' && first.order === 'colorGrade|bloom|vignette' && first.total === 3 && first.enabled === 3 && Number.isFinite(first.fingerprint) && first.fingerprint > 0 && first.mutationDelta === 11 && first.lastReasonCode === 'postfx_ok' && first.lastOk === true; })()",
+        },
+        {
+          id: 'draw3d.postfx.target-chain.custom-pass.deterministic',
+          expression: "(() => { const runSample = () => { const baseline = aura.draw3d.getPostFXState(); aura.draw3d.removePostFXPass('bloom'); aura.draw3d.removePostFXPass('colorGrade'); aura.draw3d.removePostFXPass('vignette'); aura.draw3d.removePostFXPass('fxaa'); aura.draw3d.removePostFXPass('custom:filmgrain'); aura.draw3d.removePostFXPass('custom:glow'); const setBloom = aura.draw3d.setPostFXPass('bloom', { strength: 1.1, targetChain: { intermediateTargets: ['mainA', 'mainB', 'mainA'], pingPong: true, composeMode: 'additive' } }); const setCustom = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 0.75, threshold: 0.33 } }); const updateCustom = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 0.5, threshold: 0.2 } }); const setFilmgrain = aura.draw3d.setPostFXPass('custom:filmgrain', { customParams: { amount: 0.2, grain: 0.1 } }); const state = aura.draw3d.getPostFXState(); const targetChain = state?.targetChain || {}; const customGlow = Array.isArray(state?.passes) ? state.passes.find((pass) => pass.pass === 'custom:glow') : null; const customParams = customGlow?.customParams || {}; const customParamKeys = Object.keys(customParams).sort().join('|'); return { status: [setBloom?.reasonCode, setCustom?.reasonCode, updateCustom?.reasonCode, setFilmgrain?.reasonCode].join('|'), order: Array.isArray(state?.passes) ? state.passes.map((pass) => pass.pass).join('|') : '', enabled: state?.enabledPasses, total: state?.totalPasses, customPassCount: state?.customPassCount, targetChainTargets: Array.isArray(targetChain?.intermediateTargets) ? targetChain.intermediateTargets.join('|') : '', targetChainCount: targetChain?.intermediateTargetCount, targetChainPingPong: targetChain?.pingPong === true, targetChainComposeMode: targetChain?.composeMode, targetChainFingerprint: state?.targetChainFingerprint, customParamFingerprint: state?.customParamFingerprint, customGlowIsCustom: customGlow?.isCustom === true, customGlowParamKeys: customParamKeys, customGlowIntensity: customParams?.intensity, customGlowThreshold: customParams?.threshold, mutationDelta: Number(state?.mutationCount || 0) - Number(baseline?.mutationCount || 0), lastReasonCode: state?.lastReasonCode, lastOk: state?.lastOk }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.status === 'postfx_ok|postfx_ok|postfx_ok|postfx_ok' && first.order === 'bloom|custom:filmgrain|custom:glow' && first.total === 3 && first.enabled === 3 && first.customPassCount === 2 && first.targetChainTargets === 'maina|mainb' && first.targetChainCount === 2 && first.targetChainPingPong === true && first.targetChainComposeMode === 'additive' && Number.isFinite(first.targetChainFingerprint) && first.targetChainFingerprint > 0 && Number.isFinite(first.customParamFingerprint) && first.customParamFingerprint > 0 && first.customGlowIsCustom === true && first.customGlowParamKeys === 'intensity|threshold' && Math.abs(Number(first.customGlowIntensity) - 0.5) < 1e-3 && Math.abs(Number(first.customGlowThreshold) - 0.2) < 1e-3 && first.mutationDelta === 10 && first.lastReasonCode === 'postfx_ok' && first.lastOk === true; })()",
+        },
+        {
+          id: 'draw3d.postfx.motion-blur.state.deterministic',
+          expression: "(() => { const resetPasses = () => { for (const passName of ['ssr', 'dof', 'motionBlur', 'bloom', 'colorGrade', 'vignette', 'fxaa', 'ssao', 'custom:filmgrain', 'custom:glow']) { aura.draw3d.removePostFXPass(passName); } }; const runSample = () => { resetPasses(); const baseline = aura.draw3d.getPostFXState() || {}; const setInitial = aura.draw3d.setPostFXPass('motionBlur', { strength: 0.75, radius: 12, threshold: 1.0, targetChain: { intermediateTargets: [], pingPong: false, composeMode: 'replace' } }); const disable = aura.draw3d.setPostFXEnabled('motionBlur', false); const reenable = aura.draw3d.setPostFXEnabled('motionBlur', true); const update = aura.draw3d.setPostFXPass('motionBlur', { strength: 0.35, radius: 6, threshold: 0.0 }); const state = aura.draw3d.getPostFXState() || {}; const pass = Array.isArray(state?.passes) ? state.passes.find((entry) => entry.pass === 'motionBlur') : null; return { status: [setInitial?.reasonCode, disable?.reasonCode, reenable?.reasonCode, update?.reasonCode].join('|'), order: Array.isArray(state?.passes) ? state.passes.map((entry) => entry.pass).join('|') : '', total: Number(state?.totalPasses || 0), enabled: Number(state?.enabledPasses || 0), strength: Number(pass?.strength || 0), radius: Number(pass?.radius || 0), threshold: Number(pass?.threshold || 0), mutationDelta: Number(state?.mutationCount || 0) - Number(baseline?.mutationCount || 0), lastReasonCode: state?.lastReasonCode, lastOk: state?.lastOk, targetChainCount: Number(state?.targetChain?.intermediateTargetCount || 0), targetChainPingPong: state?.targetChain?.pingPong === true, targetChainComposeMode: state?.targetChain?.composeMode || null }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.status === 'postfx_ok|postfx_ok|postfx_ok|postfx_ok' && first.order === 'motionBlur' && first.total === 1 && first.enabled === 1 && Math.abs(first.strength - 0.35) < 1e-3 && Math.abs(first.radius - 6.0) < 1e-3 && Math.abs(first.threshold - 0.0) < 1e-3 && first.targetChainCount === 0 && first.targetChainPingPong === false && first.targetChainComposeMode === 'replace' && first.mutationDelta === 4 && first.lastReasonCode === 'postfx_ok' && first.lastOk === true; })()",
+        },
+        {
+          id: 'draw3d.postfx.ssao.state.deterministic',
+          expression: "(() => { const resetPasses = () => { for (const passName of ['ssr', 'dof', 'motionBlur', 'bloom', 'colorGrade', 'vignette', 'fxaa', 'ssao', 'custom:filmgrain', 'custom:glow']) { aura.draw3d.removePostFXPass(passName); } }; const runSample = () => { resetPasses(); const baseline = aura.draw3d.getPostFXState() || {}; const setInitial = aura.draw3d.setPostFXPass('ssao', { strength: 1.1, radius: 0.42, threshold: 0.18, targetChain: { intermediateTargets: [], pingPong: false, composeMode: 'replace' } }); const disable = aura.draw3d.setPostFXEnabled('ssao', false); const reenable = aura.draw3d.setPostFXEnabled('ssao', true); const update = aura.draw3d.setPostFXPass('ssao', { strength: 0.92, radius: 0.36, threshold: 0.24 }); const state = aura.draw3d.getPostFXState() || {}; const pass = Array.isArray(state?.passes) ? state.passes.find((entry) => entry.pass === 'ssao') : null; return { status: [setInitial?.reasonCode, disable?.reasonCode, reenable?.reasonCode, update?.reasonCode].join('|'), order: Array.isArray(state?.passes) ? state.passes.map((entry) => entry.pass).join('|') : '', total: Number(state?.totalPasses || 0), enabled: Number(state?.enabledPasses || 0), strength: Number(pass?.strength || 0), radius: Number(pass?.radius || 0), threshold: Number(pass?.threshold || 0), mutationDelta: Number(state?.mutationCount || 0) - Number(baseline?.mutationCount || 0), lastReasonCode: state?.lastReasonCode, lastOk: state?.lastOk, targetChainCount: Number(state?.targetChain?.intermediateTargetCount || 0), targetChainPingPong: state?.targetChain?.pingPong === true, targetChainComposeMode: state?.targetChain?.composeMode || null }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.status === 'postfx_ok|postfx_ok|postfx_ok|postfx_ok' && first.order === 'ssao' && first.total === 1 && first.enabled === 1 && Math.abs(first.strength - 0.92) < 1e-3 && Math.abs(first.radius - 0.36) < 1e-3 && Math.abs(first.threshold - 0.24) < 1e-3 && first.targetChainCount === 0 && first.targetChainPingPong === false && first.targetChainComposeMode === 'replace' && first.mutationDelta === 4 && first.lastReasonCode === 'postfx_ok' && first.lastOk === true; })()",
+        },
+        {
+          id: 'draw3d.postfx.reason-codes.stable',
+          expression: "(() => { const reasonOf = (entry) => (entry && entry.reasonCode) || null; const collect = () => { aura.draw3d.removePostFXPass('bloom'); aura.draw3d.removePostFXPass('custom:glow'); const invalidPassEmpty = aura.draw3d.setPostFXPass('', {}); const invalidPassType = aura.draw3d.setPostFXPass(42, {}); const configuredSsao = aura.draw3d.setPostFXPass('ssao', { radius: 0.6, intensity: 0.8 }); const removeSsao = aura.draw3d.removePostFXPass('ssao'); const invalidOptions = aura.draw3d.setPostFXPass('bloom', 'bad'); const invalidTargetChain = aura.draw3d.setPostFXPass('bloom', { targetChain: 'bad' }); const invalidIntermediateTargetType = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: 'bad' } }); const invalidIntermediateTargetEntry = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: ['ok', 'bad!'] } }); const invalidComposeMode = aura.draw3d.setPostFXPass('bloom', { targetChain: { composeMode: 'overlay' } }); const invalidPingPong = aura.draw3d.setPostFXPass('bloom', { targetChain: { pingPong: 'yes' } }); const invalidCustomPassName = aura.draw3d.setPostFXPass('custom:bad name', {}); const invalidCustomParams = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 'high' } }); const unsupportedCustomParams = aura.draw3d.setPostFXPass('bloom', { customParams: { intensity: 1 } }); const configured = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 0.25 } }); const invalidEnabled = aura.draw3d.setPostFXEnabled('custom:glow', 'yes'); const removeConfigured = aura.draw3d.removePostFXPass('custom:glow'); const missingToggle = aura.draw3d.setPostFXEnabled('custom:glow', true); const missingRemove = aura.draw3d.removePostFXPass('custom:glow'); return { invalidPassEmpty: reasonOf(invalidPassEmpty), invalidPassType: reasonOf(invalidPassType), configuredSsaoOk: !!configuredSsao && configuredSsao.ok === true, configuredSsaoReason: reasonOf(configuredSsao), removeSsaoOk: !!removeSsao && removeSsao.ok === true, removeSsaoReason: reasonOf(removeSsao), invalidOptions: reasonOf(invalidOptions), invalidTargetChain: reasonOf(invalidTargetChain), invalidIntermediateTargetType: reasonOf(invalidIntermediateTargetType), invalidIntermediateTargetEntry: reasonOf(invalidIntermediateTargetEntry), invalidComposeMode: reasonOf(invalidComposeMode), invalidPingPong: reasonOf(invalidPingPong), invalidCustomPassName: reasonOf(invalidCustomPassName), invalidCustomParams: reasonOf(invalidCustomParams), unsupportedCustomParams: reasonOf(unsupportedCustomParams), configuredOk: !!configured && configured.ok === true, configuredReason: reasonOf(configured), invalidEnabled: reasonOf(invalidEnabled), removeConfiguredOk: !!removeConfigured && removeConfigured.ok === true, removeConfiguredReason: reasonOf(removeConfigured), missingToggle: reasonOf(missingToggle), missingRemove: reasonOf(missingRemove) }; }; const first = collect(); const second = collect(); const ssaoConfiguredStable = (first.configuredSsaoOk === true && first.configuredSsaoReason === 'postfx_ok') || (first.configuredSsaoOk === false && first.configuredSsaoReason === 'postfx_pass_unsupported'); const ssaoRemovedStable = (first.removeSsaoOk === true && first.removeSsaoReason === 'postfx_ok') || (first.removeSsaoOk === false && first.removeSsaoReason === 'postfx_pass_unsupported'); return JSON.stringify(first) === JSON.stringify(second) && first.invalidPassEmpty === 'postfx_invalid_pass_name' && first.invalidPassType === 'postfx_invalid_pass_name' && ssaoConfiguredStable && ssaoRemovedStable && first.invalidOptions === 'postfx_invalid_options' && first.invalidTargetChain === 'postfx_invalid_target_chain' && first.invalidIntermediateTargetType === 'postfx_invalid_intermediate_target' && first.invalidIntermediateTargetEntry === 'postfx_invalid_intermediate_target' && first.invalidComposeMode === 'postfx_invalid_compose_mode' && first.invalidPingPong === 'postfx_invalid_ping_pong' && first.invalidCustomPassName === 'postfx_invalid_custom_pass_name' && first.invalidCustomParams === 'postfx_invalid_custom_params' && first.unsupportedCustomParams === 'postfx_custom_param_unsupported' && first.configuredOk === true && first.configuredReason === 'postfx_ok' && first.invalidEnabled === 'postfx_invalid_enabled' && first.removeConfiguredOk === true && first.removeConfiguredReason === 'postfx_ok' && first.missingToggle === 'postfx_pass_missing' && first.missingRemove === 'postfx_pass_missing'; })()",
+        },
+        {
+          id: 'draw3d.postfx.ssr-dof.runtime.setup',
+          expression: `(() => { try { const resetPasses = () => { for (const passName of ['ssr', 'dof', 'motionBlur', 'bloom', 'colorGrade', 'vignette', 'fxaa', 'ssao', 'custom:filmgrain', 'custom:glow']) { aura.draw3d.removePostFXPass(passName); } }; resetPasses(); const baseline = aura.draw3d.getPostFXState() || {}; const meshHandle = aura.mesh.createBox(1, 1, 1); const materialHandle = aura.material.create({ color: { r: 0.35, g: 0.7, b: 0.95, a: 1 }, metallic: 0.1, roughness: 0.6 }); const nodeId = aura.scene3d.createNode({ position: { x: 0, y: 0, z: -2.5 } }); const bind = aura.scene3d.bindRenderNode(nodeId, meshHandle, materialHandle, { layer: 0, visible: true, cull: false }); aura.camera3d.perspective(60, 0.1, 100); aura.camera3d.setPosition(0, 0, 4); aura.camera3d.lookAt(0, 0, 0); const setSsr = aura.draw3d.setPostFXPass('ssr', { strength: 1.0, threshold: 0.35, maxSteps: 96, thickness: 0.25, fadeEdge: 0.8, targetChain: { intermediateTargets: [], pingPong: false, composeMode: 'replace' } }); const setDof = aura.draw3d.setPostFXPass('dof', { strength: 0.9, focalDistance: 2.5, focalLength: 50, aperture: 2.2, maxBlur: 6.0 }); const setMotionBlur = aura.draw3d.setPostFXPass('motionBlur', { strength: 0.65, radius: 12.0, threshold: 0.0 }); const baseDraw = aura.draw; aura.draw = function () { const frameIndex = Number(globalThis.__postfxRuntimeFrame || 0); aura.camera3d.setPosition(frameIndex * 0.15, 0, 4 - (frameIndex * 0.1)); aura.camera3d.lookAt(0, 0, 0); aura.draw3d.clear3d({ r: 0.02, g: 0.02, b: 0.03, a: 1 }); aura.scene3d.submitRenderBindings(); globalThis.__postfxRuntimeFrame = frameIndex + 1; baseDraw(); }; globalThis.__postfxRuntimeFrame = 0; globalThis.__postfxRuntimeProbe = { meshHandle, materialHandle, nodeId, bindOk: bind?.ok === true, setSsrReason: setSsr?.reasonCode || null, setDofReason: setDof?.reasonCode || null, setMotionBlurReason: setMotionBlur?.reasonCode || null, baselineMutationCount: Number(baseline?.mutationCount || 0) }; return Number.isInteger(meshHandle) && meshHandle > 0 && Number.isInteger(materialHandle) && materialHandle > 0 && Number.isInteger(nodeId) && nodeId > 0 && bind?.ok === true && setSsr?.ok === true && setDof?.ok === true && setMotionBlur?.ok === true; } catch (_) { return false; } })()`,
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw3d.postfx.ssr-dof.runtime.evidence',
+          expression: `(() => { try { const probe = globalThis.__postfxRuntimeProbe || {}; const postfx = aura.draw3d.getPostFXState() || {}; aura.debug.enableInspector(true); const stats = aura.debug.inspectorStats() || {}; aura.debug.enableInspector(false); const submission = stats?.scene3dRuntime?.submission || {}; const render = aura.scene3d.getRenderSubmissionState() || {}; const baselineMutationCount = Number(probe.baselineMutationCount || 0); return probe.bindOk === true && probe.setSsrReason === 'postfx_ok' && probe.setDofReason === 'postfx_ok' && probe.setMotionBlurReason === 'postfx_ok' && Array.isArray(postfx?.passes) && postfx.passes.map((pass) => pass.pass).join('|') === 'ssr|dof|motionBlur' && Number(postfx?.totalPasses || 0) === 3 && Number(postfx?.enabledPasses || 0) === 3 && (Number(postfx?.mutationCount || 0) - baselineMutationCount) === 3 && Number(submission?.scene3dSubmitted || 0) >= 1 && Number(submission?.postfxPassCount || 0) === 3 && Number(submission?.postfxEnabledPassCount || 0) === 3 && (Number(submission?.postfxMutationCount || 0) - baselineMutationCount) === 3 && Number(submission?.postfxLastExecutedPassCount || 0) === 3 && Number(submission?.postfxLastExecutedSsrCount || 0) === 1 && Number(submission?.postfxLastExecutedDofCount || 0) === 1 && Number(submission?.postfxLastExecutedMotionBlurCount || 0) === 1 && Number(submission?.postfxLastExecutionFingerprint || 0) > 0 && submission?.postfxLastExecutionReasonCode === 'postfx_executed' && submission?.postfxLastExecutionOk === true && submission?.postfxLastReasonCode === 'postfx_ok' && submission?.postfxLastOk === true && Number(render?.submitted || 0) >= 1 && Number(render?.submitted || 0) === Number(submission?.scene3dSubmitted || 0) && Number(render?.orderFingerprint || 0) > 0; } catch (_) { return false; } })()`,
+        },
+      ],
+      source: `
+        aura.setup = function () {};
+      `,
+      nativeFrames: 3,
+    },
+  {
+      id: 'asset-streaming-cache-preload-parity',
+      modes: ['native'],
+      namespaces: ['assets'],
+      functions: [
+        'aura.assets.load',
+        'aura.assets.getFormatSupport',
+        'aura.assets.getState',
+        'aura.assets.getStateHistory',
+        'aura.assets.evict',
+        'aura.assets.getCachePolicy',
+        'aura.assets.setCachePolicy',
+        'aura.assets.preload2d',
+        'aura.assets.preload3d',
+      ],
+      nativeChecks: [
+        {
+          id: 'assets.streaming.surface.methods',
+          expression: "(() => ['load','getFormatSupport','getState','getStateHistory','evict','getCachePolicy','setCachePolicy','preload2d','preload3d'].every((name) => typeof aura.assets?.[name] === 'function'))()",
+        },
+        {
+          id: 'assets.streaming.lifecycle.preload.deterministic',
+          expression: "(() => { const runSample = (tag) => { const miss2d = `__missing__/stream-2d-${tag}.png`; const miss3d = `__missing__/stream-3d-${tag}.glb`; const preload2d = aura.assets.preload2d([miss2d]); const preload3d = aura.assets.preload3d([miss3d]); const state2d = aura.assets.getState(miss2d); const state3d = aura.assets.getState(miss3d); const history2d = aura.assets.getStateHistory(miss2d); const history3d = aura.assets.getStateHistory(miss3d); return { preload2d, preload3d, state2d: state2d ? { state: state2d.state, reasonCode: state2d.reasonCode } : null, state3d: state3d ? { state: state3d.state, reasonCode: state3d.reasonCode } : null, history2d: Array.isArray(history2d) ? history2d.map((entry) => entry.state).join('|') : '', history3d: Array.isArray(history3d) ? history3d.map((entry) => entry.state).join('|') : '' }; }; const first = runSample('a'); const second = runSample('b'); return JSON.stringify(first) === JSON.stringify(second) && first.preload2d?.ok === false && first.preload2d?.reasonCode === 'assets_preload_partial_failure' && first.preload2d?.requested === 1 && first.preload2d?.failed === 1 && Array.isArray(first.preload2d?.failures) && first.preload2d.failures.length === 1 && first.preload2d.failures[0].reasonCode === 'missing_asset' && first.preload3d?.ok === false && first.preload3d?.reasonCode === 'assets_preload_partial_failure' && first.preload3d?.requested === 1 && first.preload3d?.failed === 1 && Array.isArray(first.preload3d?.failures) && first.preload3d.failures.length === 1 && first.preload3d.failures[0].reasonCode === 'missing_asset' && first.state2d?.state === 'failed' && first.state2d?.reasonCode === 'missing_asset' && first.state3d?.state === 'failed' && first.state3d?.reasonCode === 'missing_asset' && first.history2d === 'queued|loading|failed' && first.history3d === 'queued|loading|failed'; })()",
+        },
+        {
+          id: 'assets.format-support.reason-codes.stable',
+          expression: "(() => { const normalize = (entry) => entry ? { ok: entry.ok === true, status: entry.status || null, reasonCode: entry.reasonCode || null, extension: entry.extension || null, supported: entry.supported === true, deferred: entry.deferred === true } : null; const runSample = () => { const supported = normalize(aura.assets.getFormatSupport('sprite.png')); const promoted = normalize(aura.assets.getFormatSupport('sprite.webp')); const deferred = normalize(aura.assets.getFormatSupport('sprite.bmp')); const model = normalize(aura.assets.getFormatSupport('future.glb')); const nativeVideo = normalize(aura.assets.getFormatSupport('future.mp4')); const font = normalize(aura.assets.getFormatSupport('font.woff2')); const unsupported = normalize(aura.assets.getFormatSupport('blob.xyz')); const invalidRaw = aura.assets.getFormatSupport(42); const invalid = invalidRaw ? { ok: invalidRaw.ok === true, status: invalidRaw.status || null, reasonCode: invalidRaw.reasonCode || null } : null; const loadReason = (() => { try { aura.assets.load('future.bmp'); } catch (err) { return String(err); } return ''; })(); const preload3d = aura.assets.preload3d(['future.glb']); return { supported, promoted, deferred, model, nativeVideo, font, unsupported, invalid, loadReason, preload3dReason: preload3d?.failures?.[0]?.reasonCode || null }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.supported?.ok === true && first.supported?.status === 'supported' && first.supported?.reasonCode === 'asset_format_supported' && first.supported?.supported === true && first.supported?.deferred === false && first.promoted?.status === 'supported' && first.promoted?.reasonCode === 'asset_format_supported' && first.promoted?.deferred === false && first.deferred?.status === 'unsupported' && first.deferred?.reasonCode === 'asset_format_unsupported' && first.deferred?.deferred === false && first.model?.status === 'supported' && first.model?.reasonCode === 'asset_format_supported' && first.nativeVideo?.status === 'supported' && first.nativeVideo?.reasonCode === 'asset_format_supported' && first.nativeVideo?.extension === 'mp4' && first.font?.status === 'supported' && first.font?.reasonCode === 'asset_format_supported' && first.unsupported?.status === 'unsupported' && first.unsupported?.reasonCode === 'asset_format_unsupported' && first.invalid?.ok === false && first.invalid?.status === 'unsupported' && first.invalid?.reasonCode === 'invalid_format_probe' && first.loadReason.includes('[reason:asset_format_unsupported]') && first.preload3dReason === 'missing_asset'; })()",
+        },
+        {
+          id: 'assets.streaming.cache-policy.reason-codes',
+          expression: "(() => { const invalidPaths = aura.assets.preload2d('bad'); const invalidPath = aura.assets.preload3d(['../bad.glb']); const invalidMaxEntries = aura.assets.setCachePolicy({ maxEntries: 0 }); const invalidMaxBytes = aura.assets.setCachePolicy({ maxBytes: 0 }); const invalidMode = aura.assets.setCachePolicy({ evictionMode: 'fifo' }); const updated = aura.assets.setCachePolicy({ maxEntries: 4, maxBytes: null, evictionMode: 'oldest' }); const policy = aura.assets.getCachePolicy(); const missingEvict = aura.assets.evict('__missing__/ghost.png'); const invalidEvict = aura.assets.evict('../ghost.png'); return invalidPaths?.ok === false && invalidPaths?.reasonCode === 'invalid_preload_paths' && invalidPath?.ok === false && invalidPath?.reasonCode === 'invalid_preload_path' && invalidMaxEntries?.ok === false && invalidMaxEntries?.reasonCode === 'invalid_max_entries' && invalidMaxBytes?.ok === false && invalidMaxBytes?.reasonCode === 'invalid_max_bytes' && invalidMode?.ok === false && invalidMode?.reasonCode === 'invalid_eviction_mode' && updated?.ok === true && updated?.reasonCode === 'cache_policy_updated' && policy?.maxEntries === 4 && policy?.maxBytes === null && policy?.evictionMode === 'oldest' && missingEvict?.ok === false && missingEvict?.reasonCode === 'missing_asset' && invalidEvict?.ok === false && invalidEvict?.reasonCode === 'invalid_path'; })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {};
+      `,
+      nativeFrames: 2,
+    },
+  {
+      id: 'physics-contact-filter-query-parity',
+      modes: ['native'],
+      namespaces: ['physics', 'debug'],
+      functions: [
+        'aura.physics.configureStep',
+        'aura.physics.body',
+        'aura.physics.step',
+        'aura.physics.queryOverlap',
+        'aura.physics.queryPointDetailed',
+        'aura.physics.queryRaycast',
+        'aura.debug.inspectorStats',
+      ],
+      optionalModuleReadiness: { module: 'physics', state: 'enabled' },
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '1',
+        AURA_MODULE_NET: '0',
+      },
+      nativeChecks: [
+        {
+          id: 'physics.contact-filter-query.surface.methods',
+          expression: "(() => { const physics = aura.physics || {}; const filterMethodNames = ['setContactFilter', 'setCollisionFilter', 'setFilter']; const rootFilterAvailable = filterMethodNames.some((name) => typeof physics[name] === 'function'); const queryAvailable = ['queryOverlap', 'queryPointDetailed', 'queryRaycast'].every((name) => typeof physics[name] === 'function'); const coreAvailable = ['configureStep', 'body', 'step'].every((name) => typeof physics[name] === 'function'); let bodyFilterAvailable = false; try { const probe = physics.body('static', { x: 512, y: 512, shape: 'circle', radius: 0.25 }); bodyFilterAvailable = !!probe && filterMethodNames.some((name) => typeof probe?.[name] === 'function'); } catch (_) { bodyFilterAvailable = false; } return coreAvailable && queryAvailable && (rootFilterAvailable || bodyFilterAvailable); })()",
+        },
+        {
+          id: 'physics.contact-filter-query.callback-ordering.filters.deterministic',
+          expression: "(() => { try { const runSample = () => { const physics = aura.physics || {}; physics.configureStep({ stepSeconds: 1 / 120, maxSubSteps: 16, auto: false, resetAccumulator: true, resetWorld: true }); const hits = []; const a = physics.body('dynamic', { x: 0, y: 0, shape: 'circle', radius: 1 }); const b = physics.body('static', { x: 0, y: 0, shape: 'circle', radius: 1 }); const c = physics.body('static', { x: 0, y: 0, shape: 'circle', radius: 1 }); if (!a || !b || !c || !Number.isFinite(a.id) || !Number.isFinite(b.id) || !Number.isFinite(c.id)) return null; if (typeof a.onCollide === 'function') a.onCollide((other) => hits.push('a:' + other)); if (typeof b.onCollide === 'function') b.onCollide((other) => hits.push('b:' + other)); if (typeof c.onCollide === 'function') c.onCollide((other) => hits.push('c:' + other)); const fa = globalThis.__physicsInvokeFilterMutation(a, 0x0001, 0x0002); const fb = globalThis.__physicsInvokeFilterMutation(b, 0x0002, 0x0001); const fc = globalThis.__physicsInvokeFilterMutation(c, 0x0004, 0x0000); const step = physics.step(1 / 60); const idMap = { [a.id]: 'A', [b.id]: 'B', [c.id]: 'C' }; return { normalizedHits: globalThis.__physicsNormalizeHitTrace(hits, idMap), expectedHits: 'a:B|b:A', filterReasonCodes: [fa?.reasonCode || null, fb?.reasonCode || null, fc?.reasonCode || null], filterOk: [fa, fb, fc].every((entry) => !!entry && entry.ok === true), stepOk: !(step && step.ok === false) }; }; const first = runSample(); const second = runSample(); return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && first.filterOk === true && first.stepOk === true && first.normalizedHits === first.expectedHits; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'physics.contact-filter-query.query-ordering-guarantees.deterministic',
+          expression: "(() => { try { const runSample = () => { const physics = aura.physics || {}; physics.configureStep({ stepSeconds: 1 / 120, maxSubSteps: 16, auto: false, resetAccumulator: true, resetWorld: true }); const a = physics.body('static', { x: -3, y: 0, shape: 'circle', radius: 1 }); const b = physics.body('static', { x: 0, y: 0, shape: 'circle', radius: 1 }); const c = physics.body('static', { x: 3, y: 0, shape: 'circle', radius: 1 }); if (!a || !b || !c || !Number.isFinite(a.id) || !Number.isFinite(b.id) || !Number.isFinite(c.id)) return null; const fa = globalThis.__physicsInvokeFilterMutation(a, 0x0001, 0x0001); const fb = globalThis.__physicsInvokeFilterMutation(b, 0x0002, 0x0002); const fc = globalThis.__physicsInvokeFilterMutation(c, 0x0001, 0x0001); const tracked = new Set([a.id, b.id, c.id]); const area = { x: -5, y: -2, w: 10, h: 4 }; const filter = { category: 0x0001, mask: 0x0001 }; const overlapA = globalThis.__physicsInvokeFilteredQuery(area, filter); const overlapB = globalThis.__physicsInvokeFilteredQuery(area, filter); const overlapHitsA = globalThis.__physicsExtractHits(overlapA).filter((id) => tracked.has(id)); const overlapHitsB = globalThis.__physicsExtractHits(overlapB).filter((id) => tracked.has(id)); const pointA = physics.queryPointDetailed({ x: 0, y: 0 }); const pointB = physics.queryPointDetailed({ x: 0, y: 0 }); const pointHitsA = globalThis.__physicsExtractHits(pointA).filter((id) => tracked.has(id)); const pointHitsB = globalThis.__physicsExtractHits(pointB).filter((id) => tracked.has(id)); return { filterOk: [fa, fb, fc].every((entry) => !!entry && entry.ok === true), overlapOrder: overlapHitsA.join('|'), overlapRepeatOrder: overlapHitsB.join('|'), overlapSortedOrder: overlapHitsA.slice().sort((x, y) => x - y).join('|'), overlapCount: overlapHitsA.length, pointOrder: pointHitsA.join('|'), pointRepeatOrder: pointHitsB.join('|') }; }; const first = runSample(); const second = runSample(); return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && first.filterOk === true && first.overlapCount === 2 && first.overlapOrder === first.overlapRepeatOrder && first.overlapOrder === first.overlapSortedOrder && first.pointOrder === first.pointRepeatOrder; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'physics.contact-filter-query.invalid-filter.reason-codes',
+          expression: "(() => { try { const runSample = () => { const physics = aura.physics || {}; const body = physics.body('static', { x: 32, y: 32, shape: 'circle', radius: 0.5 }); if (!body || !Number.isFinite(body.id)) return null; const invalidA = globalThis.__physicsInvokeInvalidFilterMutation(body, 'bad', 1); const invalidB = globalThis.__physicsInvokeInvalidFilterMutation(body, 1, 'bad'); const invalidC = globalThis.__physicsInvokeInvalidFilterMutation(body, -1, 1); const failures = [invalidA, invalidB, invalidC].map((entry) => ({ ok: entry?.ok, reasonCode: entry?.reasonCode || null })); const reasonCoded = failures.every((entry) => entry.ok === false && typeof entry.reasonCode === 'string' && entry.reasonCode.length > 0 && entry.reasonCode !== 'filter_api_missing' && entry.reasonCode !== 'filter_call_failed' && entry.reasonCode !== 'filter_invalid_not_reason_coded'); return { failures, reasonCoded }; }; const first = runSample(); const second = runSample(); return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && first.reasonCoded === true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'physics.contact-filter-query.inspector.telemetry-if-available',
+          expression: "(() => { try { if (typeof aura.debug?.enableInspector !== 'function' || typeof aura.debug?.inspectorStats !== 'function') return true; aura.debug.enableInspector(true); const stats = aura.debug.inspectorStats() || {}; aura.debug.enableInspector(false); const rows = []; const pushRow = (entry) => { if (entry && typeof entry === 'object') rows.push(entry); }; pushRow(stats.physicsRuntime); pushRow(stats.scene3dRuntime && stats.scene3dRuntime.physics); pushRow(stats.scene3dRuntime && stats.scene3dRuntime.physicsRuntime); pushRow(stats.phase2 && stats.phase2.physics); if (rows.length === 0) return true; return rows.every((row) => { const scalarValues = Object.values(row).filter((value) => typeof value === 'number' || typeof value === 'boolean'); if (scalarValues.length === 0) return false; return scalarValues.every((value) => (typeof value === 'number' ? Number.isFinite(value) && value >= 0 : typeof value === 'boolean')); }); } catch (_) { return false; } })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {};
+  
+        globalThis.__physicsNormalizeMutationResult = function __physicsNormalizeMutationResult(result) {
+          if (result === undefined || result === null) return { ok: true, reasonCode: null };
+          if (typeof result === 'boolean') return { ok: result, reasonCode: result ? null : 'boolean_false' };
+          if (typeof result === 'object') {
+            if (typeof result.ok === 'boolean') {
+              return {
+                ok: result.ok,
+                reasonCode: typeof result.reasonCode === 'string' ? result.reasonCode : null,
+              };
+            }
+            if (typeof result.reasonCode === 'string') {
+              return { ok: result.ok !== false, reasonCode: result.reasonCode };
+            }
+            return { ok: true, reasonCode: null };
+          }
+          return { ok: true, reasonCode: null };
+        };
+  
+        globalThis.__physicsInvokeFilterMutation = function __physicsInvokeFilterMutation(body, category, mask) {
+          const physics = aura.physics || {};
+          const bodyId = body && Number.isFinite(body.id) ? body.id : null;
+          const attempts = [];
+          const pushAttempts = (target, method, withBodyId) => {
+            if (!target || typeof target[method] !== 'function') return;
+            attempts.push(() => (withBodyId ? target[method](bodyId, { category, mask }) : target[method]({ category, mask })));
+            attempts.push(() => (withBodyId ? target[method](bodyId, category, mask) : target[method](category, mask)));
+            attempts.push(() => (withBodyId ? target[method](bodyId, { categoryBits: category, maskBits: mask }) : target[method]({ categoryBits: category, maskBits: mask })));
+            attempts.push(() => (withBodyId ? target[method](bodyId, { categories: category, masks: mask }) : target[method]({ categories: category, masks: mask })));
+          };
+  
+          for (const method of ['setContactFilter', 'setCollisionFilter', 'setFilter']) {
+            pushAttempts(body, method, false);
+            pushAttempts(physics, method, true);
+          }
+  
+          if (attempts.length === 0) return { ok: false, reasonCode: 'filter_api_missing' };
+          for (const invoke of attempts) {
+            try {
+              return globalThis.__physicsNormalizeMutationResult(invoke());
+            } catch (_) {}
+          }
+          return { ok: false, reasonCode: 'filter_call_failed' };
+        };
+  
+        globalThis.__physicsInvokeInvalidFilterMutation = function __physicsInvokeInvalidFilterMutation(body, invalidCategory, invalidMask) {
+          const physics = aura.physics || {};
+          const bodyId = body && Number.isFinite(body.id) ? body.id : null;
+          const attempts = [];
+          const pushAttempts = (target, method, withBodyId) => {
+            if (!target || typeof target[method] !== 'function') return;
+            attempts.push(() => (withBodyId ? target[method](bodyId, { category: invalidCategory, mask: invalidMask }) : target[method]({ category: invalidCategory, mask: invalidMask })));
+            attempts.push(() => (withBodyId ? target[method](bodyId, invalidCategory, invalidMask) : target[method](invalidCategory, invalidMask)));
+            attempts.push(() => (withBodyId ? target[method](bodyId, { categoryBits: invalidCategory, maskBits: invalidMask }) : target[method]({ categoryBits: invalidCategory, maskBits: invalidMask })));
+          };
+  
+          for (const method of ['setContactFilter', 'setCollisionFilter', 'setFilter']) {
+            pushAttempts(body, method, false);
+            pushAttempts(physics, method, true);
+          }
+  
+          if (attempts.length === 0) return { ok: false, reasonCode: 'filter_api_missing' };
+          for (const invoke of attempts) {
+            try {
+              const normalized = globalThis.__physicsNormalizeMutationResult(invoke());
+              if (normalized.ok === false && typeof normalized.reasonCode === 'string' && normalized.reasonCode.length > 0) {
+                return normalized;
+              }
+            } catch (_) {}
+          }
+          return { ok: false, reasonCode: 'filter_invalid_not_reason_coded' };
+        };
+  
+        globalThis.__physicsInvokeFilteredQuery = function __physicsInvokeFilteredQuery(area, filter) {
+          const physics = aura.physics || {};
+          const attempts = [
+            () => physics.queryOverlap({ x: area.x, y: area.y, w: area.w, h: area.h, filter }),
+            () => physics.queryOverlap({ x: area.x, y: area.y, w: area.w, h: area.h, category: filter.category, mask: filter.mask }),
+            () => physics.queryOverlap({ x: area.x, y: area.y, w: area.w, h: area.h, categoryBits: filter.category, maskBits: filter.mask }),
+            () => physics.queryOverlap(area, filter),
+            () => physics.queryOverlap(area),
+            () => physics.queryOverlap(area.x, area.y, area.w, area.h),
+          ];
+          for (const invoke of attempts) {
+            try {
+              const result = invoke();
+              if (result !== undefined) return result;
+            } catch (_) {}
+          }
+          return null;
+        };
+  
+        globalThis.__physicsExtractHits = function __physicsExtractHits(result) {
+          if (Array.isArray(result)) return result.slice();
+          if (result && Array.isArray(result.hits)) return result.hits.slice();
+          return [];
+        };
+  
+        globalThis.__physicsNormalizeHitTrace = function __physicsNormalizeHitTrace(hits, idMap) {
+          return hits.map((entry) => {
+            const raw = String(entry);
+            const split = raw.split(':');
+            if (split.length !== 2) return raw;
+            const role = split[0];
+            const idValue = Number(split[1]);
+            const mapped = Number.isFinite(idValue) ? idMap[idValue] : null;
+            return mapped ? role + ':' + mapped : raw;
+          }).join('|');
+        };
+      `,
+      nativeFrames: 2,
+    },
+  {
+      id: 'physics-snapshot-replay-rollback-primitives',
+      modes: ['native'],
+      namespaces: ['physics'],
+      functions: [
+        'aura.physics.captureSnapshot',
+        'aura.physics.restoreSnapshot',
+        'aura.physics.replay',
+        'aura.physics.rollback',
+      ],
+      optionalModuleReadiness: { module: 'physics', state: 'enabled' },
+      nativeEnv: {
+        AURA_MODULE_PHYSICS: '1',
+        AURA_MODULE_NET: '0',
+      },
+      nativeChecks: [
+        {
+          id: 'physics.snapshot-replay-rollback.surface.methods',
+          expression: "(() => { const info = globalThis.__physicsSnapshotReplaySurface(); globalThis.__physicsSnapshotReplaySurfaceInfo = info; return info.ready || info.absent; })()",
+        },
+        {
+          id: 'physics.snapshot-replay-rollback.invalid-operations.reason-codes',
+          expression: "(() => { const info = globalThis.__physicsSnapshotReplaySurfaceInfo || globalThis.__physicsSnapshotReplaySurface(); if (info.absent) return true; if (!info.ready) return false; const runSample = () => { const restoreInvalid = globalThis.__physicsSnapshotReplayInvoke('restore', [[null], ['invalid'], [{ snapshot: null }], [{ frameIndex: 'bad' }]]); const replayInvalid = globalThis.__physicsSnapshotReplayInvoke('replay', [[null], [{ snapshot: null, frames: [] }], [{ frames: 'bad' }], [{ frameCount: -1 }]]); const rollbackInvalid = globalThis.__physicsSnapshotReplayInvoke('rollback', [[-1], [{ frameIndex: -1 }], [Number.MAX_SAFE_INTEGER], [{ frameIndex: Number.MAX_SAFE_INTEGER }]]); return { restore: globalThis.__physicsSnapshotReplayInvalidReason(restoreInvalid), replay: globalThis.__physicsSnapshotReplayInvalidReason(replayInvalid), rollback: globalThis.__physicsSnapshotReplayInvalidReason(rollbackInvalid) }; }; const first = runSample(); const second = runSample(); const reasonCoded = Object.values(first).every((reason) => typeof reason === 'string' && reason.length > 0 && reason !== 'surface_missing' && reason !== 'failed_without_reason_code' && reason !== 'operation_succeeded_without_reason'); return JSON.stringify(first) === JSON.stringify(second) && reasonCoded; })()",
+        },
+        {
+          id: 'physics.snapshot-replay-rollback.rollback-boundary.reason-codes',
+          expression: "(() => { const info = globalThis.__physicsSnapshotReplaySurfaceInfo || globalThis.__physicsSnapshotReplaySurface(); if (info.absent) return true; if (!info.ready) return false; const runSample = () => { const capture = globalThis.__physicsSnapshotReplayInvoke('capture', [[], [{ deterministic: true }], [{ includeBodies: true }]]); const captureNorm = globalThis.__physicsSnapshotReplayNormalize(capture); if (captureNorm.ok === false || capture.result === undefined || capture.result === null) return null; const snapshot = capture.result; const low = globalThis.__physicsSnapshotReplayNormalize(globalThis.__physicsSnapshotReplayInvoke('rollback', [[-1], [{ frameIndex: -1 }], [snapshot, -1], [{ snapshot, frameIndex: -1 }]])); const high = globalThis.__physicsSnapshotReplayNormalize(globalThis.__physicsSnapshotReplayInvoke('rollback', [[Number.MAX_SAFE_INTEGER], [{ frameIndex: Number.MAX_SAFE_INTEGER }], [snapshot, Number.MAX_SAFE_INTEGER], [{ snapshot, frameIndex: Number.MAX_SAFE_INTEGER }]])); const valid = globalThis.__physicsSnapshotReplayNormalize(globalThis.__physicsSnapshotReplayInvoke('rollback', [[0], [{ frameIndex: 0 }], [snapshot, 0], [{ snapshot, frameIndex: 0 }]])); return { low, high, valid }; }; const first = runSample(); const second = runSample(); if (!first || !second) return false; const reasonCoded = first.low.ok === false && first.high.ok === false && typeof first.low.reasonCode === 'string' && first.low.reasonCode.length > 0 && typeof first.high.reasonCode === 'string' && first.high.reasonCode.length > 0; const stableFrameIndex = first.valid.frameIndex === null || Number.isInteger(first.valid.frameIndex); return JSON.stringify(first) === JSON.stringify(second) && reasonCoded && stableFrameIndex; })()",
+        },
+        {
+          id: 'physics.snapshot-replay-rollback.replay-integrity.deterministic',
+          expression: "(() => { const info = globalThis.__physicsSnapshotReplaySurfaceInfo || globalThis.__physicsSnapshotReplaySurface(); if (info.absent) return true; if (!info.ready) return false; const baselineFrames = [1 / 60, 1 / 60, 1 / 60, 1 / 30, 1 / 120]; const first = globalThis.__physicsSnapshotReplayRun(baselineFrames); const second = globalThis.__physicsSnapshotReplayRun(baselineFrames); if (first.skipped || second.skipped) return true; if (!first.ok || !second.ok) return false; const normalizedFirst = JSON.stringify({ replay: first.replay, state: first.state, rollback: first.rollback }); const normalizedSecond = JSON.stringify({ replay: second.replay, state: second.state, rollback: second.rollback }); const frameIndexed = first.replay.frameIndex === null || Number.isInteger(first.replay.frameIndex); return normalizedFirst === normalizedSecond && frameIndexed; })()",
+        },
+        {
+          id: 'physics.snapshot-replay-rollback.replay-divergence.detection',
+          expression: "(() => { const info = globalThis.__physicsSnapshotReplaySurfaceInfo || globalThis.__physicsSnapshotReplaySurface(); if (info.absent) return true; if (!info.ready) return false; const baselineFrames = [1 / 60, 1 / 60, 1 / 60, 1 / 30, 1 / 120]; const divergentFrames = [1 / 60, 1 / 60, 1 / 120, 1 / 30, 1 / 120]; const baselineA = globalThis.__physicsSnapshotReplayRun(baselineFrames); const baselineB = globalThis.__physicsSnapshotReplayRun(baselineFrames); const divergent = globalThis.__physicsSnapshotReplayRun(divergentFrames); if (baselineA.skipped || baselineB.skipped || divergent.skipped) return true; if (!baselineA.ok || !baselineB.ok || !divergent.ok) return false; const stableBaseline = JSON.stringify({ replay: baselineA.replay, state: baselineA.state }) === JSON.stringify({ replay: baselineB.replay, state: baselineB.state }); const baselineSignature = JSON.stringify({ replay: baselineA.replay, state: baselineA.state }); const divergentSignature = JSON.stringify({ replay: divergent.replay, state: divergent.state }); const explicitDivergence = divergent.replay.diverged === true || Number.isInteger(divergent.replay.divergenceFrame); return stableBaseline && (explicitDivergence || baselineSignature !== divergentSignature); })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {};
+  
+        globalThis.__physicsSnapshotReplaySurface = function __physicsSnapshotReplaySurface() {
+          const physics = aura.physics || {};
+          const pick = (names) => names.find((name) => typeof physics[name] === 'function') || null;
+          const info = {
+            capture: pick(['captureSnapshot', 'snapshotCapture', 'snapshot', 'createSnapshot']),
+            restore: pick(['restoreSnapshot', 'snapshotRestore', 'restoreSnapshotState', 'restore']),
+            replay: pick(['replay', 'runReplay', 'replayFrames', 'replaySnapshot']),
+            rollback: pick(['rollback', 'rollbackToFrame', 'rollbackFrame', 'rewindToFrame']),
+            state: pick(['getReplayState', 'getSnapshotReplayState', 'getRollbackState']),
+          };
+          info.methodCount = ['capture', 'restore', 'replay', 'rollback'].filter((key) => typeof info[key] === 'string').length;
+          info.absent = info.methodCount === 0;
+          info.ready = info.methodCount === 4;
+          return info;
+        };
+  
+        globalThis.__physicsSnapshotReplayReasonFromValue = function __physicsSnapshotReplayReasonFromValue(value) {
+          if (!value || typeof value !== 'object') return null;
+          if (typeof value.reasonCode === 'string' && value.reasonCode.length > 0) return value.reasonCode;
+          if (typeof value.reason === 'string' && value.reason.length > 0) return value.reason;
+          if (typeof value.errorCode === 'string' && value.errorCode.length > 0) return value.errorCode;
+          if (typeof value.error === 'string' && value.error.length > 0) return value.error;
+          return null;
+        };
+  
+        globalThis.__physicsSnapshotReplayExtractErrorReason = function __physicsSnapshotReplayExtractErrorReason(error) {
+          if (!error) return null;
+          if (typeof error.reasonCode === 'string' && error.reasonCode.length > 0) return error.reasonCode;
+          if (typeof error.reason === 'string' && error.reason.length > 0) return error.reason;
+          if (typeof error.message === 'string' && error.message.length > 0) return error.message;
+          const asString = String(error);
+          return asString && asString.length > 0 ? asString : null;
+        };
+  
+        globalThis.__physicsSnapshotReplayInvoke = function __physicsSnapshotReplayInvoke(kind, argForms) {
+          const physics = aura.physics || {};
+          const info = globalThis.__physicsSnapshotReplaySurfaceInfo || globalThis.__physicsSnapshotReplaySurface();
+          const methodName = info[kind];
+          if (!methodName || typeof physics[methodName] !== 'function') {
+            return { available: false, methodName, threw: false, result: null, errorReason: kind + '_surface_missing' };
+          }
+  
+          const forms = Array.isArray(argForms) && argForms.length > 0 ? argForms : [[]];
+          let lastReason = null;
+          for (const form of forms) {
+            const args = Array.isArray(form) ? form : [form];
+            try {
+              const result = physics[methodName](...args);
+              return { available: true, methodName, threw: false, result, errorReason: null };
+            } catch (error) {
+              lastReason = globalThis.__physicsSnapshotReplayExtractErrorReason(error);
+            }
+          }
+          return { available: true, methodName, threw: true, result: null, errorReason: lastReason || 'exception_without_reason' };
+        };
+  
+        globalThis.__physicsSnapshotReplayNormalize = function __physicsSnapshotReplayNormalize(entry) {
+          if (!entry || entry.available !== true) {
+            return {
+              available: false,
+              ok: null,
+              reasonCode: entry && typeof entry.errorReason === 'string' ? entry.errorReason : null,
+              frameIndex: null,
+              diverged: null,
+              divergenceFrame: null,
+              digest: null,
+            };
+          }
+  
+          const value = entry.result;
+          const reasonCode = globalThis.__physicsSnapshotReplayReasonFromValue(value) || entry.errorReason || null;
+          const ok = entry.threw
+            ? false
+            : (
+              value && typeof value === 'object' && typeof value.ok === 'boolean'
+                ? value.ok
+                : true
+            );
+          const frameIndex = value && typeof value === 'object'
+            ? (
+              Number.isFinite(value.frameIndex)
+                ? Math.trunc(value.frameIndex)
+                : (
+                  Number.isFinite(value.frame)
+                    ? Math.trunc(value.frame)
+                    : (
+                      Number.isFinite(value.replayFrame)
+                        ? Math.trunc(value.replayFrame)
+                        : null
+                    )
+                )
+            )
+            : null;
+          const diverged = value && typeof value === 'object'
+            ? (
+              typeof value.diverged === 'boolean'
+                ? value.diverged
+                : (
+                  typeof value.divergence === 'boolean'
+                    ? value.divergence
+                    : (
+                      typeof value.replayDiverged === 'boolean'
+                        ? value.replayDiverged
+                        : null
+                    )
+                )
+            )
+            : null;
+          const divergenceFrame = value && typeof value === 'object'
+            ? (
+              Number.isFinite(value.divergenceFrame)
+                ? Math.trunc(value.divergenceFrame)
+                : (
+                  Number.isFinite(value.divergenceFrameIndex)
+                    ? Math.trunc(value.divergenceFrameIndex)
+                    : null
+                )
+            )
+            : null;
+          const digest = value && typeof value === 'object'
+            ? (
+              typeof value.digest === 'string'
+                ? value.digest
+                : (
+                  typeof value.hash === 'string'
+                    ? value.hash
+                    : (
+                      typeof value.finalStateHash === 'string'
+                        ? value.finalStateHash
+                        : null
+                    )
+                )
+            )
+            : null;
+  
+          return { available: true, ok, reasonCode, frameIndex, diverged, divergenceFrame, digest };
+        };
+  
+        globalThis.__physicsSnapshotReplayInvalidReason = function __physicsSnapshotReplayInvalidReason(entry) {
+          const normalized = globalThis.__physicsSnapshotReplayNormalize(entry);
+          if (normalized.available !== true) return 'surface_missing';
+          if (normalized.ok === false && typeof normalized.reasonCode === 'string' && normalized.reasonCode.length > 0) {
+            return normalized.reasonCode;
+          }
+          if (normalized.ok === false) return 'failed_without_reason_code';
+          return 'operation_succeeded_without_reason';
+        };
+  
+        globalThis.__physicsSnapshotReplayRun = function __physicsSnapshotReplayRun(frames) {
+          const baseCapture = globalThis.__physicsSnapshotReplayInvoke('capture', [[], [{ deterministic: true }], [{ includeBodies: true }]]);
+          const baseCaptureNorm = globalThis.__physicsSnapshotReplayNormalize(baseCapture);
+          if (baseCaptureNorm.available !== true) {
+            return {
+              skipped: true,
+              ok: true,
+              capture: baseCaptureNorm,
+              replay: { available: false, ok: null, reasonCode: 'replay_surface_missing', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              state: { available: false, ok: null, reasonCode: 'state_surface_missing', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              rollback: { available: false, ok: null, reasonCode: 'rollback_surface_missing', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+            };
+          }
+  
+          if (
+            baseCaptureNorm.ok === false
+            || baseCapture.result === undefined
+            || baseCapture.result === null
+            || typeof baseCapture.result.snapshot !== 'string'
+          ) {
+            return {
+              skipped: false,
+              ok: false,
+              capture: baseCaptureNorm,
+              replay: { available: false, ok: null, reasonCode: 'capture_failed', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              state: { available: false, ok: null, reasonCode: 'capture_failed', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              rollback: { available: false, ok: null, reasonCode: 'capture_failed', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+            };
+          }
+  
+          if (typeof globalThis.__physicsSnapshotReplayBaseSnapshot !== 'string') {
+            globalThis.__physicsSnapshotReplayBaseSnapshot = baseCapture.result.snapshot;
+            globalThis.__physicsSnapshotReplayBaseFrameIndex = Number.isInteger(baseCaptureNorm.frameIndex)
+              ? baseCaptureNorm.frameIndex
+              : 0;
+          }
+  
+          const baseSnapshot = globalThis.__physicsSnapshotReplayBaseSnapshot;
+          const baseFrameIndex = Number.isInteger(globalThis.__physicsSnapshotReplayBaseFrameIndex)
+            ? globalThis.__physicsSnapshotReplayBaseFrameIndex
+            : 0;
+  
+          const restoreBaseline = globalThis.__physicsSnapshotReplayNormalize(globalThis.__physicsSnapshotReplayInvoke('restore', [
+            [baseSnapshot],
+            [{ snapshot: baseSnapshot }],
+          ]));
+          if (restoreBaseline.available !== true || restoreBaseline.ok === false) {
+            return {
+              skipped: false,
+              ok: false,
+              capture: baseCaptureNorm,
+              replay: { available: false, ok: null, reasonCode: 'restore_baseline_failed', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              state: { available: false, ok: null, reasonCode: 'restore_baseline_failed', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              rollback: restoreBaseline,
+            };
+          }
+  
+          const physics = aura.physics || {};
+          if (
+            typeof physics.setGravity !== 'function'
+            || typeof physics.configureStep !== 'function'
+            || typeof physics.body !== 'function'
+            || typeof physics.step !== 'function'
+          ) {
+            return {
+              skipped: true,
+              ok: true,
+              capture: baseCaptureNorm,
+              replay: { available: false, ok: null, reasonCode: 'step_api_missing', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              state: { available: false, ok: null, reasonCode: 'step_api_missing', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              rollback: restoreBaseline,
+            };
+          }
+  
+          const sequence = Array.isArray(frames) && frames.length > 0
+            ? frames
+            : [1 / 60, 1 / 60, 1 / 30, 1 / 120];
+          let body = null;
+          try {
+            physics.setGravity(0, 0);
+            physics.configureStep({ stepSeconds: 1 / 60, maxSubSteps: 8, auto: false, resetAccumulator: true });
+            body = physics.body('dynamic', { x: 0, y: 0, shape: 'circle', radius: 0.5 });
+            if (!body || typeof body.setVelocity !== 'function') {
+              return {
+                skipped: true,
+                ok: true,
+                capture: baseCaptureNorm,
+                replay: { available: false, ok: null, reasonCode: 'body_api_missing', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+                state: { available: false, ok: null, reasonCode: 'body_api_missing', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+                rollback: restoreBaseline,
+              };
+            }
+            for (let index = 0; index < sequence.length; index += 1) {
+              const dt = Number(sequence[index]);
+              if (!Number.isFinite(dt) || dt <= 0) continue;
+              const speed = 1 + (dt * 60);
+              body.setVelocity(speed, 0);
+              physics.step(dt);
+            }
+          } catch (error) {
+            return {
+              skipped: false,
+              ok: false,
+              capture: baseCaptureNorm,
+              replay: { available: false, ok: null, reasonCode: 'step_failed', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              state: { available: false, ok: null, reasonCode: String(error && error.message ? error.message : error), frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              rollback: restoreBaseline,
+            };
+          }
+  
+          const postCapture = globalThis.__physicsSnapshotReplayInvoke('capture', [[], [{ deterministic: true }], [{ includeBodies: true }]]);
+          const postCaptureNorm = globalThis.__physicsSnapshotReplayNormalize(postCapture);
+          if (
+            postCaptureNorm.available !== true
+            || postCaptureNorm.ok === false
+            || !postCapture.result
+            || typeof postCapture.result.snapshot !== 'string'
+          ) {
+            return {
+              skipped: false,
+              ok: false,
+              capture: postCaptureNorm,
+              replay: { available: false, ok: null, reasonCode: 'post_capture_failed', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              state: { available: false, ok: null, reasonCode: 'post_capture_failed', frameIndex: null, diverged: null, divergenceFrame: null, digest: null },
+              rollback: restoreBaseline,
+            };
+          }
+  
+          const targetFrame = Number.isInteger(postCaptureNorm.frameIndex)
+            ? postCaptureNorm.frameIndex
+            : null;
+          const rollback = globalThis.__physicsSnapshotReplayNormalize(globalThis.__physicsSnapshotReplayInvoke('rollback', [
+            [baseFrameIndex],
+            [{ frameIndex: baseFrameIndex }],
+          ]));
+          const replay = targetFrame == null
+            ? { available: true, ok: false, reasonCode: 'invalid_frame_index', frameIndex: null, diverged: null, divergenceFrame: null, digest: null }
+            : globalThis.__physicsSnapshotReplayNormalize(globalThis.__physicsSnapshotReplayInvoke('replay', [
+              [targetFrame],
+              [{ frameIndex: targetFrame }],
+            ]));
+  
+          const replayStateCapture = globalThis.__physicsSnapshotReplayInvoke('capture', [[], [{ deterministic: true }], [{ includeBodies: true }]]);
+          const replayStateNorm = globalThis.__physicsSnapshotReplayNormalize(replayStateCapture);
+          const replayDigest = replayStateCapture
+            && replayStateCapture.result
+            && typeof replayStateCapture.result.snapshot === 'string'
+            ? replayStateCapture.result.snapshot
+            : null;
+          const state = {
+            available: replayStateNorm.available,
+            ok: replayStateNorm.ok,
+            reasonCode: replayStateNorm.reasonCode,
+            frameIndex: replayStateNorm.frameIndex,
+            diverged: replayStateNorm.diverged,
+            divergenceFrame: replayStateNorm.divergenceFrame,
+            digest: replayDigest,
+          };
+  
+          globalThis.__physicsSnapshotReplayInvoke('restore', [
+            [baseSnapshot],
+            [{ snapshot: baseSnapshot }],
+          ]);
+  
+          const ok = (
+            replay.available === true
+            && replay.ok !== false
+            && rollback.available === true
+            && rollback.ok !== false
+            && state.available === true
+            && state.ok !== false
+          );
+          return { skipped: false, ok, capture: postCaptureNorm, replay, state, rollback };
+        };
+      `,
+      nativeFrames: 2,
+    },
+  {
+      id: 'phaser-scene-lifecycle-timed-events-parity',
+      modes: ['shim', 'native'],
+      namespaces: ['scene'],
+      functions: [
+        'aura.scene.define',
+        'aura.scene.register',
+        'aura.scene.start',
+        'aura.scene.switchTo',
+        'aura.scene.update',
+        'aura.scene.getState',
+        'aura.scene.schedule',
+        'aura.scene.pauseEvent',
+        'aura.scene.resumeEvent',
+        'aura.scene.cancelEvent',
+        'aura.scene.getEventState',
+      ],
+      nativeChecks: [
+        {
+          id: 'scene.surface.methods',
+          expression: "(() => ['define','register','start','switchTo','update','getState','schedule','pauseEvent','resumeEvent','cancelEvent','getEventState'].every((name) => typeof aura.scene?.[name] === 'function'))()",
+        },
+        {
+          id: 'scene.lifecycle.ordering.deterministic',
+          expression: "(() => { const runSample = () => { const trace = []; aura.scene.define('scene-lifecycle-a', { preload: () => trace.push('a:preload'), create: () => trace.push('a:create'), update: () => { trace.push('a:update'); aura.scene.switchTo('scene-lifecycle-b'); }, shutdown: (_ctx, reason) => trace.push('a:shutdown:' + reason) }); aura.scene.register('scene-lifecycle-b', { preload: () => trace.push('b:preload'), create: () => trace.push('b:create'), update: () => trace.push('b:update'), shutdown: (_ctx, reason) => trace.push('b:shutdown:' + reason) }); const started = aura.scene.start('scene-lifecycle-a'); const stepA = aura.scene.update(1 / 60); const stepB = aura.scene.update(1 / 60); const state = aura.scene.getState(); return JSON.stringify({ started: !!started && started.ok === true, stepA: !!stepA && stepA.ok === true, stepB: !!stepB && stepB.ok === true, active: state ? state.activeScene : null, trace }); }; const expected = JSON.stringify({ started: true, stepA: true, stepB: true, active: 'scene-lifecycle-b', trace: ['a:preload', 'a:create', 'a:update', 'a:shutdown:switch', 'b:preload', 'b:create', 'b:update'] }); const first = runSample(); const second = runSample(); return first === expected && second === expected; })()",
+        },
+        {
+          id: 'scene.timed-events.pause-resume-cancel.reason-codes',
+          expression: "(() => { const eventTrace = []; const noActiveUpdate = aura.scene.update(1 / 60); const invalidSceneKey = aura.scene.start(''); const missingScene = aura.scene.start('missing-scene'); aura.scene.define('scene-events-main', {}); const started = aura.scene.start('scene-events-main'); const invalidDelay = aura.scene.schedule(0, () => {}); const invalidCallback = aura.scene.schedule(0.05, null); const invalidOptions = aura.scene.schedule(0.05, () => {}, 'bad'); const invalidRepeat = aura.scene.schedule(0.05, () => {}, { repeat: 'yes' }); const invalidInterval = aura.scene.schedule(0.05, () => {}, { repeat: true, interval: 0 }); const scheduled = aura.scene.schedule(0.05, (evt) => eventTrace.push('tick:' + evt.dispatchCount), { repeat: true, interval: 0.05 }); if (!scheduled || scheduled.ok !== true) return false; const paused = aura.scene.pauseEvent(scheduled.eventId); const pausedState = aura.scene.getEventState(scheduled.eventId); const pausedStep = aura.scene.update(1 / 60); const resumed = aura.scene.resumeEvent(scheduled.eventId); const stepA = aura.scene.update(1 / 60); const stepB = aura.scene.update(1 / 60); const stepC = aura.scene.update(1 / 60); const afterFire = aura.scene.getEventState(scheduled.eventId); const cancelled = aura.scene.cancelEvent(scheduled.eventId); const afterCancel = aura.scene.getEventState(scheduled.eventId); const invalidEventId = aura.scene.pauseEvent('bad'); const missingEvent = aura.scene.pauseEvent(999999); return noActiveUpdate && ((noActiveUpdate.ok === false && noActiveUpdate.reasonCode === 'no_active_scene') || (noActiveUpdate.ok === true && noActiveUpdate.reasonCode === 'scene_updated')) && invalidSceneKey && invalidSceneKey.ok === false && invalidSceneKey.reasonCode === 'invalid_scene_key' && missingScene && missingScene.ok === false && missingScene.reasonCode === 'missing_scene_definition' && started && started.ok === true && invalidDelay && invalidDelay.ok === false && invalidDelay.reasonCode === 'invalid_delay' && invalidCallback && invalidCallback.ok === false && invalidCallback.reasonCode === 'invalid_callback' && invalidOptions && invalidOptions.ok === false && invalidOptions.reasonCode === 'invalid_event_options' && invalidRepeat && invalidRepeat.ok === false && invalidRepeat.reasonCode === 'invalid_repeat_flag' && invalidInterval && invalidInterval.ok === false && invalidInterval.reasonCode === 'invalid_interval' && paused && paused.ok === true && paused.reasonCode === 'scene_event_paused' && pausedState && pausedState.paused === true && pausedState.dispatchCount === 0 && pausedStep && pausedStep.ok === true && pausedStep.firedEvents === 0 && resumed && resumed.ok === true && stepA && stepA.ok === true && stepB && stepB.ok === true && stepC && stepC.ok === true && eventTrace.join('|') === 'tick:1' && afterFire && afterFire.dispatchCount === 1 && cancelled && cancelled.ok === true && afterCancel === null && invalidEventId && invalidEventId.ok === false && invalidEventId.reasonCode === 'invalid_event_id' && missingEvent && missingEvent.ok === false && missingEvent.reasonCode === 'missing_event'; })()",
+          debugExpression: "(() => { const eventTrace = []; const noActiveUpdate = aura.scene.update(1 / 60); const invalidSceneKey = aura.scene.start(''); const missingScene = aura.scene.start('missing-scene'); aura.scene.define('scene-events-main', {}); const started = aura.scene.start('scene-events-main'); const invalidDelay = aura.scene.schedule(0, () => {}); const invalidCallback = aura.scene.schedule(0.05, null); const invalidOptions = aura.scene.schedule(0.05, () => {}, 'bad'); const invalidRepeat = aura.scene.schedule(0.05, () => {}, { repeat: 'yes' }); const invalidInterval = aura.scene.schedule(0.05, () => {}, { repeat: true, interval: 0 }); const scheduled = aura.scene.schedule(0.05, (evt) => eventTrace.push('tick:' + evt.dispatchCount), { repeat: true, interval: 0.05 }); if (!scheduled || scheduled.ok !== true) { return { stage: 'schedule', scheduled }; } const paused = aura.scene.pauseEvent(scheduled.eventId); const pausedState = aura.scene.getEventState(scheduled.eventId); const pausedStep = aura.scene.update(1 / 60); const resumed = aura.scene.resumeEvent(scheduled.eventId); const stepA = aura.scene.update(1 / 60); const stepB = aura.scene.update(1 / 60); const stepC = aura.scene.update(1 / 60); const afterFire = aura.scene.getEventState(scheduled.eventId); const cancelled = aura.scene.cancelEvent(scheduled.eventId); const afterCancel = aura.scene.getEventState(scheduled.eventId); const invalidEventId = aura.scene.pauseEvent('bad'); const missingEvent = aura.scene.pauseEvent(999999); return { noActiveUpdate, invalidSceneKey, missingScene, started, invalidDelay, invalidCallback, invalidOptions, invalidRepeat, invalidInterval, scheduled, paused, pausedState, pausedStep, resumed, stepA, stepB, stepC, eventTrace, afterFire, cancelled, afterCancel, invalidEventId, missingEvent }; })()",
+        },
+      ],
+      source: `
+        const __sceneTrace = [];
+        let __frame = 0;
+        let __timerEventId = null;
+        let __pausedSnapshot = null;
+        let __invalidChecks = null;
+  
+        aura.setup = function () {
+          const noActiveUpdate = aura.scene.update(1 / 60);
+          const invalidSceneKey = aura.scene.start('');
+          const missingScene = aura.scene.start('missing-scene');
+          const invalidDelay = aura.scene.schedule(0, () => {});
+          const invalidCallback = aura.scene.schedule(0.05, null);
+          const invalidOptions = aura.scene.schedule(0.05, () => {}, 'bad');
+          const invalidEventId = aura.scene.pauseEvent('bad');
+  
+          __invalidChecks = {
+            noActiveUpdate,
+            invalidSceneKey,
+            missingScene,
+            invalidDelay,
+            invalidCallback,
+            invalidOptions,
+            invalidEventId,
+          };
+  
+          aura.scene.define('boot', {
+            preload() {
+              __sceneTrace.push('boot:preload');
+            },
+            create() {
+              __sceneTrace.push('boot:create');
+              const repeating = aura.scene.schedule(0.05, (evt) => {
+                __sceneTrace.push('timer:tick:' + evt.dispatchCount);
+              }, { repeat: true, interval: 0.05 });
+              const cancelled = aura.scene.schedule(0.2, () => {
+                __sceneTrace.push('timer:cancelled');
+              });
+              __timerEventId = repeating.eventId;
+              aura.scene.pauseEvent(__timerEventId);
+              __pausedSnapshot = aura.scene.getEventState(__timerEventId);
+              aura.scene.cancelEvent(cancelled.eventId);
+            },
+            update() {
+              __sceneTrace.push('boot:update');
+              if (__frame === 0) {
+                aura.scene.resumeEvent(__timerEventId);
+              }
+              if (__frame === 1) {
+                aura.scene.switchTo('play');
+              }
+            },
+            shutdown(_ctx, reason) {
+              __sceneTrace.push('boot:shutdown:' + reason);
+            },
+          });
+  
+          aura.scene.register('play', {
+            preload() {
+              __sceneTrace.push('play:preload');
+            },
+            create() {
+              __sceneTrace.push('play:create');
+            },
+            update() {
+              __sceneTrace.push('play:update');
+            },
+            shutdown(_ctx, reason) {
+              __sceneTrace.push('play:shutdown:' + reason);
+            },
+          });
+  
+          aura.scene.start('boot');
+        };
+  
+        aura.update = function (dt) {
+          aura.scene.update(dt);
+          __frame += 1;
+        };
+  
+        aura.draw = function () {
+          if (__frame !== 4) return;
+  
+          const expected = [
+            'boot:preload',
+            'boot:create',
+            'boot:update',
+            'boot:update',
+            'boot:shutdown:switch',
+            'play:preload',
+            'play:create',
+            'play:update',
+            'timer:tick:1',
+            'play:update',
+          ];
+  
+          aura.test.equal(
+            __sceneTrace.join('|'),
+            expected.join('|'),
+            'scene lifecycle and timed-event ordering should be deterministic',
+          );
+          aura.test.assert(
+            __pausedSnapshot && __pausedSnapshot.paused === true && __pausedSnapshot.dispatchCount === 0,
+            'paused timed-event snapshot should be deterministic',
+          );
+  
+          const checks = __invalidChecks;
+          aura.test.assert(
+            checks.noActiveUpdate && checks.noActiveUpdate.ok === false && checks.noActiveUpdate.reasonCode === 'no_active_scene',
+            'scene.update without active scene should be reason-coded',
+          );
+          aura.test.assert(
+            checks.invalidSceneKey && checks.invalidSceneKey.ok === false && checks.invalidSceneKey.reasonCode === 'invalid_scene_key',
+            'scene.start invalid key should be reason-coded',
+          );
+          aura.test.assert(
+            checks.missingScene && checks.missingScene.ok === false && checks.missingScene.reasonCode === 'missing_scene_definition',
+            'scene.start missing scene should be reason-coded',
+          );
+          aura.test.assert(
+            checks.invalidDelay && checks.invalidDelay.ok === false && checks.invalidDelay.reasonCode === 'invalid_delay',
+            'scene.schedule invalid delay should be reason-coded',
+          );
+          aura.test.assert(
+            checks.invalidCallback && checks.invalidCallback.ok === false && checks.invalidCallback.reasonCode === 'invalid_callback',
+            'scene.schedule invalid callback should be reason-coded',
+          );
+          aura.test.assert(
+            checks.invalidOptions && checks.invalidOptions.ok === false && checks.invalidOptions.reasonCode === 'invalid_event_options',
+            'scene.schedule invalid options should be reason-coded',
+          );
+          aura.test.assert(
+            checks.invalidEventId && checks.invalidEventId.ok === false && checks.invalidEventId.reasonCode === 'invalid_event_id',
+            'scene.pauseEvent invalid event id should be reason-coded',
+          );
+  
+          const cancelled = aura.scene.cancelEvent(__timerEventId);
+          aura.test.assert(
+            cancelled && cancelled.ok === true && cancelled.reasonCode === 'scene_event_cancelled',
+            'scene timer cancel should succeed after deterministic tick',
+          );
+  
+          const state = aura.scene.getState();
+          aura.test.equal(state.activeScene, 'play', 'scene active state should point at play');
+          aura.test.assert(
+            Array.isArray(state.timedEvents) && state.timedEvents.length === 0,
+            'scene timed-event list should be empty after cancellation',
+          );
+        };
+      `,
+      frames: 4,
+    }
+];