@auraindustry/aurajs 0.0.7 → 0.1.0

package/src/conformance/cases/app-and-ui-runtime-cases.mjs

@@ -0,0 +1,3309 @@
+import { readConformanceSource } from '../shared.mjs';
+
+const STARTER_SCENE_FLOW_RUNTIME_SOURCE = readConformanceSource(
+  'src/cli/templates/create/shared/src/runtime/scene-flow.js',
+).replace(/^export\s+/gm, '');
+
+const STARTER_SCREEN_SHELL_RUNTIME_SOURCE = readConformanceSource(
+  'src/cli/templates/create/shared/src/runtime/screen-shell.js',
+).replace(/^export\s+/gm, '');
+
+export const APP_AND_UI_RUNTIME_CONFORMANCE_CASES = [
+  {
+      id: 'tilemap-import-draw-culling',
+      modes: ['shim', 'native'],
+      namespaces: ['tilemap'],
+      functions: [
+        'aura.tilemap.import',
+        'aura.tilemap.unload',
+        'aura.tilemap.getInfo',
+        'aura.tilemap.drawLayer',
+        'aura.tilemap.draw',
+      ],
+      nativeChecks: [
+        {
+          id: 'tilemap.import.draw.layer-order.deterministic',
+          expression: "(() => { const fixture = { width: 8, height: 8, tilewidth: 16, tileheight: 16, properties: [{ name: 'theme', type: 'string', value: 'forest' }], layers: [ { name: 'ground', type: 'tilelayer', width: 8, height: 8, properties: [{ name: 'solid', type: 'bool', value: true }], data: Array.from({ length: 64 }, () => 1) }, { name: 'spawn', type: 'objectgroup', properties: [{ name: 'kind', type: 'string', value: 'spawns' }], objects: [ { id: 10, name: 'hero', x: 16, y: 16, width: 16, height: 16, properties: [{ name: 'faction', type: 'string', value: 'player' }] }, { id: 11, name: 'loot', x: 32, y: 32, point: true, properties: { rarity: 'common', value: 1 } } ] }, { name: 'decor', type: 'tilelayer', width: 8, height: 8, data: Array.from({ length: 64 }, (_, i) => (i % 5 === 0 ? 1 : 0)) } ], tilesets: [ { firstgid: 1, image: 'tiles.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1, properties: [{ name: 'atlas', value: 'base' }] } ] }; const mapId = aura.tilemap.import(fixture); const first = aura.tilemap.draw(mapId, { camera: { x: 0, y: 0, width: 32, height: 32 } }); const second = aura.tilemap.draw(mapId, { camera: { x: 0, y: 0, width: 32, height: 32 } }); const info = aura.tilemap.getInfo(mapId); aura.tilemap.unload(mapId); return !!info && info.layerCount === 2 && info.objectLayerCount === 1 && info.objectCount === 2 && info.mapPropertyCount === 1 && first && second && first.layerOrder.join(',') === 'ground,decor' && JSON.stringify(first.layerOrder) === JSON.stringify(second.layerOrder) && first.drawnTiles === second.drawnTiles; })()",
+        },
+        {
+          id: 'tilemap.import.expanded-schema.acceptance.deterministic',
+          expression: "(() => { const runSample = () => { const fixture = { width: 4, height: 4, tilewidth: 16, tileheight: 16, properties: { difficulty: 'hard', seed: 7 }, solidLayerNames: ['collision'], layers: [ { name: 'ground', type: 'tilelayer', width: 4, height: 4, offsetx: 2, offsety: 4, data: Array.from({ length: 16 }, () => 1), properties: { solid: true } }, { name: 'collision', type: 'tilelayer', width: 4, height: 4, data: [0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], properties: [{ name: 'solid', value: true }] }, { name: 'objects', type: 'objectgroup', draworder: 'index', objects: [ { id: 1, name: 'rect', x: 0, y: 0, width: 16, height: 16, properties: { loot: false } }, { id: 2, name: 'point', x: 16, y: 16, point: true, properties: [{ name: 'kind', value: 'spawn' }] }, { id: 3, name: 'ellipse', x: 32, y: 16, width: 16, height: 8, ellipse: true }, { id: 4, name: 'poly', x: 48, y: 16, polygon: [{ x: 0, y: 0 }, { x: 8, y: 0 }, { x: 8, y: 8 }] }, { id: 5, name: 'path', x: 48, y: 32, polyline: [{ x: 0, y: 0 }, { x: 8, y: 8 }] }, { id: 6, name: 'tileobj', x: 0, y: 32, gid: 5, width: 16, height: 16 } ] } ], tilesets: [ { firstgid: 1, image: 'tiles_a.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1, margin: 1, spacing: 0, properties: { atlas: 'a' } }, { firstgid: 5, image: 'tiles_b.png', tilewidth: 16, tileheight: 16, tilecount: 2, columns: 1, margin: 0, spacing: 1, properties: [{ name: 'atlas', value: 'b' }] } ] }; const mapId = aura.tilemap.import(fixture); const info = aura.tilemap.getInfo(mapId); const draw = aura.tilemap.draw(mapId, { cull: false }); const ground = aura.tilemap.drawLayer(mapId, 'ground', { cull: false }); const unload = aura.tilemap.unload(mapId); return { layerCount: Number(info?.layerCount || 0), objectLayerCount: Number(info?.objectLayerCount || 0), objectCount: Number(info?.objectCount || 0), tilesetCount: Number(info?.tilesetCount || 0), mapPropertyCount: Number(info?.mapPropertyCount || 0), layerOrder: Array.isArray(draw?.layerOrder) ? draw.layerOrder.join(',') : '', drawnTiles: Number(draw?.drawnTiles || 0), groundDrawnTiles: Number(ground?.drawnTiles || 0), unload }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.layerCount === 2 && first.objectLayerCount === 1 && first.objectCount === 6 && first.tilesetCount === 2 && first.mapPropertyCount === 2 && first.layerOrder === 'ground,collision' && first.drawnTiles === 17 && first.groundDrawnTiles === 16 && first.unload === true; })()",
+        },
+        {
+          id: 'tilemap.culling.reduces-draw-submissions',
+          expression: "(() => { const size = 32; const fixture = { width: size, height: size, tilewidth: 16, tileheight: 16, layers: [ { name: 'ground', type: 'tilelayer', width: size, height: size, data: Array.from({ length: size * size }, () => 1) } ], tilesets: [ { firstgid: 1, image: 'tiles.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1 } ] }; const mapId = aura.tilemap.import(fixture); const full = aura.tilemap.drawLayer(mapId, 'ground', { cull: false }); const culled = aura.tilemap.drawLayer(mapId, 'ground', { camera: { x: 0, y: 0, width: 64, height: 64 } }); aura.tilemap.unload(mapId); return !!full && !!culled && full.drawnTiles === (size * size) && culled.drawnTiles < full.drawnTiles && culled.consideredTiles < full.consideredTiles && culled.culledTiles > 0; })()",
+        },
+        {
+          id: 'tilemap.import.invalid-schema.reason-code',
+          expression: "(() => { try { aura.tilemap.import({ width: 2, height: 2, tilewidth: 16, tileheight: 16, layers: [{ name: 'bad', type: 'tilelayer', data: [1, 1, 1] }], tilesets: [{ firstgid: 1, image: 'tiles.png', columns: 1, tilecount: 1 }] }); return false; } catch (e) { return String(e).includes('aura.tilemap.import: invalid-layer-data'); } })()",
+        },
+        {
+          id: 'tilemap.import.invalid-object-property.reason-code',
+          expression: "(() => { try { aura.tilemap.import({ width: 2, height: 2, tilewidth: 16, tileheight: 16, layers: [ { name: 'ground', type: 'tilelayer', width: 2, height: 2, data: [1, 1, 1, 1] }, { name: 'objects', type: 'objectgroup', objects: [ { id: 1, x: 0, y: 0, properties: [ { name: 'bad', value: { nested: true } } ] } ] } ], tilesets: [{ firstgid: 1, image: 'tiles.png', columns: 1, tilecount: 1 }] }); return false; } catch (e) { return String(e).includes('aura.tilemap.import: invalid-property-value'); } })()",
+        },
+        {
+          id: 'tilemap.import.expanded-schema.rejection.reason-codes',
+          expression: "(() => { const runSample = () => { const expectImportFailure = (factory, reasonCode) => { try { aura.tilemap.import(factory()); return false; } catch (err) { return String(err).includes('aura.tilemap.import: ' + reasonCode); } }; return { compression: expectImportFailure(() => ({ width: 2, height: 2, tilewidth: 16, tileheight: 16, layers: [{ name: 'ground', type: 'tilelayer', width: 2, height: 2, compression: 'zlib', data: [1, 1, 1, 1] }], tilesets: [{ firstgid: 1, image: 'tiles.png', columns: 1, tilecount: 1 }] }), 'unsupported-layer-compression'), encoding: expectImportFailure(() => ({ width: 2, height: 2, tilewidth: 16, tileheight: 16, layers: [{ name: 'ground', type: 'tilelayer', width: 2, height: 2, encoding: 'base64', data: [1, 1, 1, 1] }], tilesets: [{ firstgid: 1, image: 'tiles.png', columns: 1, tilecount: 1 }] }), 'unsupported-layer-encoding'), invalidObjectShape: expectImportFailure(() => ({ width: 2, height: 2, tilewidth: 16, tileheight: 16, layers: [ { name: 'ground', type: 'tilelayer', width: 2, height: 2, data: [1, 1, 1, 1] }, { name: 'objects', type: 'objectgroup', objects: [ { id: 1, x: 0, y: 0, polygon: [{ x: 0, y: 0 }, { x: 1, y: 0 }], polyline: [{ x: 0, y: 0 }, { x: 1, y: 1 }] } ] } ], tilesets: [{ firstgid: 1, image: 'tiles.png', columns: 1, tilecount: 1 }] }), 'invalid-object-shape'), unmappedObjectGid: expectImportFailure(() => ({ width: 2, height: 2, tilewidth: 16, tileheight: 16, layers: [ { name: 'ground', type: 'tilelayer', width: 2, height: 2, data: [1, 1, 1, 1] }, { name: 'objects', type: 'objectgroup', objects: [ { id: 1, x: 0, y: 0, gid: 99 } ] } ], tilesets: [{ firstgid: 1, image: 'tiles.png', columns: 1, tilecount: 1 }] }), 'unmapped-object-gid') }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.compression === true && first.encoding === true && first.invalidObjectShape === true && first.unmappedObjectGid === true; })()",
+        },
+      ],
+      source: `
+        let tilemapId = 0;
+        let verified = false;
+        const fixture = {
+          width: 8,
+          height: 8,
+          tilewidth: 16,
+          tileheight: 16,
+          properties: [{ name: 'theme', type: 'string', value: 'forest' }],
+          layers: [
+            {
+              name: 'ground',
+              type: 'tilelayer',
+              width: 8,
+              height: 8,
+              properties: [{ name: 'solid', type: 'bool', value: true }],
+              data: Array.from({ length: 64 }, () => 1),
+            },
+            {
+              name: 'spawn',
+              type: 'objectgroup',
+              properties: [{ name: 'kind', type: 'string', value: 'spawns' }],
+              objects: [
+                {
+                  id: 10,
+                  name: 'hero',
+                  x: 16,
+                  y: 16,
+                  width: 16,
+                  height: 16,
+                  properties: [{ name: 'faction', type: 'string', value: 'player' }],
+                },
+                {
+                  id: 11,
+                  name: 'loot',
+                  x: 32,
+                  y: 32,
+                  point: true,
+                  properties: { rarity: 'common', value: 1 },
+                },
+              ],
+            },
+            {
+              name: 'decor',
+              type: 'tilelayer',
+              width: 8,
+              height: 8,
+              data: Array.from({ length: 64 }, (_, i) => (i % 5 === 0 ? 1 : 0)),
+            },
+          ],
+          tilesets: [
+            { firstgid: 1, image: 'tiles.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1, properties: [{ name: 'atlas', value: 'base' }] },
+          ],
+        };
+  
+        aura.setup = function () {
+          tilemapId = aura.tilemap.import(fixture);
+        };
+  
+        aura.draw = function () {
+          if (verified) return;
+          const first = aura.tilemap.draw(tilemapId, { camera: { x: 0, y: 0, width: 32, height: 32 } });
+          const second = aura.tilemap.draw(tilemapId, { camera: { x: 0, y: 0, width: 32, height: 32 } });
+          const full = aura.tilemap.drawLayer(tilemapId, 'ground', { cull: false });
+          const culled = aura.tilemap.drawLayer(tilemapId, 'ground', { camera: { x: 0, y: 0, width: 32, height: 32 } });
+          const info = aura.tilemap.getInfo(tilemapId);
+  
+          aura.test.assert(!!first && !!second, 'tilemap draw summary should exist');
+          aura.test.equal(first.layerOrder.join(','), 'ground,decor', 'tilemap layer draw order must be deterministic');
+          aura.test.equal(first.drawnTiles, second.drawnTiles, 'tilemap draw totals must be deterministic');
+          aura.test.assert(!!full && !!culled && culled.drawnTiles < full.drawnTiles, 'tilemap culling should reduce submissions');
+          aura.test.assert(culled.culledTiles > 0, 'tilemap culling should report culled tiles');
+          aura.test.assert(!!info && info.objectLayerCount === 1 && info.objectCount === 2 && info.mapPropertyCount === 1, 'tilemap object layer/property metadata should be exposed');
+          aura.test.equal(aura.tilemap.unload(tilemapId), true, 'tilemap unload should return true');
+          aura.test.equal(aura.tilemap.getInfo(tilemapId), null, 'tilemap getInfo should return null after unload');
+          verified = true;
+        };
+      `,
+      frames: 2,
+    },
+  {
+      id: 'anim2d-state-machine',
+      modes: ['shim', 'native'],
+      namespaces: ['anim2d'],
+      functions: [
+        'aura.anim2d.registerClip',
+        'aura.anim2d.createMachine',
+        'aura.anim2d.defineState',
+        'aura.anim2d.play',
+        'aura.anim2d.update',
+        'aura.anim2d.getState',
+        'aura.anim2d.onComplete',
+      ],
+      nativeChecks: [
+        {
+          id: 'anim2d.clip-and-state.registration',
+          expression: "(() => { const machine = aura.anim2d.createMachine(); const clipOk = aura.anim2d.registerClip('run', [0, 1, 2], { frameDuration: 0.1, loop: false }); const stateOk = aura.anim2d.defineState(machine, 'run', 'run'); return clipOk === true && stateOk === true; })()",
+        },
+        {
+          id: 'anim2d.completion.callback-ordering.deterministic',
+          expression: "(() => { const machine = aura.anim2d.createMachine(); aura.anim2d.registerClip('jump', [0, 1, 2], { frameDuration: 0.1, loop: false }); aura.anim2d.defineState(machine, 'jump', 'jump'); const calls = []; aura.anim2d.onComplete(machine, () => calls.push('late'), 20); aura.anim2d.onComplete(machine, () => calls.push('early'), 5); const started = aura.anim2d.play(machine, 'jump'); aura.anim2d.update(0.35); const state = aura.anim2d.getState(machine); return started === true && !!state && state.completed === true && state.frameIndex === 2 && state.frame === 2 && calls.join(',') === 'early,late'; })()",
+        },
+        {
+          id: 'anim2d.invalid-input.safe-false',
+          expression: "(() => { const machine = aura.anim2d.createMachine(); return aura.anim2d.registerClip('', [0, 1]) === false && aura.anim2d.defineState(machine, 'idle', 'missing') === false && aura.anim2d.play(machine, 'missing') === false && aura.anim2d.onComplete(machine, null, 0) === false; })()",
+        },
+        {
+          id: 'anim2d.deterministic-rerun-sequence',
+          expression: "(() => { const runSample = () => { const machine = aura.anim2d.createMachine(); aura.anim2d.registerClip('sample', [0, 1, 2], { frameDuration: 0.05, loop: true }); aura.anim2d.defineState(machine, 'sample', 'sample'); aura.anim2d.play(machine, 'sample'); const trace = []; for (const dt of [0.05, 0.05, 0.1, 0.05]) { aura.anim2d.update(dt); const state = aura.anim2d.getState(machine); trace.push(state ? state.frame : null); } return trace.join(','); }; return runSample() === runSample(); })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {
+          const machine = aura.anim2d.createMachine();
+          aura.anim2d.registerClip('idle', [0, 1], { frameDuration: 0.1, loop: true });
+          aura.anim2d.defineState(machine, 'idle', 'idle');
+          aura.anim2d.play(machine, 'idle');
+        };
+        aura.update = function (dt) {
+          aura.anim2d.update(dt);
+        };
+      `,
+      frames: 2,
+    },
+  {
+      id: 'material-runtime-controls',
+      modes: ['shim', 'native'],
+      namespaces: ['material'],
+      functions: [
+        'aura.material.create',
+        'aura.material.setColor',
+        'aura.material.setTexture',
+        'aura.material.setMetallic',
+        'aura.material.setRoughness',
+        'aura.material.setMetallicRoughness',
+        'aura.material.reset',
+        'aura.material.clone',
+        'aura.material.unload',
+      ],
+      nativeChecks: [
+        { id: 'material.create', expression: "typeof aura.material?.create === 'function'" },
+        { id: 'material.setColor', expression: "typeof aura.material?.setColor === 'function'" },
+        { id: 'material.setTexture', expression: "typeof aura.material?.setTexture === 'function'" },
+        { id: 'material.setMetallic', expression: "typeof aura.material?.setMetallic === 'function'" },
+        { id: 'material.setRoughness', expression: "typeof aura.material?.setRoughness === 'function'" },
+        { id: 'material.setMetallicRoughness', expression: "typeof aura.material?.setMetallicRoughness === 'function'" },
+        { id: 'material.reset', expression: "typeof aura.material?.reset === 'function'" },
+        { id: 'material.clone', expression: "typeof aura.material?.clone === 'function'" },
+        { id: 'material.unload', expression: "typeof aura.material?.unload === 'function'" },
+        {
+          id: 'material.setTexture.invalidType.throws',
+          expression: "(() => { const handle = aura.material.create(); try { aura.material.setTexture(handle, 42); return false; } catch (error) { return error instanceof Error; } })()",
+        },
+        {
+          id: 'material.clone.invalidHandle.throws',
+          expression: "(() => { try { aura.material.clone(987654321); return false; } catch (error) { return error instanceof Error; } })()",
+        },
+        {
+          id: 'material.clone.texture-preserving.deterministic',
+          expression: "(() => { const runSample = () => { const base = aura.material.create({ texture: 'textures/clone-source.png', metallic: 0.25, roughness: 0.75 }); const cloneA = aura.material.clone(base); const cloneB = aura.material.clone(base); aura.material.setTexture(cloneA, null); aura.material.setMetallicRoughness(cloneB, 0.8, 0.2); aura.material.unload(cloneA); aura.material.unload(cloneB); aura.material.unload(base); return { base, cloneA, cloneB, distinct: base !== cloneA && base !== cloneB && cloneA !== cloneB }; }; const normalize = (sample) => ({ deltaBaseToCloneA: sample.cloneA - sample.base, deltaCloneAToCloneB: sample.cloneB - sample.cloneA, distinct: sample.distinct === true }); const first = runSample(); const second = runSample(); return JSON.stringify(normalize(first)) === JSON.stringify(normalize(second)) && first.distinct === true && second.distinct === true && first.base > 0 && second.base > 0; })()",
+        },
+        {
+          id: 'material.create.extended-pbr-options.accepted',
+          expression: "(() => { const handle = aura.material.create({ emissive: { r: 0.2, g: 0.1, b: 0.3 }, metallicRoughnessTexture: 'textures/clone-source.png', aoTexture: 'textures/clone-source.png', emissiveTexture: 'textures/clone-source.png', alphaMode: 'blend', alphaCutoff: 0.25, doubleSided: true, clearcoat: 0.4, clearcoatRoughness: 0.2, sheenColor: { r: 0.6, g: 0.3, b: 0.1 }, sheenRoughness: 0.5, occlusionStrength: 0.7 }); aura.material.unload(handle); return typeof handle === 'number' && handle > 0; })()",
+        },
+        {
+          id: 'material.create.masked-alpha.deterministic',
+          expression: "(() => { const runSample = () => { const maskedDefault = aura.material.create({ texture: 'textures/clone-source.png', alphaMode: 'mask' }); const maskedClamped = aura.material.create({ texture: 'textures/clone-source.png', alphaMode: 'mask', alphaCutoff: 2, doubleSided: true }); aura.material.unload(maskedClamped); aura.material.unload(maskedDefault); return { maskedDefault, maskedClamped, delta: maskedClamped - maskedDefault }; }; const first = runSample(); const second = runSample(); return JSON.stringify({ delta: first.delta }) === JSON.stringify({ delta: second.delta }) && first.maskedDefault > 0 && first.maskedClamped > first.maskedDefault && first.delta === 1; })()",
+        },
+      ],
+      source: `
+        aura.setup = function () {
+          const handle = aura.material.create({ metallic: 2, roughness: -1 });
+          aura.test.assert(typeof handle === 'number' && handle > 0, 'create should return numeric handle');
+  
+          aura.material.setColor(handle, { r: 0.25, g: 0.5, b: 0.75, a: 1 });
+          aura.material.setMetallic(handle, 0.2);
+          aura.material.setRoughness(handle, 0.8);
+          aura.material.setMetallicRoughness(handle, 0.9, 0.1);
+          aura.material.setTexture(handle, null);
+          aura.material.reset(handle);
+  
+          const clone = aura.material.clone(handle);
+          aura.test.assert(typeof clone === 'number' && clone !== handle, 'clone should return distinct numeric handle');
+          aura.material.unload(clone);
+          aura.material.unload(123456789); // silent no-op
+  
+          const textured = aura.material.create({ texture: 'textures/clone-source.png', metallic: 0.4, roughness: 0.6 });
+          const texturedClone = aura.material.clone(textured);
+          aura.test.assert(typeof texturedClone === 'number' && texturedClone !== textured, 'textured clone should return distinct numeric handle');
+          aura.material.setTexture(texturedClone, null);
+          aura.material.unload(texturedClone);
+          aura.material.unload(textured);
+  
+          let textureTypeError = false;
+          try {
+            aura.material.setTexture(handle, 123);
+          } catch (error) {
+            textureTypeError = true;
+          }
+          aura.test.assert(textureTypeError, 'setTexture should throw on non-string/non-null');
+  
+          let cloneError = false;
+          try {
+            aura.material.clone(999999999);
+          } catch (error) {
+            cloneError = true;
+          }
+          aura.test.assert(cloneError, 'clone should throw for invalid handle');
+        };
+      `,
+      frames: 1,
+    },
+  {
+      id: 'storage-persistence-seed',
+      modes: ['native'],
+      namespaces: ['storage'],
+      functions: ['aura.storage.save', 'aura.storage.load'],
+      nativeChecks: [
+        {
+          id: 'storage.seed.persistedValueWritten',
+          expression: "(() => { const key = '__conformance_persist__'; aura.storage.save(key, { sentinel: 1337, marker: 'seed' }); const loaded = aura.storage.load(key); return !!loaded && loaded.sentinel === 1337 && loaded.marker === 'seed'; })()",
+        },
+      ],
+      // Allow one extra native frame so storage flush is deterministic before process exit.
+      nativeFrames: 2,
+      source: `
+        aura.setup = function () {};
+      `,
+    },
+  {
+      id: 'storage-persistence-verify',
+      modes: ['native'],
+      namespaces: ['storage'],
+      functions: ['aura.storage.load', 'aura.storage.keys', 'aura.storage.delete'],
+      nativeChecks: [
+        {
+          id: 'storage.verify.valueSurvivesProcessRestart',
+          expression: "(() => { const key = '__conformance_persist__'; const loaded = aura.storage.load(key); const listed = aura.storage.keys(); aura.storage.delete(key); return !!loaded && loaded.sentinel === 1337 && loaded.marker === 'seed' && Array.isArray(listed) && listed.includes(key) && aura.storage.load(key) === null; })()",
+        },
+      ],
+      nativeFrames: 1,
+      source: `
+        aura.setup = function () {};
+      `,
+    },
+  {
+      id: 'math-color-vec-collision-timer',
+      namespaces: ['math', 'color-vector', 'collision', 'timer'],
+      functions: [
+        'aura.math.lerp',
+        'aura.math.clamp',
+        'aura.math.random',
+        'aura.math.distance',
+        'aura.math.angle',
+        'aura.math.PI',
+        'aura.math.TAU',
+        'aura.rgb',
+        'aura.rgba',
+        'aura.Color.*',
+        'aura.vec2.*',
+        'aura.vec3.*',
+        'aura.collision.*',
+        'aura.timer.*',
+      ],
+      nativeChecks: [
+        { id: 'math.lerp', expression: "typeof aura.math?.lerp === 'function'" },
+        { id: 'math.clamp', expression: "typeof aura.math?.clamp === 'function'" },
+        { id: 'math.random', expression: "typeof aura.math?.random === 'function'" },
+        { id: 'math.distance', expression: "typeof aura.math?.distance === 'function'" },
+        { id: 'math.angle', expression: "typeof aura.math?.angle === 'function'" },
+        { id: 'math.PI', expression: "typeof aura.math?.PI === 'number'" },
+        { id: 'math.TAU', expression: "typeof aura.math?.TAU === 'number'" },
+        { id: 'rgb', expression: "typeof aura.rgb === 'function'" },
+        { id: 'rgba', expression: "typeof aura.rgba === 'function'" },
+        { id: 'Color.RED', expression: "typeof aura.Color?.RED === 'object'" },
+        { id: 'Color.TRANSPARENT', expression: "typeof aura.Color?.TRANSPARENT === 'object'" },
+        { id: 'vec2.constructor', expression: "typeof aura.vec2 === 'function'" },
+        {
+          id: 'vec2.add',
+          expression: "(() => { const v = aura.vec2.add(aura.vec2(3, 4), aura.vec2(2, 1)); return v.x === 5 && v.y === 5; })()",
+        },
+        {
+          id: 'vec2.sub',
+          expression: "(() => { const v = aura.vec2.sub(aura.vec2(3, 4), aura.vec2(2, 1)); return v.x === 1 && v.y === 3; })()",
+        },
+        {
+          id: 'vec2.scale',
+          expression: "(() => { const v = aura.vec2.scale(aura.vec2(3, 4), 2); return v.x === 6 && v.y === 8; })()",
+        },
+        { id: 'vec2.dot', expression: "aura.vec2.dot(aura.vec2(3, 4), aura.vec2(2, 1)) === 10" },
+        { id: 'vec2.length', expression: "aura.vec2.length(aura.vec2(3, 4)) === 5" },
+        {
+          id: 'vec2.normalize',
+          expression: "(() => { const v = aura.vec2.normalize(aura.vec2(3, 4)); return Math.abs(v.x - 0.6) < 1e-9 && Math.abs(v.y - 0.8) < 1e-9; })()",
+        },
+        {
+          id: 'vec2.distance',
+          expression: "Math.abs(aura.vec2.distance(aura.vec2(3, 4), aura.vec2(2, 1)) - Math.sqrt(10)) < 1e-9",
+        },
+        {
+          id: 'vec2.lerp',
+          expression: "(() => { const v = aura.vec2.lerp(aura.vec2(3, 4), aura.vec2(2, 1), 0.5); return v.x === 2.5 && v.y === 2.5; })()",
+        },
+        { id: 'vec3.constructor', expression: "typeof aura.vec3 === 'function'" },
+        {
+          id: 'vec3.add',
+          expression: "(() => { const v = aura.vec3.add(aura.vec3(1, 2, 3), aura.vec3(4, 5, 6)); return v.x === 5 && v.y === 7 && v.z === 9; })()",
+        },
+        {
+          id: 'vec3.sub',
+          expression: "(() => { const v = aura.vec3.sub(aura.vec3(4, 5, 6), aura.vec3(1, 2, 3)); return v.x === 3 && v.y === 3 && v.z === 3; })()",
+        },
+        {
+          id: 'vec3.scale',
+          expression: "(() => { const v = aura.vec3.scale(aura.vec3(1, 2, 3), 2); return v.x === 2 && v.y === 4 && v.z === 6; })()",
+        },
+        { id: 'vec3.dot', expression: "aura.vec3.dot(aura.vec3(1, 2, 3), aura.vec3(4, 5, 6)) === 32" },
+        {
+          id: 'vec3.cross',
+          expression: "(() => { const v = aura.vec3.cross(aura.vec3(1, 0, 0), aura.vec3(0, 1, 0)); return v.x === 0 && v.y === 0 && v.z === 1; })()",
+        },
+        { id: 'vec3.length', expression: "aura.vec3.length(aura.vec3(0, 3, 4)) === 5" },
+        {
+          id: 'vec3.normalize',
+          expression: "(() => { const v = aura.vec3.normalize(aura.vec3(0, 3, 4)); return Math.abs(v.x - 0) < 1e-9 && Math.abs(v.y - 0.6) < 1e-9 && Math.abs(v.z - 0.8) < 1e-9; })()",
+        },
+        {
+          id: 'vec3.distance',
+          expression: "Math.abs(aura.vec3.distance(aura.vec3(1, 2, 3), aura.vec3(4, 5, 6)) - Math.sqrt(27)) < 1e-9",
+        },
+        {
+          id: 'vec3.lerp',
+          expression: "(() => { const v = aura.vec3.lerp(aura.vec3(0, 0, 0), aura.vec3(2, 4, 6), 0.5); return v.x === 1 && v.y === 2 && v.z === 3; })()",
+        },
+        {
+          id: 'collision.rectRect',
+          expression: "aura.collision.rectRect({ x: 0, y: 0, w: 10, h: 10 }, { x: 5, y: 5, w: 10, h: 10 }) === true",
+        },
+        {
+          id: 'collision.rectPoint',
+          expression: "aura.collision.rectPoint({ x: 0, y: 0, w: 10, h: 10 }, { x: 2, y: 2 }) === true",
+        },
+        {
+          id: 'collision.circleCircle',
+          expression: "aura.collision.circleCircle({ x: 0, y: 0, radius: 4 }, { x: 6, y: 0, radius: 4 }) === true",
+        },
+        {
+          id: 'collision.circlePoint',
+          expression: "aura.collision.circlePoint({ x: 0, y: 0, radius: 4 }, { x: 0, y: 0 }) === true",
+        },
+        {
+          id: 'collision.circleRect',
+          expression: "aura.collision.circleRect({ x: 20, y: 20, radius: 2 }, { x: 0, y: 0, w: 10, h: 10 }) === false",
+        },
+        {
+          id: 'collision.rectPointBatch',
+          expression: "(() => { const hits = aura.collision.rectPointBatch({ x: 0, y: 0, w: 5, h: 5 }, [{ x: 1, y: 1 }, { x: 8, y: 8 }, { x: 4, y: 4 }]); return Array.isArray(hits) && hits.length === 3 && hits[0] === true && hits[1] === false && hits[2] === true; })()",
+        },
+        {
+          id: 'collision.circleRectBatch',
+          expression: "(() => { const hits = aura.collision.circleRectBatch({ x: 0, y: 0, radius: 4 }, [{ x: -2, y: -2, w: 2, h: 2 }, { x: 10, y: 10, w: 2, h: 2 }]); return Array.isArray(hits) && hits.length === 2 && hits[0] === true && hits[1] === false; })()",
+        },
+        {
+          id: 'collision.batch.invalid-input.safe-array',
+          expression: "Array.isArray(aura.collision.rectPointBatch({ x: 0, y: 0, w: 1, h: 1 }, null)) && Array.isArray(aura.collision.circleRectBatch({ x: 0, y: 0, radius: 1 }, 'bad'))",
+        },
+        { id: 'timer.after', expression: "typeof aura.timer?.after === 'function'" },
+        { id: 'timer.every', expression: "typeof aura.timer?.every === 'function'" },
+        { id: 'timer.cancel', expression: "typeof aura.timer?.cancel === 'function'" },
+        { id: 'timer.getDelta', expression: "typeof aura.timer?.getDelta === 'function'" },
+        { id: 'timer.getTime', expression: "typeof aura.timer?.getTime === 'function'" },
+      ],
+      frames: 1,
+      source: `
+        aura.setup = function () {
+          aura.test.equal(aura.math.clamp(11, 0, 10), 10, 'math.clamp should clamp high values');
+          aura.test.equal(aura.math.lerp(0, 10, 0.5), 5, 'math.lerp should interpolate');
+          const r = aura.math.random(1, 3);
+          aura.test.assert(Number.isFinite(r), 'math.random should be finite');
+          aura.test.assert(r >= 1 && r <= 3, 'math.random should be in range');
+          aura.test.equal(aura.math.distance(0, 0, 3, 4), 5, 'math.distance should be euclidean');
+          aura.test.equal(aura.math.angle(0, 0, 1, 0), 0, 'math.angle should measure from points');
+          aura.test.equal(aura.math.PI, Math.PI, 'math.PI should match');
+          aura.test.equal(aura.math.TAU, Math.PI * 2, 'math.TAU should match');
+  
+          const c = aura.rgba(1, 0, 0, 0.5);
+          aura.test.equal(c.r, 1, 'aura.rgba should preserve r');
+          aura.test.equal(c.g, 0, 'aura.rgba should preserve g');
+          aura.test.equal(c.b, 0, 'aura.rgba should preserve b');
+          aura.test.equal(c.a, 0.5, 'aura.rgba should preserve a');
+          aura.test.equal(aura.Color.WHITE.a, 1, 'aura.Color.WHITE should exist');
+  
+          const a = aura.vec2(3, 4);
+          const b = aura.vec2(2, 1);
+          const sum = aura.vec2.add(a, b);
+          aura.test.equal(sum.x, 5, 'vec2.add x');
+          aura.test.equal(sum.y, 5, 'vec2.add y');
+          const diff = aura.vec2.sub(a, b);
+          aura.test.equal(diff.x, 1, 'vec2.sub x');
+          aura.test.equal(diff.y, 3, 'vec2.sub y');
+          const scaled = aura.vec2.scale(a, 2);
+          aura.test.equal(scaled.x, 6, 'vec2.scale x');
+          aura.test.equal(scaled.y, 8, 'vec2.scale y');
+          aura.test.equal(aura.vec2.dot(a, b), 10, 'vec2.dot');
+          aura.test.equal(aura.vec2.length(a), 5, 'vec2.length');
+          const normalized = aura.vec2.normalize(a);
+          aura.test.assert(Math.abs(normalized.x - 0.6) < 1e-9, 'vec2.normalize x');
+          aura.test.assert(Math.abs(normalized.y - 0.8) < 1e-9, 'vec2.normalize y');
+          const distance = aura.vec2.distance(a, b);
+          aura.test.assert(Math.abs(distance - Math.sqrt(10)) < 1e-9, 'vec2.distance');
+          const lerped = aura.vec2.lerp(a, b, 0.5);
+          aura.test.equal(lerped.x, 2.5, 'vec2.lerp x');
+          aura.test.equal(lerped.y, 2.5, 'vec2.lerp y');
+  
+          const v3a = aura.vec3(1, 2, 3);
+          const v3b = aura.vec3(4, 5, 6);
+          const v3sum = aura.vec3.add(v3a, v3b);
+          aura.test.equal(v3sum.x, 5, 'vec3.add x');
+          aura.test.equal(v3sum.y, 7, 'vec3.add y');
+          aura.test.equal(v3sum.z, 9, 'vec3.add z');
+          const v3sub = aura.vec3.sub(v3b, v3a);
+          aura.test.equal(v3sub.x, 3, 'vec3.sub x');
+          aura.test.equal(v3sub.y, 3, 'vec3.sub y');
+          aura.test.equal(v3sub.z, 3, 'vec3.sub z');
+          const v3scaled = aura.vec3.scale(v3a, 2);
+          aura.test.equal(v3scaled.x, 2, 'vec3.scale x');
+          aura.test.equal(v3scaled.y, 4, 'vec3.scale y');
+          aura.test.equal(v3scaled.z, 6, 'vec3.scale z');
+          aura.test.equal(aura.vec3.dot(v3a, v3b), 32, 'vec3.dot');
+          const cross = aura.vec3.cross(aura.vec3(1, 0, 0), aura.vec3(0, 1, 0));
+          aura.test.equal(cross.x, 0, 'vec3.cross x');
+          aura.test.equal(cross.y, 0, 'vec3.cross y');
+          aura.test.equal(cross.z, 1, 'vec3.cross z');
+          aura.test.equal(aura.vec3.length(aura.vec3(0, 3, 4)), 5, 'vec3.length');
+          const v3normalized = aura.vec3.normalize(aura.vec3(0, 3, 4));
+          aura.test.assert(Math.abs(v3normalized.y - 0.6) < 1e-9, 'vec3.normalize y');
+          aura.test.assert(Math.abs(v3normalized.z - 0.8) < 1e-9, 'vec3.normalize z');
+          aura.test.assert(
+            Math.abs(aura.vec3.distance(v3a, v3b) - Math.sqrt(27)) < 1e-9,
+            'vec3.distance',
+          );
+          const v3lerped = aura.vec3.lerp(aura.vec3(0, 0, 0), aura.vec3(2, 4, 6), 0.5);
+          aura.test.equal(v3lerped.x, 1, 'vec3.lerp x');
+          aura.test.equal(v3lerped.y, 2, 'vec3.lerp y');
+          aura.test.equal(v3lerped.z, 3, 'vec3.lerp z');
+  
+          aura.test.equal(
+            aura.collision.rectRect(
+              { x: 0, y: 0, w: 10, h: 10 },
+              { x: 5, y: 5, w: 10, h: 10 },
+            ),
+            true,
+            'collision.rectRect overlap',
+          );
+          aura.test.equal(
+            aura.collision.rectPoint(
+              { x: 0, y: 0, w: 10, h: 10 },
+              { x: 2, y: 2 },
+            ),
+            true,
+            'collision.rectPoint true',
+          );
+          aura.test.equal(
+            aura.collision.circleCircle(
+              { x: 0, y: 0, radius: 4 },
+              { x: 6, y: 0, radius: 4 },
+            ),
+            true,
+            'collision.circleCircle overlap',
+          );
+          aura.test.equal(
+            aura.collision.circlePoint(
+              { x: 0, y: 0, radius: 4 },
+              { x: 0, y: 0 },
+            ),
+            true,
+            'collision.circlePoint true',
+          );
+          aura.test.equal(
+            aura.collision.circleRect(
+              { x: 20, y: 20, radius: 2 },
+              { x: 0, y: 0, w: 10, h: 10 },
+            ),
+            false,
+            'collision.circleRect false case',
+          );
+  
+          let afterCount = 0;
+          let everyCount = 0;
+  
+          aura.timer.after(0.05, () => {
+            afterCount += 1;
+          });
+  
+          const token = aura.timer.every(0.05, () => {
+            everyCount += 1;
+          });
+          aura.timer.cancel(token);
+  
+          aura.test.assert(Number.isFinite(aura.timer.getDelta()), 'timer.getDelta should be numeric');
+          aura.test.assert(Number.isFinite(aura.timer.getTime()), 'timer.getTime should be numeric');
+          aura.test.assert(afterCount >= 0 && afterCount <= 1, 'timer.after should not synchronously over-fire');
+          aura.test.assert(everyCount >= 0 && everyCount <= 1, 'timer.every should not synchronously over-fire');
+        };
+      `,
+    },
+  {
+      id: 'phaser-platformer-vertical-slice',
+      modes: ['shim', 'native'],
+      namespaces: ['gameplay', 'draw2d', 'collision', 'tilemap'],
+      functions: [
+        'aura.update',
+        'aura.draw',
+        'aura.draw2d.clear',
+        'aura.draw2d.rect',
+        'aura.collision.rectRect',
+        'aura.tilemap.import',
+        'aura.tilemap.queryPoint',
+        'aura.tilemap.setRegion',
+        'aura.tilemap.removeRegion',
+        'aura.tilemap.setLayerCollision',
+        'aura.tilemap.setLayerVisibility',
+        'aura.tilemap.draw',
+        'aura.tilemap.unload',
+      ],
+      verticalSliceScenario: {
+        engine: 'phaser',
+        scenarioId: 'platformer',
+        scenarioName: 'Platformer movement/jump loop',
+        parityClaims: [
+          'fixed-step horizontal movement stays deterministic',
+          'jump apex/landing timing remains deterministic',
+          'post-landing grounding lock is stable',
+          'tilemap runtime edits and layer controls keep query/draw state deterministic',
+        ],
+        checks: [
+          'phaser.platformer.fixed-step.motion',
+          'phaser.platformer.jump.apex-and-landing',
+          'phaser.platformer.ground-lock.stable',
+          'phaser.platformer.tilemap-mutation-query.deterministic',
+        ],
+        expectedDeterministicState: {
+          finalX: 12,
+          finalY: 0,
+          maxJumpHeight: 9,
+          landedStep: 6,
+          tilemapHitsBefore: 1,
+          tilemapHitsAfterRemove: 0,
+          tilemapHitsAfterRestore: 1,
+        },
+      },
+      nativeChecks: [
+        {
+          id: 'phaser.platformer.surface.collision-available',
+          expression: "typeof aura.collision?.rectRect === 'function'",
+        },
+        {
+          id: 'phaser.platformer.fixed-step.motion',
+          expression: "(() => { const input = [1, 1, 1, 0, 0, -1, -1, 0]; const state = { x: 0, y: 0, vx: 0, vy: 0, grounded: true }; for (let i = 0; i < input.length; i += 1) { const axis = input[i]; if (axis > 0) state.vx = Math.min(state.vx + 2, 4); else if (axis < 0) state.vx = Math.max(state.vx - 2, -4); else if (state.vx > 0) state.vx -= 1; else if (state.vx < 0) state.vx += 1; if (i === 1 && state.grounded) { state.vy = 7; state.grounded = false; } if (!state.grounded) { state.vy -= 2; state.y += state.vy; if (state.y <= 0) { state.y = 0; state.vy = 0; state.grounded = true; } } state.x += state.vx; } return state.x === 12 && state.y === 0 && state.vx === -1; })()",
+        },
+        {
+          id: 'phaser.platformer.jump.apex-and-landing',
+          expression: "(() => { const input = [1, 1, 1, 0, 0, -1, -1, 0]; const state = { y: 0, vy: 0, grounded: true, maxJumpHeight: 0, landedStep: null }; for (let i = 0; i < input.length; i += 1) { if (i === 1 && state.grounded) { state.vy = 7; state.grounded = false; } if (!state.grounded) { state.vy -= 2; state.y += state.vy; if (state.y > state.maxJumpHeight) state.maxJumpHeight = state.y; if (state.y <= 0) { state.y = 0; state.vy = 0; state.grounded = true; if (state.landedStep == null && i > 1) state.landedStep = i; } } } return state.maxJumpHeight === 9 && state.landedStep === 6 && state.y === 0 && state.grounded === true; })()",
+        },
+        {
+          id: 'phaser.platformer.ground-lock.stable',
+          expression: "(() => { const input = [1, 1, 1, 0, 0, -1, -1, 0, 0, 0]; const state = { y: 0, vy: 0, grounded: true }; const tail = []; for (let i = 0; i < input.length; i += 1) { if (i === 1 && state.grounded) { state.vy = 7; state.grounded = false; } if (!state.grounded) { state.vy -= 2; state.y += state.vy; if (state.y <= 0) { state.y = 0; state.vy = 0; state.grounded = true; } } tail.push(state.y); } return tail.slice(-3).every((entry) => entry === 0); })()",
+        },
+        {
+          id: 'phaser.platformer.tilemap-mutation-query.deterministic',
+          expression: "(() => { const fixture = { width: 4, height: 2, tilewidth: 16, tileheight: 16, solidLayerNames: ['blockers'], layers: [ { name: 'ground', type: 'tilelayer', width: 4, height: 2, data: Array.from({ length: 8 }, () => 1) }, { name: 'blockers', type: 'tilelayer', width: 4, height: 2, data: [0, 0, 1, 0, 0, 0, 0, 0] } ], tilesets: [ { firstgid: 1, image: 'tiles.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1 } ] }; const mapId = aura.tilemap.import(fixture); const before = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 0.5 }); aura.tilemap.removeRegion(mapId, 'blockers', { x: 2, y: 0, w: 1, h: 1 }); const removed = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 0.5 }); aura.tilemap.setRegion(mapId, 'blockers', { x: 2, y: 0, w: 1, h: 1 }, 1); aura.tilemap.setLayerCollision(mapId, 'blockers', false); const muted = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 0.5 }); aura.tilemap.setLayerCollision(mapId, 'blockers', true); const restored = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 0.5 }); aura.tilemap.setLayerVisibility(mapId, 'blockers', false); const hidden = aura.tilemap.draw(mapId, { cull: false }); aura.tilemap.setLayerVisibility(mapId, 'blockers', true); const visible = aura.tilemap.draw(mapId, { cull: false }); aura.tilemap.unload(mapId); return Array.isArray(before?.hits) && before.hits.length === 1 && Array.isArray(removed?.hits) && removed.hits.length === 0 && Array.isArray(muted?.hits) && muted.hits.length === 0 && Array.isArray(restored?.hits) && restored.hits.length === 1 && hidden?.layerOrder?.join(',') === 'ground' && visible?.layerOrder?.join(',') === 'ground,blockers'; })()",
+        },
+      ],
+      frames: 8,
+      source: `
+        const __platformerInput = [1, 1, 1, 0, 0, -1, -1, 0];
+        const __platformer = {
+          frame: 0,
+          x: 0,
+          y: 0,
+          vx: 0,
+          vy: 0,
+          grounded: true,
+          maxJumpHeight: 0,
+          landedStep: null,
+          tilemapId: 0,
+          tilemapHitsBefore: -1,
+          tilemapHitsAfterRemove: -1,
+          tilemapHitsMuted: -1,
+          tilemapHitsAfterRestore: -1,
+          tilemapHiddenOrder: '',
+          tilemapVisibleOrder: '',
+        };
+  
+        function __stepPlatformer(step) {
+          const axis = __platformerInput[step];
+          if (axis > 0) __platformer.vx = Math.min(__platformer.vx + 2, 4);
+          else if (axis < 0) __platformer.vx = Math.max(__platformer.vx - 2, -4);
+          else if (__platformer.vx > 0) __platformer.vx -= 1;
+          else if (__platformer.vx < 0) __platformer.vx += 1;
+  
+          if (step === 1 && __platformer.grounded) {
+            __platformer.vy = 7;
+            __platformer.grounded = false;
+          }
+  
+          if (!__platformer.grounded) {
+            __platformer.vy -= 2;
+            __platformer.y += __platformer.vy;
+            if (__platformer.y > __platformer.maxJumpHeight) __platformer.maxJumpHeight = __platformer.y;
+            if (__platformer.y <= 0) {
+              __platformer.y = 0;
+              __platformer.vy = 0;
+              __platformer.grounded = true;
+              if (__platformer.landedStep == null && step > 1) __platformer.landedStep = step;
+            }
+          }
+  
+          __platformer.x += __platformer.vx;
+        }
+  
+        function __stepTilemapMutation(step) {
+          if (__platformer.tilemapId <= 0) return;
+          if (step === 0) {
+            const before = aura.tilemap.queryPoint(__platformer.tilemapId, { x: 32.5, y: 0.5 });
+            __platformer.tilemapHitsBefore = Array.isArray(before?.hits) ? before.hits.length : -1;
+          }
+          if (step === 2) {
+            aura.tilemap.removeRegion(__platformer.tilemapId, 'blockers', { x: 2, y: 0, w: 1, h: 1 });
+            const removed = aura.tilemap.queryPoint(__platformer.tilemapId, { x: 32.5, y: 0.5 });
+            __platformer.tilemapHitsAfterRemove = Array.isArray(removed?.hits) ? removed.hits.length : -1;
+          }
+          if (step === 4) {
+            aura.tilemap.setRegion(__platformer.tilemapId, 'blockers', { x: 2, y: 0, w: 1, h: 1 }, 1);
+            aura.tilemap.setLayerCollision(__platformer.tilemapId, 'blockers', false);
+            const muted = aura.tilemap.queryPoint(__platformer.tilemapId, { x: 32.5, y: 0.5 });
+            __platformer.tilemapHitsMuted = Array.isArray(muted?.hits) ? muted.hits.length : -1;
+            aura.tilemap.setLayerCollision(__platformer.tilemapId, 'blockers', true);
+            const restored = aura.tilemap.queryPoint(__platformer.tilemapId, { x: 32.5, y: 0.5 });
+            __platformer.tilemapHitsAfterRestore = Array.isArray(restored?.hits) ? restored.hits.length : -1;
+          }
+          if (step === 5) {
+            aura.tilemap.setLayerVisibility(__platformer.tilemapId, 'blockers', false);
+            const hidden = aura.tilemap.draw(__platformer.tilemapId, { cull: false });
+            __platformer.tilemapHiddenOrder = hidden?.layerOrder?.join(',') || '';
+          }
+          if (step === 6) {
+            aura.tilemap.setLayerVisibility(__platformer.tilemapId, 'blockers', true);
+            const visible = aura.tilemap.draw(__platformer.tilemapId, { cull: false });
+            __platformer.tilemapVisibleOrder = visible?.layerOrder?.join(',') || '';
+          }
+        }
+  
+        aura.setup = function () {
+          __platformer.tilemapId = aura.tilemap.import({
+            width: 4,
+            height: 2,
+            tilewidth: 16,
+            tileheight: 16,
+            solidLayerNames: ['blockers'],
+            layers: [
+              {
+                name: 'ground',
+                type: 'tilelayer',
+                width: 4,
+                height: 2,
+                data: Array.from({ length: 8 }, () => 1),
+              },
+              {
+                name: 'blockers',
+                type: 'tilelayer',
+                width: 4,
+                height: 2,
+                data: [0, 0, 1, 0, 0, 0, 0, 0],
+              },
+            ],
+            tilesets: [
+              { firstgid: 1, image: 'tiles.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1 },
+            ],
+          });
+        };
+  
+        aura.update = function () {
+          if (__platformer.frame < __platformerInput.length) {
+            __stepPlatformer(__platformer.frame);
+            __stepTilemapMutation(__platformer.frame);
+          }
+          __platformer.frame += 1;
+        };
+  
+        aura.draw = function () {
+          aura.draw2d.clear(8, 10, 16);
+          aura.draw2d.rect(__platformer.x + 200, 140 - (__platformer.y * 2), 12, 18, aura.colors.white);
+          aura.draw2d.rect(0, 140, 320, 6, aura.colors.green);
+  
+          if (__platformer.frame === __platformerInput.length) {
+            aura.test.equal(__platformer.x, 12, 'platformer x progression should stay deterministic');
+            aura.test.equal(__platformer.y, 0, 'platformer should land exactly on ground');
+            aura.test.equal(__platformer.maxJumpHeight, 9, 'platformer jump apex should stay deterministic');
+            aura.test.equal(__platformer.landedStep, 6, 'platformer landing step should stay deterministic');
+            aura.test.equal(__platformer.tilemapHitsBefore, 1, 'platformer tilemap query should start with one blocker hit');
+            aura.test.equal(__platformer.tilemapHitsAfterRemove, 0, 'platformer tilemap query should reflect live tile removal');
+            aura.test.equal(__platformer.tilemapHitsMuted, 0, 'platformer tilemap collision toggle should mute blocker hits');
+            aura.test.equal(__platformer.tilemapHitsAfterRestore, 1, 'platformer tilemap query should restore after collision toggle');
+            aura.test.equal(__platformer.tilemapHiddenOrder, 'ground', 'platformer tilemap visibility toggle should affect draw order');
+            aura.test.equal(__platformer.tilemapVisibleOrder, 'ground,blockers', 'platformer tilemap visibility restore should recover draw order');
+            aura.test.equal(aura.tilemap.unload(__platformer.tilemapId), true, 'platformer tilemap should unload after deterministic assertions');
+            __platformer.tilemapId = 0;
+          }
+        };
+      `,
+    },
+  {
+      id: 'phaser-topdown-combat-vertical-slice',
+      modes: ['shim', 'native'],
+      namespaces: ['gameplay', 'draw2d', 'collision', 'tilemap', 'input'],
+      functions: [
+        'aura.update',
+        'aura.draw',
+        'aura.draw2d.clear',
+        'aura.draw2d.rect',
+        'aura.collision.rectRect',
+        'aura.tilemap.import',
+        'aura.tilemap.queryPoint',
+        'aura.tilemap.unload',
+        'aura.input.isKeyDown',
+      ],
+      verticalSliceScenario: {
+        engine: 'phaser',
+        scenarioId: 'topdown-combat',
+        scenarioName: 'Topdown movement/combat loop',
+        parityClaims: [
+          'topdown movement path remains deterministic through runtime tilemap queries',
+          'projectile loop is deterministic through runtime collision hooks',
+          'reason-coded tilemap guardrails remain stable in gameplay loop',
+        ],
+        checks: [
+          'phaser.topdown.fixed-step.pathing',
+          'phaser.topdown.projectile-loop.deterministic',
+          'phaser.topdown.enemy-defeat.deterministic',
+        ],
+        expectedDeterministicState: {
+          playerX: 1,
+          playerY: 1,
+          enemyHp: 0,
+          blockedMoves: 1,
+          spawnedProjectiles: 2,
+          hitCount: 1,
+        },
+      },
+      nativeChecks: [
+        {
+          id: 'phaser.topdown.surface.draw2d-available',
+          expression: "typeof aura.draw2d?.rect === 'function' && typeof aura.collision?.rectRect === 'function' && typeof aura.tilemap?.import === 'function' && typeof aura.tilemap?.queryPoint === 'function' && typeof aura.input?.isKeyDown === 'function'",
+        },
+        {
+          id: 'phaser.topdown.fixed-step.pathing',
+          expression: "(() => { const runSample = () => { const fixture = { width: 5, height: 5, tilewidth: 1, tileheight: 1, solidLayerNames: ['walls'], layers: [ { name: 'ground', type: 'tilelayer', width: 5, height: 5, data: Array.from({ length: 25 }, () => 1) }, { name: 'walls', type: 'tilelayer', width: 5, height: 5, data: [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] } ], tilesets: [ { firstgid: 1, image: 'tiles.png', tilewidth: 1, tileheight: 1, tilecount: 1, columns: 1 } ] }; const mapId = aura.tilemap.import(fixture); const invalidPoint = aura.tilemap.queryPoint(mapId, { x: 'bad', y: 0 }); const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 }); const inputProbe = ['left', 'right', 'up', 'down'].every((key) => typeof aura.input.isKeyDown(key) === 'boolean'); const steps = [{ x: 1, y: 0 }, { x: 1, y: 0 }, { x: 0, y: 1 }, { x: -1, y: 0 }, { x: 0, y: 1 }]; const player = { x: 0, y: 0, w: 0.8, h: 0.8 }; let blockedMoves = 0; for (const step of steps) { const nextX = player.x + step.x; const nextY = player.y + step.y; const probe = aura.tilemap.queryPoint(mapId, { x: nextX + 0.5, y: nextY + 0.5 }); const blocked = Array.isArray(probe?.hits) && probe.hits.length > 0; if (blocked) { blockedMoves += 1; continue; } player.x = nextX; player.y = nextY; } const unloaded = aura.tilemap.unload(mapId); return { playerX: player.x, playerY: player.y, blockedMoves, invalidPoint: invalidPoint?.reasonCode || null, invalidHandle: invalidHandle?.reasonCode || null, inputProbe, unloaded }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.playerX === 1 && first.playerY === 1 && first.blockedMoves === 1 && first.invalidPoint === 'invalid_point_args' && first.invalidHandle === 'invalid_map_handle' && first.inputProbe === true && first.unloaded === true; })()",
+        },
+        {
+          id: 'phaser.topdown.projectile-loop.deterministic',
+          expression: "(() => { const runSample = () => { const enemy = { x: 4, y: 2, w: 1, h: 1, hp: 1 }; const projectiles = []; let spawned = 0; let hits = 0; for (let frame = 0; frame < 5; frame += 1) { if (frame === 0 || frame === 2) { projectiles.push({ x: 1, y: 2, w: 0.5, h: 0.5, vx: 1, alive: true }); spawned += 1; } for (const shot of projectiles) { if (!shot.alive) continue; shot.x += shot.vx; if (aura.collision.rectRect(shot.x, shot.y, shot.w, shot.h, enemy.x, enemy.y, enemy.w, enemy.h) && enemy.hp > 0) { enemy.hp -= 1; hits += 1; shot.alive = false; } } } const remaining = projectiles.filter((shot) => shot.alive && shot.x < 8).length; const farApart = aura.collision.rectRect(0, 0, 1, 1, 10, 10, 1, 1); const overlaps = aura.collision.rectRect(0, 0, 1, 1, 0.25, 0.25, 1, 1); return { spawned, hits, remaining, enemyHp: enemy.hp, farApart, overlaps }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.spawned === 2 && first.hits === 1 && first.remaining === 1 && first.enemyHp === 0 && first.farApart === false && first.overlaps === true; })()",
+        },
+        {
+          id: 'phaser.topdown.enemy-defeat.deterministic',
+          expression: "(() => { const runSample = () => { const enemy = { x: 4, y: 2, w: 1, h: 1, hp: 2 }; const projectiles = []; let spawned = 0; let hits = 0; let defeatFrame = null; for (let frame = 0; frame < 7; frame += 1) { if (frame === 0 || frame === 2 || frame === 4) { projectiles.push({ x: 1, y: 2, w: 0.5, h: 0.5, vx: 1, alive: true }); spawned += 1; } for (const shot of projectiles) { if (!shot.alive) continue; shot.x += shot.vx; if (aura.collision.rectRect(shot.x, shot.y, shot.w, shot.h, enemy.x, enemy.y, enemy.w, enemy.h) && enemy.hp > 0) { enemy.hp -= 1; hits += 1; shot.alive = false; if (enemy.hp === 0 && defeatFrame === null) defeatFrame = frame; } } } return { enemyHp: enemy.hp, spawned, hits, defeatFrame }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.enemyHp === 0 && first.spawned === 3 && first.hits === 2 && first.defeatFrame === 4; })()",
+        },
+      ],
+      frames: 7,
+      source: `
+        const __topdownInput = [
+          { x: 1, y: 0, fire: false },
+          { x: 1, y: 0, fire: true },
+          { x: 0, y: 1, fire: false },
+          { x: -1, y: 0, fire: false },
+          { x: 0, y: 1, fire: true },
+          { x: 0, y: 0, fire: false },
+          { x: 0, y: 0, fire: false },
+        ];
+        const __topdown = {
+          frame: 0,
+          player: { x: 0, y: 0, w: 0.8, h: 0.8 },
+          enemy: { x: 10, y: 0, hp: 1 },
+          projectiles: [],
+          spawned: 0,
+          hits: 0,
+          blockedMoves: 0,
+          mapId: 0,
+          invalidPointReason: null,
+          invalidHandleReason: null,
+          inputProbeOk: false,
+        };
+  
+        function __createTopdownFixture() {
+          return {
+            width: 5,
+            height: 5,
+            tilewidth: 1,
+            tileheight: 1,
+            solidLayerNames: ['walls'],
+            layers: [
+              {
+                name: 'ground',
+                type: 'tilelayer',
+                width: 5,
+                height: 5,
+                data: Array.from({ length: 25 }, () => 1),
+              },
+              {
+                name: 'walls',
+                type: 'tilelayer',
+                width: 5,
+                height: 5,
+                data: [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+              },
+            ],
+            tilesets: [
+              { firstgid: 1, image: 'tiles.png', tilewidth: 1, tileheight: 1, tilecount: 1, columns: 1 },
+            ],
+          };
+        }
+  
+        function __stepTopdown(step) {
+          const nextX = __topdown.player.x + step.x;
+          const nextY = __topdown.player.y + step.y;
+          const probe = aura.tilemap.queryPoint(__topdown.mapId, { x: nextX + 0.5, y: nextY + 0.5 });
+          const blocked = Array.isArray(probe?.hits) && probe.hits.length > 0;
+          if (blocked) {
+            __topdown.blockedMoves += 1;
+          } else {
+            __topdown.player.x = nextX;
+            __topdown.player.y = nextY;
+          }
+  
+          if (step.fire) {
+            __topdown.projectiles.push({ x: __topdown.player.x + 0.2, y: __topdown.player.y + 0.2, w: 0.4, h: 0.4, vx: 2, vy: 0, alive: true });
+            __topdown.spawned += 1;
+          }
+  
+          for (const shot of __topdown.projectiles) {
+            if (!shot.alive) continue;
+            shot.x += shot.vx;
+            shot.y += shot.vy;
+            if (
+              aura.collision.rectRect(
+                shot.x,
+                shot.y,
+                shot.w,
+                shot.h,
+                __topdown.enemy.x,
+                __topdown.enemy.y,
+                1,
+                1,
+              ) && __topdown.enemy.hp > 0
+            ) {
+              __topdown.enemy.hp -= 1;
+              __topdown.hits += 1;
+              shot.alive = false;
+            }
+          }
+          __topdown.projectiles = __topdown.projectiles.filter((shot) => shot.alive && shot.x < 12);
+        }
+  
+        aura.setup = function () {
+          __topdown.mapId = aura.tilemap.import(__createTopdownFixture());
+          const invalidPoint = aura.tilemap.queryPoint(__topdown.mapId, { x: 'bad', y: 0 });
+          const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 });
+          __topdown.invalidPointReason = invalidPoint?.reasonCode || null;
+          __topdown.invalidHandleReason = invalidHandle?.reasonCode || null;
+          __topdown.inputProbeOk = ['left', 'right', 'up', 'down']
+            .every((key) => typeof aura.input.isKeyDown(key) === 'boolean');
+        };
+  
+        aura.update = function () {
+          if (__topdown.frame < __topdownInput.length) {
+            __stepTopdown(__topdownInput[__topdown.frame]);
+          }
+          __topdown.frame += 1;
+        };
+  
+        aura.draw = function () {
+          aura.draw2d.clear(12, 12, 20);
+          aura.draw2d.rect(80 + (__topdown.player.x * 8), 60 + (__topdown.player.y * 8), 8, 8, aura.colors.white);
+          if (__topdown.enemy.hp > 0) {
+            aura.draw2d.rect(80 + (__topdown.enemy.x * 8), 60 + (__topdown.enemy.y * 8), 8, 8, aura.colors.red);
+          }
+          for (const shot of __topdown.projectiles) {
+            aura.draw2d.rect(80 + (shot.x * 8), 60 + (shot.y * 8), 3, 2, aura.colors.yellow);
+          }
+  
+          if (__topdown.frame === __topdownInput.length) {
+            aura.test.equal(__topdown.player.x, 1, 'topdown player x should be deterministic');
+            aura.test.equal(__topdown.player.y, 1, 'topdown player y should be deterministic');
+            aura.test.equal(__topdown.blockedMoves, 1, 'topdown blocked movement count should be deterministic');
+            aura.test.equal(__topdown.spawned, 2, 'topdown projectile spawns should be deterministic');
+            aura.test.equal(__topdown.hits, 1, 'topdown hit count should be deterministic');
+            aura.test.equal(__topdown.enemy.hp, 0, 'topdown enemy should be defeated deterministically');
+            aura.test.equal(__topdown.invalidPointReason, 'invalid_point_args', 'topdown invalid point reason code should be deterministic');
+            aura.test.equal(__topdown.invalidHandleReason, 'invalid_map_handle', 'topdown invalid map reason code should be deterministic');
+            aura.test.equal(__topdown.inputProbeOk, true, 'topdown input hooks should remain callable');
+            aura.test.equal(aura.tilemap.unload(__topdown.mapId), true, 'topdown tilemap should unload after assertions');
+            __topdown.mapId = 0;
+          }
+        };
+      `,
+    },
+  {
+      id: 'phaser-arcade-collision-loop-vertical-slice',
+      modes: ['shim', 'native'],
+      namespaces: ['gameplay', 'draw2d', 'collision', 'tilemap'],
+      functions: [
+        'aura.update',
+        'aura.draw',
+        'aura.draw2d.clear',
+        'aura.draw2d.rect',
+        'aura.collision.rectRect',
+        'aura.tilemap.import',
+        'aura.tilemap.queryPoint',
+        'aura.tilemap.unload',
+      ],
+      verticalSliceScenario: {
+        engine: 'phaser',
+        scenarioId: 'arcade-collision-loop',
+        scenarioName: 'Arcade collision/collectible loop',
+        parityClaims: [
+          'pickup resolution order is deterministic',
+          'single-hit enemy damage loop is deterministic',
+          'score/life deltas are deterministic',
+        ],
+        checks: [
+          'phaser.arcade.pickup-score.deterministic',
+          'phaser.arcade.enemy-collision.single-hit',
+          'phaser.arcade.final-state.deterministic',
+        ],
+        expectedDeterministicState: {
+          score: 30,
+          lives: 2,
+          enemyHits: 1,
+          remainingPickups: 0,
+          hazardContacts: 2,
+        },
+      },
+      nativeChecks: [
+        {
+          id: 'phaser.arcade.surface.collision-available',
+          expression: "typeof aura.collision?.rectRect === 'function' && typeof aura.tilemap?.import === 'function' && typeof aura.tilemap?.queryPoint === 'function'",
+        },
+        {
+          id: 'phaser.arcade.pickup-score.deterministic',
+          expression: "(() => { const runSample = () => { const state = { player: { x: 0, y: 0, w: 2, h: 2 }, enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 }, pickups: [{ x: 3, y: 0, w: 1, h: 1, active: true }, { x: 7, y: 0, w: 1, h: 1, active: true }, { x: 11, y: 0, w: 1, h: 1, active: true }], score: 0, enemyHits: 0, lives: 3 }; for (let frame = 0; frame < 7; frame += 1) { state.player.x += 2; state.enemy.x += state.enemy.vx; for (const pickup of state.pickups) { if (pickup.active && aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, pickup.x, pickup.y, pickup.w, pickup.h)) { pickup.active = false; state.score += 10; } } if (aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, state.enemy.x, state.enemy.y, state.enemy.w, state.enemy.h)) { state.enemyHits += 1; if (state.enemyHits === 1) state.lives -= 1; } } return { score: state.score, inactivePickups: state.pickups.filter((pickup) => pickup.active === false).length, enemyHits: state.enemyHits, lives: state.lives }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.score === 30 && first.inactivePickups === 3 && first.enemyHits === 1 && first.lives === 2; })()",
+        },
+        {
+          id: 'phaser.arcade.enemy-collision.single-hit',
+          expression: "(() => { const runSample = () => { const state = { player: { x: 0, y: 0, w: 2, h: 2 }, enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 }, lives: 3, enemyHits: 0 }; for (let frame = 0; frame < 7; frame += 1) { state.player.x += 2; state.enemy.x += state.enemy.vx; if (aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, state.enemy.x, state.enemy.y, state.enemy.w, state.enemy.h)) { state.enemyHits += 1; if (state.enemyHits === 1) state.lives -= 1; } } const farApart = aura.collision.rectRect(0, 0, 1, 1, 9, 9, 1, 1); const overlaps = aura.collision.rectRect(0, 0, 2, 2, 1, 1, 2, 2); return { enemyHits: state.enemyHits, lives: state.lives, farApart, overlaps }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.enemyHits === 1 && first.lives === 2 && first.farApart === false && first.overlaps === true; })()",
+        },
+        {
+          id: 'phaser.arcade.final-state.deterministic',
+          expression: "(() => { const runSample = () => { const fixture = { width: 4, height: 1, tilewidth: 1, tileheight: 1, solidLayerNames: ['hazards'], layers: [ { name: 'ground', type: 'tilelayer', width: 4, height: 1, data: [1, 1, 1, 1] }, { name: 'hazards', type: 'tilelayer', width: 4, height: 1, data: [0, 0, 1, 0] } ], tilesets: [ { firstgid: 1, image: 'tiles.png', tilewidth: 1, tileheight: 1, tilecount: 1, columns: 1 } ] }; const mapId = aura.tilemap.import(fixture); const invalidPoint = aura.tilemap.queryPoint(mapId, { x: 'bad', y: 0 }); const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 }); const state = { player: { x: 0, y: 0, w: 2, h: 2 }, enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 }, pickups: [{ x: 3, y: 0, w: 1, h: 1, active: true }, { x: 7, y: 0, w: 1, h: 1, active: true }, { x: 11, y: 0, w: 1, h: 1, active: true }], score: 0, enemyHits: 0, lives: 3, hazardContacts: 0 }; for (let frame = 0; frame < 7; frame += 1) { state.player.x += 2; state.enemy.x += state.enemy.vx; for (const pickup of state.pickups) { if (pickup.active && aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, pickup.x, pickup.y, pickup.w, pickup.h)) { pickup.active = false; state.score += 10; } } const hazard = aura.tilemap.queryPoint(mapId, { x: Math.min(3.5, (state.player.x / 4) + 0.5), y: 0.5 }); if (Array.isArray(hazard?.hits) && hazard.hits.length > 0) state.hazardContacts += 1; if (aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, state.enemy.x, state.enemy.y, state.enemy.w, state.enemy.h)) { state.enemyHits += 1; if (state.enemyHits === 1) state.lives -= 1; } } const unloaded = aura.tilemap.unload(mapId); return { playerX: state.player.x, enemyX: state.enemy.x, score: state.score, lives: state.lives, enemyHits: state.enemyHits, remainingPickups: state.pickups.filter((pickup) => pickup.active).length, hazardContacts: state.hazardContacts, invalidPoint: invalidPoint?.reasonCode || null, invalidHandle: invalidHandle?.reasonCode || null, unloaded }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.playerX === 14 && first.enemyX === 4 && first.score === 30 && first.lives === 2 && first.enemyHits === 1 && first.remainingPickups === 0 && first.hazardContacts === 2 && first.invalidPoint === 'invalid_point_args' && first.invalidHandle === 'invalid_map_handle' && first.unloaded === true; })()",
+        },
+      ],
+      frames: 7,
+      source: `
+        const __arcade = {
+          frame: 0,
+          player: { x: 0, y: 0, w: 2, h: 2 },
+          enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 },
+          pickups: [
+            { id: 1, x: 3, y: 0, w: 1, h: 1, active: true },
+            { id: 2, x: 7, y: 0, w: 1, h: 1, active: true },
+            { id: 3, x: 11, y: 0, w: 1, h: 1, active: true },
+          ],
+          score: 0,
+          lives: 3,
+          enemyHits: 0,
+          hazardContacts: 0,
+          mapId: 0,
+          invalidPointReason: null,
+          invalidHandleReason: null,
+        };
+  
+        function __createArcadeFixture() {
+          return {
+            width: 4,
+            height: 1,
+            tilewidth: 1,
+            tileheight: 1,
+            solidLayerNames: ['hazards'],
+            layers: [
+              {
+                name: 'ground',
+                type: 'tilelayer',
+                width: 4,
+                height: 1,
+                data: [1, 1, 1, 1],
+              },
+              {
+                name: 'hazards',
+                type: 'tilelayer',
+                width: 4,
+                height: 1,
+                data: [0, 0, 1, 0],
+              },
+            ],
+            tilesets: [
+              { firstgid: 1, image: 'tiles.png', tilewidth: 1, tileheight: 1, tilecount: 1, columns: 1 },
+            ],
+          };
+        }
+  
+        function __stepArcade() {
+          __arcade.player.x += 2;
+          __arcade.enemy.x += __arcade.enemy.vx;
+  
+          for (const pickup of __arcade.pickups) {
+            if (
+              pickup.active
+              && aura.collision.rectRect(
+                __arcade.player.x,
+                __arcade.player.y,
+                __arcade.player.w,
+                __arcade.player.h,
+                pickup.x,
+                pickup.y,
+                pickup.w,
+                pickup.h,
+              )
+            ) {
+              pickup.active = false;
+              __arcade.score += 10;
+            }
+          }
+  
+          if (
+            aura.collision.rectRect(
+              __arcade.player.x,
+              __arcade.player.y,
+              __arcade.player.w,
+              __arcade.player.h,
+              __arcade.enemy.x,
+              __arcade.enemy.y,
+              __arcade.enemy.w,
+              __arcade.enemy.h,
+            )
+          ) {
+            __arcade.enemyHits += 1;
+            if (__arcade.enemyHits === 1) {
+              __arcade.lives -= 1;
+            }
+          }
+  
+          const hazardProbe = aura.tilemap.queryPoint(
+            __arcade.mapId,
+            { x: Math.min(3.5, (__arcade.player.x / 4) + 0.5), y: 0.5 },
+          );
+          if (Array.isArray(hazardProbe?.hits) && hazardProbe.hits.length > 0) {
+            __arcade.hazardContacts += 1;
+          }
+        }
+  
+        aura.setup = function () {
+          __arcade.mapId = aura.tilemap.import(__createArcadeFixture());
+          const invalidPoint = aura.tilemap.queryPoint(__arcade.mapId, { x: 'bad', y: 0 });
+          const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 });
+          __arcade.invalidPointReason = invalidPoint?.reasonCode || null;
+          __arcade.invalidHandleReason = invalidHandle?.reasonCode || null;
+        };
+  
+        aura.update = function () {
+          if (__arcade.frame < 7) {
+            __stepArcade();
+          }
+          __arcade.frame += 1;
+        };
+  
+        aura.draw = function () {
+          aura.draw2d.clear(6, 6, 12);
+          aura.draw2d.rect(40 + (__arcade.player.x * 8), 80, 8, 8, aura.colors.white);
+          aura.draw2d.rect(40 + (__arcade.enemy.x * 8), 80, 8, 8, aura.colors.red);
+          for (const pickup of __arcade.pickups) {
+            if (pickup.active) {
+              aura.draw2d.rect(40 + (pickup.x * 8), 78, 4, 4, aura.colors.yellow);
+            }
+          }
+  
+          if (__arcade.frame === 7) {
+            aura.test.equal(__arcade.score, 30, 'arcade score should be deterministic');
+            aura.test.equal(__arcade.lives, 2, 'arcade life decrement should be deterministic');
+            aura.test.equal(__arcade.enemyHits, 1, 'arcade enemy collision count should be deterministic');
+            aura.test.equal(__arcade.pickups.filter((pickup) => pickup.active).length, 0, 'arcade pickups should all resolve');
+            aura.test.equal(__arcade.hazardContacts, 2, 'arcade tilemap hazard contacts should be deterministic');
+            aura.test.equal(__arcade.invalidPointReason, 'invalid_point_args', 'arcade invalid point reason code should be deterministic');
+            aura.test.equal(__arcade.invalidHandleReason, 'invalid_map_handle', 'arcade invalid map reason code should be deterministic');
+            aura.test.equal(aura.tilemap.unload(__arcade.mapId), true, 'arcade tilemap should unload after assertions');
+            __arcade.mapId = 0;
+          }
+        };
+      `,
+    },
+  {
+      id: 'draw2d-layout-widgets-runtime-native',
+      modes: ['native'],
+      namespaces: ['draw2d', 'ui'],
+      functions: [
+        'aura.draw2d.clear',
+        'aura.ui.beginLayout',
+        'aura.ui.label',
+        'aura.ui.button',
+        'aura.ui.toggle',
+        'aura.ui.slider',
+        'aura.ui.moveFocus',
+        'aura.ui.activate',
+        'aura.ui.adjustValue',
+        'aura.ui.endLayout',
+        'aura.ui.getFocusState',
+        'aura.ui.getWidgetState',
+        'aura.ui.reset',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.layout-widgets.surface.methods',
+          expression: "(() => ['beginLayout','label','button','toggle','slider','moveFocus','activate','adjustValue','endLayout','getFocusState','getWidgetState','reset','__inspectorStats'].every((name) => typeof aura.ui?.[name] === 'function') && typeof aura.draw2d?.clear === 'function')()",
+        },
+        {
+          id: 'draw2d.layout-widgets.runtime.setup',
+          expression: `(() => { try { globalThis.__draw2dLayoutWidgetsProbe = { frames: [], musicValue: false, volumeValue: 4, invalidFocusReason: aura.ui.moveFocus('sideways')?.reasonCode || null, invalidActivateReason: aura.ui.activate('')?.reasonCode || null, invalidAdjustReason: aura.ui.adjustValue('volume', 0)?.reasonCode || null, resetReason: null }; return globalThis.__draw2dLayoutWidgetsProbe.invalidFocusReason === 'invalid_focus_direction' && globalThis.__draw2dLayoutWidgetsProbe.invalidActivateReason === 'invalid_widget_target' && globalThis.__draw2dLayoutWidgetsProbe.invalidAdjustReason === 'invalid_widget_delta'; } catch (_) { return false; } })()`,
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw2d.layout-widgets.runtime.evidence',
+          expression: `(() => { try { const probe = globalThis.__draw2dLayoutWidgetsProbe || {}; const frames = Array.isArray(probe.frames) ? probe.frames : []; const frame0 = frames[0] || {}; const frame1 = frames[1] || {}; const frame2 = frames[2] || {}; const frame3 = frames[3] || {}; const frame4 = frames[4] || {}; const frame5 = frames[5] || {}; return probe.invalidFocusReason === 'invalid_focus_direction' && probe.invalidActivateReason === 'invalid_widget_target' && probe.invalidAdjustReason === 'invalid_widget_delta' && probe.moveReason === 'ui_focus_move_requested' && probe.activateReason === 'ui_widget_activation_requested' && probe.moveReason2 === 'ui_focus_move_requested' && probe.adjustReason === 'ui_widget_adjust_requested' && probe.resetReason === 'ui_focus_reset' && frames.length === 6 && frame0.endReason === 'ui_focus_initialized' && frame0.focusedId === 'play' && frame0.focusedIndex === 0 && frame0.inspect?.focusedWidgetId === 'play' && frame1.endReason === 'ui_focus_advanced' && frame1.focusedId === 'music' && frame1.inspect?.focusedWidgetId === 'music' && frame2.endReason === 'ui_layout_committed' && frame2.musicActivated === true && frame2.musicToggled === true && frame2.musicValue === true && frame2.musicStateReason === 'ui_toggle_changed' && frame2.inspect?.activatedWidgetId === 'music' && Array.isArray(frame2.inspect?.changedWidgetIds) && frame2.inspect.changedWidgetIds.includes('music') && frame3.endReason === 'ui_focus_advanced' && frame3.focusedId === 'volume' && frame3.inspect?.focusedWidgetId === 'volume' && frame4.endReason === 'ui_layout_committed' && frame4.volumeValue === 6 && frame4.volumeStateReason === 'ui_slider_changed' && Array.isArray(frame4.inspect?.changedWidgetIds) && frame4.inspect.changedWidgetIds.includes('volume') && frame5.endReason === 'ui_focus_initialized' && frame5.focusedId === 'play' && frame5.focusedIndex === 0 && frame5.inspect?.focusedWidgetId === 'play'; } catch (_) { return false; } })()`,
+        },
+      ],
+      nativeFrames: 6,
+      source: `
+        globalThis.__draw2dLayoutWidgetsProbe = {
+          frames: [],
+          musicValue: false,
+          volumeValue: 4,
+          invalidFocusReason: null,
+          invalidActivateReason: null,
+          invalidAdjustReason: null,
+          resetReason: null,
+        };
+      `,
+      nativeSource: `
+        const __checks = [];
+        let __reported = false;
+  
+        function __toErrorString(value) {
+          return String(value && value.message ? value.message : value);
+        }
+  
+        function __record(id, pass, detail, trace = null) {
+          const row = { id, pass: !!pass, detail: detail || null };
+          if (!row.pass && trace !== null && trace !== undefined) {
+            row.trace = trace;
+          }
+          __checks.push(row);
+        }
+  
+        function __finish() {
+          if (__reported) {
+            return;
+          }
+          const __failedChecks = __checks.filter((check) => !check.pass);
+          console.log('__AURA_CONFORMANCE_NATIVE__' + JSON.stringify({
+            caseId: 'draw2d-layout-widgets-runtime-native',
+            ok: __failedChecks.length === 0,
+            checks: __checks,
+            failed: __failedChecks.length,
+            passed: __checks.length - __failedChecks.length,
+            runtimeCacheDiagnostics: null,
+            runtimeInspectorSnapshot: null,
+          }));
+          __reported = true;
+          if (aura.window && typeof aura.window.close === 'function') {
+            aura.window.close();
+          }
+        }
+  
+        globalThis.__draw2dLayoutWidgetsProbe = {
+          frames: [],
+          musicValue: false,
+          volumeValue: 4,
+          invalidFocusReason: null,
+          invalidActivateReason: null,
+          invalidAdjustReason: null,
+          resetReason: null,
+        };
+  
+        aura.setup = function () {
+          try {
+            const methodsOk = ['beginLayout', 'label', 'button', 'toggle', 'slider', 'moveFocus', 'activate', 'adjustValue', 'endLayout', 'getFocusState', 'getWidgetState', 'reset', '__inspectorStats']
+              .every((name) => typeof aura.ui?.[name] === 'function')
+              && typeof aura.draw2d?.clear === 'function';
+            __record(
+              'draw2d.layout-widgets.surface.methods',
+              methodsOk,
+              methodsOk ? null : 'required_methods_missing',
+              methodsOk ? null : {
+                uiInspectorStats: typeof aura.ui?.__inspectorStats,
+                draw2dClear: typeof aura.draw2d?.clear,
+              },
+            );
+  
+            const probe = {
+              frames: [],
+              musicValue: false,
+              volumeValue: 4,
+              invalidFocusReason: aura.ui.moveFocus('sideways')?.reasonCode || null,
+              invalidActivateReason: aura.ui.activate('')?.reasonCode || null,
+              invalidAdjustReason: aura.ui.adjustValue('volume', 0)?.reasonCode || null,
+              resetReason: null,
+            };
+            globalThis.__draw2dLayoutWidgetsProbe = probe;
+            const setupOk = probe.invalidFocusReason === 'invalid_focus_direction'
+              && probe.invalidActivateReason === 'invalid_widget_target'
+              && probe.invalidAdjustReason === 'invalid_widget_delta';
+            __record(
+              'draw2d.layout-widgets.runtime.setup',
+              setupOk,
+              setupOk ? null : 'draw2d_layout_widgets_setup_failed',
+              setupOk ? null : { probe },
+            );
+  
+            aura.update = function () {};
+            aura.draw = function () {
+              const frameProbe = globalThis.__draw2dLayoutWidgetsProbe || {};
+              const frameIndex = Array.isArray(frameProbe.frames) ? frameProbe.frames.length : 0;
+  
+              if (frameIndex === 1) {
+                frameProbe.moveReason = aura.ui.moveFocus('next')?.reasonCode || null;
+              } else if (frameIndex === 2) {
+                frameProbe.activateReason = aura.ui.activate()?.reasonCode || null;
+              } else if (frameIndex === 3) {
+                frameProbe.moveReason2 = aura.ui.moveFocus('next')?.reasonCode || null;
+              } else if (frameIndex === 4) {
+                frameProbe.adjustReason = aura.ui.adjustValue(1)?.reasonCode || null;
+              } else if (frameIndex === 5) {
+                frameProbe.resetReason = aura.ui.reset('menu')?.reasonCode || null;
+              }
+  
+              aura.draw2d.clear(6, 8, 12);
+              const start = aura.ui.beginLayout({ id: 'menu', x: 8, y: 12, direction: 'vertical', gap: 4 });
+              const title = aura.ui.label('title', { text: 'Main Menu', width: 120, height: 20 });
+              const play = aura.ui.button('play', { label: 'Play', width: 120, height: 24 });
+              const music = aura.ui.toggle('music', { label: 'Music', width: 120, height: 24, value: frameProbe.musicValue });
+              const volume = aura.ui.slider('volume', { label: 'Volume', width: 120, height: 24, min: 0, max: 10, step: 2, value: frameProbe.volumeValue });
+              const end = aura.ui.endLayout();
+              const focus = aura.ui.getFocusState('menu');
+              const playState = aura.ui.getWidgetState('play', 'menu');
+              const musicState = aura.ui.getWidgetState('music', 'menu');
+              const volumeState = aura.ui.getWidgetState('volume', 'menu');
+              const inspect = aura.ui.__inspectorStats();
+  
+              frameProbe.musicValue = musicState?.value ?? frameProbe.musicValue;
+              frameProbe.volumeValue = volumeState?.value ?? frameProbe.volumeValue;
+              frameProbe.frames.push({
+                frameIndex,
+                startReason: start?.reasonCode || null,
+                titleReason: title?.reasonCode || null,
+                playReason: play?.reasonCode || null,
+                musicReason: music?.reasonCode || null,
+                volumeReason: volume?.reasonCode || null,
+                endReason: end?.reasonCode || null,
+                focusedId: focus?.focusedId || null,
+                focusedIndex: Number(focus?.focusedIndex ?? -1),
+                playFocused: playState?.focused === true,
+                musicFocused: musicState?.focused === true,
+                musicActivated: musicState?.activated === true,
+                musicToggled: musicState?.toggled === true,
+                musicValue: musicState?.value ?? null,
+                musicStateReason: musicState?.reasonCode || null,
+                volumeFocused: volumeState?.focused === true,
+                volumeValue: volumeState?.value ?? null,
+                volumeStateReason: volumeState?.reasonCode || null,
+                inspect,
+              });
+  
+              if (frameProbe.frames.length < 6) {
+                return;
+              }
+  
+              const frames = frameProbe.frames;
+              const frame0 = frames[0] || {};
+              const frame1 = frames[1] || {};
+              const frame2 = frames[2] || {};
+              const frame3 = frames[3] || {};
+              const frame4 = frames[4] || {};
+              const frame5 = frames[5] || {};
+              const evidenceOk = frameProbe.invalidFocusReason === 'invalid_focus_direction'
+                && frameProbe.invalidActivateReason === 'invalid_widget_target'
+                && frameProbe.invalidAdjustReason === 'invalid_widget_delta'
+                && frameProbe.moveReason === 'ui_focus_move_requested'
+                && frameProbe.activateReason === 'ui_widget_activation_requested'
+                && frameProbe.moveReason2 === 'ui_focus_move_requested'
+                && frameProbe.adjustReason === 'ui_widget_adjust_requested'
+                && frameProbe.resetReason === 'ui_focus_reset'
+                && frames.length === 6
+                && frame0.startReason === 'ui_layout_started'
+                && frame0.titleReason === 'ui_label_registered'
+                && frame0.playReason === 'ui_button_registered'
+                && frame0.musicReason === 'ui_toggle_registered'
+                && frame0.volumeReason === 'ui_slider_registered'
+                && frame0.endReason === 'ui_focus_initialized'
+                && frame0.focusedId === 'play'
+                && frame0.focusedIndex === 0
+                && frame0.playFocused === true
+                && frame0.musicValue === false
+                && frame0.volumeValue === 4
+                && frame0.inspect?.widgetCount === 4
+                && frame0.inspect?.focusableCount === 3
+                && frame0.inspect?.focusedWidgetId === 'play'
+                && frame0.inspect?.lastReasonCode === 'ui_focus_initialized'
+                && frame1.endReason === 'ui_focus_advanced'
+                && frame1.focusedId === 'music'
+                && frame1.focusedIndex === 1
+                && frame1.musicFocused === true
+                && frame1.inspect?.focusedWidgetId === 'music'
+                && frame1.inspect?.lastReasonCode === 'ui_focus_advanced'
+                && frame2.endReason === 'ui_layout_committed'
+                && frame2.focusedId === 'music'
+                && frame2.focusedIndex === 1
+                && frame2.musicFocused === true
+                && frame2.musicActivated === true
+                && frame2.musicToggled === true
+                && frame2.musicValue === true
+                && frame2.musicStateReason === 'ui_toggle_changed'
+                && frame2.inspect?.activatedWidgetId === 'music'
+                && Array.isArray(frame2.inspect?.changedWidgetIds)
+                && frame2.inspect.changedWidgetIds.includes('music')
+                && frame2.inspect?.lastWidgetReasonCode === 'ui_toggle_changed'
+                && frame3.endReason === 'ui_focus_advanced'
+                && frame3.focusedId === 'volume'
+                && frame3.focusedIndex === 2
+                && frame3.volumeFocused === true
+                && frame3.inspect?.focusedWidgetId === 'volume'
+                && frame3.inspect?.lastReasonCode === 'ui_focus_advanced'
+                && frame4.endReason === 'ui_layout_committed'
+                && frame4.focusedId === 'volume'
+                && frame4.focusedIndex === 2
+                && frame4.volumeFocused === true
+                && frame4.volumeValue === 6
+                && frame4.volumeStateReason === 'ui_slider_changed'
+                && Array.isArray(frame4.inspect?.changedWidgetIds)
+                && frame4.inspect.changedWidgetIds.includes('volume')
+                && frame4.inspect?.lastWidgetReasonCode === 'ui_slider_changed'
+                && frame5.endReason === 'ui_focus_initialized'
+                && frame5.focusedId === 'play'
+                && frame5.focusedIndex === 0
+                && frame5.playFocused === true
+                && frame5.musicValue === true
+                && frame5.volumeValue === 6
+                && frame5.inspect?.focusedWidgetId === 'play'
+                && frame5.inspect?.lastReasonCode === 'ui_focus_initialized';
+              __record(
+                'draw2d.layout-widgets.runtime.evidence',
+                evidenceOk,
+                evidenceOk ? null : 'draw2d_layout_widgets_evidence_failed',
+                evidenceOk ? null : { probe: frameProbe },
+              );
+              __finish();
+            };
+          } catch (__error) {
+            __record('draw2d.layout-widgets.runtime.setup', false, __toErrorString(__error), {
+              probe: globalThis.__draw2dLayoutWidgetsProbe || null,
+            });
+            __finish();
+          }
+        };
+      `,
+    },
+  {
+      id: 'draw2d-compositor-fx-runtime-native',
+      modes: ['native'],
+      namespaces: ['draw2d', 'debug'],
+      functions: [
+        'aura.draw2d.clear',
+        'aura.draw2d.createRenderTarget',
+        'aura.draw2d.destroyRenderTarget',
+        'aura.draw2d.withRenderTargets',
+        'aura.draw2d.sprite',
+        'aura.draw2d.spriteFx',
+        'aura.draw2d.rectFill',
+        'aura.debug.inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.compositor-fx.surface.methods',
+          expression: "(() => ['clear','createRenderTarget','destroyRenderTarget','withRenderTargets','sprite','spriteFx','rectFill'].every((name) => typeof aura.draw2d?.[name] === 'function') && typeof aura.debug?.inspectorStats === 'function')()",
+        },
+        {
+          id: 'draw2d.compositor-fx.runtime.setup',
+          expression: `(() => { try { const rtA = aura.draw2d.createRenderTarget(32, 16); const rtB = aura.draw2d.createRenderTarget(48, 24); globalThis.__draw2dCompositorFxProbe = { rtA, rtB, frames: [] }; return rtA?.ok === true && rtB?.ok === true && rtA?.type === 'renderTarget' && rtB?.type === 'renderTarget' && rtA?.__renderTarget === true && rtB?.__renderTarget === true && Number.isInteger(rtA?.handle) && Number.isInteger(rtB?.handle) && rtA.handle !== rtB.handle; } catch (_) { return false; } })()`,
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw2d.compositor-fx.runtime.evidence',
+          expression: `(() => { try { const probe = globalThis.__draw2dCompositorFxProbe || {}; const frames = Array.isArray(probe.frames) ? probe.frames : []; const frame0 = frames[0] || {}; const frame1 = frames[1] || {}; const frame2 = frames[2] || {}; const destroyA = aura.draw2d.destroyRenderTarget(probe.rtA); const destroyB = aura.draw2d.destroyRenderTarget(probe.rtB); const missingDestroy = aura.draw2d.destroyRenderTarget(probe.rtB); return frames.length === 3 && frame0.duplicateReason === 'duplicate_render_target_stage' && frame0.invalidFxHandleReason === 'invalid_sprite_fx_source_handle' && frame0.missingShadowReason === 'missing_sprite_fx_effect' && frame0.graphReason === 'draw2d_render_targets_captured' && frame0.stageCount === 2 && frame0.commandCount === 5 && frame0.handlesLength === 2 && frame0.fxQueueReason === 'draw2d_sprite_fx_queued' && frame0.submittedFxDrawCount === 1 && frame0.pendingFxCommandCount === 1 && frame0.lastSubmittedFxCommandCount === 0 && frame0.lastExecutedFxCommandCount === 0 && frame0.lastReasonCode === 'draw2d_fx_idle' && frame0.lastOk === true && frame1.pendingFxCommandCount === 0 && frame1.lastSubmittedFxCommandCount === 1 && frame1.lastExecutedFxCommandCount === 1 && frame1.lastReasonCode === 'draw2d_fx_executed' && frame1.lastOk === true && frame2.pendingFxCommandCount === 0 && frame2.lastSubmittedFxCommandCount === 0 && frame2.lastExecutedFxCommandCount === 0 && frame2.lastReasonCode === 'draw2d_fx_idle' && frame2.lastOk === true && destroyA?.ok === true && destroyA?.reasonCode === 'draw2d_render_target_destroyed' && destroyB?.ok === true && destroyB?.reasonCode === 'draw2d_render_target_destroyed' && missingDestroy?.ok === false && missingDestroy?.reasonCode === 'missing_render_target'; } catch (_) { return false; } })()`,
+        },
+      ],
+      nativeFrames: 3,
+      source: `
+        globalThis.__draw2dCompositorFxProbe = {
+          rtA: null,
+          rtB: null,
+          frames: [],
+        };
+      `,
+      nativeSource: `
+        const __checks = [];
+        let __reported = false;
+  
+        function __toErrorString(value) {
+          return String(value && value.message ? value.message : value);
+        }
+  
+        function __record(id, pass, detail, trace = null) {
+          const row = { id, pass: !!pass, detail: detail || null };
+          if (!row.pass && trace !== null && trace !== undefined) {
+            row.trace = trace;
+          }
+          __checks.push(row);
+        }
+  
+        function __finish() {
+          if (__reported) {
+            return;
+          }
+          const __failedChecks = __checks.filter((check) => !check.pass);
+          console.log('__AURA_CONFORMANCE_NATIVE__' + JSON.stringify({
+            caseId: 'draw2d-compositor-fx-runtime-native',
+            ok: __failedChecks.length === 0,
+            checks: __checks,
+            failed: __failedChecks.length,
+            passed: __checks.length - __failedChecks.length,
+            runtimeCacheDiagnostics: null,
+            runtimeInspectorSnapshot: null,
+          }));
+          __reported = true;
+          if (aura.window && typeof aura.window.close === 'function') {
+            aura.window.close();
+          }
+        }
+  
+        globalThis.__draw2dCompositorFxProbe = {
+          rtA: null,
+          rtB: null,
+          frames: [],
+        };
+  
+        aura.setup = function () {
+          try {
+            const methodsOk = ['clear', 'createRenderTarget', 'destroyRenderTarget', 'withRenderTargets', 'sprite', 'spriteFx', 'rectFill']
+              .every((name) => typeof aura.draw2d?.[name] === 'function')
+              && typeof aura.debug?.inspectorStats === 'function';
+            __record(
+              'draw2d.compositor-fx.surface.methods',
+              methodsOk,
+              methodsOk ? null : 'required_methods_missing',
+              methodsOk ? null : {
+                draw2d: {
+                  clear: typeof aura.draw2d?.clear,
+                  createRenderTarget: typeof aura.draw2d?.createRenderTarget,
+                  destroyRenderTarget: typeof aura.draw2d?.destroyRenderTarget,
+                  withRenderTargets: typeof aura.draw2d?.withRenderTargets,
+                  sprite: typeof aura.draw2d?.sprite,
+                  spriteFx: typeof aura.draw2d?.spriteFx,
+                  rectFill: typeof aura.draw2d?.rectFill,
+                },
+                debugInspectorStats: typeof aura.debug?.inspectorStats,
+              },
+            );
+  
+            const rtA = aura.draw2d.createRenderTarget(32, 16);
+            const rtB = aura.draw2d.createRenderTarget(48, 24);
+            const probe = { rtA, rtB, frames: [] };
+            globalThis.__draw2dCompositorFxProbe = probe;
+            const setupOk = rtA?.ok === true
+              && rtB?.ok === true
+              && rtA?.type === 'renderTarget'
+              && rtB?.type === 'renderTarget'
+              && rtA?.__renderTarget === true
+              && rtB?.__renderTarget === true
+              && Number.isInteger(rtA?.handle)
+              && Number.isInteger(rtB?.handle)
+              && rtA.handle !== rtB.handle;
+            __record(
+              'draw2d.compositor-fx.runtime.setup',
+              setupOk,
+              setupOk ? null : 'draw2d_compositor_fx_setup_failed',
+              setupOk ? null : { probe },
+            );
+  
+            aura.update = function () {};
+            aura.draw = function () {
+              const frameProbe = globalThis.__draw2dCompositorFxProbe || {};
+              const frameIndex = Array.isArray(frameProbe.frames) ? frameProbe.frames.length : 0;
+              const white = aura.Color?.WHITE || aura.colors?.white || aura.rgba(1, 1, 1, 1);
+  
+              aura.draw2d.clear(4, 6, 10);
+              let duplicate = null;
+              let invalidFxHandle = null;
+              let missingShadow = null;
+              let graph = null;
+              let fxQueued = null;
+  
+              if (frameIndex === 0) {
+                duplicate = aura.draw2d.withRenderTargets([
+                  { target: frameProbe.rtA, draw: () => {} },
+                  { target: frameProbe.rtA, draw: () => {} },
+                ]);
+                invalidFxHandle = aura.draw2d.spriteFx({ type: 'renderTarget', handle: 9999 }, 1, 2, {
+                  shadow: { offsetX: 1, offsetY: 1 },
+                });
+                missingShadow = aura.draw2d.spriteFx('hero.png', 1, 2, {});
+                graph = aura.draw2d.withRenderTargets([
+                  {
+                    target: frameProbe.rtA,
+                    draw: () => {
+                      aura.draw2d.clear(0, 0, 0, 0);
+                      aura.draw2d.rectFill(1, 2, 3, 4, white);
+                    },
+                  },
+                  {
+                    target: frameProbe.rtB,
+                    draw: () => {
+                      aura.draw2d.sprite(frameProbe.rtA, 0, 0, 16, 16);
+                      fxQueued = aura.draw2d.spriteFx(frameProbe.rtA, 8, 6, {
+                        width: 16,
+                        height: 12,
+                        shadow: { offsetX: 3, offsetY: 4 },
+                      });
+                    },
+                  },
+                ]);
+              }
+  
+              aura.draw2d.sprite(frameProbe.rtB, 8, 9, 64, 32);
+              const stats = aura.debug.inspectorStats() || {};
+              const fx = stats.draw2dRuntime?.fx || {};
+              frameProbe.frames.push({
+                frameIndex,
+                duplicateReason: duplicate?.reasonCode || null,
+                invalidFxHandleReason: invalidFxHandle?.reasonCode || null,
+                missingShadowReason: missingShadow?.reasonCode || null,
+                graphReason: graph?.reasonCode || null,
+                stageCount: Number(graph?.stageCount || 0),
+                commandCount: Number(graph?.commandCount || 0),
+                handlesLength: Array.isArray(graph?.handles) ? graph.handles.length : 0,
+                fxQueueReason: fxQueued?.reasonCode || null,
+                submittedFxDrawCount: Number(fxQueued?.submittedFxDrawCount || 0),
+                pendingFxCommandCount: Number(fx.pendingFxCommandCount || 0),
+                lastSubmittedFxCommandCount: Number(fx.lastSubmittedFxCommandCount || 0),
+                lastExecutedFxCommandCount: Number(fx.lastExecutedFxCommandCount || 0),
+                lastReasonCode: fx.lastReasonCode || null,
+                lastOk: fx.lastOk === true,
+              });
+  
+              if (frameProbe.frames.length < 3) {
+                return;
+              }
+  
+              const frames = frameProbe.frames;
+              const frame0 = frames[0] || {};
+              const frame1 = frames[1] || {};
+              const frame2 = frames[2] || {};
+              const destroyA = aura.draw2d.destroyRenderTarget(frameProbe.rtA);
+              const destroyB = aura.draw2d.destroyRenderTarget(frameProbe.rtB);
+              const missingDestroy = aura.draw2d.destroyRenderTarget(frameProbe.rtB);
+              const evidenceOk = frame0.duplicateReason === 'duplicate_render_target_stage'
+                && frame0.invalidFxHandleReason === 'invalid_sprite_fx_source_handle'
+                && frame0.missingShadowReason === 'missing_sprite_fx_effect'
+                && frame0.graphReason === 'draw2d_render_targets_captured'
+                && frame0.stageCount === 2
+                && frame0.commandCount === 5
+                && frame0.handlesLength === 2
+                && frame0.fxQueueReason === 'draw2d_sprite_fx_queued'
+                && frame0.submittedFxDrawCount === 1
+                && frame0.pendingFxCommandCount === 1
+                && frame0.lastSubmittedFxCommandCount === 0
+                && frame0.lastExecutedFxCommandCount === 0
+                && frame0.lastReasonCode === 'draw2d_fx_idle'
+                && frame0.lastOk === true
+                && frame1.graphReason === null
+                && frame1.pendingFxCommandCount === 0
+                && frame1.lastSubmittedFxCommandCount === 1
+                && frame1.lastExecutedFxCommandCount === 1
+                && frame1.lastReasonCode === 'draw2d_fx_executed'
+                && frame1.lastOk === true
+                && frame2.graphReason === null
+                && frame2.pendingFxCommandCount === 0
+                && frame2.lastSubmittedFxCommandCount === 0
+                && frame2.lastExecutedFxCommandCount === 0
+                && frame2.lastReasonCode === 'draw2d_fx_idle'
+                && frame2.lastOk === true
+                && destroyA?.ok === true
+                && destroyA?.reasonCode === 'draw2d_render_target_destroyed'
+                && destroyB?.ok === true
+                && destroyB?.reasonCode === 'draw2d_render_target_destroyed'
+                && missingDestroy?.ok === false
+                && missingDestroy?.reasonCode === 'missing_render_target';
+              __record(
+                'draw2d.compositor-fx.runtime.evidence',
+                evidenceOk,
+                evidenceOk ? null : 'draw2d_compositor_fx_evidence_failed',
+                evidenceOk ? null : { probe: frameProbe, destroyA, destroyB, missingDestroy },
+              );
+              __finish();
+            };
+          } catch (__error) {
+            __record('draw2d.compositor-fx.runtime.setup', false, __toErrorString(__error), {
+              probe: globalThis.__draw2dCompositorFxProbe || null,
+            });
+            __finish();
+          }
+        };
+      `,
+    },
+  {
+      id: 'draw2d-advanced-mask-runtime-native',
+      modes: ['native'],
+      namespaces: ['draw2d', 'debug'],
+      functions: [
+        'aura.draw2d.clear',
+        'aura.draw2d.withMask',
+        'aura.draw2d.rectFill',
+        'aura.draw2d.circleFill',
+        'aura.draw2d.text',
+        'aura.debug.inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.advanced-mask.surface.methods',
+          expression: "(() => ['clear','withMask','rectFill','circleFill','text'].every((name) => typeof aura.draw2d?.[name] === 'function') && typeof aura.debug?.inspectorStats === 'function')()",
+        },
+        {
+          id: 'draw2d.advanced-mask.runtime.setup',
+          expression: "(() => true)()",
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw2d.advanced-mask.runtime.evidence',
+          expression: "(() => { try { const probe = globalThis.__draw2dAdvancedMaskProbe || {}; return Array.isArray(probe.frames) && probe.frames.length === 3; } catch (_) { return false; } })()",
+        },
+      ],
+      nativeFrames: 3,
+      source: `
+        globalThis.__draw2dAdvancedMaskProbe = {
+          frames: [],
+        };
+      `,
+      nativeSource: `
+        const __checks = [];
+        let __reported = false;
+  
+        function __toErrorString(value) {
+          return String(value && value.message ? value.message : value);
+        }
+  
+        function __record(id, pass, detail, trace = null) {
+          const row = { id, pass: !!pass, detail: detail || null };
+          if (!row.pass && trace !== null && trace !== undefined) {
+            row.trace = trace;
+          }
+          __checks.push(row);
+        }
+  
+        function __finish() {
+          if (__reported) {
+            return;
+          }
+          const __failedChecks = __checks.filter((check) => !check.pass);
+          console.log('__AURA_CONFORMANCE_NATIVE__' + JSON.stringify({
+            caseId: 'draw2d-advanced-mask-runtime-native',
+            ok: __failedChecks.length === 0,
+            checks: __checks,
+            failed: __failedChecks.length,
+            passed: __checks.length - __failedChecks.length,
+            runtimeCacheDiagnostics: null,
+            runtimeInspectorSnapshot: null,
+          }));
+          __reported = true;
+          if (aura.window && typeof aura.window.close === 'function') {
+            aura.window.close();
+          }
+        }
+  
+        globalThis.__draw2dAdvancedMaskProbe = {
+          frames: [],
+        };
+  
+        aura.setup = function () {
+          try {
+            const methodsOk = ['clear', 'withMask', 'rectFill', 'circleFill', 'text']
+              .every((name) => typeof aura.draw2d?.[name] === 'function')
+              && typeof aura.debug?.inspectorStats === 'function';
+            __record('draw2d.advanced-mask.surface.methods', methodsOk, methodsOk ? null : 'required_methods_missing');
+            __record('draw2d.advanced-mask.runtime.setup', true, null);
+  
+            aura.update = function () {};
+            aura.draw = function () {
+              const probe = globalThis.__draw2dAdvancedMaskProbe || {};
+              const frameIndex = Array.isArray(probe.frames) ? probe.frames.length : 0;
+              const white = aura.Color?.WHITE || aura.colors?.white || aura.rgba(1, 1, 1, 1);
+  
+              aura.draw2d.clear(6, 8, 12);
+  
+              let invalidShape = null;
+              let invalidFeather = null;
+              let masked = null;
+  
+              if (frameIndex === 0) {
+                invalidShape = aura.draw2d.withMask({ type: 'analytic', shape: 'triangle' }, 0, 0, 8, 8, () => {});
+                invalidFeather = aura.draw2d.withMask({ type: 'analytic', shape: 'circle', feather: -0.5 }, 0, 0, 8, 8, () => {});
+                masked = aura.draw2d.withMask(
+                  { type: 'analytic', shape: 'circle', feather: 0.25 },
+                  18,
+                  14,
+                  88,
+                  88,
+                  () => {
+                    aura.draw2d.rectFill(14, 12, 96, 72, aura.rgba(0.18, 0.32, 0.55, 0.94));
+                    aura.draw2d.circleFill(62, 48, 18, aura.rgba(0.96, 0.82, 0.28, 0.92));
+                    aura.draw2d.text('MASK', 34, 40, { size: 12, color: white });
+                  },
+                  { invert: true },
+                );
+              }
+  
+              const stats = aura.debug.inspectorStats() || {};
+              const masking = stats.draw2dRuntime?.masking || {};
+              probe.frames.push({
+                frameIndex,
+                invalidShapeReason: invalidShape?.reasonCode || null,
+                invalidFeatherReason: invalidFeather?.reasonCode || null,
+                maskedReason: masked?.reasonCode || null,
+                maskedCommandCount: Number(masked?.commandCount || 0),
+                maskKind: masked?.maskKind || null,
+                maskShape: masked?.maskShape || null,
+                maskFeather: Number(masked?.maskFeather || 0),
+                pendingPassCount: Number(masking.pendingPassCount || 0),
+                pendingAdvancedPassCount: Number(masking.pendingAdvancedPassCount || 0),
+                lastSubmittedPassCount: Number(masking.lastSubmittedPassCount || 0),
+                lastExecutedPassCount: Number(masking.lastExecutedPassCount || 0),
+                lastSubmittedCommandCount: Number(masking.lastSubmittedCommandCount || 0),
+                lastReasonCode: masking.lastReasonCode || null,
+                lastOk: masking.lastOk === true,
+                lastRequestedMaskKind: masking.lastRequestedMaskKind || null,
+                lastRequestedMaskShape: masking.lastRequestedMaskShape || null,
+                lastRequestedMaskFeather: Number(masking.lastRequestedMaskFeather || 0),
+              });
+  
+              if (probe.frames.length < 3) {
+                return;
+              }
+  
+              const frames = probe.frames;
+              const frame0 = frames[0] || {};
+              const frame1 = frames[1] || {};
+              const frame2 = frames[2] || {};
+              const evidenceOk = frame0.invalidShapeReason === 'unsupported_mask_shape'
+                && frame0.invalidFeatherReason === 'invalid_mask_feather'
+                && frame0.maskedReason === 'draw2d_mask_captured'
+                && frame0.maskedCommandCount === 3
+                && frame0.maskKind === 'analytic'
+                && frame0.maskShape === 'circle'
+                && Math.abs(frame0.maskFeather - 0.25) < 1e-6
+                && frame0.pendingPassCount === 1
+                && frame0.pendingAdvancedPassCount === 1
+                && frame0.lastSubmittedPassCount === 0
+                && frame0.lastExecutedPassCount === 0
+                && frame0.lastSubmittedCommandCount === 0
+                && frame0.lastReasonCode === 'draw2d_mask_idle'
+                && frame0.lastOk === true
+                && frame0.lastRequestedMaskKind === 'analytic'
+                && frame0.lastRequestedMaskShape === 'circle'
+                && Math.abs(frame0.lastRequestedMaskFeather - 0.25) < 1e-6
+                && frame1.maskedReason === null
+                && frame1.pendingPassCount === 0
+                && frame1.pendingAdvancedPassCount === 0
+                && frame1.lastSubmittedPassCount === 1
+                && frame1.lastExecutedPassCount === 1
+                && frame1.lastSubmittedCommandCount === 3
+                && frame1.lastReasonCode === 'draw2d_mask_executed'
+                && frame1.lastOk === true
+                && frame2.maskedReason === null
+                && frame2.pendingPassCount === 0
+                && frame2.pendingAdvancedPassCount === 0
+                && frame2.lastSubmittedPassCount === 0
+                && frame2.lastExecutedPassCount === 0
+                && frame2.lastSubmittedCommandCount === 0
+                && frame2.lastReasonCode === 'draw2d_mask_idle'
+                && frame2.lastOk === true;
+              __record(
+                'draw2d.advanced-mask.runtime.evidence',
+                evidenceOk,
+                evidenceOk ? null : 'draw2d_advanced_mask_evidence_failed',
+                evidenceOk ? null : { probe },
+              );
+              __finish();
+            };
+          } catch (__error) {
+            __record('draw2d.advanced-mask.runtime.setup', false, __toErrorString(__error), {
+              probe: globalThis.__draw2dAdvancedMaskProbe || null,
+            });
+            __finish();
+          }
+        };
+      `,
+    },
+  {
+      id: 'draw2d-retained-ui-runtime-native',
+      modes: ['native'],
+      namespaces: ['ui', 'draw2d'],
+      functions: [
+        'aura.draw2d.clear',
+        'aura.ui.beginContainer',
+        'aura.ui.region',
+        'aura.ui.selectOption',
+        'aura.ui.endContainer',
+        'aura.ui.getContainerState',
+        'aura.ui.getRegionState',
+        'aura.ui.getScrollState',
+        'aura.ui.scrollBy',
+        'aura.ui.getSelectionState',
+        'aura.ui.activate',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.retained-ui.surface.methods',
+          expression: "(() => ['clear'].every((name) => typeof aura.draw2d?.[name] === 'function') && ['beginContainer','region','selectOption','endContainer','getContainerState','getRegionState','getScrollState','scrollBy','getSelectionState','activate'].every((name) => typeof aura.ui?.[name] === 'function'))()",
+        },
+        {
+          id: 'draw2d.retained-ui.runtime.setup',
+          expression: "(() => true)()",
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw2d.retained-ui.runtime.evidence',
+          expression: "(() => { try { const probe = globalThis.__draw2dRetainedUiProbe || {}; return Array.isArray(probe.frames) && probe.frames.length === 4; } catch (_) { return false; } })()",
+        },
+      ],
+      nativeFrames: 4,
+      source: `
+        globalThis.__draw2dRetainedUiProbe = {
+          frames: [],
+          selectedRegionId: null,
+        };
+      `,
+      nativeSource: `
+        const __checks = [];
+        let __reported = false;
+  
+        function __toErrorString(value) {
+          return String(value && value.message ? value.message : value);
+        }
+  
+        function __record(id, pass, detail, trace = null) {
+          const row = { id, pass: !!pass, detail: detail || null };
+          if (!row.pass && trace !== null && trace !== undefined) {
+            row.trace = trace;
+          }
+          __checks.push(row);
+        }
+  
+        function __finish() {
+          if (__reported) {
+            return;
+          }
+          const __failedChecks = __checks.filter((check) => !check.pass);
+          console.log('__AURA_CONFORMANCE_NATIVE__' + JSON.stringify({
+            caseId: 'draw2d-retained-ui-runtime-native',
+            ok: __failedChecks.length === 0,
+            checks: __checks,
+            failed: __failedChecks.length,
+            passed: __checks.length - __failedChecks.length,
+            runtimeCacheDiagnostics: null,
+            runtimeInspectorSnapshot: null,
+          }));
+          __reported = true;
+          if (aura.window && typeof aura.window.close === 'function') {
+            aura.window.close();
+          }
+        }
+  
+        globalThis.__draw2dRetainedUiProbe = {
+          frames: [],
+          selectedRegionId: null,
+        };
+  
+        function __runUiFrame(frameIndex) {
+          const probe = globalThis.__draw2dRetainedUiProbe || {};
+          let scrollByResult = null;
+          let activateResult = null;
+  
+          if (frameIndex === 1) {
+            scrollByResult = aura.ui.scrollBy('inventory', 0, 18);
+          }
+  
+          const begin = aura.ui.beginContainer({
+            id: 'inventory',
+            x: 18,
+            y: 12,
+            width: 84,
+            height: 36,
+            direction: 'vertical',
+            gap: 4,
+            padding: 2,
+          });
+          const header = aura.ui.region('header', { width: 76, height: 12 });
+          const sword = aura.ui.selectOption('sword', {
+            label: 'Sword',
+            value: 'sword',
+            width: 76,
+            height: 12,
+            selected: probe.selectedRegionId === 'sword',
+          });
+          const shield = aura.ui.selectOption('shield', {
+            label: 'Shield',
+            value: 'shield',
+            width: 76,
+            height: 12,
+            selected: probe.selectedRegionId === 'shield',
+          });
+          const potion = aura.ui.selectOption('potion', {
+            label: 'Potion',
+            value: 'potion',
+            width: 76,
+            height: 12,
+            selected: probe.selectedRegionId === 'potion',
+          });
+          if (frameIndex === 2) {
+            activateResult = aura.ui.activate('shield');
+          }
+          const end = aura.ui.endContainer();
+          const container = aura.ui.getContainerState('inventory');
+          const headerState = aura.ui.getRegionState('header', 'inventory');
+          const shieldState = aura.ui.getRegionState('shield', 'inventory');
+          const scroll = aura.ui.getScrollState('inventory');
+          const selection = aura.ui.getSelectionState('inventory');
+  
+          probe.selectedRegionId = selection && selection.selectedRegionId
+            ? selection.selectedRegionId
+            : null;
+  
+          return {
+            begin,
+            header,
+            sword,
+            shield,
+            potion,
+            end,
+            container,
+            headerState,
+            shieldState,
+            scroll,
+            selection,
+            scrollByResult,
+            activateResult,
+          };
+        }
+  
+        aura.setup = function () {
+          try {
+            const methodsOk = ['clear'].every((name) => typeof aura.draw2d?.[name] === 'function')
+              && ['beginContainer', 'region', 'selectOption', 'endContainer', 'getContainerState', 'getRegionState', 'getScrollState', 'scrollBy', 'getSelectionState', 'activate']
+                .every((name) => typeof aura.ui?.[name] === 'function');
+            __record('draw2d.retained-ui.surface.methods', methodsOk, methodsOk ? null : 'required_methods_missing');
+            __record('draw2d.retained-ui.runtime.setup', true, null);
+  
+            aura.update = function () {};
+            aura.draw = function () {
+              const probe = globalThis.__draw2dRetainedUiProbe || {};
+              const frameIndex = Array.isArray(probe.frames) ? probe.frames.length : 0;
+  
+              aura.draw2d.clear(8, 10, 14);
+              const uiState = __runUiFrame(frameIndex);
+  
+              probe.frames.push({
+                frameIndex,
+                beginReason: uiState.begin?.reasonCode || null,
+                endReason: uiState.end?.reasonCode || null,
+                containerFocusedRegionId: uiState.container?.focusedRegionId || null,
+                regionCount: Number(uiState.container?.regionCount || 0),
+                optionCount: Number(uiState.container?.optionCount || 0),
+                scrollY: Number(uiState.scroll?.scrollY || 0),
+                maxScrollY: Number(uiState.scroll?.maxScrollY || 0),
+                scrollReason: uiState.scroll?.lastReasonCode || null,
+                scrollByReason: uiState.scrollByResult?.reasonCode || null,
+                selectedRegionId: uiState.selection?.selectedRegionId || null,
+                selectedValue: uiState.selection?.selectedValue || null,
+                activatedRegionId: uiState.selection?.activatedRegionId || null,
+                selectionReason: uiState.selection?.lastReasonCode || null,
+                activateReason: uiState.activateResult?.reasonCode || null,
+                headerFocused: uiState.headerState?.focused === true,
+                shieldSelected: uiState.shieldState?.selected === true,
+                shieldActivated: uiState.shieldState?.activated === true,
+              });
+  
+              if (probe.frames.length < 4) {
+                return;
+              }
+  
+              const frames = probe.frames;
+              const frame0 = frames[0] || {};
+              const frame1 = frames[1] || {};
+              const frame2 = frames[2] || {};
+              const frame3 = frames[3] || {};
+              const evidenceOk = frame0.beginReason === 'ui_container_started'
+                && frame0.endReason === 'ui_container_focus_initialized'
+                && frame0.containerFocusedRegionId === 'header'
+                && frame0.regionCount === 4
+                && frame0.optionCount === 3
+                && frame0.scrollY === 0
+                && frame0.maxScrollY > 0
+                && frame0.selectedRegionId === null
+                && frame0.selectionReason === 'ui_select_idle'
+                && frame0.headerFocused === true
+                && frame1.scrollByReason === 'ui_scroll_updated'
+                && frame1.scrollY === 18
+                && frame1.scrollReason === 'ui_scroll_updated'
+                && frame1.selectedRegionId === null
+                && frame2.activateReason === 'ui_widget_activation_requested'
+                && frame2.selectedRegionId === 'shield'
+                && frame2.selectedValue === 'shield'
+                && frame2.activatedRegionId === 'shield'
+                && frame2.selectionReason === 'ui_option_selected'
+                && frame2.shieldSelected === true
+                && frame2.shieldActivated === true
+                && frame3.selectedRegionId === 'shield'
+                && frame3.selectedValue === 'shield'
+                && frame3.selectionReason === 'ui_select_idle'
+                && frame3.shieldSelected === true;
+              __record(
+                'draw2d.retained-ui.runtime.evidence',
+                evidenceOk,
+                evidenceOk ? null : 'draw2d_retained_ui_evidence_failed',
+                evidenceOk ? null : { probe },
+              );
+              __finish();
+            };
+          } catch (__error) {
+            __record('draw2d.retained-ui.runtime.setup', false, __toErrorString(__error), {
+              probe: globalThis.__draw2dRetainedUiProbe || null,
+            });
+            __finish();
+          }
+        };
+      `,
+    },
+  {
+      id: 'draw2d-ui-dom-runtime-native',
+      modes: ['native'],
+      namespaces: ['ui', 'draw2d'],
+      functions: [
+        'aura.draw2d.clear',
+        'aura.ui.setTheme',
+        'aura.ui.getTheme',
+        'aura.ui.beginView',
+        'aura.ui.endView',
+        'aura.ui.beginRow',
+        'aura.ui.endRow',
+        'aura.ui.beginColumn',
+        'aura.ui.endColumn',
+        'aura.ui.text',
+        'aura.ui.button',
+        'aura.ui.moveFocus',
+        'aura.ui.activate',
+        'aura.ui.getViewState',
+        'aura.ui.reset',
+        'aura.ui.__inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.ui-dom.surface.methods',
+          expression: "(() => ['clear'].every((name) => typeof aura.draw2d?.[name] === 'function') && ['setTheme','getTheme','beginView','endView','beginRow','endRow','beginColumn','endColumn','text','button','moveFocus','activate','getViewState','reset','__inspectorStats'].every((name) => typeof aura.ui?.[name] === 'function'))()",
+        },
+        {
+          id: 'draw2d.ui-dom.runtime.setup',
+          expression: "(() => { try { globalThis.__draw2dUiDomProbe = { frames: [], invalidThemeReason: null, invalidViewReason: null, theme: null, moveReason: null, activateReason: null, resetReason: null }; return true; } catch (_) { return false; } })()",
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw2d.ui-dom.runtime.evidence',
+          expression: "(() => { try { const probe = globalThis.__draw2dUiDomProbe || {}; const frames = Array.isArray(probe.frames) ? probe.frames : []; const frame0 = frames[0] || {}; const frame1 = frames[1] || {}; const frame2 = frames[2] || {}; const frame3 = frames[3] || {}; return probe.invalidThemeReason === 'invalid_ui_theme' && probe.invalidViewReason === 'invalid_view_options' && Number(probe.theme?.fontSize || 0) === 18 && Number(probe.theme?.buttonHeight || 0) === 34 && frames.length === 4 && frame0.viewNodeCount === 9 && frame0.focusedViewNodeId === 'start' && frame0.rowDirection === 'horizontal' && frame0.infoDirection === 'vertical' && frame0.actionsDirection === 'vertical' && frame1.moveReason === 'ui_focus_move_requested' && frame1.layoutReasonCode === 'ui_focus_advanced' && frame1.focusedViewNodeId === 'options' && frame2.activateReason === 'ui_widget_activation_requested' && frame2.optionsClicked === true && frame2.optionsReason === 'ui_button_activated' && frame2.clickedViewNodeId === 'options' && frame2.lastWidgetReasonCode === 'ui_button_activated' && frame3.resetReason === 'ui_focus_reset' && frame3.layoutReasonCode === 'ui_focus_initialized' && frame3.focusedViewNodeId === 'start'; } catch (_) { return false; } })()",
+        },
+      ],
+      nativeFrames: 4,
+      source: `
+        globalThis.__draw2dUiDomProbe = {
+          frames: [],
+          invalidThemeReason: null,
+          invalidViewReason: null,
+          theme: null,
+          moveReason: null,
+          activateReason: null,
+          resetReason: null,
+        };
+      `,
+      nativeSource: `
+        const __checks = [];
+        let __reported = false;
+  
+        function __toErrorString(value) {
+          return String(value && value.message ? value.message : value);
+        }
+  
+        function __record(id, pass, detail, trace = null) {
+          const row = { id, pass: !!pass, detail: detail || null };
+          if (!row.pass && trace !== null && trace !== undefined) {
+            row.trace = trace;
+          }
+          __checks.push(row);
+        }
+  
+        function __finish() {
+          if (__reported) {
+            return;
+          }
+          const __failedChecks = __checks.filter((check) => !check.pass);
+          console.log('__AURA_CONFORMANCE_NATIVE__' + JSON.stringify({
+            caseId: 'draw2d-ui-dom-runtime-native',
+            ok: __failedChecks.length === 0,
+            checks: __checks,
+            failed: __failedChecks.length,
+            passed: __checks.length - __failedChecks.length,
+            runtimeCacheDiagnostics: null,
+            runtimeInspectorSnapshot: null,
+          }));
+          __reported = true;
+          if (aura.window && typeof aura.window.close === 'function') {
+            aura.window.close();
+          }
+        }
+  
+        globalThis.__draw2dUiDomProbe = {
+          frames: [],
+          invalidThemeReason: null,
+          invalidViewReason: null,
+          theme: null,
+          moveReason: null,
+          activateReason: null,
+          resetReason: null,
+        };
+  
+        function __runUiFrame(frameIndex) {
+          const begin = aura.ui.beginView({
+            id: 'hud',
+            x: 24,
+            y: 20,
+            width: 280,
+            gap: 10,
+            padding: 12,
+            clip: true,
+            background: '#101820',
+            borderColor: '#4a6a88',
+          });
+          const title = aura.ui.text('title', {
+            text: 'Command Deck',
+            size: 18,
+            color: '#f5f8ff',
+          });
+          const row = aura.ui.beginRow({ id: 'contentRow', gap: 12 });
+          const infoCol = aura.ui.beginColumn({ id: 'infoCol', width: 136, gap: 4 });
+          const statA = aura.ui.text('statA', { text: 'Crew Ready', color: '#9bc0e8' });
+          const statB = aura.ui.text('statB', { text: 'UI DOM Proof', color: '#b8d5f4' });
+          const endInfo = aura.ui.endColumn();
+          const actionsCol = aura.ui.beginColumn({ id: 'actionsCol', width: 'fill', gap: 6 });
+          const start = aura.ui.button('start', { label: 'Start Mission', width: 'fill' });
+          const options = aura.ui.button('options', { label: 'Options', width: 'fill' });
+          const endActions = aura.ui.endColumn();
+          const endRow = aura.ui.endRow();
+          const end = aura.ui.endView();
+  
+          return {
+            begin,
+            title,
+            row,
+            infoCol,
+            statA,
+            statB,
+            endInfo,
+            actionsCol,
+            start,
+            options,
+            endActions,
+            endRow,
+            end,
+            root: aura.ui.getViewState('hud'),
+            rowState: aura.ui.getViewState('contentRow'),
+            infoState: aura.ui.getViewState('infoCol'),
+            actionsState: aura.ui.getViewState('actionsCol'),
+            startState: aura.ui.getViewState('start'),
+            optionsState: aura.ui.getViewState('options'),
+            inspect: aura.ui.__inspectorStats(),
+          };
+        }
+  
+        aura.setup = function () {
+          try {
+            const methodsOk = ['clear'].every((name) => typeof aura.draw2d?.[name] === 'function')
+              && ['setTheme', 'getTheme', 'beginView', 'endView', 'beginRow', 'endRow', 'beginColumn', 'endColumn', 'text', 'button', 'moveFocus', 'activate', 'getViewState', 'reset', '__inspectorStats']
+                .every((name) => typeof aura.ui?.[name] === 'function');
+            __record('draw2d.ui-dom.surface.methods', methodsOk, methodsOk ? null : 'required_methods_missing');
+  
+            const themeResult = aura.ui.setTheme({
+              gap: 8,
+              padding: 12,
+              fontSize: 18,
+              buttonHeight: 34,
+              borderWidth: 1,
+              textColor: '#f5f8ff',
+              panelBorderColor: '#4a6a88',
+              buttonColor: '#213247',
+              buttonHoverColor: '#335577',
+              buttonFocusColor: '#245d9f',
+              buttonActiveColor: '#1177dd',
+              buttonTextColor: '#ffffff',
+            });
+  
+            const probe = globalThis.__draw2dUiDomProbe || {};
+            probe.invalidThemeReason = aura.ui.setTheme('bad')?.reasonCode || null;
+            probe.invalidViewReason = aura.ui.beginView('bad')?.reasonCode || null;
+            probe.theme = aura.ui.getTheme();
+  
+            const setupOk = themeResult?.ok === true
+              && themeResult?.reasonCode === 'ui_theme_updated'
+              && probe.invalidThemeReason === 'invalid_ui_theme'
+              && probe.invalidViewReason === 'invalid_view_options'
+              && Number(probe.theme?.fontSize || 0) === 18
+              && Number(probe.theme?.buttonHeight || 0) === 34;
+  
+            __record(
+              'draw2d.ui-dom.runtime.setup',
+              setupOk,
+              setupOk ? null : 'draw2d_ui_dom_setup_failed',
+              setupOk ? null : { themeResult, probe },
+            );
+  
+            aura.update = function () {};
+            aura.draw = function () {
+              const probe = globalThis.__draw2dUiDomProbe || {};
+              const frameIndex = Array.isArray(probe.frames) ? probe.frames.length : 0;
+  
+              if (frameIndex === 1) {
+                probe.moveReason = aura.ui.moveFocus('next')?.reasonCode || null;
+              } else if (frameIndex === 2) {
+                probe.activateReason = aura.ui.activate('options')?.reasonCode || null;
+              } else if (frameIndex === 3) {
+                probe.resetReason = aura.ui.reset('hud')?.reasonCode || null;
+              }
+  
+              aura.draw2d.clear(6, 8, 12);
+              const uiState = __runUiFrame(frameIndex);
+              probe.frames.push({
+                frameIndex,
+                moveReason: probe.moveReason || null,
+                activateReason: probe.activateReason || null,
+                resetReason: probe.resetReason || null,
+                beginReason: uiState.begin?.reasonCode || null,
+                titleReason: uiState.title?.reasonCode || null,
+                rowReason: uiState.row?.reasonCode || null,
+                infoReason: uiState.infoCol?.reasonCode || null,
+                endInfoReason: uiState.endInfo?.reasonCode || null,
+                actionsReason: uiState.actionsCol?.reasonCode || null,
+                endActionsReason: uiState.endActions?.reasonCode || null,
+                endRowReason: uiState.endRow?.reasonCode || null,
+                endReason: uiState.end?.reasonCode || null,
+                layoutReasonCode: uiState.end?.layoutReasonCode || null,
+                rootKind: uiState.root?.kind || null,
+                rowDirection: uiState.rowState?.direction || null,
+                infoDirection: uiState.infoState?.direction || null,
+                actionsDirection: uiState.actionsState?.direction || null,
+                startFocused: uiState.startState?.focused === true,
+                optionsFocused: uiState.optionsState?.focused === true,
+                optionsClicked: uiState.optionsState?.clicked === true,
+                optionsReason: uiState.optionsState?.reasonCode || null,
+                focusedViewNodeId: uiState.inspect?.focusedViewNodeId || null,
+                clickedViewNodeId: uiState.inspect?.clickedViewNodeId || null,
+                viewNodeCount: Number(uiState.inspect?.viewNodeCount || 0),
+                lastViewReasonCode: uiState.inspect?.lastViewReasonCode || null,
+                lastWidgetReasonCode: uiState.inspect?.lastWidgetReasonCode || null,
+              });
+  
+              if (probe.frames.length < 4) {
+                return;
+              }
+  
+              const frames = probe.frames;
+              const frame0 = frames[0] || {};
+              const frame1 = frames[1] || {};
+              const frame2 = frames[2] || {};
+              const frame3 = frames[3] || {};
+              const evidenceOk = probe.invalidThemeReason === 'invalid_ui_theme'
+                && probe.invalidViewReason === 'invalid_view_options'
+                && Number(probe.theme?.fontSize || 0) === 18
+                && Number(probe.theme?.buttonHeight || 0) === 34
+                && frames.length === 4
+                && frame0.beginReason === 'ui_view_started'
+                && frame0.titleReason === 'ui_text_registered'
+                && frame0.rowReason === 'ui_div_started'
+                && frame0.infoReason === 'ui_div_started'
+                && frame0.endInfoReason === 'ui_div_committed'
+                && frame0.actionsReason === 'ui_div_started'
+                && frame0.endActionsReason === 'ui_div_committed'
+                && frame0.endRowReason === 'ui_div_committed'
+                && frame0.endReason === 'ui_view_committed'
+                && frame0.layoutReasonCode === 'ui_focus_initialized'
+                && frame0.rootKind === 'view'
+                && frame0.rowDirection === 'horizontal'
+                && frame0.infoDirection === 'vertical'
+                && frame0.actionsDirection === 'vertical'
+                && frame0.startFocused === true
+                && frame0.focusedViewNodeId === 'start'
+                && frame0.viewNodeCount === 9
+                && frame0.lastViewReasonCode === 'ui_focus_initialized'
+                && frame1.moveReason === 'ui_focus_move_requested'
+                && frame1.layoutReasonCode === 'ui_focus_advanced'
+                && frame1.optionsFocused === true
+                && frame1.focusedViewNodeId === 'options'
+                && frame1.lastViewReasonCode === 'ui_focus_advanced'
+                && frame2.activateReason === 'ui_widget_activation_requested'
+                && frame2.layoutReasonCode === 'ui_layout_committed'
+                && frame2.optionsFocused === true
+                && frame2.optionsClicked === true
+                && frame2.optionsReason === 'ui_button_activated'
+                && frame2.clickedViewNodeId === 'options'
+                && frame2.lastWidgetReasonCode === 'ui_button_activated'
+                && frame3.resetReason === 'ui_focus_reset'
+                && frame3.layoutReasonCode === 'ui_focus_initialized'
+                && frame3.startFocused === true
+                && frame3.focusedViewNodeId === 'start'
+                && frame3.clickedViewNodeId === null;
+  
+              __record(
+                'draw2d.ui-dom.runtime.evidence',
+                evidenceOk,
+                evidenceOk ? null : 'draw2d_ui_dom_evidence_failed',
+                evidenceOk ? null : { probe },
+              );
+              __finish();
+            };
+          } catch (__error) {
+            __record('draw2d.ui-dom.runtime.setup', false, __toErrorString(__error), {
+              probe: globalThis.__draw2dUiDomProbe || null,
+            });
+            __finish();
+          }
+        };
+      `,
+    },
+  {
+      id: 'draw2d-ui-authored-widgets-runtime-native',
+      modes: ['native'],
+      namespaces: ['ui', 'draw2d'],
+      functions: [
+        'aura.draw2d.clear',
+        'aura.ui.setTheme',
+        'aura.ui.getTheme',
+        'aura.ui.beginView',
+        'aura.ui.endView',
+        'aura.ui.beginColumn',
+        'aura.ui.endColumn',
+        'aura.ui.text',
+        'aura.ui.toggle',
+        'aura.ui.slider',
+        'aura.ui.button',
+        'aura.ui.moveFocus',
+        'aura.ui.activate',
+        'aura.ui.adjustValue',
+        'aura.ui.getViewState',
+        'aura.ui.reset',
+        'aura.ui.__inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.ui-authored-widgets.surface.methods',
+          expression: "(() => ['clear'].every((name) => typeof aura.draw2d?.[name] === 'function') && ['setTheme','getTheme','beginView','endView','beginColumn','endColumn','text','toggle','slider','button','moveFocus','activate','adjustValue','getViewState','reset','__inspectorStats'].every((name) => typeof aura.ui?.[name] === 'function'))()",
+        },
+        {
+          id: 'draw2d.ui-authored-widgets.runtime.setup',
+          expression: "(() => { try { globalThis.__draw2dUiAuthoredWidgetsProbe = { frames: [], theme: null, invalidThemeReason: null, activateReason: null, moveReason: null, adjustReason: null, resetReason: null, musicValue: false, volumeValue: 4 }; return true; } catch (_) { return false; } })()",
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw2d.ui-authored-widgets.runtime.evidence',
+          expression: "(() => { try { const probe = globalThis.__draw2dUiAuthoredWidgetsProbe || {}; const frames = Array.isArray(probe.frames) ? probe.frames : []; const frame0 = frames[0] || {}; const frame1 = frames[1] || {}; const frame2 = frames[2] || {}; const frame3 = frames[3] || {}; const frame4 = frames[4] || {}; return probe.invalidThemeReason === 'invalid_ui_theme' && Number(probe.theme?.fontSize || 0) === 16 && Number(probe.theme?.buttonHeight || 0) === 34 && frames.length === 5 && frame0.beginReason === 'ui_view_started' && frame0.endReason === 'ui_view_committed' && frame0.layoutReasonCode === 'ui_focus_initialized' && frame0.rootKind === 'view' && frame0.controlsDirection === 'vertical' && frame0.musicFocused === true && frame0.musicValue === false && frame0.volumeValue === 4 && frame0.focusedViewNodeId === 'music' && frame0.viewNodeCount === 6 && frame1.activateReason === 'ui_widget_activation_requested' && frame1.layoutReasonCode === 'ui_layout_committed' && frame1.musicFocused === true && frame1.musicActivated === true && frame1.musicClicked === true && frame1.musicToggled === true && frame1.musicValue === true && frame1.musicReason === 'ui_toggle_changed' && frame1.clickedViewNodeId === 'music' && frame1.lastWidgetReasonCode === 'ui_toggle_changed' && frame2.moveReason === 'ui_focus_move_requested' && frame2.layoutReasonCode === 'ui_focus_advanced' && frame2.volumeFocused === true && frame2.focusedViewNodeId === 'volume' && frame2.clickedViewNodeId === null && frame3.adjustReason === 'ui_widget_adjust_requested' && frame3.layoutReasonCode === 'ui_layout_committed' && frame3.volumeFocused === true && frame3.volumeChanged === true && frame3.volumeClicked === true && frame3.volumeValue === 6 && frame3.volumeReason === 'ui_slider_changed' && frame3.clickedViewNodeId === 'volume' && frame3.lastWidgetReasonCode === 'ui_slider_changed' && frame4.resetReason === 'ui_focus_reset' && frame4.layoutReasonCode === 'ui_focus_initialized' && frame4.musicFocused === true && frame4.musicValue === true && frame4.volumeValue === 6 && frame4.focusedViewNodeId === 'music' && frame4.clickedViewNodeId === null; } catch (_) { return false; } })()",
+        },
+      ],
+      nativeFrames: 5,
+      source: `
+        globalThis.__draw2dUiAuthoredWidgetsProbe = {
+          frames: [],
+          theme: null,
+          invalidThemeReason: null,
+          activateReason: null,
+          moveReason: null,
+          adjustReason: null,
+          resetReason: null,
+          musicValue: false,
+          volumeValue: 4,
+        };
+      `,
+      nativeSource: `
+        const __checks = [];
+        let __reported = false;
+  
+        function __toErrorString(value) {
+          return String(value && value.message ? value.message : value);
+        }
+  
+        function __record(id, pass, detail, trace = null) {
+          const row = { id, pass: !!pass, detail: detail || null };
+          if (!row.pass && trace !== null && trace !== undefined) {
+            row.trace = trace;
+          }
+          __checks.push(row);
+        }
+  
+        function __finish() {
+          if (__reported) {
+            return;
+          }
+          const __failedChecks = __checks.filter((check) => !check.pass);
+          console.log('__AURA_CONFORMANCE_NATIVE__' + JSON.stringify({
+            caseId: 'draw2d-ui-authored-widgets-runtime-native',
+            ok: __failedChecks.length === 0,
+            checks: __checks,
+            failed: __failedChecks.length,
+            passed: __checks.length - __failedChecks.length,
+            runtimeCacheDiagnostics: null,
+            runtimeInspectorSnapshot: null,
+          }));
+          __reported = true;
+          if (aura.window && typeof aura.window.close === 'function') {
+            aura.window.close();
+          }
+        }
+  
+        globalThis.__draw2dUiAuthoredWidgetsProbe = {
+          frames: [],
+          theme: null,
+          invalidThemeReason: null,
+          activateReason: null,
+          moveReason: null,
+          adjustReason: null,
+          resetReason: null,
+          musicValue: false,
+          volumeValue: 4,
+        };
+  
+        function __runWidgetFrame(frameProbe) {
+          const begin = aura.ui.beginView({
+            id: 'settings',
+            x: 28,
+            y: 22,
+            width: 300,
+            gap: 10,
+            padding: 14,
+            background: '#0d1826',
+            borderColor: '#35506c',
+          });
+          const title = aura.ui.text('title', {
+            text: 'Settings',
+            size: 18,
+            color: '#f3f7ff',
+          });
+          const controls = aura.ui.beginColumn({
+            id: 'controls',
+            gap: 8,
+          });
+          const music = aura.ui.toggle('music', {
+            label: 'Music',
+            width: 'fill',
+            value: frameProbe.musicValue,
+          });
+          const volume = aura.ui.slider('volume', {
+            label: 'Master Volume',
+            width: 'fill',
+            min: 0,
+            max: 10,
+            step: 2,
+            value: frameProbe.volumeValue,
+          });
+          const apply = aura.ui.button('apply', {
+            label: 'Apply',
+            width: 'fill',
+          });
+          const endControls = aura.ui.endColumn();
+          const end = aura.ui.endView();
+  
+          return {
+            begin,
+            title,
+            controls,
+            music,
+            volume,
+            apply,
+            endControls,
+            end,
+            root: aura.ui.getViewState('settings'),
+            controlsState: aura.ui.getViewState('controls'),
+            musicState: aura.ui.getViewState('music'),
+            volumeState: aura.ui.getViewState('volume'),
+            applyState: aura.ui.getViewState('apply'),
+            inspect: aura.ui.__inspectorStats(),
+          };
+        }
+  
+        aura.setup = function () {
+          try {
+            const methodsOk = ['clear'].every((name) => typeof aura.draw2d?.[name] === 'function')
+              && ['setTheme', 'getTheme', 'beginView', 'endView', 'beginColumn', 'endColumn', 'text', 'toggle', 'slider', 'button', 'moveFocus', 'activate', 'adjustValue', 'getViewState', 'reset', '__inspectorStats']
+                .every((name) => typeof aura.ui?.[name] === 'function');
+            __record('draw2d.ui-authored-widgets.surface.methods', methodsOk, methodsOk ? null : 'required_methods_missing');
+  
+            const themeResult = aura.ui.setTheme({
+              gap: 8,
+              padding: 12,
+              fontSize: 16,
+              buttonHeight: 34,
+              borderWidth: 1,
+              textColor: '#eef5ff',
+              panelBorderColor: '#35506c',
+              buttonColor: '#142334',
+              buttonHoverColor: '#25415f',
+              buttonFocusColor: '#1d5b96',
+              buttonActiveColor: '#1f7fce',
+              buttonTextColor: '#ffffff',
+            });
+  
+            const probe = globalThis.__draw2dUiAuthoredWidgetsProbe || {};
+            probe.invalidThemeReason = aura.ui.setTheme('bad')?.reasonCode || null;
+            probe.theme = aura.ui.getTheme();
+  
+            const setupOk = themeResult?.ok === true
+              && themeResult?.reasonCode === 'ui_theme_updated'
+              && probe.invalidThemeReason === 'invalid_ui_theme'
+              && Number(probe.theme?.fontSize || 0) === 16
+              && Number(probe.theme?.buttonHeight || 0) === 34;
+            __record(
+              'draw2d.ui-authored-widgets.runtime.setup',
+              setupOk,
+              setupOk ? null : 'draw2d_ui_authored_widgets_setup_failed',
+              setupOk ? null : { themeResult, probe },
+            );
+  
+            aura.update = function () {};
+            aura.draw = function () {
+              const probe = globalThis.__draw2dUiAuthoredWidgetsProbe || {};
+              const frameIndex = Array.isArray(probe.frames) ? probe.frames.length : 0;
+  
+              if (frameIndex === 1) {
+                probe.activateReason = aura.ui.activate()?.reasonCode || null;
+              } else if (frameIndex === 2) {
+                probe.moveReason = aura.ui.moveFocus('next')?.reasonCode || null;
+              } else if (frameIndex === 3) {
+                probe.adjustReason = aura.ui.adjustValue(1)?.reasonCode || null;
+              } else if (frameIndex === 4) {
+                probe.resetReason = aura.ui.reset('settings')?.reasonCode || null;
+              }
+  
+              aura.draw2d.clear(5, 8, 12);
+              const uiState = __runWidgetFrame(probe);
+              probe.musicValue = uiState.musicState?.value ?? probe.musicValue;
+              probe.volumeValue = uiState.volumeState?.value ?? probe.volumeValue;
+              probe.frames.push({
+                frameIndex,
+                activateReason: probe.activateReason || null,
+                moveReason: probe.moveReason || null,
+                adjustReason: probe.adjustReason || null,
+                resetReason: probe.resetReason || null,
+                beginReason: uiState.begin?.reasonCode || null,
+                titleReason: uiState.title?.reasonCode || null,
+                controlsReason: uiState.controls?.reasonCode || null,
+                endControlsReason: uiState.endControls?.reasonCode || null,
+                musicReasonRegistered: uiState.music?.reasonCode || null,
+                volumeReasonRegistered: uiState.volume?.reasonCode || null,
+                applyReasonRegistered: uiState.apply?.reasonCode || null,
+                endReason: uiState.end?.reasonCode || null,
+                layoutReasonCode: uiState.end?.layoutReasonCode || null,
+                rootKind: uiState.root?.kind || null,
+                controlsDirection: uiState.controlsState?.direction || null,
+                musicFocused: uiState.musicState?.focused === true,
+                musicActivated: uiState.musicState?.activated === true,
+                musicClicked: uiState.musicState?.clicked === true,
+                musicToggled: uiState.musicState?.toggled === true,
+                musicValue: uiState.musicState?.value ?? null,
+                musicReason: uiState.musicState?.reasonCode || null,
+                volumeFocused: uiState.volumeState?.focused === true,
+                volumeChanged: uiState.volumeState?.changed === true,
+                volumeClicked: uiState.volumeState?.clicked === true,
+                volumeValue: uiState.volumeState?.value ?? null,
+                volumeReason: uiState.volumeState?.reasonCode || null,
+                applyFocused: uiState.applyState?.focused === true,
+                focusedViewNodeId: uiState.inspect?.focusedViewNodeId || null,
+                clickedViewNodeId: uiState.inspect?.clickedViewNodeId || null,
+                viewNodeCount: Number(uiState.inspect?.viewNodeCount || 0),
+                lastViewReasonCode: uiState.inspect?.lastViewReasonCode || null,
+                lastWidgetReasonCode: uiState.inspect?.lastWidgetReasonCode || null,
+              });
+  
+              if (probe.frames.length < 5) {
+                return;
+              }
+  
+              const frames = probe.frames;
+              const frame0 = frames[0] || {};
+              const frame1 = frames[1] || {};
+              const frame2 = frames[2] || {};
+              const frame3 = frames[3] || {};
+              const frame4 = frames[4] || {};
+              const evidenceOk = probe.invalidThemeReason === 'invalid_ui_theme'
+                && Number(probe.theme?.fontSize || 0) === 16
+                && Number(probe.theme?.buttonHeight || 0) === 34
+                && frames.length === 5
+                && frame0.beginReason === 'ui_view_started'
+                && frame0.titleReason === 'ui_text_registered'
+                && frame0.controlsReason === 'ui_div_started'
+                && frame0.endControlsReason === 'ui_div_committed'
+                && frame0.musicReasonRegistered === 'ui_toggle_registered'
+                && frame0.volumeReasonRegistered === 'ui_slider_registered'
+                && frame0.applyReasonRegistered === 'ui_button_registered'
+                && frame0.endReason === 'ui_view_committed'
+                && frame0.layoutReasonCode === 'ui_focus_initialized'
+                && frame0.rootKind === 'view'
+                && frame0.controlsDirection === 'vertical'
+                && frame0.musicFocused === true
+                && frame0.musicValue === false
+                && frame0.volumeValue === 4
+                && frame0.focusedViewNodeId === 'music'
+                && frame0.viewNodeCount === 6
+                && frame1.activateReason === 'ui_widget_activation_requested'
+                && frame1.layoutReasonCode === 'ui_layout_committed'
+                && frame1.musicFocused === true
+                && frame1.musicActivated === true
+                && frame1.musicClicked === true
+                && frame1.musicToggled === true
+                && frame1.musicValue === true
+                && frame1.musicReason === 'ui_toggle_changed'
+                && frame1.clickedViewNodeId === 'music'
+                && frame1.lastWidgetReasonCode === 'ui_toggle_changed'
+                && frame2.moveReason === 'ui_focus_move_requested'
+                && frame2.layoutReasonCode === 'ui_focus_advanced'
+                && frame2.volumeFocused === true
+                && frame2.focusedViewNodeId === 'volume'
+                && frame2.clickedViewNodeId === null
+                && frame3.adjustReason === 'ui_widget_adjust_requested'
+                && frame3.layoutReasonCode === 'ui_layout_committed'
+                && frame3.volumeFocused === true
+                && frame3.volumeChanged === true
+                && frame3.volumeClicked === true
+                && frame3.volumeValue === 6
+                && frame3.volumeReason === 'ui_slider_changed'
+                && frame3.clickedViewNodeId === 'volume'
+                && frame3.lastWidgetReasonCode === 'ui_slider_changed'
+                && frame4.resetReason === 'ui_focus_reset'
+                && frame4.layoutReasonCode === 'ui_focus_initialized'
+                && frame4.musicFocused === true
+                && frame4.musicValue === true
+                && frame4.volumeValue === 6
+                && frame4.focusedViewNodeId === 'music'
+                && frame4.clickedViewNodeId === null;
+  
+              __record(
+                'draw2d.ui-authored-widgets.runtime.evidence',
+                evidenceOk,
+                evidenceOk ? null : 'draw2d_ui_authored_widgets_evidence_failed',
+                evidenceOk ? null : { probe },
+              );
+              __finish();
+            };
+          } catch (__error) {
+            __record('draw2d.ui-authored-widgets.runtime.setup', false, __toErrorString(__error), {
+              probe: globalThis.__draw2dUiAuthoredWidgetsProbe || null,
+            });
+            __finish();
+          }
+        };
+      `,
+    },
+  {
+      id: 'scene-flow-app-framework-runtime-native',
+      modes: ['native'],
+      namespaces: ['draw2d'],
+      functions: [
+        'aura.draw2d.clear',
+        'aura.draw2d.rectFill',
+        'aura.draw2d.text',
+        'aura.rgba',
+      ],
+      nativeChecks: [
+        {
+          id: 'scene-flow.app-framework.runtime.setup',
+          expression: "(() => { try { const probe = globalThis.__sceneFlowFrontierProbe || null; return probe?.schema === 'aurajs.scene-flow-frontier.v1'; } catch (_) { return false; } })()",
+          debugExpression: 'globalThis.__sceneFlowFrontierProbe || null',
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'scene-flow.app-framework.runtime.evidence',
+          expression: "(() => { try { const probe = globalThis.__sceneFlowFrontierProbe || {}; const frames = Array.isArray(probe.frames) ? probe.frames : []; const transitions = Array.isArray(probe.transitions) ? probe.transitions : []; const modalEvents = Array.isArray(probe.modalEvents) ? probe.modalEvents : []; const promptHistory = Array.isArray(probe.promptHistory) ? probe.promptHistory : []; const tags = transitions.map((row) => `${row.type}:${row.action}:${row.sceneId}`); const hasGameplay = frames.some((row) => row.activeSceneId === 'gameplay' && row.hudScreenId === 'hud'); const hasBriefing = frames.some((row) => row.activeSceneId === 'briefing' && row.stackDepth === 2); const hasPause = frames.some((row) => row.modalDepth === 1 && row.modalIds.includes('pause')); const hasSettings = frames.some((row) => row.modalDepth === 2 && row.modalIds.includes('pause') && row.modalIds.includes('settings')); const hasComplete = frames.some((row) => row.activeSceneId === 'complete' && row.objectiveReached === true); const promptReady = promptHistory.some((row) => row.triggerId === 'terminal' && row.ready === true); return probe.schema === 'aurajs.scene-flow-frontier.v1' && probe.objectiveReached === true && frames.length >= 5 && promptReady && hasGameplay && hasBriefing && hasPause && hasSettings && hasComplete && tags.includes('replace:enter:gameplay') && tags.includes('push:enter:briefing') && tags.includes('pop:resume:gameplay') && tags.includes('replace:enter:complete') && modalEvents.some((row) => row.action === 'push' && row.screenId === 'pause' && row.modalDepth === 1) && modalEvents.some((row) => row.action === 'push' && row.screenId === 'settings' && row.modalDepth === 2) && modalEvents.some((row) => row.action === 'pop' && row.screenId === 'settings' && row.modalDepth === 1) && modalEvents.some((row) => row.action === 'pop' && row.screenId === 'pause' && row.modalDepth === 0); } catch (_) { return false; } })()",
+          debugExpression: 'globalThis.__sceneFlowFrontierProbe || null',
+        },
+      ],
+      nativeFrames: 5,
+      source: () => readConformanceSource('examples/scene-flow-frontier/src/main.js'),
+      nativeSource: () => `
+        ${readConformanceSource('examples/scene-flow-frontier/src/main.js')}
+  
+        const __checks = [];
+        let __reported = false;
+  
+        function __toErrorString(value) {
+          return String(value && value.message ? value.message : value);
+        }
+  
+        function __record(id, pass, detail, trace = null) {
+          const row = { id, pass: !!pass, detail: detail || null };
+          if (!row.pass && trace !== null && trace !== undefined) {
+            row.trace = trace;
+          }
+          __checks.push(row);
+        }
+  
+        function __finish() {
+          if (__reported) {
+            return;
+          }
+          const __failedChecks = __checks.filter((check) => !check.pass);
+          console.log('__AURA_CONFORMANCE_NATIVE__' + JSON.stringify({
+            caseId: 'scene-flow-app-framework-runtime-native',
+            ok: __failedChecks.length === 0,
+            checks: __checks,
+            failed: __failedChecks.length,
+            passed: __checks.length - __failedChecks.length,
+            runtimeCacheDiagnostics: null,
+            runtimeInspectorSnapshot: null,
+          }));
+          __reported = true;
+          if (aura.window && typeof aura.window.close === 'function') {
+            aura.window.close();
+          }
+        }
+  
+        aura.setup = function () {
+          try {
+            globalThis.__sceneFlowFrontierRuntime.setup();
+            const probe = globalThis.__sceneFlowFrontierProbe || null;
+            const runtime = globalThis.__sceneFlowFrontierRuntime || null;
+            const setupOk = probe?.schema === 'aurajs.scene-flow-frontier.v1'
+              && runtime
+              && typeof runtime.update === 'function'
+              && typeof runtime.draw === 'function';
+            __record(
+              'scene-flow.app-framework.runtime.setup',
+              setupOk,
+              setupOk ? null : 'scene_flow_frontier_setup_failed',
+              setupOk ? null : { probe, runtimeReady: !!runtime },
+            );
+          } catch (__error) {
+            __record('scene-flow.app-framework.runtime.setup', false, __toErrorString(__error), {
+              probe: globalThis.__sceneFlowFrontierProbe || null,
+            });
+            __finish();
+          }
+        };
+  
+        aura.update = function (dt) {
+          try {
+            globalThis.__sceneFlowFrontierRuntime.update(dt);
+          } catch (__error) {
+            __record('scene-flow.app-framework.runtime.evidence', false, __toErrorString(__error), {
+              probe: globalThis.__sceneFlowFrontierProbe || null,
+            });
+            __finish();
+          }
+        };
+  
+        aura.draw = function () {
+          if (__reported) {
+            return;
+          }
+          try {
+            globalThis.__sceneFlowFrontierRuntime.draw();
+            const probe = globalThis.__sceneFlowFrontierProbe || {};
+            const frames = Array.isArray(probe.frames) ? probe.frames : [];
+            if (frames.length < 5) {
+              return;
+            }
+            const transitions = Array.isArray(probe.transitions) ? probe.transitions : [];
+            const modalEvents = Array.isArray(probe.modalEvents) ? probe.modalEvents : [];
+            const promptHistory = Array.isArray(probe.promptHistory) ? probe.promptHistory : [];
+            const tags = transitions.map((row) => \`\${row.type}:\${row.action}:\${row.sceneId}\`);
+            const hasGameplay = frames.some((row) => row.activeSceneId === 'gameplay' && row.hudScreenId === 'hud');
+            const hasBriefing = frames.some((row) => row.activeSceneId === 'briefing' && row.stackDepth === 2);
+            const hasPause = frames.some((row) => row.modalDepth === 1 && row.modalIds.includes('pause'));
+            const hasSettings = frames.some((row) => row.modalDepth === 2 && row.modalIds.includes('pause') && row.modalIds.includes('settings'));
+            const hasComplete = frames.some((row) => row.activeSceneId === 'complete' && row.objectiveReached === true);
+            const promptReady = promptHistory.some((row) => row.triggerId === 'terminal' && row.ready === true);
+            const evidenceOk = probe.schema === 'aurajs.scene-flow-frontier.v1'
+              && probe.objectiveReached === true
+              && frames.length >= 5
+              && promptReady
+              && hasGameplay
+              && hasBriefing
+              && hasPause
+              && hasSettings
+              && hasComplete
+              && tags.includes('replace:enter:gameplay')
+              && tags.includes('push:enter:briefing')
+              && tags.includes('pop:resume:gameplay')
+              && tags.includes('replace:enter:complete')
+              && modalEvents.some((row) => row.action === 'push' && row.screenId === 'pause' && row.modalDepth === 1)
+              && modalEvents.some((row) => row.action === 'push' && row.screenId === 'settings' && row.modalDepth === 2)
+              && modalEvents.some((row) => row.action === 'pop' && row.screenId === 'settings' && row.modalDepth === 1)
+              && modalEvents.some((row) => row.action === 'pop' && row.screenId === 'pause' && row.modalDepth === 0);
+            __record(
+              'scene-flow.app-framework.runtime.evidence',
+              evidenceOk,
+              evidenceOk ? null : 'scene_flow_frontier_evidence_failed',
+              evidenceOk ? null : probe,
+            );
+            __finish();
+          } catch (__error) {
+            __record('scene-flow.app-framework.runtime.evidence', false, __toErrorString(__error), {
+              probe: globalThis.__sceneFlowFrontierProbe || null,
+            });
+            __finish();
+          }
+        };
+      `,
+    },
+  {
+      id: 'starter-scene-flow-continuity-runtime-native',
+      modes: ['native'],
+      namespaces: ['draw2d'],
+      functions: ['aura.draw2d.clear', 'aura.draw2d.rectFill', 'aura.draw2d.text', 'aura.rgba'],
+      nativeChecks: [
+        {
+          id: 'starter.scene-flow.continuity.surface.methods',
+          expression: "(() => ['clear','rectFill','text'].every((name) => typeof aura.draw2d?.[name] === 'function') && typeof aura.rgba === 'function')()",
+          debugExpression: "(() => ({ hasDraw2d: !!aura.draw2d, hasRgba: typeof aura.rgba === 'function' }))()",
+        },
+        {
+          id: 'starter.scene-flow.continuity.runtime.setup',
+          expression: "(() => { try { const probe = globalThis.__starterSceneFlowContinuityProbe || null; return probe?.schema === 'aurajs.starter-scene-flow-continuity.v1'; } catch (_) { return false; } })()",
+          debugExpression: 'globalThis.__starterSceneFlowContinuityProbe || null',
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'starter.scene-flow.continuity.runtime.evidence',
+          expression: "(() => { try { const probe = globalThis.__starterSceneFlowContinuityProbe || {}; const captured = probe.captured || {}; const restored = probe.restored || {}; const continued = probe.continued || {}; const invalid = probe.invalid || {}; const frames = Array.isArray(probe.frames) ? probe.frames : []; return probe.schema === 'aurajs.starter-scene-flow-continuity.v1' && captured.sceneFlow?.schema === 'aurajs.scene-flow.v1' && captured.screenShell?.schema === 'aurajs.screen-shell.v1' && restored.sceneRestore?.ok === true && restored.screenRestore?.ok === true && restored.sceneMatch === true && restored.screenMatch === true && invalid.scene?.ok === false && invalid.scene?.reasonCode === 'scene_flow_unknown_scene' && invalid.screenShell?.ok === false && invalid.screenShell?.reasonCode === 'screen_shell_unknown_screen' && invalid.sceneStateStable === true && invalid.screenStateStable === true && continued.popScene?.ok === true && continued.popModal?.ok === true && continued.clearOverlay?.ok === true && continued.replaceScene?.ok === true && continued.setHud?.ok === true && continued.sceneFlow?.currentSceneId === 'complete' && continued.sceneFlow?.depth === 1 && continued.screenShell?.modalDepth === 0 && continued.screenShell?.overlay === null && continued.screenShell?.hud?.data?.status === 'restored-and-continued' && frames.length >= 3 && frames.some((row) => row.stage === 'captured' && row.sceneDepth === 2 && row.modalDepth === 1) && frames.some((row) => row.stage === 'restored' && row.sceneDepth === 2 && row.modalDepth === 1) && frames.some((row) => row.stage === 'continued' && row.sceneDepth === 1 && row.modalDepth === 0); } catch (_) { return false; } })()",
+          debugExpression: 'globalThis.__starterSceneFlowContinuityProbe || null',
+        },
+      ],
+      nativeFrames: 3,
+      source: () => `globalThis.__starterSceneFlowContinuityProbe = { schema: 'aurajs.starter-scene-flow-continuity.v1', captured: null, restored: null, continued: null, invalid: null, frames: [] };`,
+      nativeSource: () => `
+        const __checks = [];
+        let __reported = false;
+        const __starterSceneFlowRuntime = (() => { ${STARTER_SCENE_FLOW_RUNTIME_SOURCE} return { createSceneFlow, SCENE_FLOW_SCHEMA }; })();
+        const __starterScreenShellRuntime = (() => { ${STARTER_SCREEN_SHELL_RUNTIME_SOURCE} return { createScreenShell, SCREEN_SHELL_SCHEMA }; })();
+        const __clone = (value) => (value == null ? value : JSON.parse(JSON.stringify(value)));
+        const __same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+        const __toErrorString = (value) => String(value && value.message ? value.message : value);
+        function __record(id, pass, detail, trace = null) { const row = { id, pass: !!pass, detail: detail || null }; if (!row.pass && trace !== null && trace !== undefined) row.trace = trace; __checks.push(row); }
+        function __finish() { if (__reported) return; const __failedChecks = __checks.filter((check) => !check.pass); console.log('__AURA_CONFORMANCE_NATIVE__' + JSON.stringify({ caseId: 'starter-scene-flow-continuity-runtime-native', ok: __failedChecks.length === 0, checks: __checks, failed: __failedChecks.length, passed: __checks.length - __failedChecks.length, runtimeCacheDiagnostics: null, runtimeInspectorSnapshot: null })); __reported = true; if (aura.window && typeof aura.window.close === 'function') aura.window.close(); }
+        const __resolveScene = (sceneId) => ['title', 'gameplay', 'briefing', 'complete'].includes(sceneId) ? { id: sceneId } : null;
+        const __resolveScreen = (screenId) => ['hud', 'overlay', 'pause'].includes(screenId) ? { id: screenId } : null;
+        const __createSceneFlow = () => __starterSceneFlowRuntime.createSceneFlow({ resolveScene: __resolveScene });
+        const __createScreenShell = () => __starterScreenShellRuntime.createScreenShell({ resolveScreen: __resolveScreen });
+        function __runProof() {
+          const probe = globalThis.__starterSceneFlowContinuityProbe = { schema: 'aurajs.starter-scene-flow-continuity.v1', captured: null, restored: null, continued: null, invalid: null, frames: [] };
+          const sceneFlow = __createSceneFlow();
+          const screenShell = __createScreenShell();
+          sceneFlow.replace('gameplay', { checkpoint: 'alpha', coins: 3 });
+          sceneFlow.push('briefing', { source: 'terminal', prompt: 'Press E to open briefing' });
+          screenShell.setHud('hud', { title: 'Gameplay', status: 'captured' });
+          screenShell.showOverlay('overlay', { promptText: 'Press E to continue' });
+          screenShell.pushModal('pause', { reason: 'pause-menu' });
+          const capturedSceneFlow = sceneFlow.getState();
+          const capturedScreenShell = screenShell.getState();
+          probe.captured = { sceneFlow: capturedSceneFlow, screenShell: capturedScreenShell };
+          const restoredSceneFlow = __createSceneFlow();
+          const restoredScreenShell = __createScreenShell();
+          const sceneRestore = restoredSceneFlow.applyState(capturedSceneFlow);
+          const screenRestore = restoredScreenShell.applyState(capturedScreenShell);
+          const restoredSceneState = restoredSceneFlow.getState();
+          const restoredScreenState = restoredScreenShell.getState();
+          probe.restored = { sceneRestore, screenRestore, sceneFlow: restoredSceneState, screenShell: restoredScreenState, sceneMatch: __same(capturedSceneFlow, restoredSceneState), screenMatch: __same(capturedScreenShell, restoredScreenState) };
+          const invalidSceneBefore = __clone(restoredSceneState);
+          const invalidScreenBefore = __clone(restoredScreenState);
+          const invalidScene = restoredSceneFlow.applyState({ schema: __starterSceneFlowRuntime.SCENE_FLOW_SCHEMA, stack: [{ sceneId: 'missing-scene', data: null, mountId: 99 }], mutationCount: restoredSceneState.mutationCount });
+          const invalidScreenShell = restoredScreenShell.applyState({ schema: __starterScreenShellRuntime.SCREEN_SHELL_SCHEMA, hud: { screenId: 'missing-screen', data: null, mountId: 77 }, overlay: null, modals: [], mutationCount: restoredScreenState.mutationCount });
+          probe.invalid = { scene: invalidScene, screenShell: invalidScreenShell, sceneStateStable: __same(invalidSceneBefore, restoredSceneFlow.getState()), screenStateStable: __same(invalidScreenBefore, restoredScreenShell.getState()) };
+          const popScene = restoredSceneFlow.pop({ acknowledged: true });
+          const popModal = restoredScreenShell.popModal({ resumed: true });
+          const clearOverlay = restoredScreenShell.clearOverlay();
+          const replaceScene = restoredSceneFlow.replace('complete', { summary: 'continued-from-restored-state' });
+          const setHud = restoredScreenShell.setHud('hud', { title: 'Complete', status: 'restored-and-continued' });
+          probe.continued = { popScene, popModal, clearOverlay, replaceScene, setHud, sceneFlow: restoredSceneFlow.getState(), screenShell: restoredScreenShell.getState() };
+        }
+        function __recordFrame(stage, detail) { const probe = globalThis.__starterSceneFlowContinuityProbe || null; if (!probe || !Array.isArray(probe.frames)) return; const sceneState = detail?.sceneFlow || null; const shellState = detail?.screenShell || null; probe.frames.push({ stage, sceneId: sceneState?.currentSceneId || null, sceneDepth: Number(sceneState?.depth || 0), modalDepth: Number(shellState?.modalDepth || 0), hudStatus: shellState?.hud?.data?.status || null, overlayPrompt: shellState?.overlay?.data?.promptText || null }); }
+
+        aura.setup = function () {
+          try {
+            const methodsOk = ['clear', 'rectFill', 'text'].every((name) => typeof aura.draw2d?.[name] === 'function') && typeof aura.rgba === 'function';
+            __record('starter.scene-flow.continuity.surface.methods', methodsOk, methodsOk ? null : 'required_methods_missing');
+            __runProof();
+            const probe = globalThis.__starterSceneFlowContinuityProbe || null;
+            const setupOk = probe?.schema === 'aurajs.starter-scene-flow-continuity.v1' && probe?.captured?.sceneFlow?.schema === __starterSceneFlowRuntime.SCENE_FLOW_SCHEMA && probe?.captured?.screenShell?.schema === __starterScreenShellRuntime.SCREEN_SHELL_SCHEMA && probe?.restored?.sceneRestore?.ok === true && probe?.restored?.screenRestore?.ok === true;
+            __record('starter.scene-flow.continuity.runtime.setup', setupOk, setupOk ? null : 'starter_scene_flow_continuity_setup_failed', setupOk ? null : probe);
+          } catch (__error) {
+            __record('starter.scene-flow.continuity.runtime.setup', false, __toErrorString(__error), { probe: globalThis.__starterSceneFlowContinuityProbe || null });
+            __finish();
+          }
+        };
+
+        aura.update = function () {};
+
+        aura.draw = function () {
+          if (__reported) return;
+          try {
+            const probe = globalThis.__starterSceneFlowContinuityProbe || {};
+            const frames = Array.isArray(probe.frames) ? probe.frames : [];
+            const nextIndex = frames.length;
+            const detail = nextIndex === 0 ? probe.captured : nextIndex === 1 ? probe.restored : probe.continued;
+            const stage = nextIndex === 0 ? 'captured' : nextIndex === 1 ? 'restored' : 'continued';
+            __recordFrame(stage, detail || null);
+
+            aura.draw2d.clear(aura.rgba(0.04, 0.06, 0.1, 1));
+            aura.draw2d.rectFill(80, 88, 1120, 180, aura.rgba(0.05, 0.08, 0.13, 0.94));
+            aura.draw2d.text('STARTER CONTINUITY ' + stage.toUpperCase() + '  scene=' + String(detail?.sceneFlow?.currentSceneId || 'none') + ' depth=' + String(detail?.sceneFlow?.depth || 0) + ' modals=' + String(detail?.screenShell?.modalDepth || 0), 120, 150, { size: 20, color: aura.rgba(0.95, 0.98, 1, 1) });
+            aura.draw2d.text('hud=' + String(detail?.screenShell?.hud?.data?.status || 'none') + ' overlay=' + String(detail?.screenShell?.overlay?.data?.promptText || 'none'), 120, 190, { size: 16, color: aura.rgba(0.8, 0.88, 0.95, 1) });
+            if (frames.length < 3) return;
+            const evidenceOk = probe.schema === 'aurajs.starter-scene-flow-continuity.v1' && probe.captured?.sceneFlow?.schema === __starterSceneFlowRuntime.SCENE_FLOW_SCHEMA && probe.captured?.screenShell?.schema === __starterScreenShellRuntime.SCREEN_SHELL_SCHEMA && probe.restored?.sceneRestore?.ok === true && probe.restored?.screenRestore?.ok === true && probe.restored?.sceneMatch === true && probe.restored?.screenMatch === true && probe.invalid?.scene?.ok === false && probe.invalid?.scene?.reasonCode === 'scene_flow_unknown_scene' && probe.invalid?.screenShell?.ok === false && probe.invalid?.screenShell?.reasonCode === 'screen_shell_unknown_screen' && probe.invalid?.sceneStateStable === true && probe.invalid?.screenStateStable === true && probe.continued?.popScene?.ok === true && probe.continued?.popModal?.ok === true && probe.continued?.clearOverlay?.ok === true && probe.continued?.replaceScene?.ok === true && probe.continued?.setHud?.ok === true && probe.continued?.sceneFlow?.currentSceneId === 'complete' && probe.continued?.sceneFlow?.depth === 1 && probe.continued?.screenShell?.modalDepth === 0 && probe.continued?.screenShell?.overlay === null && probe.continued?.screenShell?.hud?.data?.status === 'restored-and-continued' && frames.some((row) => row.stage === 'captured' && row.sceneDepth === 2 && row.modalDepth === 1) && frames.some((row) => row.stage === 'restored' && row.sceneDepth === 2 && row.modalDepth === 1) && frames.some((row) => row.stage === 'continued' && row.sceneDepth === 1 && row.modalDepth === 0);
+            __record('starter.scene-flow.continuity.runtime.evidence', evidenceOk, evidenceOk ? null : 'starter_scene_flow_continuity_evidence_failed', evidenceOk ? null : probe);
+            __finish();
+          } catch (__error) {
+            __record('starter.scene-flow.continuity.runtime.evidence', false, __toErrorString(__error), { probe: globalThis.__starterSceneFlowContinuityProbe || null });
+            __finish();
+          }
+        };
+      `,
+    },
+  {
+      id: 'draw2d-compositor-graph-runtime-native',
+      modes: ['native'],
+      namespaces: ['draw2d', 'debug'],
+      functions: [
+        'aura.draw2d.clear',
+        'aura.draw2d.createRenderTarget',
+        'aura.draw2d.destroyRenderTarget',
+        'aura.draw2d.runCompositorGraph',
+        'aura.draw2d.exportRenderTarget',
+        'aura.draw2d.sprite',
+        'aura.draw2d.spriteFx',
+        'aura.draw2d.rectFill',
+        'aura.draw2d.text',
+        'aura.debug.inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.compositor-graph.surface.methods',
+          expression: "(() => ['clear','createRenderTarget','destroyRenderTarget','runCompositorGraph','exportRenderTarget','sprite','spriteFx','rectFill','text'].every((name) => typeof aura.draw2d?.[name] === 'function') && typeof aura.debug?.inspectorStats === 'function')()",
+        },
+        {
+          id: 'draw2d.compositor-graph.runtime.setup',
+          expression: "(() => true)()",
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw2d.compositor-graph.runtime.evidence',
+          expression: "(() => { try { const probe = globalThis.__draw2dCompositorGraphProbe || {}; return Array.isArray(probe.frames) && probe.frames.length === 3; } catch (_) { return false; } })()",
+        },
+      ],
+      nativeFrames: 3,
+      source: `
+        globalThis.__draw2dCompositorGraphProbe = {
+          panelTarget: null,
+          fxTarget: null,
+          finalTarget: null,
+          frames: [],
+        };
+      `,
+      nativeSource: `
+        const __checks = [];
+        let __reported = false;
+  
+        function __toErrorString(value) {
+          return String(value && value.message ? value.message : value);
+        }
+  
+        function __record(id, pass, detail, trace = null) {
+          const row = { id, pass: !!pass, detail: detail || null };
+          if (!row.pass && trace !== null && trace !== undefined) {
+            row.trace = trace;
+          }
+          __checks.push(row);
+        }
+  
+        function __finish() {
+          if (__reported) {
+            return;
+          }
+          const __failedChecks = __checks.filter((check) => !check.pass);
+          console.log('__AURA_CONFORMANCE_NATIVE__' + JSON.stringify({
+            caseId: 'draw2d-compositor-graph-runtime-native',
+            ok: __failedChecks.length === 0,
+            checks: __checks,
+            failed: __failedChecks.length,
+            passed: __checks.length - __failedChecks.length,
+            runtimeCacheDiagnostics: null,
+            runtimeInspectorSnapshot: null,
+          }));
+          __reported = true;
+          if (aura.window && typeof aura.window.close === 'function') {
+            aura.window.close();
+          }
+        }
+  
+        globalThis.__draw2dCompositorGraphProbe = {
+          panelTarget: null,
+          fxTarget: null,
+          finalTarget: null,
+          frames: [],
+        };
+  
+        aura.setup = function () {
+          try {
+            const methodsOk = ['clear', 'createRenderTarget', 'destroyRenderTarget', 'runCompositorGraph', 'exportRenderTarget', 'sprite', 'spriteFx', 'rectFill', 'text']
+              .every((name) => typeof aura.draw2d?.[name] === 'function')
+              && typeof aura.debug?.inspectorStats === 'function';
+            __record('draw2d.compositor-graph.surface.methods', methodsOk, methodsOk ? null : 'required_methods_missing');
+  
+            const panelTarget = aura.draw2d.createRenderTarget(112, 72);
+            const fxTarget = aura.draw2d.createRenderTarget(144, 96);
+            const finalTarget = aura.draw2d.createRenderTarget(176, 112);
+            globalThis.__draw2dCompositorGraphProbe = {
+              panelTarget,
+              fxTarget,
+              finalTarget,
+              frames: [],
+            };
+  
+            const setupOk = panelTarget?.ok === true
+              && fxTarget?.ok === true
+              && finalTarget?.ok === true
+              && Number.isInteger(panelTarget?.handle)
+              && Number.isInteger(fxTarget?.handle)
+              && Number.isInteger(finalTarget?.handle);
+            __record(
+              'draw2d.compositor-graph.runtime.setup',
+              setupOk,
+              setupOk ? null : 'draw2d_compositor_graph_setup_failed',
+              setupOk ? null : { panelTarget, fxTarget, finalTarget },
+            );
+  
+            aura.update = function () {};
+            aura.draw = function () {
+              const probe = globalThis.__draw2dCompositorGraphProbe || {};
+              const frameIndex = Array.isArray(probe.frames) ? probe.frames.length : 0;
+              const white = aura.Color?.WHITE || aura.colors?.white || aura.rgba(1, 1, 1, 1);
+  
+              aura.draw2d.clear(5, 7, 11);
+              let duplicateGraph = null;
+              let validGraph = null;
+              let invalidExport = null;
+              let exportQueued = null;
+              let invalidOutline = null;
+              let outlineQueued = null;
+  
+              if (frameIndex === 0) {
+                duplicateGraph = aura.draw2d.runCompositorGraph('frontier-invalid', [
+                  { id: 'panel', target: probe.panelTarget, draw: () => {} },
+                  { id: 'panel', target: probe.fxTarget, draw: () => {} },
+                ]);
+                validGraph = aura.draw2d.runCompositorGraph('frontier-main', [
+                  {
+                    id: 'panel',
+                    target: probe.panelTarget,
+                    draw: () => {
+                      aura.draw2d.clear(0, 0, 0, 0);
+                      aura.draw2d.rectFill(0, 0, 112, 72, aura.rgba(0.15, 0.2, 0.3, 0.94));
+                      aura.draw2d.rectFill(10, 42, 72, 12, aura.rgba(0.22, 0.82, 1, 0.68));
+                      aura.draw2d.text('ENERGY 72', 12, 16, { size: 12, color: white });
+                    },
+                  },
+                  {
+                    id: 'fx',
+                    target: probe.fxTarget,
+                    draw: () => {
+                      aura.draw2d.clear(0, 0, 0, 0);
+                      aura.draw2d.sprite(probe.panelTarget, 0, 0, { width: 144, height: 96 });
+                      aura.draw2d.text('OUTLINE', 18, 62, { size: 11, color: white });
+                    },
+                  },
+                  {
+                    id: 'final',
+                    target: probe.finalTarget,
+                    draw: () => {
+                      aura.draw2d.clear(0, 0, 0, 0);
+                      aura.draw2d.sprite(probe.fxTarget, 0, 0, { width: 176, height: 112 });
+                    },
+                  },
+                ]);
+                if (Array.isArray(validGraph?.stages) && validGraph.stages.length === 3) {
+                  invalidExport = aura.draw2d.exportRenderTarget(validGraph.stages[2], 'frontier-export.jpg');
+                  exportQueued = aura.draw2d.exportRenderTarget(validGraph.stages[2], 'frontier-export.png');
+                  invalidOutline = aura.draw2d.spriteFx(validGraph.stages[1], 212, 28, {
+                    width: 54,
+                    height: 34,
+                    outline: { thickness: 0 },
+                  });
+                  outlineQueued = aura.draw2d.spriteFx(validGraph.stages[1], 212, 76, {
+                    width: 64,
+                    height: 40,
+                    outline: { thickness: 2, alpha: 0.8 },
+                  });
+                  aura.draw2d.sprite(validGraph.stages[2], 18, 18, { width: 176, height: 112 });
+                }
+              } else {
+                aura.draw2d.sprite(probe.finalTarget, 18, 18, { width: 176, height: 112 });
+              }
+  
+              const stats = aura.debug.inspectorStats() || {};
+              const compositor = stats.draw2dRuntime?.compositor || {};
+              const fx = stats.draw2dRuntime?.fx || {};
+              probe.frames.push({
+                frameIndex,
+                duplicateGraphReason: duplicateGraph?.reasonCode || null,
+                graphReason: validGraph?.reasonCode || null,
+                graphName: validGraph?.graphName || null,
+                graphStageCount: Number(validGraph?.stageCount || 0),
+                graphCommandCount: Number(validGraph?.commandCount || 0),
+                stagesLength: Array.isArray(validGraph?.stages) ? validGraph.stages.length : 0,
+                invalidExportReason: invalidExport?.reasonCode || null,
+                exportQueuedReason: exportQueued?.reasonCode || null,
+                exportQueuedPath: exportQueued?.path || null,
+                invalidOutlineReason: invalidOutline?.reasonCode || null,
+                outlineQueuedReason: outlineQueued?.reasonCode || null,
+                submittedFxDrawCount: Number(outlineQueued?.submittedFxDrawCount || 0),
+                knownGraphCount: Number(compositor.knownGraphCount || 0),
+                knownStageCount: Number(compositor.knownStageCount || 0),
+                lastGraphName: compositor.lastGraphName || null,
+                lastGraphStageCount: Number(compositor.lastGraphStageCount || 0),
+                lastGraphCommandCount: Number(compositor.lastGraphCommandCount || 0),
+                lastGraphReasonCode: compositor.lastGraphReasonCode || null,
+                lastGraphOk: compositor.lastGraphOk === true,
+                pendingExportCount: Number(compositor.pendingExportCount || 0),
+                lastSubmittedExportCount: Number(compositor.lastSubmittedExportCount || 0),
+                lastExecutedExportCount: Number(compositor.lastExecutedExportCount || 0),
+                lastExportReasonCode: compositor.lastExportReasonCode || null,
+                lastExportOk: compositor.lastExportOk === true,
+                pendingFxCommandCount: Number(fx.pendingFxCommandCount || 0),
+                lastSubmittedFxCommandCount: Number(fx.lastSubmittedFxCommandCount || 0),
+                lastExecutedFxCommandCount: Number(fx.lastExecutedFxCommandCount || 0),
+                lastFxReasonCode: fx.lastReasonCode || null,
+                lastFxOk: fx.lastOk === true,
+              });
+  
+              if (probe.frames.length < 3) {
+                return;
+              }
+  
+              const frames = probe.frames;
+              const frame0 = frames[0] || {};
+              const frame1 = frames[1] || {};
+              const frame2 = frames[2] || {};
+              const destroyPanel = aura.draw2d.destroyRenderTarget(probe.panelTarget);
+              const destroyFx = aura.draw2d.destroyRenderTarget(probe.fxTarget);
+              const destroyFinal = aura.draw2d.destroyRenderTarget(probe.finalTarget);
+              const missingDestroy = aura.draw2d.destroyRenderTarget(probe.finalTarget);
+              const evidenceOk = frame0.duplicateGraphReason === 'duplicate_compositor_stage_id'
+                && frame0.graphReason === 'draw2d_compositor_captured'
+                && frame0.graphName === 'frontier-main'
+                && frame0.graphStageCount === 3
+                && frame0.graphCommandCount === 9
+                && frame0.stagesLength === 3
+                && frame0.invalidExportReason === 'unsupported_export_format'
+                && frame0.exportQueuedReason === 'draw2d_render_target_export_queued'
+                && frame0.exportQueuedPath === 'frontier-export.png'
+                && frame0.invalidOutlineReason === 'invalid_sprite_fx_outline'
+                && frame0.outlineQueuedReason === 'draw2d_sprite_fx_queued'
+                && frame0.submittedFxDrawCount === 16
+                && frame0.knownGraphCount === 1
+                && frame0.knownStageCount === 3
+                && frame0.lastGraphName === 'frontier-main'
+                && frame0.lastGraphStageCount === 3
+                && frame0.lastGraphCommandCount === 9
+                && frame0.lastGraphReasonCode === 'draw2d_compositor_captured'
+                && frame0.lastGraphOk === true
+                && frame0.pendingExportCount === 1
+                && frame0.lastSubmittedExportCount === 0
+                && frame0.lastExecutedExportCount === 0
+                && frame0.lastExportReasonCode === 'draw2d_export_idle'
+                && frame0.lastExportOk === true
+                && frame0.pendingFxCommandCount === 16
+                && frame0.lastSubmittedFxCommandCount === 0
+                && frame0.lastExecutedFxCommandCount === 0
+                && frame0.lastFxReasonCode === 'draw2d_fx_idle'
+                && frame0.lastFxOk === true
+                && frame1.graphReason === null
+                && frame1.pendingExportCount === 0
+                && frame1.lastSubmittedExportCount === 1
+                && frame1.lastExecutedExportCount === 1
+                && frame1.lastExportReasonCode === 'draw2d_export_executed'
+                && frame1.lastExportOk === true
+                && frame1.pendingFxCommandCount === 0
+                && frame1.lastSubmittedFxCommandCount === 16
+                && frame1.lastExecutedFxCommandCount === 16
+                && frame1.lastFxReasonCode === 'draw2d_fx_executed'
+                && frame1.lastFxOk === true
+                && frame2.graphReason === null
+                && frame2.pendingExportCount === 0
+                && frame2.lastSubmittedExportCount === 0
+                && frame2.lastExecutedExportCount === 0
+                && frame2.lastExportReasonCode === 'draw2d_export_idle'
+                && frame2.lastExportOk === true
+                && frame2.pendingFxCommandCount === 0
+                && frame2.lastSubmittedFxCommandCount === 0
+                && frame2.lastExecutedFxCommandCount === 0
+                && frame2.lastFxReasonCode === 'draw2d_fx_idle'
+                && frame2.lastFxOk === true
+                && destroyPanel?.ok === true
+                && destroyPanel?.reasonCode === 'draw2d_render_target_destroyed'
+                && destroyFx?.ok === true
+                && destroyFx?.reasonCode === 'draw2d_render_target_destroyed'
+                && destroyFinal?.ok === true
+                && destroyFinal?.reasonCode === 'draw2d_render_target_destroyed'
+                && missingDestroy?.ok === false
+                && missingDestroy?.reasonCode === 'missing_render_target';
+              __record(
+                'draw2d.compositor-graph.runtime.evidence',
+                evidenceOk,
+                evidenceOk ? null : 'draw2d_compositor_graph_evidence_failed',
+                evidenceOk ? null : { probe, destroyPanel, destroyFx, destroyFinal, missingDestroy },
+              );
+              __finish();
+            };
+          } catch (__error) {
+            __record('draw2d.compositor-graph.runtime.setup', false, __toErrorString(__error), {
+              probe: globalThis.__draw2dCompositorGraphProbe || null,
+            });
+            __finish();
+          }
+        };
+      `,
+    }
+];