@auraindustry/aurajs 0.0.6 → 0.1.0

package/src/conformance/cases/core-runtime-cases.mjs

@@ -0,0 +1,1431 @@
+export const CORE_RUNTIME_CONFORMANCE_CASES = [
+  {
+      id: 'lifecycle-window',
+      namespaces: ['lifecycle', 'window'],
+      functions: [
+        'aura.setup',
+        'aura.update',
+        'aura.draw',
+        'aura.onResize',
+        'aura.onFocus',
+        'aura.onBlur',
+        'aura.window.setTitle',
+        'aura.window.setSize',
+        'aura.window.setFullscreen',
+        'aura.window.setCursorVisible',
+        'aura.window.setCursorLocked',
+        'aura.window.getSize',
+        'aura.window.getPixelRatio',
+        'aura.window.getFPS',
+      ],
+      nativeChecks: [
+        { id: 'window.setTitle', expression: "typeof aura.window?.setTitle === 'function'" },
+        { id: 'window.setSize', expression: "typeof aura.window?.setSize === 'function'" },
+        { id: 'window.setFullscreen', expression: "typeof aura.window?.setFullscreen === 'function'" },
+        { id: 'window.setCursorVisible', expression: "typeof aura.window?.setCursorVisible === 'function'" },
+        { id: 'window.setCursorLocked', expression: "typeof aura.window?.setCursorLocked === 'function'" },
+        { id: 'window.getSize', expression: "typeof aura.window?.getSize === 'function'" },
+        { id: 'window.getPixelRatio', expression: "typeof aura.window?.getPixelRatio === 'function'" },
+        { id: 'window.getFPS', expression: "typeof aura.window?.getFPS === 'function'" },
+        {
+          id: 'lifecycle.onResize.numericArgs',
+          expression: "(() => { let calls = 0; let seen = null; aura.onResize = function (w, h) { calls += 1; seen = [typeof w, typeof h, w, h]; }; aura.onResize(1280, 720); return calls === 1 && Array.isArray(seen) && seen[0] === 'number' && seen[1] === 'number' && seen[2] === 1280 && seen[3] === 720; })()",
+        },
+        {
+          id: 'lifecycle.onFocus.callable',
+          expression: "(() => { let calls = 0; aura.onFocus = function () { calls += 1; }; aura.onFocus(); return calls === 1; })()",
+        },
+        {
+          id: 'lifecycle.onBlur.callable',
+          expression: "(() => { let calls = 0; aura.onBlur = function () { calls += 1; }; aura.onBlur(); return calls === 1; })()",
+        },
+      ],
+      nativePostChecks: [
+        { id: 'lifecycle.setup.calledOnce', expression: '__setupCalls === 1' },
+        { id: 'lifecycle.update.calledPerFrame', expression: '__updateCalls === 3' },
+        { id: 'lifecycle.draw.calledPerFrame', expression: '__drawCalls === 3' },
+        {
+          id: 'lifecycle.update.dtPositiveNumber',
+          expression: "typeof __lastDt === 'number' && Number.isFinite(__lastDt) && __lastDt > 0",
+        },
+        { id: 'lifecycle.update.afterSetup', expression: '__updateBeforeSetup === false' },
+        { id: 'lifecycle.draw.afterSetup', expression: '__drawBeforeSetup === false' },
+      ],
+      frames: 3,
+      nativeFrames: 3,
+      source: `
+        let setupCount = 0;
+        let updateCount = 0;
+        let drawCount = 0;
+        let resizeCount = 0;
+        let focusCount = 0;
+        let blurCount = 0;
+        let resizeArgs = null;
+  
+        aura.setup = function () {
+          setupCount += 1;
+          aura.window.setTitle('Conformance');
+          aura.window.setSize(640, 360);
+          aura.window.setFullscreen(false);
+          aura.window.setCursorVisible(true);
+          aura.window.setCursorLocked(false);
+
+          const windowSize = aura.window.getSize();
+          aura.test.assert(typeof aura.window.width === 'number', 'window.width should be numeric');
+          aura.test.assert(typeof aura.window.height === 'number', 'window.height should be numeric');
+          aura.test.equal(windowSize.width, aura.window.width, 'window.getSize width should match snapshot');
+          aura.test.equal(windowSize.height, aura.window.height, 'window.getSize height should match snapshot');
+          aura.test.assert(typeof aura.window.pixelRatio === 'number', 'window.pixelRatio should be numeric');
+          aura.test.assert(typeof aura.window.fps === 'number', 'window.fps should be numeric');
+          aura.test.assert(typeof aura.window.close === 'function', 'window.close should exist');
+          aura.test.assert(typeof aura.window.setCursorVisible === 'function', 'window.setCursorVisible should exist');
+          aura.test.assert(typeof aura.window.setCursorLocked === 'function', 'window.setCursorLocked should exist');
+  
+          aura.onResize = function (width, height) {
+            resizeCount += 1;
+            resizeArgs = [width, height];
+          };
+          aura.onFocus = function () {
+            focusCount += 1;
+          };
+          aura.onBlur = function () {
+            blurCount += 1;
+          };
+  
+          aura.onResize(640, 360);
+          aura.onFocus();
+          aura.onBlur();
+        };
+  
+        aura.update = function (dt) {
+          updateCount += 1;
+          aura.test.assert(dt > 0, 'dt should be positive');
+        };
+  
+        aura.draw = function () {
+          drawCount += 1;
+          aura.draw2d.clear(10, 20, 30);
+  
+          if (drawCount === 3) {
+            aura.test.equal(setupCount, 1, 'setup called once');
+            aura.test.equal(updateCount, 3, 'update called once per frame');
+            aura.test.equal(resizeCount, 1, 'onResize should be callable');
+            aura.test.equal(focusCount, 1, 'onFocus should be callable');
+            aura.test.equal(blurCount, 1, 'onBlur should be callable');
+            aura.test.equal(resizeArgs[0], 640, 'onResize width arg');
+            aura.test.equal(resizeArgs[1], 360, 'onResize height arg');
+          }
+        };
+      `,
+    },
+  {
+      id: 'input-surface',
+      namespaces: ['input'],
+      functions: [
+        'aura.input.isKeyDown',
+        'aura.input.isKeyPressed',
+        'aura.input.isKeyReleased',
+        'aura.input.getMousePosition',
+        'aura.input.getMouseDelta',
+        'aura.input.isMouseDown',
+        'aura.input.isMousePressed',
+        'aura.input.getMouseWheel',
+        'aura.input.isGamepadConnected',
+        'aura.input.getGamepadAxis',
+        'aura.input.isGamepadButtonDown',
+      ],
+      nativeChecks: [
+        { id: 'input.isKeyDown', expression: "typeof aura.input?.isKeyDown === 'function'" },
+        { id: 'input.isKeyPressed', expression: "typeof aura.input?.isKeyPressed === 'function'" },
+        { id: 'input.isKeyReleased', expression: "typeof aura.input?.isKeyReleased === 'function'" },
+        { id: 'input.getMousePosition', expression: "typeof aura.input?.getMousePosition === 'function'" },
+        { id: 'input.getMouseDelta', expression: "typeof aura.input?.getMouseDelta === 'function'" },
+        { id: 'input.isMouseDown', expression: "typeof aura.input?.isMouseDown === 'function'" },
+        { id: 'input.isMousePressed', expression: "typeof aura.input?.isMousePressed === 'function'" },
+        { id: 'input.getMouseWheel', expression: "typeof aura.input?.getMouseWheel === 'function'" },
+        { id: 'input.isGamepadConnected', expression: "typeof aura.input?.isGamepadConnected === 'function'" },
+        { id: 'input.getGamepadAxis', expression: "typeof aura.input?.getGamepadAxis === 'function'" },
+        { id: 'input.isGamepadButtonDown', expression: "typeof aura.input?.isGamepadButtonDown === 'function'" },
+        {
+          id: 'input.key.invalid-input.safe-false',
+          expression: "(() => { const invalid = [42, {}, null, undefined, ['space']]; return invalid.every((key) => aura.input.isKeyDown(key) === false && aura.input.isKeyPressed(key) === false && aura.input.isKeyReleased(key) === false); })()",
+        },
+      ],
+      frames: 1,
+      source: `
+        aura.setup = function () {
+          aura.test.equal(aura.input.isDown('space'), false, 'keyboard isDown default false');
+          aura.test.equal(aura.input.isPressed('space'), false, 'keyboard isPressed default false');
+          aura.test.equal(aura.input.isReleased('space'), false, 'keyboard isReleased default false');
+  
+          const delta = aura.input.getMouseDelta();
+          aura.test.assert(typeof aura.input.mouse.x === 'number', 'mouse.x should be numeric');
+          aura.test.assert(typeof aura.input.mouse.y === 'number', 'mouse.y should be numeric');
+          aura.test.assert(typeof aura.input.mouse.scroll === 'number', 'mouse.scroll should be numeric');
+          aura.test.assert(typeof delta.x === 'number', 'mouse delta x should be numeric');
+          aura.test.assert(typeof delta.y === 'number', 'mouse delta y should be numeric');
+          aura.test.equal(aura.input.mouse.isDown('left'), false, 'mouse isDown default false');
+          aura.test.equal(aura.input.mouse.isPressed('left'), false, 'mouse isPressed default false');
+          aura.test.equal(aura.input.mouse.isReleased('left'), false, 'mouse isReleased default false');
+  
+          aura.test.equal(aura.input.gamepad.connected, false, 'gamepad default disconnected');
+          aura.test.assert(typeof aura.input.gamepad.axis('leftX') === 'number', 'gamepad axis should return number');
+          aura.test.equal(aura.input.gamepad.isDown('a'), false, 'gamepad isDown default false');
+          aura.test.equal(aura.input.gamepad.isPressed('a'), false, 'gamepad isPressed default false');
+          aura.test.equal(aura.input.gamepad.isReleased('a'), false, 'gamepad isReleased default false');
+          aura.input.gamepad.rumble(0.2, 20);
+        };
+      `,
+    },
+  {
+      id: 'rust-host-native-readiness-smoke',
+      modes: ['native'],
+      namespaces: ['lifecycle', 'input', 'draw2d', 'assets', 'audio', 'net', 'debug'],
+      functions: [
+        'aura.setup',
+        'aura.update',
+        'aura.draw',
+        'aura.onResize',
+        'aura.input.isKeyDown',
+        'aura.input.isKeyPressed',
+        'aura.input.isKeyReleased',
+        'aura.draw2d.clear',
+        'aura.draw2d.rect',
+        'aura.debug.inspectorStats',
+        'aura.assets.load',
+        'aura.assets.getFormatSupport',
+        'aura.audio.setBusVolume',
+        'aura.audio.fadeTrack',
+        'aura.net.connect',
+        'aura.net.websocket',
+        'aura.net.fetch',
+        'aura.net.get',
+        'aura.net.post',
+      ],
+      nativeChecks: [
+        {
+          id: 'smoke.lifecycle-input.readiness.deterministic',
+          expression: "(() => { const runSample = () => { let resizeSeen = null; aura.onResize = (w, h) => { resizeSeen = [typeof w, typeof h, w, h]; }; aura.onResize(640, 360); const setupOk = typeof aura.setup === 'function'; const updateOk = typeof aura.update === 'function'; const drawOk = typeof aura.draw === 'function'; const hasInputFns = typeof aura.input?.isKeyDown === 'function' && typeof aura.input?.isKeyPressed === 'function' && typeof aura.input?.isKeyReleased === 'function'; const keySnapshot = {}; if (hasInputFns) { for (const key of ['left', 'right', 'up', 'down', 'arrowup', 'arrowdown', 'space']) { keySnapshot[key] = { down: aura.input.isKeyDown(key), pressed: aura.input.isKeyPressed(key), released: aura.input.isKeyReleased(key) }; } } const keyBooleans = Object.values(keySnapshot).every((row) => typeof row.down === 'boolean' && typeof row.pressed === 'boolean' && typeof row.released === 'boolean'); const aliasStable = hasInputFns && aura.input.isKeyDown('up') === aura.input.isKeyDown('arrowup') && aura.input.isKeyPressed('up') === aura.input.isKeyPressed('arrowup') && aura.input.isKeyReleased('up') === aura.input.isKeyReleased('arrowup'); const invalidSafe = hasInputFns && [42, {}, null, undefined, ['space']].every((key) => aura.input.isKeyDown(key) === false && aura.input.isKeyPressed(key) === false && aura.input.isKeyReleased(key) === false); return { setupOk, updateOk, drawOk, resizeSeen, hasInputFns, keyBooleans, aliasStable, invalidSafe, keySnapshot }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.setupOk === true && first.updateOk === true && first.drawOk === true && Array.isArray(first.resizeSeen) && first.resizeSeen[0] === 'number' && first.resizeSeen[1] === 'number' && first.resizeSeen[2] === 640 && first.resizeSeen[3] === 360 && first.hasInputFns === true && first.keyBooleans === true && first.aliasStable === true && first.invalidSafe === true; })()",
+        },
+        {
+          id: 'smoke.render.queue.readiness.deterministic',
+          expression: "(() => { const runSample = () => { const inspector = aura.debug?.inspectorStats; if (typeof inspector !== 'function') return null; const before = inspector(); const beforeDraw2d = Number(before?.queues?.draw2dPending); const beforeDraw3d = Number(before?.queues?.draw3dPending); const beforeOverlay = Number(before?.queues?.debugOverlayPending); const beforeNumeric = [beforeDraw2d, beforeDraw3d, beforeOverlay].every((value) => Number.isFinite(value)); let drawCallsAccepted = true; try { const white = aura.Color?.WHITE || aura.colors?.white || (typeof aura.rgba === 'function' ? aura.rgba(1, 1, 1, 1) : null); aura.draw2d.clear(0, 0, 0); aura.draw2d.rect(4, 6, 8, 10, white); aura.draw2d.rect(12, 9, 6, 4, white); } catch (_) { drawCallsAccepted = false; } const after = inspector(); const afterDraw2d = Number(after?.queues?.draw2dPending); const afterDraw3d = Number(after?.queues?.draw3dPending); const afterOverlay = Number(after?.queues?.debugOverlayPending); const afterNumeric = [afterDraw2d, afterDraw3d, afterOverlay].every((value) => Number.isFinite(value)); const draw2dDelta = beforeNumeric && afterNumeric ? (afterDraw2d - beforeDraw2d) : NaN; const draw3dDelta = beforeNumeric && afterNumeric ? (afterDraw3d - beforeDraw3d) : NaN; const overlayDelta = beforeNumeric && afterNumeric ? (afterOverlay - beforeOverlay) : NaN; return { drawCallsAccepted, beforeNumeric, afterNumeric, beforeDraw2d, afterDraw2d, draw2dDelta, draw3dDelta, overlayDelta }; }; const first = runSample(); const second = runSample(); return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && first.drawCallsAccepted === true && first.beforeNumeric === true && first.afterNumeric === true && Number.isFinite(first.draw2dDelta) && Number.isFinite(first.draw3dDelta) && Number.isFinite(first.overlayDelta) && first.draw2dDelta === 0 && first.draw3dDelta === 0 && first.overlayDelta === 0 && first.afterDraw2d === first.beforeDraw2d; })()",
+        },
+        {
+          id: 'smoke.assets-audio.reason-codes.deterministic',
+          expression: "(() => { const runSample = () => { const formatInvalidRaw = (() => { try { return aura.assets.getFormatSupport(42); } catch (_) { return null; } })(); const formatSupportedRaw = (() => { try { return aura.assets.getFormatSupport('native-smoke.png'); } catch (_) { return null; } })(); const loadMissing = (() => { try { const result = aura.assets.load('__missing__/native-smoke-missing.png'); return { threw: false, reasonCode: result?.reasonCode || null, message: null, taggedReason: null }; } catch (err) { const message = String(err); const match = /\\[reason:([^\\]]+)\\]/.exec(message); return { threw: true, reasonCode: null, message, taggedReason: match ? match[1] : null }; } })(); const invalidBusRaw = (() => { try { return aura.audio.setBusVolume('', 0.5); } catch (_) { return null; } })(); const invalidTrackRaw = (() => { try { return aura.audio.fadeTrack('invalid', { to: 0.2, duration: 0.1 }); } catch (_) { return null; } })(); return { formatInvalid: { ok: formatInvalidRaw?.ok === false, status: formatInvalidRaw?.status || null, reasonCode: formatInvalidRaw?.reasonCode || null }, formatSupported: { ok: !!formatSupportedRaw && formatSupportedRaw.ok === true, status: formatSupportedRaw?.status || null, reasonCode: formatSupportedRaw?.reasonCode || null }, loadMissing, invalidBus: { ok: invalidBusRaw?.ok === false, reasonCode: invalidBusRaw?.reasonCode || null }, invalidTrack: { ok: invalidTrackRaw?.ok === false, reasonCode: invalidTrackRaw?.reasonCode || null } }; }; const first = runSample(); const second = runSample(); const loadMissingOk = first.loadMissing?.threw === true && typeof first.loadMissing?.message === 'string' && first.loadMissing.message.includes('Asset not found: __missing__/native-smoke-missing.png') && (first.loadMissing.taggedReason === null || first.loadMissing.taggedReason === 'missing_asset'); return JSON.stringify(first) === JSON.stringify(second) && first.formatInvalid.ok === true && first.formatInvalid.status === 'unsupported' && first.formatInvalid.reasonCode === 'invalid_format_probe' && first.formatSupported.ok === true && first.formatSupported.status === 'supported' && first.formatSupported.reasonCode === 'asset_format_supported' && loadMissingOk && first.invalidBus.ok === true && first.invalidBus.reasonCode === 'invalid_bus' && first.invalidTrack.ok === true && first.invalidTrack.reasonCode === 'invalid_track_handle'; })()",
+        },
+        {
+          id: 'smoke.network.readiness.reason-codes.deterministic',
+          expression: "(() => { const parseReason = (msg) => { const match = /\\[reason:([^\\]]+)\\]/.exec(msg); return match ? match[1] : null; }; const classifyInvalidConnect = () => { try { aura.net.connect('tcp', '127.0.0.1', 0); return 'unexpected_no_throw'; } catch (err) { const msg = String(err); if (parseReason(msg) === 'optional_module_net_disabled') return 'optional_module_net_disabled'; if (msg.includes('port must be an integer in range 1..65535')) return 'invalid_connect_port'; return 'unexpected_error'; } }; const classifyInvalidWebSocket = () => { try { aura.net.websocket(42); return 'unexpected_no_throw'; } catch (err) { const msg = String(err); if (parseReason(msg) === 'optional_module_net_disabled') return 'optional_module_net_disabled'; if (msg.includes('url must be a websocket URL string')) return 'invalid_websocket_url'; return 'unexpected_error'; } }; const classifyInvalidFetch = () => { try { aura.net.fetch(42); return 'unexpected_no_throw'; } catch (err) { const msg = String(err); if (parseReason(msg) === 'optional_module_net_disabled') return 'optional_module_net_disabled'; if (msg.includes('url must be a string') || msg.includes('url must be an HTTP URL string')) return 'invalid_fetch_url'; return 'unexpected_error'; } }; const classifyRuntimeMode = () => { try { const handle = aura.net.connect('tcp', '127.0.0.1', 7777); const handleLike = !!handle && typeof handle === 'object' && typeof handle.send === 'function' && typeof handle.close === 'function'; if (handleLike) { try { handle.close(); } catch (_) {} return 'enabled_runtime'; } return 'enabled_nonstandard'; } catch (err) { const msg = String(err); if (parseReason(msg) === 'optional_module_net_disabled') return 'disabled'; return 'enabled_runtime_error'; } }; const runSample = () => { const methodsOk = typeof aura.net?.connect === 'function' && typeof aura.net?.websocket === 'function' && typeof aura.net?.fetch === 'function' && typeof aura.net?.get === 'function' && typeof aura.net?.post === 'function'; const mode = classifyRuntimeMode(); const connectReason = classifyInvalidConnect(); const websocketReason = classifyInvalidWebSocket(); const fetchReason = classifyInvalidFetch(); const consistency = mode === 'disabled' ? (connectReason === 'optional_module_net_disabled' && websocketReason === 'optional_module_net_disabled' && fetchReason === 'optional_module_net_disabled') : (connectReason === 'invalid_connect_port' && websocketReason === 'invalid_websocket_url' && fetchReason === 'invalid_fetch_url'); return { methodsOk, mode, connectReason, websocketReason, fetchReason, consistency }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.methodsOk === true && first.consistency === true && ['disabled', 'enabled_runtime', 'enabled_runtime_error', 'enabled_nonstandard'].includes(first.mode); })()",
+        },
+      ],
+      nativeFrames: 1,
+      frames: 1,
+      source: `aura.setup = function () {};`,
+    },
+  {
+      id: 'draw-audio-assets-storage',
+      namespaces: ['draw2d', 'audio', 'assets', 'storage'],
+      functions: [
+        'aura.draw2d.clear',
+        'aura.draw2d.rect',
+        'aura.draw2d.rectFill',
+        'aura.draw2d.circle',
+        'aura.draw2d.circleFill',
+        'aura.draw2d.line',
+        'aura.draw2d.sprite',
+        'aura.draw2d.text',
+        'aura.draw2d.measureText',
+        'aura.draw2d.pushTransform',
+        'aura.draw2d.popTransform',
+        'aura.draw2d.translate',
+        'aura.draw2d.rotate',
+        'aura.draw2d.scale',
+        'aura.audio.play',
+        'aura.audio.pause',
+        'aura.audio.resume',
+        'aura.audio.stop',
+        'aura.audio.setVolume',
+        'aura.audio.setMasterVolume',
+        'aura.audio.stopAll',
+        'aura.audio.setBusVolume',
+        'aura.audio.assignBus',
+        'aura.audio.fadeTrack',
+        'aura.audio.fadeBus',
+        'aura.audio.crossfade',
+        'aura.audio.update',
+        'aura.audio.clearEnvelopes',
+        'aura.audio.getMixerState',
+        'aura.assets.load',
+        'aura.assets.exists',
+        'aura.assets.loadJson',
+        'aura.assets.loadText',
+        'aura.assets.loadFont',
+        'aura.assets.loadBitmapFont',
+        'aura.assets.getFormatSupport',
+        'aura.assets.getState',
+        'aura.assets.getStateHistory',
+        'aura.assets.evict',
+        'aura.assets.getCachePolicy',
+        'aura.assets.setCachePolicy',
+        'aura.assets.preload2d',
+        'aura.assets.preload3d',
+        'aura.storage.save',
+        'aura.storage.load',
+        'aura.storage.delete',
+        'aura.storage.keys',
+      ],
+      nativeChecks: [
+        { id: 'draw2d.clear', expression: "typeof aura.draw2d?.clear === 'function'" },
+        { id: 'draw2d.rect', expression: "typeof aura.draw2d?.rect === 'function'" },
+        { id: 'draw2d.rectFill', expression: "typeof aura.draw2d?.rectFill === 'function'" },
+        { id: 'draw2d.circle', expression: "typeof aura.draw2d?.circle === 'function'" },
+        { id: 'draw2d.circleFill', expression: "typeof aura.draw2d?.circleFill === 'function'" },
+        { id: 'draw2d.line', expression: "typeof aura.draw2d?.line === 'function'" },
+        { id: 'draw2d.sprite', expression: "typeof aura.draw2d?.sprite === 'function'" },
+        { id: 'draw2d.text', expression: "typeof aura.draw2d?.text === 'function'" },
+        { id: 'draw2d.measureText', expression: "typeof aura.draw2d?.measureText === 'function'" },
+        { id: 'draw2d.pushTransform', expression: "typeof aura.draw2d?.pushTransform === 'function'" },
+        { id: 'draw2d.popTransform', expression: "typeof aura.draw2d?.popTransform === 'function'" },
+        { id: 'draw2d.translate', expression: "typeof aura.draw2d?.translate === 'function'" },
+        { id: 'draw2d.rotate', expression: "typeof aura.draw2d?.rotate === 'function'" },
+        { id: 'draw2d.scale', expression: "typeof aura.draw2d?.scale === 'function'" },
+        { id: 'audio.play', expression: "typeof aura.audio?.play === 'function'" },
+        { id: 'audio.pause', expression: "typeof aura.audio?.pause === 'function'" },
+        { id: 'audio.resume', expression: "typeof aura.audio?.resume === 'function'" },
+        { id: 'audio.stop', expression: "typeof aura.audio?.stop === 'function'" },
+        { id: 'audio.setVolume', expression: "typeof aura.audio?.setVolume === 'function'" },
+        { id: 'audio.setMasterVolume', expression: "typeof aura.audio?.setMasterVolume === 'function'" },
+        { id: 'audio.stopAll', expression: "typeof aura.audio?.stopAll === 'function'" },
+        { id: 'audio.setBusVolume', expression: "typeof aura.audio?.setBusVolume === 'function'" },
+        { id: 'audio.assignBus', expression: "typeof aura.audio?.assignBus === 'function'" },
+        { id: 'audio.fadeTrack', expression: "typeof aura.audio?.fadeTrack === 'function'" },
+        { id: 'audio.fadeBus', expression: "typeof aura.audio?.fadeBus === 'function'" },
+        { id: 'audio.crossfade', expression: "typeof aura.audio?.crossfade === 'function'" },
+        { id: 'audio.update', expression: "typeof aura.audio?.update === 'function'" },
+        { id: 'audio.clearEnvelopes', expression: "typeof aura.audio?.clearEnvelopes === 'function'" },
+        { id: 'audio.getMixerState', expression: "typeof aura.audio?.getMixerState === 'function'" },
+        { id: 'assets.load', expression: "typeof aura.assets?.load === 'function'" },
+        { id: 'assets.exists', expression: "typeof aura.assets?.exists === 'function'" },
+        { id: 'assets.loadJson', expression: "typeof aura.assets?.loadJson === 'function'" },
+        { id: 'assets.loadText', expression: "typeof aura.assets?.loadText === 'function'" },
+        { id: 'assets.loadFont', expression: "typeof aura.assets?.loadFont === 'function'" },
+        { id: 'assets.loadBitmapFont', expression: "typeof aura.assets?.loadBitmapFont === 'function'" },
+        { id: 'assets.getFormatSupport', expression: "typeof aura.assets?.getFormatSupport === 'function'" },
+        {
+          id: 'assets.streaming.surface.methods',
+          expression: "(() => ['load','getFormatSupport','getState','getStateHistory','evict','getCachePolicy','setCachePolicy','preload2d','preload3d'].every((name) => typeof aura.assets?.[name] === 'function'))()",
+        },
+        {
+          id: 'assets.streaming.lifecycle.preload.deterministic',
+          expression: "(() => { const reasonOf = (entry) => (entry && (entry.reasonCode || entry.reason)) || null; const normalizePreload = (entry) => ({ ok: !!entry && entry.ok === true, reasonCode: reasonOf(entry), requested: Number(entry?.requested || 0), loaded: Number(entry?.loaded || 0), failed: Number(entry?.failed || 0), failureReasonCodes: Array.isArray(entry?.failures) ? entry.failures.map((row) => reasonOf(row) || '').join('|') : '' }); const normalizeState = (entry) => entry ? { state: entry.state || null, reasonCode: reasonOf(entry) } : null; const normalizeHistory = (rows) => Array.isArray(rows) ? rows.map((row) => `${row.state || ''}:${reasonOf(row) || ''}`).join('|') : ''; const runSample = (tag) => { const missing2d = `__missing__/stream-2d-${tag}.png`; const missing3d = `__missing__/stream-3d-${tag}.glb`; const preload2d = aura.assets.preload2d([missing2d]); const preload3d = aura.assets.preload3d([missing3d]); const state2d = aura.assets.getState(missing2d); const state3d = aura.assets.getState(missing3d); const history2d = aura.assets.getStateHistory(missing2d); const history3d = aura.assets.getStateHistory(missing3d); return { preload2d: normalizePreload(preload2d), preload3d: normalizePreload(preload3d), state2d: normalizeState(state2d), state3d: normalizeState(state3d), history2d: normalizeHistory(history2d), history3d: normalizeHistory(history3d) }; }; const first = runSample('a'); const second = runSample('b'); return JSON.stringify(first) === JSON.stringify(second) && first.preload2d.reasonCode === 'assets_preload_partial_failure' && first.preload2d.requested === 1 && first.preload2d.failed === 1 && first.preload2d.failureReasonCodes === 'missing_asset' && first.preload3d.reasonCode === 'assets_preload_partial_failure' && first.preload3d.requested === 1 && first.preload3d.failed === 1 && first.preload3d.failureReasonCodes === 'missing_asset' && first.state2d?.state === 'failed' && first.state2d?.reasonCode === 'missing_asset' && first.state3d?.state === 'failed' && first.state3d?.reasonCode === 'missing_asset' && first.history2d.startsWith('queued:') && first.history2d.includes('|loading:') && first.history2d.includes('|failed:') && first.history3d.startsWith('queued:') && first.history3d.includes('|loading:') && first.history3d.includes('|failed:missing_asset'); })()",
+        },
+        {
+          id: 'assets.deferred-format.reason-codes.deterministic',
+          expression: "(() => { const norm = (entry) => entry ? { ok: entry.ok === true, status: entry.status || null, reasonCode: entry.reasonCode || null, extension: entry.extension || null, kindHint: entry.kindHint || null, supported: entry.supported === true, deferred: entry.deferred === true } : null; const runSample = () => { const supported = norm(aura.assets.getFormatSupport('atlas.png')); const promotedImage = norm(aura.assets.getFormatSupport('future.webp')); const deferredImage = norm(aura.assets.getFormatSupport('future.bmp')); const supportedWoff2 = norm(aura.assets.getFormatSupport('future.woff2')); const deferredFont = norm(aura.assets.getFormatSupport('future.woff')); const promotedModel = norm(aura.assets.getFormatSupport('future.glb')); const nativeVideo = norm(aura.assets.getFormatSupport('future.mp4')); const unsupported = norm(aura.assets.getFormatSupport('blob.xyz')); const invalidRaw = aura.assets.getFormatSupport(42); const invalid = invalidRaw ? { ok: invalidRaw.ok === true, status: invalidRaw.status || null, reasonCode: invalidRaw.reasonCode || null } : null; const loadReason = (() => { try { aura.assets.load('future.bmp'); } catch (err) { return String(err); } return ''; })(); const audioReason = (() => { try { aura.audio.play('future.aac'); } catch (err) { return String(err); } return ''; })(); const fontResult = aura.assets.loadFont('future.woff2'); return { supported, promotedImage, deferredImage, supportedWoff2, deferredFont, promotedModel, nativeVideo, unsupported, invalid, loadReason, audioReason, fontReason: fontResult?.reason || null }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.supported?.ok === true && first.supported?.status === 'supported' && first.supported?.reasonCode === 'asset_format_supported' && first.supported?.supported === true && first.supported?.deferred === false && first.promotedImage?.ok === true && first.promotedImage?.status === 'supported' && first.promotedImage?.reasonCode === 'asset_format_supported' && first.promotedImage?.deferred === false && first.deferredImage?.ok === true && first.deferredImage?.status === 'unsupported' && first.deferredImage?.reasonCode === 'asset_format_unsupported' && first.deferredImage?.deferred === false && first.supportedWoff2?.status === 'supported' && first.supportedWoff2?.reasonCode === 'asset_format_supported' && first.supportedWoff2?.deferred === false && first.deferredFont?.status === 'unsupported' && first.deferredFont?.reasonCode === 'asset_format_unsupported' && first.deferredFont?.deferred === false && first.promotedModel?.status === 'supported' && first.promotedModel?.reasonCode === 'asset_format_supported' && first.nativeVideo?.status === 'supported' && first.nativeVideo?.reasonCode === 'asset_format_supported' && first.nativeVideo?.extension === 'mp4' && first.unsupported?.status === 'unsupported' && first.unsupported?.reasonCode === 'asset_format_unsupported' && first.invalid?.ok === false && first.invalid?.status === 'unsupported' && first.invalid?.reasonCode === 'invalid_format_probe' && first.loadReason.includes('[reason:asset_format_unsupported]') && first.audioReason.includes('[reason:asset_format_unsupported]') && first.fontReason === 'asset_not_found'; })()",
+        },
+        {
+          id: 'assets.streaming.cache-policy.reason-codes.stable',
+          expression: "(() => { const reasonOf = (entry) => (entry && (entry.reasonCode || entry.reason)) || null; const sample = () => { const invalidPaths = aura.assets.preload2d('bad'); const invalidPath = aura.assets.preload3d(['../bad.glb']); const invalidMaxEntries = aura.assets.setCachePolicy({ maxEntries: 0 }); const invalidMaxBytes = aura.assets.setCachePolicy({ maxBytes: 0 }); const invalidMode = aura.assets.setCachePolicy({ evictionMode: 'fifo' }); const updated = aura.assets.setCachePolicy({ maxEntries: 4, maxBytes: null, evictionMode: 'oldest' }); const policy = aura.assets.getCachePolicy(); const missingEvict = aura.assets.evict('__missing__/ghost.png'); const invalidEvict = aura.assets.evict('../ghost.png'); return { invalidPaths: reasonOf(invalidPaths), invalidPath: reasonOf(invalidPath), invalidMaxEntries: reasonOf(invalidMaxEntries), invalidMaxBytes: reasonOf(invalidMaxBytes), invalidMode: reasonOf(invalidMode), updatedOk: !!updated && updated.ok === true, updatedReason: reasonOf(updated), policyMaxEntries: policy?.maxEntries, policyMaxBytes: policy?.maxBytes ?? null, policyEvictionMode: policy?.evictionMode, missingEvict: reasonOf(missingEvict), invalidEvict: reasonOf(invalidEvict) }; }; const first = sample(); const second = sample(); return JSON.stringify(first) === JSON.stringify(second) && first.invalidPaths === 'invalid_preload_paths' && first.invalidPath === 'invalid_preload_path' && first.invalidMaxEntries === 'invalid_max_entries' && first.invalidMaxBytes === 'invalid_max_bytes' && first.invalidMode === 'invalid_eviction_mode' && first.updatedOk === true && first.updatedReason === 'cache_policy_updated' && first.policyMaxEntries === 4 && first.policyMaxBytes === null && first.policyEvictionMode === 'oldest' && first.missingEvict === 'missing_asset' && first.invalidEvict === 'invalid_path'; })()",
+        },
+        {
+          id: 'audio.invalid-input.no-throw.reason-codes',
+          expression: "(() => { const runSample = () => { let threw = false; try { aura.audio.stop(-1); aura.audio.pause('x'); aura.audio.resume(99999); aura.audio.setVolume('x', 0.5); } catch (_) { threw = true; } const invalidBus = aura.audio.setBusVolume('', 0.5); const invalidTrackHandle = aura.audio.fadeTrack('oops', { to: 0.2, duration: 0.5 }); const missingBus = aura.audio.fadeBus('missing', { to: 0.2, duration: 0.5 }); const invalidCrossfade = aura.audio.crossfade('oops', 'bad', { duration: 0.5 }); return { threw, invalidBus: invalidBus?.reasonCode || null, invalidTrackHandle: invalidTrackHandle?.reasonCode || null, missingBus: missingBus?.reasonCode || null, invalidCrossfade: invalidCrossfade?.reasonCode || null }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.threw === false && first.invalidBus === 'invalid_bus' && first.invalidTrackHandle === 'invalid_track_handle' && first.missingBus === 'missing_bus' && typeof first.invalidCrossfade === 'string' && first.invalidCrossfade.length > 0; })()",
+        },
+        { id: 'storage.save', expression: "typeof aura.storage?.save === 'function'" },
+        { id: 'storage.load', expression: "typeof aura.storage?.load === 'function'" },
+        { id: 'storage.delete', expression: "typeof aura.storage?.delete === 'function'" },
+        { id: 'storage.keys', expression: "typeof aura.storage?.keys === 'function'" },
+      ],
+      frames: 2,
+      source: `
+        let img;
+        let snd;
+  
+        aura.setup = async function () {
+          await aura.assets.load(['player.png', 'coin.wav', 'level.json']);
+          img = aura.assets.image('player.png');
+          snd = aura.assets.sound('coin.wav');
+  
+          aura.test.equal(aura.assets.mesh('cube.glb').kind, 'mesh');
+          aura.test.assert(typeof aura.assets.text('dialogue.txt') === 'string');
+          const bytes = aura.assets.bytes('blob.bin');
+          aura.test.assert(typeof bytes.byteLength === 'number', 'bytes should expose byteLength');
+          aura.test.assert(typeof aura.assets.json('level.json') === 'object');
+  
+          aura.storage.set('highscore', 42);
+          aura.test.equal(aura.storage.get('highscore'), 42, 'storage get should return stored value');
+          aura.storage.delete('highscore');
+          aura.test.equal(aura.storage.get('highscore', 0), 0, 'storage fallback should apply after delete');
+  
+          const handle = aura.audio.play(snd, { loop: true });
+          aura.audio.pause(handle);
+          aura.audio.resume(handle);
+          aura.audio.setVolume(handle, 0.5);
+          aura.audio.stop(handle);
+          aura.audio.stopAll();
+        };
+  
+        aura.draw = function () {
+          aura.draw2d.clear(0, 0, 0);
+          aura.draw2d.rect(10, 10, 40, 20, aura.colors.red);
+          aura.draw2d.rectOutline(10, 40, 40, 20, aura.colors.white, 1);
+          aura.draw2d.circle(80, 20, 10, aura.colors.white);
+          aura.draw2d.circleOutline(80, 50, 10, aura.colors.white, 1);
+          aura.draw2d.line(0, 0, 100, 100, aura.colors.white, 1);
+          aura.draw2d.triangle(0, 0, 20, 0, 10, 20, aura.colors.white);
+          aura.draw2d.image(img, 30, 30);
+          aura.draw2d.sprite(img, 30, 30, { frameX: 0, frameY: 0, frameW: 16, frameH: 16 });
+          aura.draw2d.text('ok', 8, 8, { size: 12, color: aura.colors.white });
+          aura.draw2d.push();
+          aura.draw2d.translate(4, 5);
+          aura.draw2d.rotate(0.2);
+          aura.draw2d.scale(1.2, 1.2);
+          aura.draw2d.pop();
+        };
+      `,
+    },
+  {
+      id: 'compute-runtime-native',
+      modes: ['native'],
+      namespaces: ['compute'],
+      functions: [
+        'aura.compute.createPipeline',
+        'aura.compute.createBuffer',
+        'aura.compute.writeBuffer',
+        'aura.compute.createBindGroup',
+        'aura.compute.dispatch',
+        'aura.compute.readBuffer',
+        'aura.compute.destroyPipeline',
+        'aura.compute.destroyBuffer',
+        'aura.compute.destroyBindGroup',
+        'aura.compute.getError',
+      ],
+      nativeChecks: [
+        {
+          id: 'compute.surface.methods',
+          expression: "(() => ['createPipeline','createBuffer','writeBuffer','createBindGroup','dispatch','readBuffer','destroyPipeline','destroyBuffer','destroyBindGroup','getError'].every((name) => typeof aura.compute?.[name] === 'function'))()",
+        },
+        {
+          id: 'compute.dispatch.readback.queued',
+          expression: "(() => { const shader = '@group(0) @binding(0) var<storage, read_write> values: array<f32>;\\n@compute @workgroup_size(1)\\nfn main() {\\n  values[0] = values[0] + 1.0;\\n}'; const pipeline = aura.compute.createPipeline(shader); const buffer = aura.compute.createBuffer(4, 'storage-read'); aura.compute.writeBuffer(buffer, new Float32Array([2])); const bindGroup = aura.compute.createBindGroup(pipeline, [{ binding: 0, buffer }]); aura.compute.dispatch(pipeline, bindGroup, 1, 1, 1); const queued = aura.compute.readBuffer(buffer, 0, 4); globalThis.__computeNative = { pipeline, buffer, bindGroup, queuedWasNull: queued === null }; return Number.isInteger(pipeline) && pipeline > 0 && Number.isInteger(buffer) && buffer > 0 && Number.isInteger(bindGroup) && bindGroup > 0 && queued === null && aura.compute.getError(pipeline) === null && aura.compute.getError(bindGroup) === null && aura.compute.getError(buffer) === null; })()",
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'compute.dispatch.readback.deterministic',
+          expression: "(() => { const state = globalThis.__computeNative || {}; const result = aura.compute.readBuffer(state.buffer); const second = aura.compute.readBuffer(state.buffer); const values = ArrayBuffer.isView(result) ? Array.from(result).map((value) => Number(value.toFixed(6))) : []; const pipelineError = aura.compute.getError(state.pipeline); const bindGroupError = aura.compute.getError(state.bindGroup); const bufferError = aura.compute.getError(state.buffer); aura.compute.destroyBindGroup(state.bindGroup); aura.compute.destroyPipeline(state.pipeline); aura.compute.destroyBuffer(state.buffer); return state.queuedWasNull === true && result instanceof Float32Array && result.length === 1 && values.length === 1 && values[0] === 3 && second === null && pipelineError === null && bindGroupError === null && bufferError === null; })()",
+        },
+      ],
+      nativeFrames: 2,
+      frames: 1,
+      source: `
+        globalThis.__computeNative = {
+          pipeline: 0,
+          buffer: 0,
+          bindGroup: 0,
+          queuedWasNull: false,
+        };
+      `,
+    },
+  {
+      id: 'camera-2d-runtime-surface',
+      modes: ['native'],
+      namespaces: ['camera', 'draw2d', 'debug'],
+      functions: [
+        'aura.camera.x',
+        'aura.camera.y',
+        'aura.camera.zoom',
+        'aura.camera.rotation',
+        'aura.camera.follow',
+        'aura.camera.setDeadzone',
+        'aura.camera.setBounds',
+        'aura.camera.pan',
+        'aura.camera.zoomTo',
+        'aura.camera.shake',
+        'aura.camera.fade',
+        'aura.camera.flash',
+        'aura.camera.onEffectComplete',
+        'aura.camera.update',
+        'aura.camera.getState',
+        'aura.draw2d.rectFill',
+        'aura.draw2d.line',
+        'aura.draw2d.circleFill',
+        'aura.debug.inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'camera.surface.exists',
+          expression: "typeof aura.camera === 'object' && ['x', 'y', 'zoom', 'rotation'].every((key) => typeof aura.camera[key] === 'number')",
+        },
+        {
+          id: 'camera.surface.validation',
+          expression: "(() => { const original = aura.camera; aura.camera.x = 12.5; aura.camera.y = -3.25; aura.camera.zoom = 2; aura.camera.rotation = 0.5; aura.camera.x = Number.NaN; aura.camera.y = 'oops'; aura.camera.zoom = 0; aura.camera.zoom = -1; aura.camera.rotation = Number.POSITIVE_INFINITY; try { aura.camera = { x: 999 }; } catch (_) {} return aura.camera === original && aura.camera.x === 12.5 && aura.camera.y === -3.25 && aura.camera.zoom === 2 && aura.camera.rotation === 0.5; })()",
+        },
+        {
+          id: 'camera.surface.methods',
+          expression: "(() => ['follow','stopFollow','setDeadzone','clearDeadzone','setBounds','clearBounds','pan','panTo','zoomTo','rotateTo','shake','fade','flash','clearEffects','onEffectComplete','offEffectComplete','update','getState'].every((name) => typeof aura.camera?.[name] === 'function'))()",
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'camera.draw2d.pan-zoom-rotation.deterministic',
+          expression: "(() => { const sample = () => { const before = aura.debug.inspectorStats(); const start = before && before.queues ? before.queues.draw2dPending : NaN; aura.camera.x = 10; aura.camera.y = 20; aura.camera.zoom = 2; aura.camera.rotation = 0.25; aura.draw2d.rectFill(1, 2, 3, 4, aura.Color.WHITE); aura.camera.zoom = 1; aura.draw2d.line(0, 0, 4, 4, aura.Color.WHITE, 1); aura.camera.x = 0; aura.camera.y = 0; aura.camera.rotation = 0; aura.draw2d.circleFill(8, 8, 2, aura.Color.WHITE); const after = aura.debug.inspectorStats(); const end = after && after.queues ? after.queues.draw2dPending : NaN; return Number.isFinite(start) && Number.isFinite(end) ? (end - start) : NaN; }; const first = sample(); const second = sample(); return first === 12 && second === 12; })()",
+        },
+        {
+          id: 'camera.follow.deadzone.bounds.deterministic',
+          expression: "(() => { const target = { x: 0, y: 0 }; const bounded = aura.camera.setBounds({ x: -100, y: -100, width: 200, height: 200 }); const dz = aura.camera.setDeadzone({ x: -5, y: -5, width: 10, height: 10 }); const follow = aura.camera.follow(target, { lerpX: 1, lerpY: 1 }); target.x = 20; target.y = 0; const stepA = aura.camera.update(1 / 60); const stateA = aura.camera.getState(); target.x = 150; target.y = 150; const stepB = aura.camera.update(1 / 60); const stateB = aura.camera.getState(); const stop = aura.camera.stopFollow(); aura.camera.clearDeadzone(); aura.camera.clearBounds(); return bounded && bounded.ok === true && dz && dz.ok === true && follow && follow.ok === true && stepA && stepA.ok === true && stepB && stepB.ok === true && stateA && stateA.x === 15 && stateA.y === 0 && stateB && stateB.x === 100 && stateB.y === 100 && stop && stop.ok === true && stop.stopped === true; })()",
+        },
+        {
+          id: 'camera.effects.callback-ordering.deterministic',
+          expression: "(() => { aura.camera.x = 0; aura.camera.y = 0; aura.camera.zoom = 1; aura.camera.rotation = 0; aura.camera.clearEffects(); const calls = []; const late = aura.camera.onEffectComplete((evt) => calls.push(`late:${evt.effectType}:${evt.effectId}`), 10); const early = aura.camera.onEffectComplete((evt) => calls.push(`early:${evt.effectType}:${evt.effectId}`), 1); const pan = aura.camera.pan(20, 10, { duration: 0.5 }); const zoom = aura.camera.zoomTo(2, { duration: 0.5 }); const shake = aura.camera.shake({ duration: 0.5, intensity: 4, frequency: 8 }); const step = aura.camera.update(0.5); const invalidDt = aura.camera.update(0); const state = aura.camera.getState(); const removed = aura.camera.offEffectComplete(late.listenerId) === true && aura.camera.offEffectComplete(early.listenerId) === true; const expected = `early:pan:${pan.effectId}|late:pan:${pan.effectId}|early:zoom:${zoom.effectId}|late:zoom:${zoom.effectId}|early:shake:${shake.effectId}|late:shake:${shake.effectId}`; return pan && pan.ok === true && zoom && zoom.ok === true && shake && shake.ok === true && step && step.ok === true && state && Number(state.x.toFixed(6)) === 20 && Number(state.y.toFixed(6)) === 10 && Number(state.zoom.toFixed(6)) === 2 && state.activeEffects === 0 && invalidDt && invalidDt.ok === false && invalidDt.reasonCode === 'invalid_dt' && calls.join('|') === expected && removed; })()",
+        },
+        {
+          id: 'camera.effects.fade-flash.overlay-deterministic',
+          expression: "(() => { aura.camera.clearEffects(); const badFade = aura.camera.fade('bad'); const badDuration = aura.camera.fade({ duration: 0 }); const badColor = aura.camera.fade({ color: { r: 'x', g: 0, b: 0 } }); const badFlash = aura.camera.flash({ alpha: 2 }); const fade = aura.camera.fade({ duration: 0.5, fromAlpha: 0.2, toAlpha: 0.8, color: aura.rgba(0.2, 0.3, 0.4, 1) }); const start = aura.camera.getState(); const midStep = aura.camera.update(0.25); const mid = aura.camera.getState(); const flash = aura.camera.flash({ duration: 0.25, alpha: 0.6, color: aura.rgba(1, 1, 1, 1) }); const flashStart = aura.camera.getState(); const endStep = aura.camera.update(0.25); const end = aura.camera.getState(); aura.camera.clearEffects(); const cleared = aura.camera.getState(); return badFade && badFade.ok === false && badFade.reasonCode === 'invalid_fade_options' && badDuration && badDuration.ok === false && badDuration.reasonCode === 'invalid_fade_duration' && badColor && badColor.ok === false && badColor.reasonCode === 'invalid_fade_color' && badFlash && badFlash.ok === false && badFlash.reasonCode === 'invalid_flash_alpha' && fade && fade.ok === true && start && start.overlay && start.overlay.effectType === 'fade' && Number(start.overlay.alpha.toFixed(6)) === 0.2 && midStep && midStep.ok === true && mid && mid.overlay && mid.overlay.effectType === 'fade' && Number(mid.overlay.alpha.toFixed(6)) === 0.5 && flash && flash.ok === true && flash.reasonCode === 'camera_flash_started' && flashStart && flashStart.overlay && flashStart.overlay.effectType === 'flash' && Number(flashStart.overlay.alpha.toFixed(6)) === 0.6 && endStep && endStep.ok === true && end && end.overlay && end.overlay.effectType === 'fade' && Number(end.overlay.alpha.toFixed(6)) === 0.8 && cleared && cleared.overlay === null; })()",
+        },
+      ],
+      nativeFrames: 2,
+      frames: 1,
+      source: `
+        aura.setup = function () {};
+      `,
+    },
+  {
+      id: 'draw2d-product-ui-composition-native',
+      modes: ['native'],
+      namespaces: ['draw2d', 'camera', 'debug'],
+      functions: [
+        'aura.draw2d.createRenderTarget',
+        'aura.draw2d.resizeRenderTarget',
+        'aura.draw2d.destroyRenderTarget',
+        'aura.draw2d.withRenderTarget',
+        'aura.draw2d.pushClipRect',
+        'aura.draw2d.popClipRect',
+        'aura.draw2d.sprite',
+        'aura.draw2d.tileSprite',
+        'aura.draw2d.nineSlice',
+        'aura.draw2d.text',
+        'aura.camera.fade',
+        'aura.camera.flash',
+        'aura.camera.clearEffects',
+        'aura.camera.update',
+        'aura.camera.getState',
+        'aura.debug.inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.product-ui.surface.methods',
+          expression: "(() => ['createRenderTarget','resizeRenderTarget','destroyRenderTarget','withRenderTarget','pushClipRect','popClipRect','sprite','tileSprite','nineSlice','text'].every((name) => typeof aura.draw2d?.[name] === 'function') && ['fade','flash','clearEffects','update','getState'].every((name) => typeof aura.camera?.[name] === 'function') && typeof aura.debug?.inspectorStats === 'function')()",
+        },
+        {
+          id: 'draw2d.product-ui.runtime.setup',
+          expression: `(() => { try { const white = aura.Color?.WHITE || aura.colors?.white || aura.rgba(1, 1, 1, 1); const target = aura.draw2d.createRenderTarget(96, 48); const resize = aura.draw2d.resizeRenderTarget(target, 128, 64); aura.camera.clearEffects(); const fade = aura.camera.fade({ duration: 0.5, fromAlpha: 0.1, toAlpha: 0.7, color: aura.rgba(0.05, 0.08, 0.12, 1) }); globalThis.__draw2dProductUiProbe = { white, target, resize, fadeReason: fade?.reasonCode || null, frames: [], updates: [] }; aura.update = function () { const probe = globalThis.__draw2dProductUiProbe || {}; const updateIndex = Array.isArray(probe.updates) ? probe.updates.length : 0; let flash = null; let before = aura.camera.getState(); if (updateIndex === 1) { flash = aura.camera.flash({ duration: 0.25, alpha: 0.6, color: aura.rgba(1, 1, 1, 1) }); before = aura.camera.getState(); } const step = aura.camera.update(0.25); const after = aura.camera.getState(); probe.updates.push({ updateIndex, flashReason: flash?.reasonCode || null, beforeType: before?.overlay?.effectType || null, beforeAlpha: before?.overlay ? Number(before.overlay.alpha.toFixed(6)) : null, afterType: after?.overlay?.effectType || null, afterAlpha: after?.overlay ? Number(after.overlay.alpha.toFixed(6)) : null, stepReason: step?.reasonCode || null, activeEffects: Number(after?.activeEffects || 0) }); }; aura.draw = function () { const probe = globalThis.__draw2dProductUiProbe || {}; const frameIndex = Array.isArray(probe.frames) ? probe.frames.length : 0; aura.draw2d.clear(4, 6, 10); const invalidClip = aura.draw2d.pushClipRect(0, 0, 0, 10); let offscreenPush = null; let offscreenPop = null; let nestedCapture = null; const capture = aura.draw2d.withRenderTarget(probe.target, () => { aura.draw2d.clear(0, 0, 0, 0); offscreenPush = aura.draw2d.pushClipRect(4, 4, 120, 56); nestedCapture = aura.draw2d.withRenderTarget(probe.target, () => {}); aura.draw2d.rect(6, 6, 116, 52, aura.rgba(0.14, 0.18, 0.25, 0.95)); aura.draw2d.rect(10, 38, 96, 10, aura.rgba(0.4, 0.85, 1, 0.7)); aura.draw2d.text('HP 72  SCORE 1800', 14, 28, { size: 12, color: white }); offscreenPop = aura.draw2d.popClipRect(); }); const bgClip = aura.draw2d.pushClipRect(0, 0, 160, 96); aura.draw2d.tileSprite(probe.target, 0, 0, 160, 96, { tileScaleX: 1.5, tileScaleY: 1.5, tileOffsetX: frameIndex * 6, tileOffsetY: frameIndex * 3, tint: aura.rgba(0.16, 0.2, 0.26, 0.65) }); const bgPop = aura.draw2d.popClipRect(); aura.draw2d.sprite(probe.target, 12, 14, { width: 192, height: 96 }); const hudPush = aura.draw2d.pushClipRect(24, 22, 168, 72); aura.draw2d.nineSlice(probe.target, 24, 22, 168, 72, { slice: 4, tint: aura.rgba(0.18, 0.22, 0.3, 0.92) }); aura.draw2d.text('ENERGY', 36, 40, { size: 12, color: white }); aura.draw2d.tileSprite(probe.target, 36, 52, 120, 10, { tileScaleX: 0.3, tileScaleY: 0.6, tileOffsetX: frameIndex * 2, tileOffsetY: 0, tint: aura.rgba(0.4, 0.85, 1, 0.7) }); const hudPop = aura.draw2d.popClipRect(); const state = aura.camera.getState(); const inspector = aura.debug.inspectorStats(); probe.frames.push({ frameIndex, bgClip: bgClip?.reasonCode || null, bgPop: bgPop?.reasonCode || null, invalidClip: invalidClip?.reasonCode || null, captureReason: capture?.reasonCode || null, captureCommandCount: Number(capture?.commandCount || 0), offscreenPush: offscreenPush?.reasonCode || null, offscreenPop: offscreenPop?.reasonCode || null, nestedCapture: nestedCapture?.reasonCode || null, hudPush: hudPush?.reasonCode || null, hudPop: hudPop?.reasonCode || null, overlayType: state?.overlay?.effectType || null, overlayAlpha: state?.overlay ? Number(state.overlay.alpha.toFixed(6)) : null, draw2dPendingNumeric: Number.isFinite(Number(inspector?.queues?.draw2dPending)), debugOverlayPendingNumeric: Number.isFinite(Number(inspector?.queues?.debugOverlayPending)) }); }; return target?.ok === true && target?.type === 'renderTarget' && target?.__renderTarget === true && Number.isInteger(target?.handle) && target.handle > 0 && resize?.ok === true && resize?.reasonCode === 'draw2d_render_target_resized' && resize?.width === 128 && resize?.height === 64 && fade?.ok === true && fade?.reasonCode === 'camera_fade_started'; } catch (_) { return false; } })()`,
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw2d.product-ui.runtime.evidence',
+          expression: `(() => { try { const probe = globalThis.__draw2dProductUiProbe || {}; const frames = Array.isArray(probe.frames) ? probe.frames : []; const updates = Array.isArray(probe.updates) ? probe.updates : []; const frame0 = frames[0] || {}; const frame1 = frames[1] || {}; const frame2 = frames[2] || {}; const update0 = updates[0] || {}; const update1 = updates[1] || {}; const update2 = updates[2] || {}; const target = probe.target; const destroyed = aura.draw2d.destroyRenderTarget(target); const missingDestroy = aura.draw2d.destroyRenderTarget(target); aura.camera.clearEffects(); const cleared = aura.camera.getState(); return probe.fadeReason === 'camera_fade_started' && target?.ok === true && Number.isInteger(target?.handle) && target.handle > 0 && probe.resize?.ok === true && probe.resize?.width === 128 && probe.resize?.height === 64 && frames.length === 3 && updates.length === 3 && frame0.bgClip === 'draw2d_clip_pushed' && frame0.bgPop === 'draw2d_clip_popped' && frame0.invalidClip === 'invalid_clip_rect' && frame0.captureReason === 'draw2d_render_target_captured' && frame0.captureCommandCount === 6 && frame0.offscreenPush === 'draw2d_clip_pushed' && frame0.offscreenPop === 'draw2d_clip_popped' && frame0.nestedCapture === 'nested_render_target_capture' && frame0.hudPush === 'draw2d_clip_pushed' && frame0.hudPop === 'draw2d_clip_popped' && frame0.overlayType === 'fade' && frame0.overlayAlpha === 0.4 && frame0.draw2dPendingNumeric === true && frame0.debugOverlayPendingNumeric === true && frame1.captureReason === 'draw2d_render_target_captured' && frame1.captureCommandCount === 6 && frame1.overlayType === 'fade' && frame1.overlayAlpha === 0.7 && frame2.captureReason === 'draw2d_render_target_captured' && frame2.captureCommandCount === 6 && frame2.overlayType === 'fade' && frame2.overlayAlpha === 0.7 && update0.flashReason === null && update0.beforeType === 'fade' && update0.beforeAlpha === 0.1 && update0.afterType === 'fade' && update0.afterAlpha === 0.4 && update0.stepReason === 'camera_updated' && update1.flashReason === 'camera_flash_started' && update1.beforeType === 'flash' && update1.beforeAlpha === 0.6 && update1.afterType === 'fade' && update1.afterAlpha === 0.7 && update1.stepReason === 'camera_updated' && update2.flashReason === null && update2.beforeType === 'fade' && update2.beforeAlpha === 0.7 && update2.afterType === 'fade' && update2.afterAlpha === 0.7 && update2.stepReason === 'camera_updated' && destroyed?.ok === true && destroyed?.reasonCode === 'draw2d_render_target_destroyed' && missingDestroy?.ok === false && missingDestroy?.reasonCode === 'missing_render_target' && cleared?.overlay === null; } catch (_) { return false; } })()`,
+        },
+      ],
+      nativeFrames: 3,
+      source: `
+        globalThis.__draw2dProductUiProbe = {
+          target: null,
+          resize: null,
+          fadeReason: null,
+          frames: [],
+          updates: [],
+        };
+      `,
+      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-product-ui-composition-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.__draw2dProductUiProbe = {
+          target: null,
+          resize: null,
+          fadeReason: null,
+          frames: [],
+          updates: [],
+        };
+  
+        aura.setup = function () {
+          try {
+            const methodsOk = ['createRenderTarget','resizeRenderTarget','destroyRenderTarget','withRenderTarget','pushClipRect','popClipRect','sprite','tileSprite','nineSlice','text'].every((name) => typeof aura.draw2d?.[name] === 'function')
+              && ['fade','flash','clearEffects','update','getState'].every((name) => typeof aura.camera?.[name] === 'function')
+              && typeof aura.debug?.inspectorStats === 'function';
+            __record('draw2d.product-ui.surface.methods', methodsOk, methodsOk ? null : 'required_methods_missing');
+  
+            const white = aura.Color?.WHITE || aura.colors?.white || aura.rgba(1, 1, 1, 1);
+            const target = aura.draw2d.createRenderTarget(96, 48);
+            const resize = aura.draw2d.resizeRenderTarget(target, 128, 64);
+            aura.camera.clearEffects();
+            const fade = aura.camera.fade({
+              duration: 0.5,
+              fromAlpha: 0.1,
+              toAlpha: 0.7,
+              color: aura.rgba(0.05, 0.08, 0.12, 1),
+            });
+            globalThis.__draw2dProductUiProbe = {
+              white,
+              target,
+              resize,
+              fadeReason: fade?.reasonCode || null,
+              frames: [],
+              updates: [],
+            };
+            const setupOk = target?.ok === true
+              && target?.type === 'renderTarget'
+              && target?.__renderTarget === true
+              && Number.isInteger(target?.handle)
+              && target.handle > 0
+              && resize?.ok === true
+              && resize?.reasonCode === 'draw2d_render_target_resized'
+              && resize?.width === 128
+              && resize?.height === 64
+              && fade?.ok === true
+              && fade?.reasonCode === 'camera_fade_started';
+            __record('draw2d.product-ui.runtime.setup', setupOk, setupOk ? null : 'draw2d_product_ui_setup_failed');
+          } catch (__error) {
+            __record('draw2d.product-ui.runtime.setup', false, __toErrorString(__error));
+          }
+        };
+  
+        aura.update = function () {
+          if (__reported) {
+            return;
+          }
+          try {
+            const probe = globalThis.__draw2dProductUiProbe || {};
+            const updateIndex = Array.isArray(probe.updates) ? probe.updates.length : 0;
+            let flash = null;
+            let before = aura.camera.getState();
+            if (updateIndex === 1) {
+              flash = aura.camera.flash({ duration: 0.25, alpha: 0.6, color: aura.rgba(1, 1, 1, 1) });
+              before = aura.camera.getState();
+            }
+            const step = aura.camera.update(0.25);
+            const after = aura.camera.getState();
+            probe.updates.push({
+              updateIndex,
+              flashReason: flash?.reasonCode || null,
+              beforeType: before?.overlay?.effectType || null,
+              beforeAlpha: before?.overlay ? Number(before.overlay.alpha.toFixed(6)) : null,
+              afterType: after?.overlay?.effectType || null,
+              afterAlpha: after?.overlay ? Number(after.overlay.alpha.toFixed(6)) : null,
+              stepReason: step?.reasonCode || null,
+              activeEffects: Number(after?.activeEffects || 0),
+            });
+          } catch (__error) {
+            __record('draw2d.product-ui.runtime.evidence', false, __toErrorString(__error));
+            __finish();
+          }
+        };
+  
+        aura.draw = function () {
+          if (__reported) {
+            return;
+          }
+          try {
+            const probe = globalThis.__draw2dProductUiProbe || {};
+            const frameIndex = Array.isArray(probe.frames) ? probe.frames.length : 0;
+            aura.draw2d.clear(4, 6, 10);
+            const invalidClip = aura.draw2d.pushClipRect(0, 0, 0, 10);
+            let offscreenPush = null;
+            let offscreenPop = null;
+            let nestedCapture = null;
+            const capture = aura.draw2d.withRenderTarget(probe.target, () => {
+              aura.draw2d.clear(0, 0, 0, 0);
+              offscreenPush = aura.draw2d.pushClipRect(4, 4, 120, 56);
+              nestedCapture = aura.draw2d.withRenderTarget(probe.target, () => {});
+              aura.draw2d.rect(6, 6, 116, 52, aura.rgba(0.14, 0.18, 0.25, 0.95));
+              aura.draw2d.rect(10, 38, 96, 10, aura.rgba(0.4, 0.85, 1, 0.7));
+              aura.draw2d.text('HP 72  SCORE 1800', 14, 28, { size: 12, color: probe.white });
+              offscreenPop = aura.draw2d.popClipRect();
+            });
+            const bgClip = aura.draw2d.pushClipRect(0, 0, 160, 96);
+            aura.draw2d.tileSprite(probe.target, 0, 0, 160, 96, {
+              tileScaleX: 1.5,
+              tileScaleY: 1.5,
+              tileOffsetX: frameIndex * 6,
+              tileOffsetY: frameIndex * 3,
+              tint: aura.rgba(0.16, 0.2, 0.26, 0.65),
+            });
+            const bgPop = aura.draw2d.popClipRect();
+            aura.draw2d.sprite(probe.target, 12, 14, { width: 192, height: 96 });
+            const hudPush = aura.draw2d.pushClipRect(24, 22, 168, 72);
+            aura.draw2d.nineSlice(probe.target, 24, 22, 168, 72, {
+              slice: 4,
+              tint: aura.rgba(0.18, 0.22, 0.3, 0.92),
+            });
+            aura.draw2d.text('ENERGY', 36, 40, { size: 12, color: probe.white });
+            aura.draw2d.tileSprite(probe.target, 36, 52, 120, 10, {
+              tileScaleX: 0.3,
+              tileScaleY: 0.6,
+              tileOffsetX: frameIndex * 2,
+              tileOffsetY: 0,
+              tint: aura.rgba(0.4, 0.85, 1, 0.7),
+            });
+            const hudPop = aura.draw2d.popClipRect();
+            const state = aura.camera.getState();
+            const inspector = aura.debug.inspectorStats();
+            probe.frames.push({
+              frameIndex,
+              bgClip: bgClip?.reasonCode || null,
+              bgPop: bgPop?.reasonCode || null,
+              invalidClip: invalidClip?.reasonCode || null,
+              captureReason: capture?.reasonCode || null,
+              captureCommandCount: Number(capture?.commandCount || 0),
+              offscreenPush: offscreenPush?.reasonCode || null,
+              offscreenPop: offscreenPop?.reasonCode || null,
+              nestedCapture: nestedCapture?.reasonCode || null,
+              hudPush: hudPush?.reasonCode || null,
+              hudPop: hudPop?.reasonCode || null,
+              overlayType: state?.overlay?.effectType || null,
+              overlayAlpha: state?.overlay ? Number(state.overlay.alpha.toFixed(6)) : null,
+              draw2dPendingNumeric: Number.isFinite(Number(inspector?.queues?.draw2dPending)),
+              debugOverlayPendingNumeric: Number.isFinite(Number(inspector?.queues?.debugOverlayPending)),
+            });
+  
+            if (probe.frames.length < 3) {
+              return;
+            }
+  
+            const frames = Array.isArray(probe.frames) ? probe.frames : [];
+            const updates = Array.isArray(probe.updates) ? probe.updates : [];
+            const frame0 = frames[0] || {};
+            const frame1 = frames[1] || {};
+            const frame2 = frames[2] || {};
+            const update0 = updates[0] || {};
+            const update1 = updates[1] || {};
+            const update2 = updates[2] || {};
+            const target = probe.target;
+            const destroyed = aura.draw2d.destroyRenderTarget(target);
+            const missingDestroy = aura.draw2d.destroyRenderTarget(target);
+            aura.camera.clearEffects();
+            const cleared = aura.camera.getState();
+            const evidenceOk = probe.fadeReason === 'camera_fade_started'
+              && target?.ok === true
+              && Number.isInteger(target?.handle)
+              && target.handle > 0
+              && probe.resize?.ok === true
+              && probe.resize?.width === 128
+              && probe.resize?.height === 64
+              && frames.length === 3
+              && updates.length === 3
+              && frame0.bgClip === 'draw2d_clip_pushed'
+              && frame0.bgPop === 'draw2d_clip_popped'
+              && frame0.invalidClip === 'invalid_clip_rect'
+              && frame0.captureReason === 'draw2d_render_target_captured'
+              && frame0.captureCommandCount === 6
+              && frame0.offscreenPush === 'draw2d_clip_pushed'
+              && frame0.offscreenPop === 'draw2d_clip_popped'
+              && frame0.nestedCapture === 'nested_render_target_capture'
+              && frame0.hudPush === 'draw2d_clip_pushed'
+              && frame0.hudPop === 'draw2d_clip_popped'
+              && frame0.overlayType === 'fade'
+              && frame0.overlayAlpha === 0.4
+              && frame0.draw2dPendingNumeric === true
+              && frame0.debugOverlayPendingNumeric === true
+              && frame1.captureReason === 'draw2d_render_target_captured'
+              && frame1.captureCommandCount === 6
+              && frame1.overlayType === 'fade'
+              && frame1.overlayAlpha === 0.7
+              && frame2.captureReason === 'draw2d_render_target_captured'
+              && frame2.captureCommandCount === 6
+              && frame2.overlayType === 'fade'
+              && frame2.overlayAlpha === 0.7
+              && update0.flashReason === null
+              && update0.beforeType === 'fade'
+              && update0.beforeAlpha === 0.1
+              && update0.afterType === 'fade'
+              && update0.afterAlpha === 0.4
+              && update0.stepReason === 'camera_updated'
+              && update1.flashReason === 'camera_flash_started'
+              && update1.beforeType === 'flash'
+              && update1.beforeAlpha === 0.6
+              && update1.afterType === 'fade'
+              && update1.afterAlpha === 0.7
+              && update1.stepReason === 'camera_updated'
+              && update2.flashReason === null
+              && update2.beforeType === 'fade'
+              && update2.beforeAlpha === 0.7
+              && update2.afterType === 'fade'
+              && update2.afterAlpha === 0.7
+              && update2.stepReason === 'camera_updated'
+              && destroyed?.ok === true
+              && destroyed?.reasonCode === 'draw2d_render_target_destroyed'
+              && missingDestroy?.ok === false
+              && missingDestroy?.reasonCode === 'missing_render_target'
+              && cleared?.overlay === null;
+            __record(
+              'draw2d.product-ui.runtime.evidence',
+              evidenceOk,
+              evidenceOk ? null : 'draw2d_product_ui_evidence_failed',
+              evidenceOk ? null : { frames, updates, destroyed, missingDestroy, cleared },
+            );
+          } catch (__error) {
+            __record('draw2d.product-ui.runtime.evidence', false, __toErrorString(__error));
+          }
+          __finish();
+        };
+      `,
+    },
+  {
+      id: 'draw2d-mask-runtime-native',
+      modes: ['native'],
+      namespaces: ['draw2d', 'debug'],
+      functions: [
+        'aura.draw2d.createRenderTarget',
+        'aura.draw2d.destroyRenderTarget',
+        'aura.draw2d.withRenderTarget',
+        'aura.draw2d.withMask',
+        'aura.draw2d.circleFill',
+        'aura.draw2d.rectFill',
+        'aura.draw2d.line',
+        'aura.debug.inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.mask-runtime.surface.methods',
+          expression: "(() => ['createRenderTarget','destroyRenderTarget','withRenderTarget','withMask','circleFill','rectFill','line'].every((name) => typeof aura.draw2d?.[name] === 'function') && typeof aura.debug?.inspectorStats === 'function')()",
+        },
+        {
+          id: 'draw2d.mask-runtime.setup',
+          expression: `(() => { try { const white = aura.Color?.WHITE || aura.colors?.white || aura.rgba(1, 1, 1, 1); const maskTarget = aura.draw2d.createRenderTarget(64, 64); globalThis.__draw2dMaskProbe = { maskTarget, frames: [] }; aura.update = function () {}; aura.draw = function () { const probe = globalThis.__draw2dMaskProbe || {}; const frameIndex = Array.isArray(probe.frames) ? probe.frames.length : 0; aura.draw2d.clear(2, 3, 5); let nestedUnsupported = null; const renderTargetCapture = aura.draw2d.withRenderTarget(maskTarget, () => { aura.draw2d.clear(0, 0, 0, 0); aura.draw2d.circleFill(32, 32, 20, white); nestedUnsupported = aura.draw2d.withMask(maskTarget, 0, 0, 8, 8, () => {}); }); const invalidHandle = aura.draw2d.withMask({ type: 'renderTarget', handle: 9999 }, 0, 0, 8, 8, () => {}); let masked = null; if (frameIndex === 0) { masked = aura.draw2d.withMask(maskTarget, 16, 12, 48, 48, () => { aura.draw2d.rectFill(12, 10, 72, 56, aura.rgba(0.18, 0.32, 0.55, 1)); aura.draw2d.line(12, 10, 84, 66, white, 2); }); } const stats = aura.debug.inspectorStats() || {}; const masking = stats.draw2dRuntime?.masking || {}; const queues = stats.queues || {}; probe.frames.push({ frameIndex, renderTargetCapture: renderTargetCapture?.reasonCode || null, nestedUnsupported: nestedUnsupported?.reasonCode || null, invalidHandle: invalidHandle?.reasonCode || null, maskedReason: masked?.reasonCode || null, maskedCommandCount: Number(masked?.commandCount || 0), pendingPassCount: Number(masking.pendingPassCount || 0), lastSubmittedPassCount: Number(masking.lastSubmittedPassCount || 0), lastExecutedPassCount: Number(masking.lastExecutedPassCount || 0), lastSubmittedCommandCount: Number(masking.lastSubmittedCommandCount || 0), lastReasonCode: masking.lastReasonCode || null, lastOk: masking.lastOk === true, queuePending: Number(queues.draw2dMaskPending || 0) }); }; return maskTarget?.ok === true && maskTarget?.type === 'renderTarget' && maskTarget?.__renderTarget === true && Number.isInteger(maskTarget?.handle) && maskTarget.handle > 0; } catch (_) { return false; } })()`,
+        },
+      ],
+      nativePostChecks: [
+        {
+          id: 'draw2d.mask-runtime.evidence',
+          expression: `(() => { try { const probe = globalThis.__draw2dMaskProbe || {}; const frames = Array.isArray(probe.frames) ? probe.frames : []; const frame0 = frames[0] || {}; const frame1 = frames[1] || {}; const frame2 = frames[2] || {}; const target = probe.maskTarget; const destroyed = aura.draw2d.destroyRenderTarget(target); const missingDestroy = aura.draw2d.destroyRenderTarget(target); return target?.ok === true && Number.isInteger(target?.handle) && target.handle > 0 && frames.length === 3 && frame0.renderTargetCapture === 'draw2d_render_target_captured' && frame0.nestedUnsupported === 'mask_capture_inside_render_target_unsupported' && frame0.invalidHandle === 'invalid_mask_source_handle' && frame0.maskedReason === 'draw2d_mask_captured' && frame0.maskedCommandCount === 2 && frame0.pendingPassCount === 1 && frame0.queuePending === 1 && frame0.lastSubmittedPassCount === 0 && frame0.lastExecutedPassCount === 0 && frame0.lastSubmittedCommandCount === 0 && frame0.lastReasonCode === 'draw2d_mask_idle' && frame0.lastOk === true && frame1.renderTargetCapture === 'draw2d_render_target_captured' && frame1.maskedReason === null && frame1.pendingPassCount === 0 && frame1.queuePending === 0 && frame1.lastSubmittedPassCount === 1 && frame1.lastExecutedPassCount === 1 && frame1.lastSubmittedCommandCount === 2 && frame1.lastReasonCode === 'draw2d_mask_executed' && frame1.lastOk === true && frame2.renderTargetCapture === 'draw2d_render_target_captured' && frame2.maskedReason === null && frame2.pendingPassCount === 0 && frame2.queuePending === 0 && frame2.lastSubmittedPassCount === 0 && frame2.lastExecutedPassCount === 0 && frame2.lastSubmittedCommandCount === 0 && frame2.lastReasonCode === 'draw2d_mask_idle' && frame2.lastOk === true && destroyed?.ok === true && destroyed?.reasonCode === 'draw2d_render_target_destroyed' && missingDestroy?.ok === false && missingDestroy?.reasonCode === 'missing_render_target'; } catch (_) { return false; } })()`,
+          debugExpression: "(() => { try { const stats = aura.debug.inspectorStats() || {}; return { probe: globalThis.__draw2dMaskProbe || null, draw2dRuntime: stats.draw2dRuntime || null, queues: stats.queues || null }; } catch (error) { return { debugError: String(error && error.message ? error.message : error) }; } })()",
+        },
+      ],
+      nativeFrames: 3,
+      source: `
+        globalThis.__draw2dMaskProbe = {
+          maskTarget: 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-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.__draw2dMaskProbe = {
+          maskTarget: null,
+          frames: [],
+        };
+  
+        aura.setup = function () {
+          try {
+            const methodsOk = ['createRenderTarget','destroyRenderTarget','withRenderTarget','withMask','circleFill','rectFill','line']
+              .every((name) => typeof aura.draw2d?.[name] === 'function')
+              && typeof aura.debug?.inspectorStats === 'function';
+            __record('draw2d.mask-runtime.surface.methods', methodsOk, methodsOk ? null : 'required_methods_missing');
+  
+            const maskTarget = aura.draw2d.createRenderTarget(64, 64);
+            globalThis.__draw2dMaskProbe = {
+              maskTarget,
+              frames: [],
+            };
+  
+            const setupOk = maskTarget?.ok === true
+              && maskTarget?.type === 'renderTarget'
+              && maskTarget?.__renderTarget === true
+              && Number.isInteger(maskTarget?.handle)
+              && maskTarget.handle > 0;
+            __record('draw2d.mask-runtime.setup', setupOk, setupOk ? null : 'draw2d_mask_setup_failed');
+          } catch (__error) {
+            __record('draw2d.mask-runtime.setup', false, __toErrorString(__error));
+            __finish();
+          }
+        };
+  
+        aura.update = function () {};
+  
+        aura.draw = function () {
+          if (__reported) {
+            return;
+          }
+          try {
+            const probe = globalThis.__draw2dMaskProbe || {};
+            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(2, 3, 5);
+            let nestedUnsupported = null;
+            const renderTargetCapture = aura.draw2d.withRenderTarget(probe.maskTarget, () => {
+              aura.draw2d.clear(0, 0, 0, 0);
+              aura.draw2d.circleFill(32, 32, 20, white);
+              nestedUnsupported = aura.draw2d.withMask(probe.maskTarget, 0, 0, 8, 8, () => {});
+            });
+            const invalidHandle = aura.draw2d.withMask({ type: 'renderTarget', handle: 9999 }, 0, 0, 8, 8, () => {});
+            let masked = null;
+            if (frameIndex === 0) {
+              masked = aura.draw2d.withMask(probe.maskTarget, 16, 12, 48, 48, () => {
+                aura.draw2d.rectFill(12, 10, 72, 56, aura.rgba(0.18, 0.32, 0.55, 1));
+                aura.draw2d.line(12, 10, 84, 66, white, 2);
+              });
+            }
+  
+            const stats = aura.debug.inspectorStats() || {};
+            const masking = stats.draw2dRuntime?.masking || {};
+            const queues = stats.queues || {};
+            probe.frames.push({
+              frameIndex,
+              renderTargetCapture: renderTargetCapture?.reasonCode || null,
+              nestedUnsupported: nestedUnsupported?.reasonCode || null,
+              invalidHandle: invalidHandle?.reasonCode || null,
+              maskedReason: masked?.reasonCode || null,
+              maskedCommandCount: Number(masked?.commandCount || 0),
+              pendingPassCount: Number(masking.pendingPassCount || 0),
+              lastSubmittedPassCount: Number(masking.lastSubmittedPassCount || 0),
+              lastExecutedPassCount: Number(masking.lastExecutedPassCount || 0),
+              lastSubmittedCommandCount: Number(masking.lastSubmittedCommandCount || 0),
+              lastReasonCode: masking.lastReasonCode || null,
+              lastOk: masking.lastOk === true,
+              queuePending: Number(queues.draw2dMaskPending || 0),
+            });
+  
+            if (probe.frames.length < 3) {
+              return;
+            }
+  
+            const frames = Array.isArray(probe.frames) ? probe.frames : [];
+            const frame0 = frames[0] || {};
+            const frame1 = frames[1] || {};
+            const frame2 = frames[2] || {};
+            const target = probe.maskTarget;
+            const destroyed = aura.draw2d.destroyRenderTarget(target);
+            const missingDestroy = aura.draw2d.destroyRenderTarget(target);
+            const evidenceOk = target?.ok === true
+              && Number.isInteger(target?.handle)
+              && target.handle > 0
+              && frames.length === 3
+              && frame0.renderTargetCapture === 'draw2d_render_target_captured'
+              && frame0.nestedUnsupported === 'mask_capture_inside_render_target_unsupported'
+              && frame0.invalidHandle === 'invalid_mask_source_handle'
+              && frame0.maskedReason === 'draw2d_mask_captured'
+              && frame0.maskedCommandCount === 2
+              && frame0.pendingPassCount === 1
+              && frame0.queuePending === 1
+              && frame0.lastSubmittedPassCount === 0
+              && frame0.lastExecutedPassCount === 0
+              && frame0.lastSubmittedCommandCount === 0
+              && frame0.lastReasonCode === 'draw2d_mask_idle'
+              && frame0.lastOk === true
+              && frame1.renderTargetCapture === 'draw2d_render_target_captured'
+              && frame1.maskedReason === null
+              && frame1.pendingPassCount === 0
+              && frame1.queuePending === 0
+              && frame1.lastSubmittedPassCount === 1
+              && frame1.lastExecutedPassCount === 1
+              && frame1.lastSubmittedCommandCount === 2
+              && frame1.lastReasonCode === 'draw2d_mask_executed'
+              && frame1.lastOk === true
+              && frame2.renderTargetCapture === 'draw2d_render_target_captured'
+              && frame2.maskedReason === null
+              && frame2.pendingPassCount === 0
+              && frame2.queuePending === 0
+              && frame2.lastSubmittedPassCount === 0
+              && frame2.lastExecutedPassCount === 0
+              && frame2.lastSubmittedCommandCount === 0
+              && frame2.lastReasonCode === 'draw2d_mask_idle'
+              && frame2.lastOk === true
+              && destroyed?.ok === true
+              && destroyed?.reasonCode === 'draw2d_render_target_destroyed'
+              && missingDestroy?.ok === false
+              && missingDestroy?.reasonCode === 'missing_render_target';
+            __record(
+              'draw2d.mask-runtime.evidence',
+              evidenceOk,
+              evidenceOk ? null : 'draw2d_mask_runtime_evidence_failed',
+              evidenceOk ? null : { frames, destroyed, missingDestroy, draw2dRuntime: stats.draw2dRuntime || null, queues },
+            );
+          } catch (__error) {
+            __record('draw2d.mask-runtime.evidence', false, __toErrorString(__error));
+          }
+          __finish();
+        };
+      `,
+    },
+  {
+      id: 'runtime-behavior-native',
+      modes: ['native'],
+      namespaces: ['draw2d', 'audio', 'assets', 'debug', 'storage'],
+      functions: [
+        'aura.draw2d.sprite',
+        'aura.draw2d.text',
+        'aura.draw2d.measureText',
+        'aura.audio.play',
+        'aura.audio.stop',
+        'aura.audio.pause',
+        'aura.audio.resume',
+        'aura.audio.setVolume',
+        'aura.assets.load',
+        'aura.assets.exists',
+        'aura.storage.save',
+        'aura.storage.load',
+        'aura.storage.delete',
+        'aura.debug.log',
+        'aura.debug.drawRect',
+        'aura.debug.drawCircle',
+        'aura.debug.drawText',
+        'aura.debug.enableInspector',
+        'aura.debug.inspectorStats',
+      ],
+      nativeChecks: [
+        {
+          id: 'draw2d.measureText.scalesWithSize',
+          expression: "(() => { const small = aura.draw2d.measureText('Hello', { size: 8 }); const large = aura.draw2d.measureText('Hello', { size: 24 }); return Number.isFinite(small.width) && Number.isFinite(large.width) && large.width > small.width && large.height >= small.height; })()",
+        },
+        {
+          id: 'draw2d.measureText.emptyStringZeroWidth',
+          expression: "(() => { const metrics = aura.draw2d.measureText('', { size: 24 }); return metrics.width === 0 && metrics.height === 0; })()",
+        },
+        {
+          id: 'draw2d.spriteAndText.acceptCalls',
+          expression: "(() => { try { aura.draw2d.sprite({ path: 'player.png' }, 10, 20, { width: 16 }); aura.draw2d.text('ok', 5, 5, { size: 12, align: 'center', color: aura.rgba(1, 1, 1, 1) }); return true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'assets.exists.missingIsFalse',
+          expression: "aura.assets.exists('__missing__/ghost.png') === false",
+        },
+        {
+          id: 'assets.load.missingThrowsDeterministicError',
+          expression: "(() => { try { aura.assets.load('__missing__/ghost.png'); return false; } catch (e) { return String(e).includes('Asset not found: __missing__/ghost.png'); } })()",
+        },
+        {
+          id: 'audio.play.missingAssetThrows',
+          expression: "(() => { try { aura.audio.play('__missing__/ghost.wav'); return false; } catch (e) { return String(e).includes('Asset not found: __missing__/ghost.wav'); } })()",
+        },
+        {
+          id: 'audio.invalidHandle.noThrow',
+          expression: "(() => { try { aura.audio.stop(-1); aura.audio.pause('x'); aura.audio.resume(99999); aura.audio.setVolume('x', 0.5); return true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'debug.devHelpers.callable',
+          expression: "(() => { try { aura.debug.log('conformance'); aura.debug.drawRect(1, 2, 3, 4); aura.debug.drawCircle(5, 6, 7); aura.debug.drawText('dbg', 8, 9); return true; } catch (_) { return false; } })()",
+        },
+        {
+          id: 'debug.inspector.stats-shape',
+          expression: "(() => { try { const enabled = aura.debug.enableInspector(true); const stats = aura.debug.inspectorStats(); const disabled = aura.debug.enableInspector(false); const phase2 = stats.phase2 || {}; const rows = [phase2.animation, phase2.tilemap, phase2.scene3d, phase2.particles]; const phase2Ok = rows.every((row) => row && Number.isFinite(row.active) && Number.isFinite(row.total) && Number.isFinite(row.callbackQueueDepth) && row.active >= 0 && row.total >= 0 && row.callbackQueueDepth >= 0); const scene3dRuntime = stats.scene3dRuntime || {}; const submission = scene3dRuntime.submission || {}; const camera = scene3dRuntime.camera || {}; const resources = scene3dRuntime.resources || {}; const cameraVectorsOk = Number.isFinite(camera.position?.x) && Number.isFinite(camera.position?.y) && Number.isFinite(camera.position?.z) && Number.isFinite(camera.target?.x) && Number.isFinite(camera.target?.y) && Number.isFinite(camera.target?.z); const billboardOk = Number.isFinite(submission.billboardCommandsPending) && Number.isFinite(submission.billboardUniqueTextureHandles) && Number.isFinite(submission.billboardLastCommandCount) && Number.isFinite(submission.billboardLastRenderedCount) && Number.isFinite(submission.billboardLastBatchCount) && typeof submission.billboardLastReasonCode === 'string'; const morphOk = Number.isFinite(submission.morphCandidateDrawCount) && Number.isFinite(submission.morphCustomPipelineDrawCount) && Number.isFinite(submission.morphMissingBufferDrawCount) && Number.isFinite(submission.morphPreparedBindGroupCount) && Number.isFinite(submission.morphExecutedBindGroupCount) && Number.isFinite(submission.morphExecutedMeshCount) && Number.isFinite(submission.morphExecutedNonZeroWeightDrawCount) && Number.isFinite(submission.morphExecutedNonZeroWeightMeshCount) && typeof submission.morphLastReasonCode === 'string' && Number.isFinite(resources.morphTrackedMeshCount) && Number.isFinite(resources.morphPendingUploadCount); const scene3dRuntimeOk = Number.isFinite(submission.drawMeshPending) && Number.isFinite(submission.uniqueMeshHandles) && Number.isFinite(submission.uniqueMaterialHandles) && Number.isFinite(submission.nonDefaultTransforms) && billboardOk && morphOk && typeof submission.skyboxRequested === 'boolean' && typeof submission.clearRequested === 'boolean' && typeof camera.mode === 'string' && camera.mode.length > 0 && Number.isFinite(camera.aspect) && Number.isFinite(camera.fovDegrees) && Number.isFinite(camera.near) && Number.isFinite(camera.far) && cameraVectorsOk && Number.isFinite(resources.meshHandlesRegistered) && Number.isFinite(resources.meshUploadsPending) && Number.isFinite(resources.materialHandlesKnown) && Number.isFinite(resources.materialCommandsPending) && Number.isFinite(resources.lightPointCount) && typeof resources.lightDirectionalActive === 'boolean'; return enabled === true && disabled === false && Number.isFinite(stats.frameCount) && Number.isFinite(stats.frame.fps) && Number.isFinite(stats.frame.deltaSeconds) && Number.isFinite(stats.frame.elapsedSeconds) && Number.isFinite(stats.window.width) && Number.isFinite(stats.window.height) && Number.isFinite(stats.window.pixelRatio) && Number.isFinite(stats.queues.draw2dPending) && Number.isFinite(stats.queues.draw3dPending) && Number.isFinite(stats.queues.debugOverlayPending) && phase2Ok && scene3dRuntimeOk; } catch (_) { return false; } })()",
+          debugExpression: "(() => { try { const enabled = aura.debug.enableInspector(true); const stats = aura.debug.inspectorStats(); const disabled = aura.debug.enableInspector(false); const phase2 = stats.phase2 || {}; const rows = [phase2.animation, phase2.tilemap, phase2.scene3d, phase2.particles]; const phase2Rows = rows.map((row) => ({ present: !!row, active: row?.active, total: row?.total, callbackQueueDepth: row?.callbackQueueDepth })); const phase2Ok = rows.every((row) => row && Number.isFinite(row.active) && Number.isFinite(row.total) && Number.isFinite(row.callbackQueueDepth) && row.active >= 0 && row.total >= 0 && row.callbackQueueDepth >= 0); const scene3dRuntime = stats.scene3dRuntime || {}; const submission = scene3dRuntime.submission || {}; const camera = scene3dRuntime.camera || {}; const resources = scene3dRuntime.resources || {}; const cameraVectorsOk = Number.isFinite(camera.position?.x) && Number.isFinite(camera.position?.y) && Number.isFinite(camera.position?.z) && Number.isFinite(camera.target?.x) && Number.isFinite(camera.target?.y) && Number.isFinite(camera.target?.z); const billboardOk = Number.isFinite(submission.billboardCommandsPending) && Number.isFinite(submission.billboardUniqueTextureHandles) && Number.isFinite(submission.billboardLastCommandCount) && Number.isFinite(submission.billboardLastRenderedCount) && Number.isFinite(submission.billboardLastBatchCount) && typeof submission.billboardLastReasonCode === 'string'; const morphOk = Number.isFinite(submission.morphCandidateDrawCount) && Number.isFinite(submission.morphCustomPipelineDrawCount) && Number.isFinite(submission.morphMissingBufferDrawCount) && Number.isFinite(submission.morphPreparedBindGroupCount) && Number.isFinite(submission.morphExecutedBindGroupCount) && Number.isFinite(submission.morphExecutedMeshCount) && Number.isFinite(submission.morphExecutedNonZeroWeightDrawCount) && Number.isFinite(submission.morphExecutedNonZeroWeightMeshCount) && typeof submission.morphLastReasonCode === 'string' && Number.isFinite(resources.morphTrackedMeshCount) && Number.isFinite(resources.morphPendingUploadCount); const scene3dRuntimeOk = Number.isFinite(submission.drawMeshPending) && Number.isFinite(submission.uniqueMeshHandles) && Number.isFinite(submission.uniqueMaterialHandles) && Number.isFinite(submission.nonDefaultTransforms) && billboardOk && morphOk && typeof submission.skyboxRequested === 'boolean' && typeof submission.clearRequested === 'boolean' && typeof submission.environmentMapConfigured === 'boolean' && Number.isFinite(submission.pointShadowLightCount) && Number.isFinite(submission.spotShadowLightCount) && Number.isFinite(submission.pointShadowPassCount) && Number.isFinite(submission.spotShadowPassCount) && typeof camera.mode === 'string' && camera.mode.length > 0 && Number.isFinite(camera.aspect) && Number.isFinite(camera.fovDegrees) && Number.isFinite(camera.near) && Number.isFinite(camera.far) && cameraVectorsOk && Number.isFinite(resources.meshHandlesRegistered) && Number.isFinite(resources.meshUploadsPending) && Number.isFinite(resources.materialHandlesKnown) && Number.isFinite(resources.materialCommandsPending) && Number.isFinite(resources.lightPointCount) && Number.isFinite(resources.lightSpotCount) && typeof resources.lightDirectionalActive === 'boolean'; return { enabled, disabled, frameCount: stats?.frameCount, frame: stats?.frame || null, window: stats?.window || null, queues: stats?.queues || null, phase2Ok, phase2Rows, scene3dRuntimeOk, cameraMode: camera?.mode, cameraAspect: camera?.aspect, cameraVectorsOk, submission, resources }; } catch (error) { return { traceError: String(error && error.message ? error.message : error) }; } })()",
+        },
+        {
+          id: 'debug.inspector.scene3d-animation-shape',
+          expression: "(() => { try { aura.debug.enableInspector(true); const stats = aura.debug.inspectorStats(); aura.debug.enableInspector(false); const animation = stats?.scene3dRuntime?.animation || {}; return Number.isFinite(animation.clipCount) && Number.isFinite(animation.playingClipCount) && Number.isFinite(animation.transitionCount) && Number.isFinite(animation.activeWeightSum) && Number.isFinite(animation.loopEventsDispatched) && Number.isFinite(animation.completeEventsDispatched) && Number.isFinite(animation.blendEventsDispatched) && Number.isFinite(animation.skinnedClipCount) && Number.isFinite(animation.totalBoneCount) && Number.isFinite(animation.skinningInfluenceSum) && Number.isFinite(animation.skinningUpdates); } catch (_) { return false; } })()",
+        },
+        {
+          id: 'storage.saveLoadDelete.roundTrip',
+          expression: "(() => { const key = '__conformance_roundtrip__'; aura.storage.save(key, { score: 99 }); const loaded = aura.storage.load(key); const listed = aura.storage.keys(); aura.storage.delete(key); return !!loaded && loaded.score === 99 && Array.isArray(listed) && listed.includes(key) && aura.storage.load(key) === null; })()",
+        },
+        {
+          id: 'optional.modules.steam.not-exposed',
+          expression: "typeof aura.steam === 'undefined' && !Object.prototype.hasOwnProperty.call(aura, 'steam')",
+        },
+      ],
+      nativeFrames: 2,
+      source: `
+        aura.setup = function () {};
+      `,
+    },
+  {
+      id: 'audio-mixer-fade-bus-controls',
+      modes: ['shim', 'native'],
+      namespaces: ['audio', 'assets'],
+      functions: [
+        'aura.audio.setBusVolume',
+        'aura.audio.assignBus',
+        'aura.audio.fadeTrack',
+        'aura.audio.fadeBus',
+        'aura.audio.crossfade',
+        'aura.audio.update',
+        'aura.audio.clearEnvelopes',
+        'aura.audio.getMixerState',
+      ],
+      nativeChecks: [
+        {
+          id: 'audio.mixer.surface.methods',
+          expression: "(() => ['setBusVolume','assignBus','fadeTrack','fadeBus','crossfade','update','clearEnvelopes','getMixerState'].every((name) => typeof aura.audio?.[name] === 'function'))()",
+        },
+        {
+          id: 'audio.mixer.reason-codes.deterministic',
+          expression: "(() => { const runSample = () => { const invalidBus = aura.audio.setBusVolume('', 0.5); const invalidTrackHandle = aura.audio.fadeTrack('oops', { to: 0.2, duration: 0.5 }); const missingTrack = aura.audio.fadeTrack(999999, { to: 0.2, duration: 0.5 }); const missingBus = aura.audio.fadeBus('missing', { to: 0.2, duration: 0.5 }); const invalidDt = aura.audio.update(0); return { invalidBus: invalidBus?.reasonCode || null, invalidTrackHandle: invalidTrackHandle?.reasonCode || null, missingTrack: missingTrack?.reasonCode || null, missingBus: missingBus?.reasonCode || null, invalidDt: invalidDt?.reasonCode || null }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.invalidBus === 'invalid_bus' && first.invalidTrackHandle === 'invalid_track_handle' && first.missingTrack === 'missing_track' && first.missingBus === 'missing_bus' && first.invalidDt === 'invalid_dt'; })()",
+        },
+      ],
+      frames: 1,
+      nativeFrames: 1,
+      source: `
+        aura.setup = async function () {
+          if (aura.assets && typeof aura.assets.load === 'function') {
+            await aura.assets.load(['coin.wav']);
+          }
+  
+          const runSample = () => {
+            const h1 = aura.audio.play('coin.wav', { volume: 1, bus: 'music' });
+            const h2 = aura.audio.play('coin.wav', { volume: 1, bus: 'sfx' });
+            const h3 = aura.audio.play('coin.wav', { volume: 0.5, bus: 'music' });
+  
+            const invalidBus = aura.audio.setBusVolume('', 0.5);
+            const invalidTrackHandle = aura.audio.fadeTrack('oops', { to: 0.2, duration: 0.5 });
+            const missingTrack = aura.audio.fadeTrack(999999, { to: 0.2, duration: 0.5 });
+            const missingBus = aura.audio.fadeBus('missing', { to: 0.2, duration: 0.5 });
+  
+            const setMusic = aura.audio.setBusVolume('music', 0.6);
+            const setSfx = aura.audio.setBusVolume('sfx', 0.8);
+            const moveTrack = aura.audio.assignBus(h2, 'music');
+            const fadeTrack = aura.audio.fadeTrack(h3, { to: 0.1, duration: 0.5 });
+            const fadeBus = aura.audio.fadeBus('music', { to: 0.4, duration: 0.5 });
+            const crossfade = aura.audio.crossfade(h1, h2, { duration: 0.5, toStartVolume: 0, toVolume: 0.9, stopFrom: true });
+  
+            const stepA = aura.audio.update(0.25);
+            const stateA = aura.audio.getMixerState();
+            const invalidDt = aura.audio.update(0);
+            const stepB = aura.audio.update(0.25);
+            const stateB = aura.audio.getMixerState();
+            const cleared = aura.audio.clearEnvelopes();
+  
+            const musicBus = stateB && Array.isArray(stateB.buses)
+              ? stateB.buses.find((entry) => entry.bus === 'music')
+              : null;
+            const trackTwo = stateB && Array.isArray(stateB.tracks)
+              ? stateB.tracks.find((entry) => entry.handle === h2)
+              : null;
+            const trackThree = stateB && Array.isArray(stateB.tracks)
+              ? stateB.tracks.find((entry) => entry.handle === h3)
+              : null;
+  
+            const snapshot = {
+              invalidBus: invalidBus && invalidBus.reasonCode,
+              invalidTrackHandle: invalidTrackHandle && invalidTrackHandle.reasonCode,
+              missingTrack: missingTrack && missingTrack.reasonCode,
+              missingBus: missingBus && missingBus.reasonCode,
+              setMusicOk: !!setMusic && setMusic.ok === true,
+              setSfxOk: !!setSfx && setSfx.ok === true,
+              moveTrackOk: !!moveTrack && moveTrack.ok === true,
+              fadeTrackOk: !!fadeTrack && fadeTrack.ok === true,
+              fadeBusOk: !!fadeBus && fadeBus.ok === true,
+              crossfadeOk: !!crossfade && crossfade.ok === true,
+              stepAOk: !!stepA && stepA.ok === true,
+              stepBOk: !!stepB && stepB.ok === true,
+              invalidDt: invalidDt && invalidDt.reasonCode,
+              stateAEnvelopes: stateA && Array.isArray(stateA.envelopes) ? stateA.envelopes.length : -1,
+              stateBEnvelopes: stateB && Array.isArray(stateB.envelopes) ? stateB.envelopes.length : -1,
+              stateBTracks: stateB && Array.isArray(stateB.tracks) ? stateB.tracks.length : -1,
+              musicBusVolume: musicBus ? Number(musicBus.volume.toFixed(6)) : null,
+              trackTwoVolume: trackTwo ? Number(trackTwo.effectiveVolume.toFixed(6)) : null,
+              trackThreeVolume: trackThree ? Number(trackThree.effectiveVolume.toFixed(6)) : null,
+              cleared: cleared && cleared.cleared,
+            };
+  
+            aura.audio.stopAll();
+            return JSON.stringify(snapshot);
+          };
+  
+          const first = runSample();
+          const second = runSample();
+          aura.test.equal(first, second, 'audio mixer sample must be deterministic across reruns');
+  
+          const parsed = JSON.parse(first);
+          aura.test.equal(parsed.invalidBus, 'invalid_bus', 'invalid bus should be reason-coded');
+          aura.test.equal(parsed.invalidTrackHandle, 'invalid_track_handle', 'invalid track handle should be reason-coded');
+          aura.test.equal(parsed.missingTrack, 'missing_track', 'missing track should be reason-coded');
+          aura.test.equal(parsed.missingBus, 'missing_bus', 'missing bus should be reason-coded');
+          aura.test.equal(parsed.invalidDt, 'invalid_dt', 'invalid dt should be reason-coded');
+          aura.test.assert(parsed.setMusicOk && parsed.setSfxOk && parsed.moveTrackOk, 'bus transitions should succeed');
+          aura.test.assert(parsed.fadeTrackOk && parsed.fadeBusOk && parsed.crossfadeOk, 'fade helpers should succeed');
+          aura.test.assert(parsed.stepAOk && parsed.stepBOk, 'audio update steps should succeed');
+          aura.test.equal(parsed.stateAEnvelopes, 4, 'mid-step should retain all envelopes');
+          aura.test.equal(parsed.stateBEnvelopes, 0, 'final step should complete envelopes');
+          aura.test.equal(parsed.stateBTracks, 2, 'crossfade should stop source track after completion');
+          aura.test.equal(parsed.musicBusVolume, 0.4, 'music bus should settle at deterministic target');
+          aura.test.equal(parsed.trackTwoVolume, 0.36, 'crossfade target track effective volume should be deterministic');
+          aura.test.equal(parsed.trackThreeVolume, 0.04, 'faded track effective volume should be deterministic');
+          aura.test.equal(parsed.cleared, 0, 'clearEnvelopes should report zero after completion');
+        };
+      `,
+    },
+  {
+      id: 'tilemap-query-bridge',
+      namespaces: ['tilemap'],
+      functions: [
+        'aura.tilemap.queryPoint',
+        'aura.tilemap.queryAABB',
+        'aura.tilemap.queryRay',
+        'aura.tilemap.queryRaycast',
+      ],
+      nativeChecks: [
+        { id: 'tilemap.queryPoint', expression: "typeof aura.tilemap?.queryPoint === 'function'" },
+        { id: 'tilemap.queryAABB', expression: "typeof aura.tilemap?.queryAABB === 'function'" },
+        { id: 'tilemap.queryRay', expression: "typeof aura.tilemap?.queryRay === 'function'" },
+        { id: 'tilemap.queryRaycast', expression: "typeof aura.tilemap?.queryRaycast === 'function'" },
+        { id: 'tilemap.query.invalid-handle.reason-code', expression: "(() => { const result = aura.tilemap.queryPoint(999999, { x: 0, y: 0 }); return result && result.ok === false && result.reasonCode === 'invalid_map_handle'; })()" },
+        {
+          id: 'tilemap.query.reason-codes.expanded',
+          expression: "(() => { const runSample = () => { const fixture = { width: 2, height: 2, tilewidth: 16, tileheight: 16, layers: [ { name: 'ground', type: 'tilelayer', width: 2, height: 2, data: [1, 0, 0, 0], properties: { solid: true } } ], tilesets: [ { firstgid: 1, image: 'tiles.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1 } ] }; const mapId = aura.tilemap.import(fixture); const invalidPoint = aura.tilemap.queryPoint(mapId, { x: 'bad', y: 0 }); const invalidAabb = aura.tilemap.queryAABB(mapId, { x: 0, y: 0, w: 0, h: 1 }); const invalidRay = aura.tilemap.queryRay(mapId, { x: 0, y: 0, dx: 0, dy: 0, maxDistance: 10 }); const invalidModel = aura.tilemap.queryPoint({ width: 4 }, 1, 1); const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 }); let threw = false; try { aura.tilemap.queryRay(mapId, { x: 0, y: 0, dx: 'bad', dy: 0, maxDistance: 10 }); } catch (_) { threw = true; } aura.tilemap.unload(mapId); return { invalidPoint: invalidPoint?.reasonCode || null, invalidAabb: invalidAabb?.reasonCode || null, invalidRay: invalidRay?.reasonCode || null, invalidModel: invalidModel?.reasonCode || null, invalidHandle: invalidHandle?.reasonCode || null, threw }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.invalidPoint === 'invalid_point_args' && first.invalidAabb === 'invalid_aabb_args' && first.invalidRay === 'invalid_ray_args' && first.invalidModel === 'invalid_model' && first.invalidHandle === 'invalid_map_handle' && first.threw === false; })()",
+        },
+        {
+          id: 'tilemap.query.model-schema.deterministic',
+          expression: "(() => { const runSample = () => { const model = { width: 2, height: 2, tilewidth: 16, tileheight: 16, solidLayerNames: ['solid'], layers: [ { name: 'solid', width: 2, height: 2, data: [1, 0, 0, 0], properties: { solid: true } }, { name: 'dynamic', width: 2, height: 2, data: [0, 1, 0, 0], queryEnabled: true } ], solidCells: [ { x: 1, y: 0, layerIndex: 5, layerName: 'manual' }, { x: 1, y: 0, layerIndex: 5, layerName: 'manual' } ] }; const point = aura.tilemap.queryPoint(model, { x: 16.5, y: 0.5 }); const aabb = aura.tilemap.queryAABB(model, { x: 0, y: 0, w: 32, h: 16 }); const ray = aura.tilemap.queryRay(model, { x: 0.5, y: 0.5, dx: 1, dy: 0, maxDistance: 64 }); return { pointLayers: Array.isArray(point?.hits) ? point.hits.map((hit) => hit.layerIndex).join(',') : '', aabbLayers: Array.isArray(aabb?.hits) ? aabb.hits.map((hit) => hit.layerIndex).join(',') : '', rayLayer: Number(ray?.hitCell?.layerIndex ?? -1), pointOk: point?.ok === true, aabbOk: aabb?.ok === true, rayOk: ray?.ok === true, pointHit: point?.hit === true, aabbHit: aabb?.hit === true, rayHit: ray?.hit === true, invalidModelReason: aura.tilemap.queryPoint({ width: 2 }, { x: 0, y: 0 })?.reasonCode, invalidAabbReason: aura.tilemap.queryAABB(model, { x: 0, y: 0, w: 0, h: 1 })?.reasonCode }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.pointOk === true && first.aabbOk === true && first.rayOk === true && first.pointHit === true && first.aabbHit === true && first.rayHit === true && first.pointLayers === '1,5' && first.aabbLayers === '0,1,5' && first.rayLayer === 0 && first.invalidModelReason === 'invalid_model' && first.invalidAabbReason === 'invalid_aabb_args'; })()",
+        },
+      ],
+      frames: 1,
+      source: `
+        aura.setup = function () {
+          const mkLayer = (name, hits) => {
+            const data = new Array(16).fill(0);
+            for (const [x, y] of hits) data[(y * 4) + x] = 1;
+            return {
+              name,
+              type: 'tilelayer',
+              width: 4,
+              height: 4,
+              data,
+              properties: { solid: name.startsWith('walls-') },
+            };
+          };
+          const fixture = {
+            width: 4,
+            height: 4,
+            tilewidth: 16,
+            tileheight: 16,
+            solidLayerNames: ['walls-a', 'walls-b'],
+            layers: [
+              mkLayer('ground', [[0, 0], [3, 3]]),
+              mkLayer('walls-a', [[1, 1], [2, 1]]),
+              mkLayer('walls-b', [[1, 1]]),
+            ],
+            tilesets: [
+              { firstgid: 1, image: 'tiles.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1 },
+            ],
+          };
+          const mapHandle = aura.tilemap.import(fixture);
+  
+          const point = aura.tilemap.queryPoint(mapHandle, { x: 16.5, y: 16.5 });
+          const pointRepeat = aura.tilemap.queryPoint(mapHandle, { x: 16.5, y: 16.5 });
+          const aabb = aura.tilemap.queryAABB(mapHandle, { x: 0, y: 0, w: 48, h: 32 });
+          const ray = aura.tilemap.queryRay(mapHandle, { x: 0.5, y: 16.5, dx: 1, dy: 0, maxDistance: 96 });
+          const rayAlias = aura.tilemap.queryRaycast(mapHandle, { x: 0.5, y: 16.5, dx: 1, dy: 0, maxDistance: 96 });
+  
+          aura.test.assert(point && point.ok === true && point.hit === true, 'tilemap point query should hit');
+          aura.test.assert(Array.isArray(point.hits) && point.hits.length === 2, 'tilemap point should return deterministic layered hits');
+          aura.test.assert(point.hits[0].layerIndex === 1 && point.hits[1].layerIndex === 2, 'tilemap point ordering should be deterministic');
+          aura.test.assert(JSON.stringify(point.hits) === JSON.stringify(pointRepeat.hits), 'tilemap point ordering should be stable across reruns');
+  
+          aura.test.assert(aabb && aabb.ok === true && aabb.hit === true, 'tilemap aabb query should hit');
+          aura.test.assert(Array.isArray(aabb.hits) && aabb.hits.length === 3, 'tilemap aabb should include deterministic hit set');
+          aura.test.assert(aabb.hits[0].layerIndex === 1 && aabb.hits[0].x === 1 && aabb.hits[0].y === 1, 'tilemap aabb hit ordering start');
+          aura.test.assert(aabb.hits[1].layerIndex === 1 && aabb.hits[1].x === 2 && aabb.hits[1].y === 1, 'tilemap aabb hit ordering middle');
+          aura.test.assert(aabb.hits[2].layerIndex === 2 && aabb.hits[2].x === 1 && aabb.hits[2].y === 1, 'tilemap aabb hit ordering end');
+  
+          aura.test.assert(ray && ray.ok === true && ray.hit === true && ray.hitCell && ray.hitCell.x === 1 && ray.hitCell.y === 1, 'tilemap ray query should return first deterministic hit');
+          aura.test.assert(rayAlias && rayAlias.ok === true && rayAlias.hit === true && rayAlias.hitCell && rayAlias.hitCell.x === ray.hitCell.x && rayAlias.hitCell.y === ray.hitCell.y, 'tilemap ray alias should match queryRay');
+  
+          const invalidPoint = aura.tilemap.queryPoint(mapHandle, { x: 'bad', y: 0 });
+          const invalidAabb = aura.tilemap.queryAABB(mapHandle, { x: 0, y: 0, w: 0, h: 1 });
+          const invalidRay = aura.tilemap.queryRay(mapHandle, { x: 0, y: 0, dx: 0, dy: 0, maxDistance: 10 });
+          const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 });
+          const invalidModel = aura.tilemap.queryPoint({ width: 4 }, 1, 1);
+          const unloadResult = aura.tilemap.unload(mapHandle);
+  
+          aura.test.assert(invalidPoint && invalidPoint.ok === false && invalidPoint.reasonCode === 'invalid_point_args', 'tilemap invalid point input should be reason-coded');
+          aura.test.assert(invalidAabb && invalidAabb.ok === false && invalidAabb.reasonCode === 'invalid_aabb_args', 'tilemap invalid aabb input should be reason-coded');
+          aura.test.assert(invalidRay && invalidRay.ok === false && invalidRay.reasonCode === 'invalid_ray_args', 'tilemap invalid ray input should be reason-coded');
+          aura.test.assert(invalidHandle && invalidHandle.ok === false && invalidHandle.reasonCode === 'invalid_map_handle', 'tilemap invalid handle should be reason-coded');
+          aura.test.assert(invalidModel && invalidModel.ok === false && invalidModel.reasonCode === 'invalid_model', 'tilemap invalid model should be reason-coded');
+          aura.test.assert(unloadResult === true, 'tilemap handle should unload cleanly after query checks');
+        };
+      `,
+    },
+  {
+      id: 'tilemap-runtime-mutation-layer-controls',
+      modes: ['shim', 'native'],
+      namespaces: ['tilemap'],
+      functions: [
+        'aura.tilemap.setTile',
+        'aura.tilemap.setRegion',
+        'aura.tilemap.removeRegion',
+        'aura.tilemap.replaceRegion',
+        'aura.tilemap.setTileCollision',
+        'aura.tilemap.setLayerFlags',
+        'aura.tilemap.setLayerVisibility',
+        'aura.tilemap.setLayerCollision',
+        'aura.tilemap.queryObjects',
+        'aura.tilemap.queryObjectsAtPoint',
+        'aura.tilemap.queryObjectsInAABB',
+      ],
+      nativeChecks: [
+        { id: 'tilemap.mutation.setTile', expression: "typeof aura.tilemap?.setTile === 'function'" },
+        { id: 'tilemap.mutation.setRegion', expression: "typeof aura.tilemap?.setRegion === 'function'" },
+        { id: 'tilemap.mutation.removeRegion', expression: "typeof aura.tilemap?.removeRegion === 'function'" },
+        { id: 'tilemap.mutation.replaceRegion', expression: "typeof aura.tilemap?.replaceRegion === 'function'" },
+        { id: 'tilemap.mutation.setTileCollision', expression: "typeof aura.tilemap?.setTileCollision === 'function'" },
+        { id: 'tilemap.layer.setLayerFlags', expression: "typeof aura.tilemap?.setLayerFlags === 'function'" },
+        { id: 'tilemap.layer.setLayerVisibility', expression: "typeof aura.tilemap?.setLayerVisibility === 'function'" },
+        { id: 'tilemap.layer.setLayerCollision', expression: "typeof aura.tilemap?.setLayerCollision === 'function'" },
+        { id: 'tilemap.query.queryObjects', expression: "typeof aura.tilemap?.queryObjects === 'function'" },
+        { id: 'tilemap.query.queryObjectsAtPoint', expression: "typeof aura.tilemap?.queryObjectsAtPoint === 'function'" },
+        { id: 'tilemap.query.queryObjectsInAABB', expression: "typeof aura.tilemap?.queryObjectsInAABB === 'function'" },
+        {
+          id: 'tilemap.mutation.reason-codes.expanded',
+          expression: "(() => { const runSample = () => { const fixture = { width: 2, height: 2, tilewidth: 16, tileheight: 16, layers: [ { name: 'ground', type: 'tilelayer', width: 2, height: 2, data: [1, 1, 1, 1] } ], tilesets: [ { firstgid: 1, image: 'tiles-a.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1 }, { firstgid: 5, image: 'tiles-b.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1 } ] }; const mapId = aura.tilemap.import(fixture); const invalidGidArgs = aura.tilemap.setRegion(mapId, 'ground', { x: 0, y: 0, w: 1, h: 1 }, 'bad'); const unmappedBoundary = aura.tilemap.setRegion(mapId, 'ground', { x: 0, y: 0, w: 1, h: 1 }, 2); const validBoundary = aura.tilemap.setRegion(mapId, 'ground', { x: 0, y: 0, w: 1, h: 1 }, 5); const invalidReplaceArgs = aura.tilemap.replaceRegion(mapId, 'ground', { x: 0, y: 0, w: 1, h: 1 }, 1, 'bad'); const invalidLayerFlags = aura.tilemap.setLayerFlags(mapId, 'ground', {}); const invalidVisibility = aura.tilemap.setLayerVisibility(mapId, 'ground', 'yes'); const invalidCollision = aura.tilemap.setLayerCollision(mapId, 'ground', 'yes'); const invalidLayer = aura.tilemap.removeRegion(mapId, 'missing', { x: 0, y: 0, w: 1, h: 1 }); const invalidHandle = aura.tilemap.setRegion(999999, 'ground', { x: 0, y: 0, w: 1, h: 1 }, 1); aura.tilemap.unload(mapId); return { invalidGidArgs: invalidGidArgs?.reasonCode, unmappedBoundary: unmappedBoundary?.reasonCode, validBoundaryOk: validBoundary?.ok === true, validBoundaryChanged: Number(validBoundary?.changedTiles || 0), invalidReplaceArgs: invalidReplaceArgs?.reasonCode, invalidLayerFlags: invalidLayerFlags?.reasonCode, invalidVisibility: invalidVisibility?.reasonCode, invalidCollision: invalidCollision?.reasonCode, invalidLayer: invalidLayer?.reasonCode, invalidHandle: invalidHandle?.reasonCode }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.invalidGidArgs === 'invalid_gid_args' && first.unmappedBoundary === 'unmapped_layer_gid' && first.validBoundaryOk === true && first.validBoundaryChanged === 1 && first.invalidReplaceArgs === 'invalid_replace_args' && first.invalidLayerFlags === 'invalid_layer_flags' && first.invalidVisibility === 'invalid_visibility_flag' && first.invalidCollision === 'invalid_collision_flag' && first.invalidLayer === 'invalid_layer_ref' && first.invalidHandle === 'invalid_map_handle'; })()",
+        },
+        {
+          id: 'tilemap.mutation.layer-controls.deterministic',
+          expression: "(() => { const runSample = () => { const fixture = { width: 4, height: 4, tilewidth: 16, tileheight: 16, solidLayerNames: ['ground', 'hazards'], layers: [ { name: 'ground', type: 'tilelayer', width: 4, height: 4, data: Array.from({ length: 16 }, () => 1) }, { name: 'hazards', type: 'tilelayer', width: 4, height: 4, data: [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 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 initial = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 }); const setRegion = aura.tilemap.setRegion(mapId, 'ground', { x: 0, y: 0, w: 2, h: 1 }, 0); const topRow = aura.tilemap.queryAABB(mapId, { x: 0, y: 0, w: 32, h: 16 }); const removeRegion = aura.tilemap.removeRegion(mapId, 'hazards', { x: 1, y: 1, w: 1, h: 1 }); const afterRemove = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 }); const replaceRegion = aura.tilemap.replaceRegion(mapId, 'ground', { x: 1, y: 1, w: 1, h: 1 }, 1, 0); const afterReplace = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 }); const collisionOff = aura.tilemap.setLayerCollision(mapId, 'ground', false); const hazardsPoint = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 16.5 }); const visibilityOff = aura.tilemap.setLayerVisibility(mapId, 'hazards', false); const hiddenDraw = aura.tilemap.draw(mapId, { cull: false }); const flags = aura.tilemap.setLayerFlags(mapId, 'hazards', { visible: true, collision: false }); const shownDraw = aura.tilemap.draw(mapId, { cull: false }); const queryMuted = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 16.5 }); const groundCollisionOn = aura.tilemap.setLayerFlags(mapId, 'ground', { collision: true }); const hazardsCollisionOn = aura.tilemap.setLayerCollision(mapId, 'hazards', true); const queryRestored = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 16.5 }); const invalidRegion = aura.tilemap.setRegion(mapId, 'ground', { x: 0, y: 0, w: 0, h: 1 }, 1); const invalidGid = aura.tilemap.setRegion(mapId, 'ground', { x: 0, y: 0, w: 1, h: 1 }, 999); const invalidFlags = aura.tilemap.setLayerFlags(mapId, 'ground', { collision: 'yes' }); const invalidLayer = aura.tilemap.setLayerVisibility(mapId, 'missing', true); aura.tilemap.unload(mapId); return { initialHits: Array.isArray(initial?.hits) ? initial.hits.length : -1, topRowHits: Array.isArray(topRow?.hits) ? topRow.hits.length : -1, afterRemoveHits: Array.isArray(afterRemove?.hits) ? afterRemove.hits.length : -1, afterReplaceHits: Array.isArray(afterReplace?.hits) ? afterReplace.hits.length : -1, hazardsHits: Array.isArray(hazardsPoint?.hits) ? hazardsPoint.hits.length : -1, queryMutedHits: Array.isArray(queryMuted?.hits) ? queryMuted.hits.length : -1, queryRestoredHits: Array.isArray(queryRestored?.hits) ? queryRestored.hits.length : -1, setChanged: setRegion?.changedTiles, removeChanged: removeRegion?.changedTiles, replaceChanged: replaceRegion?.changedTiles, collisionOff: collisionOff?.collision, visibilityOff: visibilityOff?.visible, hiddenOrder: hiddenDraw?.layerOrder?.join(','), shownOrder: shownDraw?.layerOrder?.join(','), flagsVisible: flags?.visible, flagsCollision: flags?.collision, groundCollisionOn: groundCollisionOn?.collision, hazardsCollisionOn: hazardsCollisionOn?.collision, invalidRegion: invalidRegion?.reasonCode, invalidGid: invalidGid?.reasonCode, invalidFlags: invalidFlags?.reasonCode, invalidLayer: invalidLayer?.reasonCode }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.initialHits === 2 && first.topRowHits === 0 && first.afterRemoveHits === 1 && first.afterReplaceHits === 0 && first.hazardsHits === 1 && first.queryMutedHits === 0 && first.queryRestoredHits === 2 && first.setChanged === 2 && first.removeChanged === 1 && first.replaceChanged === 1 && first.collisionOff === false && first.visibilityOff === false && first.hiddenOrder === 'ground' && first.shownOrder === 'ground,hazards' && first.flagsVisible === true && first.flagsCollision === false && first.groundCollisionOn === true && first.hazardsCollisionOn === true && first.invalidRegion === 'invalid_region_args' && first.invalidGid === 'unmapped_layer_gid' && first.invalidFlags === 'invalid_collision_flag' && first.invalidLayer === 'invalid_layer_ref'; })()",
+        },
+        {
+          id: 'tilemap.object-query-and-tile-mutation.expanded.deterministic',
+          expression: "(() => { const runSample = () => { const fixture = { width: 4, height: 4, tilewidth: 16, tileheight: 16, layers: [ { name: 'ground', type: 'tilelayer', width: 4, height: 4, data: [1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], properties: { solid: true } }, { name: 'objects-main', type: 'objectgroup', objects: [ { id: 1, name: 'spawn', type: 'spawn', class: 'player', x: 16, y: 16, point: true, properties: { team: 'blue' } }, { id: 2, name: 'coin', type: 'pickup', x: 32, y: 16, width: 16, height: 16, properties: { kind: 'coin', value: 5 } }, { id: 3, name: 'secret', type: 'trigger', x: 48, y: 16, width: 16, height: 16, visible: false, properties: { kind: 'secret' } } ] }, { name: 'objects-props', type: 'objectgroup', objects: [ { id: 5, name: 'barrel', type: 'prop', class: 'breakable', x: 16, y: 32, width: 16, height: 16, properties: { kind: 'destructible', hp: 3 } } ] } ], tilesets: [ { firstgid: 1, image: 'tiles.png', tilewidth: 16, tileheight: 16, tilecount: 1, columns: 1 } ] }; const mapId = aura.tilemap.import(fixture); const all = aura.tilemap.queryObjects(mapId); const allRepeat = aura.tilemap.queryObjects(mapId); const withHidden = aura.tilemap.queryObjects(mapId, { includeHidden: true }); const byLayer = aura.tilemap.queryObjects(mapId, { layer: 'objects-main' }); const byProperty = aura.tilemap.queryObjects(mapId, { property: { name: 'kind', value: 'coin' } }); const byProperties = aura.tilemap.queryObjects(mapId, { properties: { kind: 'destructible', hp: 3 } }); const pointObjects = aura.tilemap.queryObjectsAtPoint(mapId, { x: 32.5, y: 16.5 }); const pointRepeat = aura.tilemap.queryObjectsAtPoint(mapId, { x: 32.5, y: 16.5 }); const aabbObjects = aura.tilemap.queryObjectsInAABB(mapId, { x: 0, y: 0, w: 64, h: 32 }); const invalidLayer = aura.tilemap.queryObjects(mapId, { layer: 'missing' }); const invalidProperty = aura.tilemap.queryObjects(mapId, { property: { name: '' } }); const invalidPoint = aura.tilemap.queryObjectsAtPoint(mapId, { x: 'bad', y: 0 }); const invalidAabb = aura.tilemap.queryObjectsInAABB(mapId, { x: 0, y: 0, w: 0, h: 1 }); const beforePoint = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 }); const setTileClear = aura.tilemap.setTile(mapId, 'ground', { x: 1, y: 1 }, 0); const afterClearPoint = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 }); const setTileRestore = aura.tilemap.setTile(mapId, 'ground', 1, 1, 1); const afterRestorePoint = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 }); const collisionOff = aura.tilemap.setTileCollision(mapId, 'ground', { x: 1, y: 1 }, false); const afterCollisionOff = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 }); const collisionOn = aura.tilemap.setTileCollision(mapId, 'ground', 1, 1, true); const afterCollisionOn = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 }); const collisionRegion = aura.tilemap.setTileCollision(mapId, 'ground', 0, 0, 2, 1, false); const topRow = aura.tilemap.queryAABB(mapId, { x: 0, y: 0, w: 32, h: 16 }); const invalidSetTile = aura.tilemap.setTile(mapId, 'ground', { x: 1, y: 1 }, 'bad'); const outOfBoundsSetTile = aura.tilemap.setTile(mapId, 'ground', { x: 99, y: 99 }, 1); const invalidSetTileCollision = aura.tilemap.setTileCollision(mapId, 'ground', { x: 1, y: 1 }, 'yes'); aura.tilemap.unload(mapId); return { allNames: Array.isArray(all?.hits) ? all.hits.map((entry) => entry.name).join(',') : '', allRepeatNames: Array.isArray(allRepeat?.hits) ? allRepeat.hits.map((entry) => entry.name).join(',') : '', hiddenNames: Array.isArray(withHidden?.hits) ? withHidden.hits.map((entry) => entry.name).join(',') : '', layerNames: Array.isArray(byLayer?.hits) ? byLayer.hits.map((entry) => entry.name).join(',') : '', propertyNames: Array.isArray(byProperty?.hits) ? byProperty.hits.map((entry) => entry.name).join(',') : '', propertiesNames: Array.isArray(byProperties?.hits) ? byProperties.hits.map((entry) => entry.name).join(',') : '', pointNames: Array.isArray(pointObjects?.hits) ? pointObjects.hits.map((entry) => entry.name).join(',') : '', pointRepeatNames: Array.isArray(pointRepeat?.hits) ? pointRepeat.hits.map((entry) => entry.name).join(',') : '', aabbCount: Number(aabbObjects?.count || 0), invalidLayer: invalidLayer?.reasonCode || null, invalidProperty: invalidProperty?.reasonCode || null, invalidPoint: invalidPoint?.reasonCode || null, invalidAabb: invalidAabb?.reasonCode || null, beforeHits: Array.isArray(beforePoint?.hits) ? beforePoint.hits.length : -1, afterClearHits: Array.isArray(afterClearPoint?.hits) ? afterClearPoint.hits.length : -1, afterRestoreHits: Array.isArray(afterRestorePoint?.hits) ? afterRestorePoint.hits.length : -1, afterCollisionOffHits: Array.isArray(afterCollisionOff?.hits) ? afterCollisionOff.hits.length : -1, afterCollisionOnHits: Array.isArray(afterCollisionOn?.hits) ? afterCollisionOn.hits.length : -1, topRowHits: Array.isArray(topRow?.hits) ? topRow.hits.length : -1, setTileClearChanged: Number(setTileClear?.changedTiles || 0), setTileRestoreChanged: Number(setTileRestore?.changedTiles || 0), collisionOffChanged: Number(collisionOff?.changedTiles || 0), collisionOnChanged: Number(collisionOn?.changedTiles || 0), collisionRegionChanged: Number(collisionRegion?.changedTiles || 0), invalidSetTile: invalidSetTile?.reasonCode || null, outOfBoundsSetTile: outOfBoundsSetTile?.reasonCode || null, invalidSetTileCollision: invalidSetTileCollision?.reasonCode || null }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.allNames === 'spawn,coin,barrel' && first.allNames === first.allRepeatNames && first.hiddenNames === 'spawn,coin,secret,barrel' && first.layerNames === 'spawn,coin' && first.propertyNames === 'coin' && first.propertiesNames === 'barrel' && first.pointNames === 'coin' && first.pointNames === first.pointRepeatNames && first.aabbCount === 2 && first.invalidLayer === 'invalid_object_layer_ref' && first.invalidProperty === 'invalid_object_property_filter' && first.invalidPoint === 'invalid_object_point_args' && first.invalidAabb === 'invalid_object_aabb_args' && first.beforeHits === 1 && first.afterClearHits === 0 && first.afterRestoreHits === 1 && first.afterCollisionOffHits === 0 && first.afterCollisionOnHits === 1 && first.topRowHits === 0 && first.setTileClearChanged === 1 && first.setTileRestoreChanged === 1 && first.collisionOffChanged === 1 && first.collisionOnChanged === 1 && first.collisionRegionChanged === 2 && first.invalidSetTile === 'invalid_gid_args' && first.outOfBoundsSetTile === 'tile_out_of_bounds' && first.invalidSetTileCollision === 'invalid_collision_flag'; })()",
+        },
+      ],
+      frames: 1,
+      source: `
+        aura.setup = function () {
+          const fixture = {
+            width: 4,
+            height: 4,
+            tilewidth: 16,
+            tileheight: 16,
+            solidLayerNames: ['ground', 'hazards'],
+            layers: [
+              {
+                name: 'ground',
+                type: 'tilelayer',
+                width: 4,
+                height: 4,
+                data: Array.from({ length: 16 }, () => 1),
+              },
+              {
+                name: 'hazards',
+                type: 'tilelayer',
+                width: 4,
+                height: 4,
+                data: [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 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 initial = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 });
+          const setRegion = aura.tilemap.setRegion(mapId, 'ground', { x: 0, y: 0, w: 2, h: 1 }, 0);
+          const topRow = aura.tilemap.queryAABB(mapId, { x: 0, y: 0, w: 32, h: 16 });
+          const removeRegion = aura.tilemap.removeRegion(mapId, 'hazards', { x: 1, y: 1, w: 1, h: 1 });
+          const afterRemove = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 });
+          const replaceRegion = aura.tilemap.replaceRegion(mapId, 'ground', { x: 1, y: 1, w: 1, h: 1 }, 1, 0);
+          const afterReplace = aura.tilemap.queryPoint(mapId, { x: 16.5, y: 16.5 });
+          const collisionOff = aura.tilemap.setLayerCollision(mapId, 'ground', false);
+          const hazardsPoint = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 16.5 });
+          const visibilityOff = aura.tilemap.setLayerVisibility(mapId, 'hazards', false);
+          const hiddenDraw = aura.tilemap.draw(mapId, { cull: false });
+          const flags = aura.tilemap.setLayerFlags(mapId, 'hazards', { visible: true, collision: false });
+          const shownDraw = aura.tilemap.draw(mapId, { cull: false });
+          const queryMuted = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 16.5 });
+          const groundCollisionOn = aura.tilemap.setLayerFlags(mapId, 'ground', { collision: true });
+          const hazardsCollisionOn = aura.tilemap.setLayerCollision(mapId, 'hazards', true);
+          const queryRestored = aura.tilemap.queryPoint(mapId, { x: 32.5, y: 16.5 });
+          const invalidRegion = aura.tilemap.setRegion(mapId, 'ground', { x: 0, y: 0, w: 0, h: 1 }, 1);
+          const invalidGid = aura.tilemap.setRegion(mapId, 'ground', { x: 0, y: 0, w: 1, h: 1 }, 999);
+          const invalidFlags = aura.tilemap.setLayerFlags(mapId, 'ground', { collision: 'yes' });
+          const invalidLayer = aura.tilemap.setLayerVisibility(mapId, 'missing', true);
+          const unload = aura.tilemap.unload(mapId);
+  
+          aura.test.assert(Array.isArray(initial.hits) && initial.hits.length === 2, 'tilemap initial layered query should hit both layers');
+          aura.test.assert(setRegion && setRegion.ok === true && setRegion.changedTiles === 2, 'tilemap setRegion should mutate deterministic tile count');
+          aura.test.assert(Array.isArray(topRow.hits) && topRow.hits.length === 0, 'tilemap setRegion should affect deterministic top-row query hits');
+          aura.test.assert(removeRegion && removeRegion.ok === true && removeRegion.changedTiles === 1, 'tilemap removeRegion should clear deterministic tile count');
+          aura.test.assert(Array.isArray(afterRemove.hits) && afterRemove.hits.length === 1, 'tilemap removeRegion should reduce layered hits');
+          aura.test.assert(replaceRegion && replaceRegion.ok === true && replaceRegion.changedTiles === 1, 'tilemap replaceRegion should deterministically swap target gid');
+          aura.test.assert(Array.isArray(afterReplace.hits) && afterReplace.hits.length === 0, 'tilemap replaceRegion should affect point query deterministically');
+          aura.test.assert(collisionOff && collisionOff.ok === true && collisionOff.collision === false, 'tilemap setLayerCollision should disable query collision');
+          aura.test.assert(Array.isArray(hazardsPoint.hits) && hazardsPoint.hits.length === 1, 'tilemap collision toggle should isolate hazard layer hits');
+          aura.test.assert(visibilityOff && visibilityOff.ok === true && visibilityOff.visible === false, 'tilemap setLayerVisibility should update visibility deterministically');
+          aura.test.assert(hiddenDraw && hiddenDraw.layerOrder.join(',') === 'ground', 'tilemap hidden layer should be omitted from draw ordering');
+          aura.test.assert(flags && flags.ok === true && flags.visible === true && flags.collision === false, 'tilemap setLayerFlags should update visible/collision together');
+          aura.test.assert(shownDraw && shownDraw.layerOrder.join(',') === 'ground,hazards', 'tilemap setLayerFlags should restore draw ordering deterministically');
+          aura.test.assert(Array.isArray(queryMuted.hits) && queryMuted.hits.length === 0, 'tilemap collision-off flags should mute query hits');
+          aura.test.assert(groundCollisionOn && groundCollisionOn.collision === true, 'tilemap ground collision flag should restore deterministically');
+          aura.test.assert(hazardsCollisionOn && hazardsCollisionOn.collision === true, 'tilemap hazard collision toggle should restore deterministically');
+          aura.test.assert(Array.isArray(queryRestored.hits) && queryRestored.hits.length === 2, 'tilemap collision flags should restore layered query hits');
+          aura.test.assert(invalidRegion && invalidRegion.ok === false && invalidRegion.reasonCode === 'invalid_region_args', 'tilemap invalid region args should be reason-coded');
+          aura.test.assert(invalidGid && invalidGid.ok === false && invalidGid.reasonCode === 'unmapped_layer_gid', 'tilemap unmapped gid mutation should be reason-coded');
+          aura.test.assert(invalidFlags && invalidFlags.ok === false && invalidFlags.reasonCode === 'invalid_collision_flag', 'tilemap invalid collision flag should be reason-coded');
+          aura.test.assert(invalidLayer && invalidLayer.ok === false && invalidLayer.reasonCode === 'invalid_layer_ref', 'tilemap invalid layer ref should be reason-coded');
+          aura.test.equal(unload, true, 'tilemap handle should unload after mutation checks');
+        };
+      `,
+    }
+];