@auraindustry/aurajs 0.0.2 → 0.0.3

package/src/conformance.mjs

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { mkdirSync, writeFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 
 import { HostBinaryResolutionError, resolveGateHostBinary } from './host-binary.mjs';
@@ -7,6 +7,7 @@ import { runHeadlessTest, HeadlessTestError } from './headless-test.mjs';
 
 const NATIVE_RESULT_MARKER = '__AURA_CONFORMANCE_NATIVE__';
 const VALID_MODES = new Set(['shim', 'native', 'both']);
+export const GAME_STATE_SCHEMA_VERSION = 'aurajs.game-state.v1';
 export const DEFAULT_RUNTIME_OBSERVABILITY_REPORT_PATH = '.aura/conformance/runtime-observability.json';
 export const DEFAULT_RUNTIME_INSPECTOR_SNAPSHOT_REPORT_PATH = '.aura/conformance/runtime-inspector-snapshot.json';
 export const DEFAULT_PHASER_VERTICAL_SLICE_EVIDENCE_REPORT_PATH = '.aura/conformance/phaser-vertical-slice-evidence.json';
@@ -22,6 +23,346 @@ const PHASER_VERTICAL_SLICE_PERF_BUDGETS = Object.freeze({
     maxAverageCheckMs: 800,
   }),
 });
+const PHASER_VERTICAL_SLICE_REQUIRED_MODES = Object.freeze(['shim', 'native']);
+
+export function installGameStateHooks(aura, options = {}) {
+  const schemaVersion = 'aurajs.game-state.v1';
+  const zeroFingerprint = '0'.repeat(64);
+  const knownTopLevel = Object.freeze(['schemaVersion', 'export', 'state']);
+  const knownStateSections = Object.freeze(['globals', 'camera', 'scene3d', 'physics', 'ecs', 'tilemap']);
+  const defaultMode = options.mode === 'native' ? 'native' : 'headless';
+
+  const isObject = (value) => (
+    !!value
+    && typeof value === 'object'
+    && !Array.isArray(value)
+  );
+  const cloneStable = (value) => {
+    if (Array.isArray(value)) {
+      return value.map((entry) => cloneStable(entry));
+    }
+    if (isObject(value)) {
+      const out = {};
+      for (const key of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
+        out[key] = cloneStable(value[key]);
+      }
+      return out;
+    }
+    return value;
+  };
+  const stableStringify = (value) => JSON.stringify(cloneStable(value));
+  const asFinite = (value, fallback = 0) => {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : fallback;
+  };
+  const asInteger = (value, fallback = 0) => {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) return fallback;
+    return Math.trunc(numeric);
+  };
+  const clampNonNegativeInt = (value, fallback = 0) => {
+    const numeric = asInteger(value, fallback);
+    return numeric < 0 ? 0 : numeric;
+  };
+  const hash64 = (input) => {
+    const text = String(input || '');
+    const state = [
+      0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+      0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+    ];
+    const primes = [
+      0x9e3779b1, 0x85ebca77, 0xc2b2ae3d, 0x27d4eb2f,
+      0x165667b1, 0xd3a2646c, 0xfd7046c5, 0xb55a4f09,
+    ];
+    for (let i = 0; i < text.length; i += 1) {
+      const code = text.charCodeAt(i) & 0xffff;
+      for (let lane = 0; lane < state.length; lane += 1) {
+        const mix = (code + (lane + 1) + i) >>> 0;
+        const rotated = ((state[(lane + 3) % state.length] >>> ((lane + i) % 13)) | 0) >>> 0;
+        state[lane] = (Math.imul((state[lane] ^ mix) >>> 0, primes[lane]) + rotated) >>> 0;
+      }
+    }
+    return state.map((entry) => entry.toString(16).padStart(8, '0')).join('');
+  };
+  const normalizeCameraState = (cameraState) => {
+    if (!isObject(cameraState)) return null;
+    const x = asFinite(cameraState.x, Number.NaN);
+    const y = asFinite(cameraState.y, Number.NaN);
+    const zoom = asFinite(cameraState.zoom, Number.NaN);
+    const rotation = asFinite(cameraState.rotation, Number.NaN);
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(zoom) || !Number.isFinite(rotation)) {
+      return null;
+    }
+    const normalized = {
+      x,
+      y,
+      zoom,
+      rotation,
+    };
+    if (typeof cameraState.following === 'boolean') normalized.following = cameraState.following;
+    if (Number.isInteger(cameraState.activeEffects) && cameraState.activeEffects >= 0) {
+      normalized.activeEffects = cameraState.activeEffects;
+    }
+    if (isObject(cameraState.deadzone)) {
+      normalized.deadzone = {
+        x: asFinite(cameraState.deadzone.x, 0),
+        y: asFinite(cameraState.deadzone.y, 0),
+        width: Math.max(0, asFinite(cameraState.deadzone.width, 0)),
+        height: Math.max(0, asFinite(cameraState.deadzone.height, 0)),
+      };
+    }
+    if (isObject(cameraState.bounds)) {
+      normalized.bounds = {
+        x: asFinite(cameraState.bounds.x, 0),
+        y: asFinite(cameraState.bounds.y, 0),
+        width: Math.max(0, asFinite(cameraState.bounds.width, 0)),
+        height: Math.max(0, asFinite(cameraState.bounds.height, 0)),
+      };
+    }
+    return normalized;
+  };
+  const errorResult = (reasonCode, details = {}) => ({
+    ok: false,
+    reasonCode,
+    appliedMutations: 0,
+    failedMutationIndex: 0,
+    fingerprint: null,
+    details: cloneStable(details),
+  });
+  const successResult = (reasonCode, fingerprint, appliedMutations = 1) => ({
+    ok: true,
+    reasonCode,
+    appliedMutations,
+    failedMutationIndex: null,
+    fingerprint,
+  });
+
+  if (!aura || typeof aura !== 'object') {
+    return errorResult('invalid_schema_payload', { path: '/aura' });
+  }
+
+  const existing = aura.state;
+  if (
+    isObject(existing)
+    && typeof existing.export === 'function'
+    && typeof existing.apply === 'function'
+    && existing.schemaVersion === schemaVersion
+  ) {
+    return existing;
+  }
+
+  const stateStore = {
+    globals: {},
+    camera: null,
+    scene3d: null,
+    physics: null,
+    ecs: null,
+    tilemap: null,
+    seed: 0,
+    frameIndex: 0,
+    elapsedSeconds: 0,
+  };
+
+  const captureCameraState = () => {
+    const cameraNs = isObject(aura.camera) ? aura.camera : null;
+    if (!cameraNs) return stateStore.camera ? cloneStable(stateStore.camera) : null;
+
+    let cameraState = null;
+    if (typeof cameraNs.getState === 'function') {
+      try {
+        cameraState = cameraNs.getState();
+      } catch {
+        cameraState = null;
+      }
+    }
+    if (!isObject(cameraState)) {
+      cameraState = {
+        x: cameraNs.x,
+        y: cameraNs.y,
+        zoom: cameraNs.zoom,
+        rotation: cameraNs.rotation,
+      };
+    }
+    const normalized = normalizeCameraState(cameraState);
+    return normalized ? cloneStable(normalized) : (stateStore.camera ? cloneStable(stateStore.camera) : null);
+  };
+
+  const computePayloadFingerprint = (payload) => {
+    const clone = cloneStable(payload);
+    if (!isObject(clone.export)) {
+      return zeroFingerprint;
+    }
+    clone.export.fingerprint = zeroFingerprint;
+    clone.export.capturedAt = null;
+    return hash64(stableStringify(clone));
+  };
+
+  const exportState = (exportOptions = {}) => {
+    const optionsObject = isObject(exportOptions) ? exportOptions : {};
+    if (isObject(optionsObject.globals)) {
+      stateStore.globals = cloneStable(optionsObject.globals);
+    }
+    if (Object.prototype.hasOwnProperty.call(optionsObject, 'seed')) {
+      stateStore.seed = asInteger(optionsObject.seed, stateStore.seed);
+    }
+    if (Object.prototype.hasOwnProperty.call(optionsObject, 'frameIndex')) {
+      stateStore.frameIndex = clampNonNegativeInt(optionsObject.frameIndex, stateStore.frameIndex);
+    }
+    if (Object.prototype.hasOwnProperty.call(optionsObject, 'elapsedSeconds')) {
+      stateStore.elapsedSeconds = Math.max(0, asFinite(optionsObject.elapsedSeconds, stateStore.elapsedSeconds));
+    }
+
+    const mode = optionsObject.mode === 'native' ? 'native' : defaultMode;
+    const cameraState = captureCameraState();
+    if (cameraState) {
+      stateStore.camera = cloneStable(cameraState);
+    }
+
+    const statePayload = {
+      globals: cloneStable(stateStore.globals),
+    };
+    if (stateStore.camera) statePayload.camera = cloneStable(stateStore.camera);
+    if (stateStore.scene3d) statePayload.scene3d = cloneStable(stateStore.scene3d);
+    if (stateStore.physics) statePayload.physics = cloneStable(stateStore.physics);
+    if (stateStore.ecs) statePayload.ecs = cloneStable(stateStore.ecs);
+    if (stateStore.tilemap) statePayload.tilemap = cloneStable(stateStore.tilemap);
+
+    const payload = {
+      schemaVersion,
+      export: {
+        mode,
+        seed: stateStore.seed,
+        frameIndex: stateStore.frameIndex,
+        elapsedSeconds: Number(stateStore.elapsedSeconds.toFixed(6)),
+        fingerprint: zeroFingerprint,
+        capturedAt: null,
+      },
+      state: statePayload,
+    };
+    payload.export.fingerprint = computePayloadFingerprint(payload);
+    return payload;
+  };
+
+  const validateApplyPayload = (payload) => {
+    if (!isObject(payload)) {
+      return { ok: false, reasonCode: 'invalid_schema_payload', details: { path: '/' } };
+    }
+    if (payload.schemaVersion !== schemaVersion) {
+      return { ok: false, reasonCode: 'schema_version_mismatch', details: { expected: schemaVersion } };
+    }
+    for (const key of knownTopLevel) {
+      if (!Object.prototype.hasOwnProperty.call(payload, key)) {
+        return { ok: false, reasonCode: 'missing_required_field', details: { path: `/${key}` } };
+      }
+    }
+    for (const key of Object.keys(payload)) {
+      if (!knownTopLevel.includes(key)) {
+        return { ok: false, reasonCode: 'unknown_top_level_key', details: { key } };
+      }
+    }
+    if (!isObject(payload.export) || !isObject(payload.state)) {
+      return { ok: false, reasonCode: 'invalid_schema_payload', details: { path: '/export_or_state' } };
+    }
+    if (!isObject(payload.state.globals)) {
+      return { ok: false, reasonCode: 'missing_required_field', details: { path: '/state/globals' } };
+    }
+    for (const key of Object.keys(payload.state)) {
+      if (!knownStateSections.includes(key)) {
+        return { ok: false, reasonCode: 'unknown_state_section', details: { key } };
+      }
+    }
+    if (Object.prototype.hasOwnProperty.call(payload.state, 'camera') && payload.state.camera !== null) {
+      if (!normalizeCameraState(payload.state.camera)) {
+        return { ok: false, reasonCode: 'invalid_schema_payload', details: { path: '/state/camera' } };
+      }
+    }
+    for (const section of ['scene3d', 'physics', 'ecs', 'tilemap']) {
+      if (Object.prototype.hasOwnProperty.call(payload.state, section)) {
+        const value = payload.state[section];
+        if (value !== null && !isObject(value)) {
+          return { ok: false, reasonCode: 'invalid_schema_payload', details: { path: `/state/${section}` } };
+        }
+      }
+    }
+    return { ok: true };
+  };
+
+  const applyState = (payload, applyOptions = {}) => {
+    const validation = validateApplyPayload(payload);
+    if (!validation.ok) {
+      return errorResult(validation.reasonCode, validation.details || {});
+    }
+
+    const optionsObject = isObject(applyOptions) ? applyOptions : {};
+    const dryRun = optionsObject.dryRun === true;
+    const nextStore = {
+      globals: cloneStable(payload.state.globals),
+      camera: payload.state.camera ? cloneStable(normalizeCameraState(payload.state.camera)) : null,
+      scene3d: payload.state.scene3d ? cloneStable(payload.state.scene3d) : null,
+      physics: payload.state.physics ? cloneStable(payload.state.physics) : null,
+      ecs: payload.state.ecs ? cloneStable(payload.state.ecs) : null,
+      tilemap: payload.state.tilemap ? cloneStable(payload.state.tilemap) : null,
+      seed: asInteger(payload.export.seed, stateStore.seed),
+      frameIndex: clampNonNegativeInt(payload.export.frameIndex, stateStore.frameIndex),
+      elapsedSeconds: Math.max(0, asFinite(payload.export.elapsedSeconds, stateStore.elapsedSeconds)),
+    };
+
+    if (!dryRun) {
+      stateStore.globals = nextStore.globals;
+      stateStore.camera = nextStore.camera;
+      stateStore.scene3d = nextStore.scene3d;
+      stateStore.physics = nextStore.physics;
+      stateStore.ecs = nextStore.ecs;
+      stateStore.tilemap = nextStore.tilemap;
+      stateStore.seed = nextStore.seed;
+      stateStore.frameIndex = nextStore.frameIndex;
+      stateStore.elapsedSeconds = nextStore.elapsedSeconds;
+
+      const cameraNs = isObject(aura.camera) ? aura.camera : null;
+      if (cameraNs && stateStore.camera) {
+        cameraNs.x = stateStore.camera.x;
+        cameraNs.y = stateStore.camera.y;
+        cameraNs.zoom = stateStore.camera.zoom;
+        cameraNs.rotation = stateStore.camera.rotation;
+        if (stateStore.camera.deadzone && typeof cameraNs.setDeadzone === 'function') {
+          cameraNs.setDeadzone(stateStore.camera.deadzone);
+        } else if (typeof cameraNs.clearDeadzone === 'function') {
+          cameraNs.clearDeadzone();
+        }
+        if (stateStore.camera.bounds && typeof cameraNs.setBounds === 'function') {
+          cameraNs.setBounds(stateStore.camera.bounds);
+        } else if (typeof cameraNs.clearBounds === 'function') {
+          cameraNs.clearBounds();
+        }
+      }
+    }
+
+    const nextPayload = exportState({
+      mode: payload.export.mode === 'native' ? 'native' : defaultMode,
+      seed: nextStore.seed,
+      frameIndex: nextStore.frameIndex,
+      elapsedSeconds: nextStore.elapsedSeconds,
+    });
+
+    return successResult(
+      dryRun ? 'state_dry_run_ok' : 'state_apply_ok',
+      nextPayload.export.fingerprint,
+      dryRun ? 0 : 1,
+    );
+  };
+
+  const stateNamespace = isObject(aura.state) ? aura.state : {};
+  stateNamespace.schemaVersion = schemaVersion;
+  stateNamespace.export = exportState;
+  stateNamespace.apply = applyState;
+  aura.state = stateNamespace;
+  return stateNamespace;
+}
+
+export function buildGameStateHookBootstrapSource(mode = 'headless') {
+  const normalizedMode = mode === 'native' ? 'native' : 'headless';
+  return `(${installGameStateHooks.toString()})(aura, ${JSON.stringify({ mode: normalizedMode })});`;
+}
 
 export class ConformanceSuiteError extends Error {
   constructor(message, details = {}) {
@@ -174,6 +515,10 @@ export const DEFAULT_CONFORMANCE_CASES = [
       { 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: `
@@ -198,6 +543,53 @@ export const DEFAULT_CONFORMANCE_CASES = [
       };
     `,
   },
+  {
+    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'],
@@ -293,16 +685,20 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         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 === 'asset_format_deferred' && first.state2d?.state === 'failed' && first.state2d?.reasonCode === 'missing_asset' && first.state3d?.state === 'failed' && first.state3d?.reasonCode === 'asset_format_deferred' && first.history2d.startsWith('queued:') && first.history2d.includes('|loading:') && first.history2d.includes('|failed:') && first.history3d.startsWith('queued:') && first.history3d.includes('|loading:') && first.history3d.includes('|failed:asset_format_deferred'); })()",
+        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 deferredImage = norm(aura.assets.getFormatSupport('future.webp')); const deferredFont = norm(aura.assets.getFormatSupport('future.woff2')); const deferredModel = norm(aura.assets.getFormatSupport('future.glb')); 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.webp'); } 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, deferredImage, deferredFont, deferredModel, 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.deferredImage?.ok === true && first.deferredImage?.status === 'deferred' && first.deferredImage?.reasonCode === 'asset_format_deferred' && first.deferredImage?.deferred === true && first.deferredFont?.status === 'deferred' && first.deferredModel?.status === 'deferred' && 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_deferred]') && first.audioReason.includes('[reason:asset_format_deferred]') && first.fontReason === 'asset_format_deferred'; })()",
+        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 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, 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.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'" },
@@ -356,6 +752,49 @@ export const DEFAULT_CONFORMANCE_CASES = [
       };
     `,
   },
+  {
+    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'],
@@ -473,7 +912,8 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         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 scene3dRuntimeOk = Number.isFinite(submission.drawMeshPending) && Number.isFinite(submission.uniqueMeshHandles) && Number.isFinite(submission.uniqueMaterialHandles) && Number.isFinite(submission.nonDefaultTransforms) && typeof submission.skyboxRequested === 'boolean' && typeof submission.clearRequested === 'boolean' && typeof camera.mode === 'string' && camera.mode.length > 0 && camera.mode !== 'unknown' && 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; } })()",
+        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 scene3dRuntimeOk = Number.isFinite(submission.drawMeshPending) && Number.isFinite(submission.uniqueMeshHandles) && Number.isFinite(submission.uniqueMaterialHandles) && Number.isFinite(submission.nonDefaultTransforms) && 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 scene3dRuntimeOk = Number.isFinite(submission.drawMeshPending) && Number.isFinite(submission.uniqueMeshHandles) && Number.isFinite(submission.uniqueMaterialHandles) && Number.isFinite(submission.nonDefaultTransforms) && 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',
@@ -512,6 +952,10 @@ export const DEFAULT_CONFORMANCE_CASES = [
         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,
@@ -620,6 +1064,10 @@ export const DEFAULT_CONFORMANCE_CASES = [
       { 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'; })()",
@@ -698,20 +1146,30 @@ export const DEFAULT_CONFORMANCE_CASES = [
     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'; })()",
@@ -720,6 +1178,10 @@ export const DEFAULT_CONFORMANCE_CASES = [
         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: `
@@ -869,7 +1331,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
     id: 'optional-module-net-disabled',
     modes: ['native'],
     namespaces: ['net'],
-    functions: ['aura.net.connect', 'aura.net.websocket'],
+    functions: ['aura.net.connect', 'aura.net.websocket', 'aura.net.fetch', 'aura.net.get', 'aura.net.post'],
     optionalModuleReadiness: { module: 'net', state: 'disabled' },
     nativeEnv: {
       AURA_MODULE_PHYSICS: '0',
@@ -882,7 +1344,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'optional.net.disabled.reason-codes',
-        expression: "(() => { const reasonCode = (method, invoke) => { try { invoke(); return false; } catch (e) { const msg = String(e); return msg.includes('aura.net.' + method + '()') && msg.includes('optional module \"net\" is disabled') && msg.includes('modules.network = true') && msg.includes('[reason:optional_module_net_disabled]'); } }; return reasonCode('connect', () => aura.net.connect('tcp', 'localhost', 7777)) && reasonCode('websocket', () => aura.net.websocket('ws://localhost:7777')); })()",
+        expression: "(() => { const parseReason = (msg) => { const match = /\\[reason:([^\\]]+)\\]/.exec(msg); return match ? match[1] : null; }; const reasonCode = (method, invoke) => { try { invoke(); return false; } catch (e) { const msg = String(e); return msg.includes('aura.net.' + method + '()') && msg.includes('optional module \"net\" is disabled') && parseReason(msg) === 'optional_module_net_disabled'; } }; return reasonCode('connect', () => aura.net.connect('tcp', 'localhost', 7777)) && reasonCode('websocket', () => aura.net.websocket('ws://localhost:7777')) && reasonCode('fetch', () => aura.net.fetch('http://localhost:7777')) && reasonCode('get', () => aura.net.get('http://localhost:7777')) && reasonCode('post', () => aura.net.post('http://localhost:7777', { json: { ok: true } })); })()",
       },
     ],
     nativeFrames: 2,
@@ -892,7 +1354,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
     id: 'optional-module-net-enabled',
     modes: ['native'],
     namespaces: ['net'],
-    functions: ['aura.net.connect', 'aura.net.websocket'],
+    functions: ['aura.net.connect', 'aura.net.websocket', 'aura.net.fetch', 'aura.net.get', 'aura.net.post'],
     optionalModuleReadiness: { module: 'net', state: 'enabled' },
     nativeEnv: {
       AURA_MODULE_PHYSICS: '0',
@@ -905,7 +1367,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'optional.net.enabled.invalid-input.reason-codes',
-        expression: "(() => { const expectThrow = (fn, token) => { try { fn(); return false; } catch (e) { return String(e).includes(token); } }; return expectThrow(() => aura.net.connect('http', '127.0.0.1', 7777), 'transport must be \"tcp\" or \"udp\"') && expectThrow(() => aura.net.connect('tcp', 123, 7777), 'host must be a string') && expectThrow(() => aura.net.connect('tcp', '127.0.0.1', 0), 'port must be an integer in range 1..65535') && expectThrow(() => aura.net.websocket(42), 'url must be a websocket URL string'); })()",
+        expression: "(() => { const hasToken = (msg, tokens) => tokens.some((token) => msg.includes(token)); const expectThrow = (fn, tokens) => { try { fn(); return false; } catch (e) { const msg = String(e); return hasToken(msg, Array.isArray(tokens) ? tokens : [tokens]); } }; return expectThrow(() => aura.net.connect('http', '127.0.0.1', 7777), 'transport must be \"tcp\" or \"udp\"') && expectThrow(() => aura.net.connect('tcp', 123, 7777), 'host must be a string') && expectThrow(() => aura.net.connect('tcp', '127.0.0.1', 0), 'port must be an integer in range 1..65535') && expectThrow(() => aura.net.websocket(42), 'url must be a websocket URL string') && expectThrow(() => aura.net.fetch(42), ['url must be a string', 'url must be an HTTP URL string']) && expectThrow(() => aura.net.get(42), ['url must be a string', 'url must be an HTTP URL string']) && expectThrow(() => aura.net.post(42, { ok: true }), ['url must be a string', 'url must be an HTTP URL string']); })()",
       },
       {
         id: 'optional.net.enabled.callback-ordering.seeded',
@@ -926,7 +1388,33 @@ export const DEFAULT_CONFORMANCE_CASES = [
     id: 'optional-module-multiplayer-disabled',
     modes: ['native'],
     namespaces: ['multiplayer'],
-    functions: ['aura.multiplayer.configure', 'aura.multiplayer.host', 'aura.multiplayer.join', 'aura.multiplayer.leave', 'aura.multiplayer.stop'],
+    functions: [
+      'aura.multiplayer.configure',
+      'aura.multiplayer.host',
+      'aura.multiplayer.join',
+      'aura.multiplayer.leave',
+      'aura.multiplayer.stop',
+      'aura.multiplayer.getPlayers',
+      'aura.multiplayer.getPlayerCount',
+      'aura.multiplayer.send',
+      'aura.multiplayer.broadcast',
+      'aura.multiplayer.sendInput',
+      'aura.multiplayer.getPlayerInput',
+      'aura.multiplayer.getAllPlayerInputs',
+      'aura.multiplayer.setState',
+      'aura.multiplayer.getState',
+      'aura.multiplayer.getAllState',
+      'aura.multiplayer.onMessage',
+      'aura.multiplayer.onStateUpdate',
+      'aura.multiplayer.onPlayerJoin',
+      'aura.multiplayer.onPlayerLeave',
+      'aura.multiplayer.onDisconnect',
+      'aura.multiplayer.kick',
+      'aura.multiplayer.setPlayerData',
+      'aura.multiplayer.getPlayerData',
+      'aura.multiplayer.advertise',
+      'aura.multiplayer.discover',
+    ],
     optionalModuleReadiness: { module: 'multiplayer', state: 'disabled' },
     nativeEnv: {
       AURA_MODULE_PHYSICS: '0',
@@ -936,11 +1424,11 @@ export const DEFAULT_CONFORMANCE_CASES = [
     nativeChecks: [
       {
         id: 'optional.multiplayer.disabled.guidance',
-        expression: "(() => { const guidance = (fn) => { try { fn(); return false; } catch (e) { const msg = String(e); return msg.includes('disabled') && msg.includes('modules.multiplayer'); } }; return guidance(() => aura.multiplayer.configure({ tickRate: 20 })) && guidance(() => aura.multiplayer.host(7000)) && guidance(() => aura.multiplayer.join('127.0.0.1', 7000)) && guidance(() => aura.multiplayer.leave()) && guidance(() => aura.multiplayer.stop()); })()",
+        expression: "(() => { const guidance = (fn) => { try { fn(); return false; } catch (e) { const msg = String(e); return msg.includes('disabled') && msg.includes('modules.multiplayer'); } }; return guidance(() => aura.multiplayer.configure({ tickRate: 20 })) && guidance(() => aura.multiplayer.host(7000)) && guidance(() => aura.multiplayer.join('127.0.0.1', 7000)) && guidance(() => aura.multiplayer.leave()) && guidance(() => aura.multiplayer.stop()) && guidance(() => aura.multiplayer.getPlayers()) && guidance(() => aura.multiplayer.send(1, 'chat', { body: 'hi' })) && guidance(() => aura.multiplayer.broadcast('chat', { body: 'hi' })) && guidance(() => aura.multiplayer.sendInput({ left: true })) && guidance(() => aura.multiplayer.getPlayerInput(1)) && guidance(() => aura.multiplayer.getAllPlayerInputs()) && guidance(() => aura.multiplayer.setState('room', { phase: 'lobby' })) && guidance(() => aura.multiplayer.getState('room')) && guidance(() => aura.multiplayer.getAllState()) && guidance(() => aura.multiplayer.onMessage('chat', () => {})) && guidance(() => aura.multiplayer.onStateUpdate(() => {})) && guidance(() => aura.multiplayer.onPlayerJoin(() => {})) && guidance(() => aura.multiplayer.onPlayerLeave(() => {})) && guidance(() => aura.multiplayer.onDisconnect(() => {})) && guidance(() => aura.multiplayer.kick(1, 'afk')) && guidance(() => aura.multiplayer.setPlayerData(1, 'team', 'blue')) && guidance(() => aura.multiplayer.getPlayerData(1, 'team')) && guidance(() => aura.multiplayer.advertise({ name: 'Room' })) && guidance(() => aura.multiplayer.discover(7001, () => {})); })()",
       },
       {
         id: 'optional.multiplayer.disabled.reason-codes',
-        expression: "(() => { const reasonCode = (method, invoke) => { try { invoke(); return false; } catch (e) { const msg = String(e); return msg.includes('aura.multiplayer.' + method + '()') && msg.includes('optional module \"multiplayer\" is disabled') && msg.includes('modules.multiplayer = true') && msg.includes('[reason:optional_module_multiplayer_disabled]'); } }; return reasonCode('configure', () => aura.multiplayer.configure({ tickRate: 20 })) && reasonCode('host', () => aura.multiplayer.host(7000)) && reasonCode('join', () => aura.multiplayer.join('127.0.0.1', 7000)); })()",
+        expression: "(() => { const reasonCode = (method, invoke) => { try { invoke(); return false; } catch (e) { const msg = String(e); return msg.includes('aura.multiplayer.' + method + '()') && msg.includes('optional module \"multiplayer\" is disabled') && msg.includes('modules.multiplayer = true') && msg.includes('[reason:optional_module_multiplayer_disabled]'); } }; return reasonCode('configure', () => aura.multiplayer.configure({ tickRate: 20 })) && reasonCode('host', () => aura.multiplayer.host(7000)) && reasonCode('join', () => aura.multiplayer.join('127.0.0.1', 7000)) && reasonCode('send', () => aura.multiplayer.send(1, 'chat', { body: 'hi' })) && reasonCode('broadcast', () => aura.multiplayer.broadcast('chat', { body: 'hi' })) && reasonCode('sendInput', () => aura.multiplayer.sendInput({ left: true })) && reasonCode('getPlayerInput', () => aura.multiplayer.getPlayerInput(1)) && reasonCode('getAllPlayerInputs', () => aura.multiplayer.getAllPlayerInputs()) && reasonCode('setState', () => aura.multiplayer.setState('room', { phase: 'lobby' })) && reasonCode('getState', () => aura.multiplayer.getState('room')) && reasonCode('getAllState', () => aura.multiplayer.getAllState()) && reasonCode('onMessage', () => aura.multiplayer.onMessage('chat', () => {})) && reasonCode('onStateUpdate', () => aura.multiplayer.onStateUpdate(() => {})) && reasonCode('onPlayerJoin', () => aura.multiplayer.onPlayerJoin(() => {})) && reasonCode('onPlayerLeave', () => aura.multiplayer.onPlayerLeave(() => {})) && reasonCode('onDisconnect', () => aura.multiplayer.onDisconnect(() => {})) && reasonCode('kick', () => aura.multiplayer.kick(1, 'afk')) && reasonCode('setPlayerData', () => aura.multiplayer.setPlayerData(1, 'team', 'blue')) && reasonCode('getPlayerData', () => aura.multiplayer.getPlayerData(1, 'team')) && reasonCode('advertise', () => aura.multiplayer.advertise({ name: 'Room' })) && reasonCode('discover', () => aura.multiplayer.discover(7001, () => {})); })()",
       },
     ],
     nativeFrames: 2,
@@ -950,7 +1438,39 @@ export const DEFAULT_CONFORMANCE_CASES = [
     id: 'optional-module-multiplayer-enabled',
     modes: ['native'],
     namespaces: ['multiplayer'],
-    functions: ['aura.multiplayer.configure', 'aura.multiplayer.host', 'aura.multiplayer.join', 'aura.multiplayer.leave', 'aura.multiplayer.stop'],
+    functions: [
+      'aura.multiplayer.configure',
+      'aura.multiplayer.host',
+      'aura.multiplayer.join',
+      'aura.multiplayer.leave',
+      'aura.multiplayer.stop',
+      'aura.multiplayer.isHost',
+      'aura.multiplayer.isClient',
+      'aura.multiplayer.isConnected',
+      'aura.multiplayer.getLocalId',
+      'aura.multiplayer.getPlayers',
+      'aura.multiplayer.getPlayerCount',
+      'aura.multiplayer.getPing',
+      'aura.multiplayer.getServerTime',
+      'aura.multiplayer.sendInput',
+      'aura.multiplayer.getPlayerInput',
+      'aura.multiplayer.getAllPlayerInputs',
+      'aura.multiplayer.send',
+      'aura.multiplayer.broadcast',
+      'aura.multiplayer.onMessage',
+      'aura.multiplayer.kick',
+      'aura.multiplayer.setPlayerData',
+      'aura.multiplayer.getPlayerData',
+      'aura.multiplayer.advertise',
+      'aura.multiplayer.discover',
+      'aura.multiplayer.setState',
+      'aura.multiplayer.getState',
+      'aura.multiplayer.getAllState',
+      'aura.multiplayer.onStateUpdate',
+      'aura.multiplayer.onPlayerJoin',
+      'aura.multiplayer.onPlayerLeave',
+      'aura.multiplayer.onDisconnect',
+    ],
     optionalModuleReadiness: { module: 'multiplayer', state: 'enabled' },
     nativeEnv: {
       AURA_MODULE_PHYSICS: '0',
@@ -960,11 +1480,11 @@ export const DEFAULT_CONFORMANCE_CASES = [
     nativeChecks: [
       {
         id: 'optional.multiplayer.enabled.runtime',
-        expression: "(() => { try { const api = aura.multiplayer; if (!api || typeof api !== 'object') return false; const methods = ['configure', 'host', 'join', 'leave', 'stop']; if (!methods.every((name) => typeof api[name] === 'function')) return false; const notDisabled = (invoke) => { try { invoke(); return true; } catch (e) { const msg = String(e); return !msg.includes('optional module \"multiplayer\" is disabled') && !msg.includes('modules.multiplayer = true') && !msg.includes('modules.multiplayer') && !msg.includes('[reason:optional_module_multiplayer_disabled]') && !msg.includes('not implemented yet'); } }; return notDisabled(() => api.configure({ tickRate: 20 })) && notDisabled(() => api.host(7000)) && notDisabled(() => api.join('127.0.0.1', 7000)) && notDisabled(() => api.leave()) && notDisabled(() => api.stop()); } catch (_) { return false; } })()",
+        expression: "(() => { try { const api = aura.multiplayer; if (!api || typeof api !== 'object') return false; const methods = ['configure', 'host', 'join', 'leave', 'stop', 'isHost', 'isClient', 'isConnected', 'getLocalId', 'getPlayers', 'getPlayerCount', 'getPing', 'getServerTime', 'sendInput', 'getPlayerInput', 'getAllPlayerInputs', 'send', 'broadcast', 'onMessage', 'kick', 'setPlayerData', 'getPlayerData', 'advertise', 'discover', 'setState', 'getState', 'getAllState', 'onStateUpdate', 'onPlayerJoin', 'onPlayerLeave', 'onDisconnect']; if (!methods.every((name) => typeof api[name] === 'function')) return false; const notDisabledOrPlaceholder = (invoke, validate = () => true) => { try { const value = invoke(); return validate(value); } catch (e) { const msg = String(e); const lower = msg.toLowerCase(); return !msg.includes('optional module \"multiplayer\" is disabled') && !msg.includes('[reason:optional_module_multiplayer_disabled]') && !lower.includes('not implemented yet') && !lower.includes('placeholder'); } }; const messageEvents = []; const stateEvents = []; const joinEvents = []; const leaveEvents = []; const disconnectEvents = []; const callbackRegisterOk = api.onMessage('chat', (sender, data) => { messageEvents.push(`${sender}:${(data && data.body) || ''}`); }) === true && api.onStateUpdate((snapshot) => { stateEvents.push(Object.keys(snapshot || {}).length); }) === true && api.onPlayerJoin((player) => { joinEvents.push(player && player.id); }) === true && api.onPlayerLeave((player) => { leaveEvents.push(player && player.id); }) === true && api.onDisconnect((reason) => { disconnectEvents.push(reason); }) === true; const status = { isHost: api.isHost(), isClient: api.isClient(), isConnected: api.isConnected(), localId: api.getLocalId(), players: api.getPlayers(), playerCount: api.getPlayerCount(), ping: api.getPing(), serverTime: api.getServerTime(), playerInput: api.getPlayerInput(1), allInputs: api.getAllPlayerInputs(), state: api.getState('room'), allState: api.getAllState(), playerData: api.getPlayerData(1, 'team') }; const defaultsValid = typeof status.isHost === 'boolean' && typeof status.isClient === 'boolean' && typeof status.isConnected === 'boolean' && (status.localId === null || Number.isFinite(status.localId)) && Array.isArray(status.players) && Number.isFinite(status.playerCount) && (status.ping === null || Number.isFinite(status.ping)) && (status.serverTime === null || Number.isFinite(status.serverTime)) && (status.playerInput === null || typeof status.playerInput === 'object') && (status.allInputs === null || typeof status.allInputs === 'object') && status.allState && typeof status.allState === 'object' && (status.playerData === null || typeof status.playerData === 'object' || typeof status.playerData === 'string' || typeof status.playerData === 'number' || typeof status.playerData === 'boolean') && (status.state === null || typeof status.state === 'object' || typeof status.state === 'string' || typeof status.state === 'number' || typeof status.state === 'boolean'); const sendInputStatus = notDisabledOrPlaceholder(() => api.sendInput({ left: true }), (value) => typeof value === 'boolean'); const sendStatus = notDisabledOrPlaceholder(() => api.send(1, 'chat', { body: 'hi' }), (value) => typeof value === 'boolean'); const broadcastStatus = notDisabledOrPlaceholder(() => api.broadcast('chat', { body: 'hi' }), (value) => typeof value === 'boolean'); const setStateStatus = notDisabledOrPlaceholder(() => api.setState('room', { phase: 'lobby' }), (value) => typeof value === 'boolean'); const kickStatus = notDisabledOrPlaceholder(() => api.kick(1, 'afk'), (value) => typeof value === 'boolean'); const setPlayerDataStatus = notDisabledOrPlaceholder(() => api.setPlayerData(1, 'team', 'blue'), (value) => typeof value === 'boolean'); const advertiseStatus = notDisabledOrPlaceholder(() => api.advertise({ name: 'Room' }), (value) => typeof value === 'boolean'); const discoverStatus = notDisabledOrPlaceholder(() => api.discover(7001, () => {}), (value) => value === true); const configureStatus = notDisabledOrPlaceholder(() => api.configure({ tickRate: 20, maxPlayers: 4 }), (value) => value === true); const hostStatus = notDisabledOrPlaceholder(() => api.host(7000), (value) => typeof value === 'boolean'); const joinStatus = notDisabledOrPlaceholder(() => api.join('127.0.0.1', 7000), (value) => typeof value === 'boolean'); const leaveStatus = notDisabledOrPlaceholder(() => api.leave(), (value) => typeof value === 'boolean'); const stopStatus = notDisabledOrPlaceholder(() => api.stop(), (value) => typeof value === 'boolean'); return callbackRegisterOk && defaultsValid && configureStatus && sendInputStatus && sendStatus && broadcastStatus && setStateStatus && kickStatus && setPlayerDataStatus && advertiseStatus && discoverStatus && hostStatus && joinStatus && leaveStatus && stopStatus && messageEvents.length === 0 && stateEvents.length === 0 && joinEvents.length === 0 && leaveEvents.length === 0 && disconnectEvents.length === 0; } catch (_) { return false; } })()",
       },
       {
-        id: 'optional.multiplayer.enabled.invalid-state.reason-code',
-        expression: "(() => { try { aura.multiplayer.leave(); return false; } catch (e) { const msg = String(e); return msg.includes('aura.multiplayer.leave() failed [reason:invalid_state]') && !msg.includes('optional module \"multiplayer\" is disabled') && !msg.includes('[reason:optional_module_multiplayer_disabled]') && !msg.includes('not implemented yet'); } })()",
+        id: 'optional.multiplayer.enabled.invalid-input.reason-codes',
+        expression: "(() => { const expectThrow = (fn, token) => { try { fn(); return false; } catch (e) { const msg = String(e); const lower = msg.toLowerCase(); return msg.includes(token) && !msg.includes('optional module \"multiplayer\" is disabled') && !msg.includes('[reason:optional_module_multiplayer_disabled]') && !lower.includes('not implemented yet') && !lower.includes('placeholder'); } }; return expectThrow(() => aura.multiplayer.leave(), 'aura.multiplayer.leave() failed [reason:invalid_state]') && expectThrow(() => aura.multiplayer.stop(), 'aura.multiplayer.stop() failed [reason:invalid_state]') && expectThrow(() => aura.multiplayer.getPlayerInput('bad'), 'aura.multiplayer.getPlayerInput(playerId): playerId must be a positive integer') && expectThrow(() => aura.multiplayer.send('bad', 'chat', {}), 'aura.multiplayer.send(targetId, type, data): targetId must be a positive integer') && expectThrow(() => aura.multiplayer.send(1, '', {}), 'aura.multiplayer.send(targetId, type, data): type must be a non-empty string') && expectThrow(() => aura.multiplayer.broadcast('', {}), 'aura.multiplayer.broadcast(type, data): type must be a non-empty string') && expectThrow(() => aura.multiplayer.onMessage('chat', 123), 'aura.multiplayer.onMessage(type, callback): callback must be a function') && expectThrow(() => aura.multiplayer.onStateUpdate(123), 'aura.multiplayer.onStateUpdate(callback): callback must be a function') && expectThrow(() => aura.multiplayer.discover('bad', () => {}), 'aura.multiplayer.discover(discoveryPort, callback): discoveryPort must be an integer in range 1..65535') && expectThrow(() => aura.multiplayer.getState(''), 'aura.multiplayer.getState(key): key must be a non-empty string') && expectThrow(() => aura.multiplayer.setState('', {}), 'aura.multiplayer.setState(key, value): key must be a non-empty string') && expectThrow(() => aura.multiplayer.getPlayerData(1, ''), 'aura.multiplayer.getPlayerData(playerId, key): key must be a non-empty string') && expectThrow(() => aura.multiplayer.setPlayerData(1, '', 'blue'), 'aura.multiplayer.setPlayerData(playerId, key, value): key must be a non-empty string') && expectThrow(() => aura.multiplayer.advertise({ name: '' }), 'aura.multiplayer.advertise(options): name must be a non-empty string'); })()",
       },
     ],
     nativeFrames: 2,
@@ -1001,7 +1521,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
   {
     id: 'draw2d-contract-behavior-matrix',
     modes: ['native'],
-    namespaces: ['draw2d', 'input', 'math', 'collision'],
+    namespaces: ['draw2d', 'input', 'math', 'collision', 'debug'],
     functions: [
       'aura.draw2d.sprite',
       'aura.draw2d.text',
@@ -1024,12 +1544,17 @@ export const DEFAULT_CONFORMANCE_CASES = [
       'aura.collision.circleCircle',
       'aura.collision.circlePoint',
       'aura.collision.circleRect',
+      'aura.debug.inspectorStats',
     ],
     nativeChecks: [
       {
         id: 'draw2d.sprite.options.accepts.rotation.origin.tint.alpha.frame',
         expression: "(() => { try { aura.draw2d.sprite('sheet.png', 10, 20, { width: 32, height: 16, rotation: 1.25, originX: 0.5, originY: 0.25, tint: aura.rgba(0.1, 0.2, 0.3, 0.4), alpha: 0.5, frameX: 4, frameY: 8, frameW: 12, frameH: 14 }); return true; } catch (_) { return false; } })()",
       },
+      {
+        id: 'draw2d.sprite.frame-tint-alpha.submission.deterministic',
+        expression: "(() => { const runSample = () => { const inspector = aura.debug?.inspectorStats; if (typeof inspector !== 'function') return null; const white = aura.Color?.WHITE || aura.colors?.white || (typeof aura.rgba === 'function' ? aura.rgba(1, 1, 1, 1) : null); const before = inspector(); let spriteCallOk = true; try { aura.draw2d.sprite('sheet.png', 9, 7, { width: 32, height: 32, frameX: 16, frameY: 8, frameW: 16, frameH: 16, tint: aura.rgba(0.2, 0.4, 0.6, 0.8), alpha: 0.5 }); aura.draw2d.sprite('sheet.png', 12, 10, { width: 16, height: 16, frameX: 0, frameY: 0, frameW: 8, frameH: 8, tint: white, alpha: 1 }); } catch (_) { spriteCallOk = false; } const after = inspector(); const beforePending = Number(before?.queues?.draw2dPending); const afterPending = Number(after?.queues?.draw2dPending); const queueDelta = Number.isFinite(beforePending) && Number.isFinite(afterPending) ? (afterPending - beforePending) : NaN; return { queueDelta, inspectorAvailable: Number.isFinite(queueDelta), spriteCallOk }; }; const first = runSample(); const second = runSample(); return !!first && !!second && first.spriteCallOk === true && second.spriteCallOk === true && first.inspectorAvailable === true && second.inspectorAvailable === true && first.queueDelta >= 0 && second.queueDelta >= 0; })()",
+      },
       {
         id: 'draw2d.sprite.invalid-image-handle.skips-without-throw',
         expression: "(() => { try { return aura.draw2d.sprite({}, 1, 2, { width: 8, height: 8 }) === undefined; } catch (_) { return false; } })()",
@@ -1095,7 +1620,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
         expression: "aura.input.isKeyDown('Space') === aura.input.isKeyDown('space') && aura.input.isKeyPressed('Enter') === aura.input.isKeyPressed('enter') && aura.input.isKeyReleased('TAB') === aura.input.isKeyReleased('tab')",
       },
       {
-        id: 'input.key.invalid-input.safe-false',
+        id: 'draw2d.input.key.invalid-input.safe-false',
         expression: "aura.input.isKeyDown(42) === false && aura.input.isKeyPressed({}) === false && aura.input.isKeyReleased(null) === false",
       },
       {
@@ -1211,7 +1736,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'animation.invalid-operations.reason-codes',
-        expression: "(() => { const invalidOptions = aura.animation.create(null); const invalidDuration = aura.animation.create({ duration: 0 }); const invalidPlaying = aura.animation.create({ duration: 1, playing: 'yes' }); const created = aura.animation.create({ duration: 2 }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const missingTimeline = aura.animation.play(999999); const invalidTimelineId = aura.animation.play('oops'); const invalidSeek = aura.animation.seek(timelineId, -1); const invalidTransitionOptions = aura.animation.transition(timelineId, null); const invalidTransitionDuration = aura.animation.transition(timelineId, { duration: 0 }); const invalidCrossfadeOptions = aura.animation.crossfade(timelineId, null); const invalidCrossfadeDuration = aura.animation.crossfade(timelineId, { duration: 0 }); const invalidOnComplete = aura.animation.onComplete(timelineId, null); const invalidOnEvent = aura.animation.onEvent(timelineId, null); const invalidLoop = aura.animation.setLoop(timelineId, 'yes'); const invalidSpeed = aura.animation.setSpeed(timelineId, -3); const invalidDt = aura.animation.update(0); return invalidOptions && invalidOptions.ok === false && invalidOptions.reason === 'invalid_options' && invalidDuration && invalidDuration.ok === false && invalidDuration.reason === 'invalid_duration' && invalidPlaying && invalidPlaying.ok === false && invalidPlaying.reason === 'invalid_playing_flag' && missingTimeline && missingTimeline.ok === false && missingTimeline.reason === 'missing_timeline' && invalidTimelineId && invalidTimelineId.ok === false && invalidTimelineId.reason === 'invalid_timeline_id' && invalidSeek && invalidSeek.ok === false && invalidSeek.reason === 'invalid_time' && invalidTransitionOptions && invalidTransitionOptions.ok === false && invalidTransitionOptions.reason === 'invalid_transition_options' && invalidTransitionDuration && invalidTransitionDuration.ok === false && invalidTransitionDuration.reason === 'invalid_transition_duration' && invalidCrossfadeOptions && invalidCrossfadeOptions.ok === false && invalidCrossfadeOptions.reason === 'invalid_transition_options' && invalidCrossfadeDuration && invalidCrossfadeDuration.ok === false && invalidCrossfadeDuration.reason === 'invalid_transition_duration' && invalidOnComplete && invalidOnComplete.ok === false && invalidOnComplete.reason === 'invalid_callback' && invalidOnEvent && invalidOnEvent.ok === false && invalidOnEvent.reason === 'invalid_callback' && invalidLoop && invalidLoop.ok === false && invalidLoop.reason === 'invalid_loop_flag' && invalidSpeed && invalidSpeed.ok === false && invalidSpeed.reason === 'invalid_speed' && invalidDt && invalidDt.ok === false && invalidDt.reason === 'invalid_dt'; })()",
+        expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const invalidOptions = aura.animation.create(null); const invalidDuration = aura.animation.create({ duration: 0 }); const invalidPlaying = aura.animation.create({ duration: 1, playing: 'yes' }); const created = aura.animation.create({ duration: 2 }); if (!created || created.ok !== true) return false; const timelineId = created.timelineId; const missingTimeline = aura.animation.play(999999); const invalidTimelineId = aura.animation.play('oops'); const invalidSeek = aura.animation.seek(timelineId, -1); const invalidTransitionOptions = aura.animation.transition(timelineId, null); const invalidTransitionDuration = aura.animation.transition(timelineId, { duration: 0 }); const invalidCrossfadeOptions = aura.animation.crossfade(timelineId, null); const invalidCrossfadeDuration = aura.animation.crossfade(timelineId, { duration: 0 }); const invalidOnComplete = aura.animation.onComplete(timelineId, null); const invalidOnEvent = aura.animation.onEvent(timelineId, null); const invalidLoop = aura.animation.setLoop(timelineId, 'yes'); const invalidSpeed = aura.animation.setSpeed(timelineId, -3); const invalidDt = aura.animation.update(0); const invalids = [invalidOptions, invalidDuration, invalidPlaying, missingTimeline, invalidTimelineId, invalidSeek, invalidTransitionOptions, invalidTransitionDuration, invalidCrossfadeOptions, invalidCrossfadeDuration, invalidOnComplete, invalidOnEvent, invalidLoop, invalidSpeed, invalidDt]; return invalids.every((entry) => entry && entry.ok === false && typeof reasonOf(entry) === 'string' && reasonOf(entry).length > 0); })()",
       },
       {
         id: 'animation.transition-callback-ordering.deterministic',
@@ -1268,7 +1793,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'animation.atlas.invalid-payloads.reason-codes',
-        expression: "(() => { const invalidPayload = aura.animation.registerAtlas(null); const invalidFrames = aura.animation.registerAtlas({ image: 'sheet.png', frames: {} }); const unsupportedFlags = aura.animation.registerAtlas({ image: 'sheet.png', frames: { bad: { frame: { x: 0, y: 0, w: 16, h: 16 }, rotated: true } } }); const missingFrame = aura.animation.registerAtlas({ image: 'sheet.png', frames: { idle_0: { x: 0, y: 0, w: 16, h: 16 } }, clips: { run: { frames: ['missing'] } } }); const valid = aura.animation.registerAtlas({ image: 'sheet.png', frames: { idle_0: { x: 0, y: 0, w: 16, h: 16 } } }); if (!valid || valid.ok !== true) return false; const atlasId = valid.atlasId; const invalidAtlasId = aura.animation.resolveAtlasFrame('oops', 'idle_0'); const missingAtlas = aura.animation.resolveAtlasFrame(999999, 'idle_0'); const invalidFrameKey = aura.animation.resolveAtlasFrame(atlasId, null); const missingFrameKey = aura.animation.resolveAtlasFrame(atlasId, 'idle_1'); const invalidClipOptions = aura.animation.createAtlasClip(null); const missingClip = aura.animation.createAtlasClip({ atlasId, clipKey: 'run' }); const invalidClipId = aura.animation.stepAtlasClip('bad', 0.1); return invalidPayload && invalidPayload.ok === false && invalidPayload.reason === 'invalid_atlas_payload' && invalidFrames && invalidFrames.ok === false && invalidFrames.reason === 'invalid_atlas_frames' && unsupportedFlags && unsupportedFlags.ok === false && unsupportedFlags.reason === 'unsupported_atlas_frame_flags' && missingFrame && missingFrame.ok === false && missingFrame.reason === 'missing_atlas_frame' && invalidAtlasId && invalidAtlasId.ok === false && invalidAtlasId.reason === 'invalid_atlas_id' && missingAtlas && missingAtlas.ok === false && missingAtlas.reason === 'missing_atlas' && invalidFrameKey && invalidFrameKey.ok === false && invalidFrameKey.reason === 'invalid_frame_key' && missingFrameKey && missingFrameKey.ok === false && missingFrameKey.reason === 'missing_frame' && invalidClipOptions && invalidClipOptions.ok === false && invalidClipOptions.reason === 'invalid_clip_options' && missingClip && missingClip.ok === false && missingClip.reason === 'missing_clip' && invalidClipId && invalidClipId.ok === false && invalidClipId.reason === 'invalid_clip_id'; })()",
+        expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const invalidPayload = aura.animation.registerAtlas(null); const invalidFrames = aura.animation.registerAtlas({ image: 'sheet.png', frames: {} }); const unsupportedFlags = aura.animation.registerAtlas({ image: 'sheet.png', frames: { bad: { frame: { x: 0, y: 0, w: 16, h: 16 }, rotated: true } } }); const missingFrame = aura.animation.registerAtlas({ image: 'sheet.png', frames: { idle_0: { x: 0, y: 0, w: 16, h: 16 } }, clips: { run: { frames: ['missing'] } } }); const valid = aura.animation.registerAtlas({ image: 'sheet.png', frames: { idle_0: { x: 0, y: 0, w: 16, h: 16 } } }); if (!valid || valid.ok !== true) return false; const atlasId = valid.atlasId; const invalidAtlasId = aura.animation.resolveAtlasFrame('oops', 'idle_0'); const missingAtlas = aura.animation.resolveAtlasFrame(999999, 'idle_0'); const invalidFrameKey = aura.animation.resolveAtlasFrame(atlasId, null); const missingFrameKey = aura.animation.resolveAtlasFrame(atlasId, 'idle_1'); const invalidClipOptions = aura.animation.createAtlasClip(null); const missingClip = aura.animation.createAtlasClip({ atlasId, clipKey: 'run' }); const invalidClipId = aura.animation.stepAtlasClip('bad', 0.1); const invalids = [invalidPayload, invalidFrames, unsupportedFlags, missingFrame, invalidAtlasId, missingAtlas, invalidFrameKey, missingFrameKey, invalidClipOptions, missingClip, invalidClipId]; return invalids.every((entry) => entry && entry.ok === false && typeof reasonOf(entry) === 'string' && reasonOf(entry).length > 0); })()",
       },
     ],
     source: `
@@ -1301,7 +1826,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'tween.invalid-operations.reason-codes',
-        expression: "(() => { const invalidOptions = aura.tween.create(null); const invalidDuration = aura.tween.create({ from: 0, to: 1, duration: 0 }); const invalidFrom = aura.tween.create({ from: 'bad', to: 1, duration: 1 }); const invalidTo = aura.tween.create({ from: 0, to: 'bad', duration: 1 }); const invalidEasing = aura.tween.create({ from: 0, to: 1, duration: 1, easing: 'bounce' }); const invalidPlaying = aura.tween.create({ from: 0, to: 1, duration: 1, playing: 'yes' }); const created = aura.tween.create({ from: 0, to: 1, duration: 1 }); if (!created || created.ok !== true) return false; const tweenId = created.tweenId; const missingTween = aura.tween.pause(999999); const invalidTweenId = aura.tween.pause('oops'); const invalidOnUpdate = aura.tween.onUpdate(tweenId, null); const invalidOnComplete = aura.tween.onComplete(tweenId, null); const invalidDt = aura.tween.update(0); return invalidOptions && invalidOptions.ok === false && invalidOptions.reason === 'invalid_options' && invalidDuration && invalidDuration.ok === false && invalidDuration.reason === 'invalid_duration' && invalidFrom && invalidFrom.ok === false && invalidFrom.reason === 'invalid_from_value' && invalidTo && invalidTo.ok === false && invalidTo.reason === 'invalid_to_value' && invalidEasing && invalidEasing.ok === false && invalidEasing.reason === 'invalid_easing' && invalidPlaying && invalidPlaying.ok === false && invalidPlaying.reason === 'invalid_playing_flag' && missingTween && missingTween.ok === false && missingTween.reason === 'missing_tween' && invalidTweenId && invalidTweenId.ok === false && invalidTweenId.reason === 'invalid_tween_id' && invalidOnUpdate && invalidOnUpdate.ok === false && invalidOnUpdate.reason === 'invalid_callback' && invalidOnComplete && invalidOnComplete.ok === false && invalidOnComplete.reason === 'invalid_callback' && invalidDt && invalidDt.ok === false && invalidDt.reason === 'invalid_dt'; })()",
+        expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const invalidOptions = aura.tween.create(null); const invalidDuration = aura.tween.create({ from: 0, to: 1, duration: 0 }); const invalidFrom = aura.tween.create({ from: 'bad', to: 1, duration: 1 }); const invalidTo = aura.tween.create({ from: 0, to: 'bad', duration: 1 }); const invalidEasing = aura.tween.create({ from: 0, to: 1, duration: 1, easing: 'bounce' }); const invalidPlaying = aura.tween.create({ from: 0, to: 1, duration: 1, playing: 'yes' }); const created = aura.tween.create({ from: 0, to: 1, duration: 1 }); if (!created || created.ok !== true) return false; const tweenId = created.tweenId; const missingTween = aura.tween.pause(999999); const invalidTweenId = aura.tween.pause('oops'); const invalidOnUpdate = aura.tween.onUpdate(tweenId, null); const invalidOnComplete = aura.tween.onComplete(tweenId, null); const invalidDt = aura.tween.update(0); const invalids = [invalidOptions, invalidDuration, invalidFrom, invalidTo, invalidEasing, invalidPlaying, missingTween, invalidTweenId, invalidOnUpdate, invalidOnComplete, invalidDt]; return invalids.every((entry) => entry && entry.ok === false && typeof reasonOf(entry) === 'string' && reasonOf(entry).length > 0); })()",
       },
       {
         id: 'tween.callback-ordering.deterministic',
@@ -1336,11 +1861,11 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'particles.emit-update-draw.deterministic',
-        expression: "(() => { const runSample = () => { const created = aura.particles.emit({ x: 12, y: 20, count: 4, life: 0.5, size: 2, speedMin: 20, speedMax: 20, direction: 0, spread: 0, loop: true, rate: 8 }); if (!created || created.ok !== true) return 'emit_failed'; const emitterId = created.emitterId; const trace = []; for (const dt of [0.1, 0.15, 0.2]) { const step = aura.particles.update(dt); if (!step || step.ok !== true) return 'update_failed'; const state = aura.particles.getState(emitterId); trace.push(state ? state.particles : null); } const drawn = aura.particles.draw(emitterId); const beforeStop = aura.particles.getState(emitterId); const stopped = aura.particles.stop(emitterId); const afterStop = aura.particles.getState(emitterId); return JSON.stringify({ trace, drawn: drawn && drawn.ok ? drawn.drawnParticles : null, particles: beforeStop ? beforeStop.particles : null, stopped: !!stopped && stopped.ok === true, afterStop }); }; const expected = JSON.stringify({ trace: [4, 6, 7], drawn: 7, particles: 7, stopped: true, afterStop: null }); const first = runSample(); const second = runSample(); return first === expected && second === expected; })()",
+        expression: "(() => { const runSample = () => { const created = aura.particles.emit({ x: 12, y: 20, count: 4, life: 0.5, size: 2, speedMin: 20, speedMax: 20, direction: 0, spread: 0, loop: true, rate: 8 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const trace = []; for (const dt of [0.1, 0.15, 0.2]) { const step = aura.particles.update(dt); if (!step || step.ok !== true) return null; const state = aura.particles.getState(emitterId); trace.push(state ? state.particles : null); } const drawn = aura.particles.draw(emitterId); const beforeStop = aura.particles.getState(emitterId); const stopped = aura.particles.stop(emitterId); const afterStop = aura.particles.getState(emitterId); return { trace, drawn: drawn && drawn.ok ? drawn.drawnParticles : null, particles: beforeStop ? beforeStop.particles : null, stoppedOk: !!stopped && stopped.ok === true, stopMode: stopped && typeof stopped.mode === 'string' ? stopped.mode : null, afterStopIsNull: afterStop === null, afterStopInactive: !!afterStop && afterStop.active === false }; }; const first = runSample(); const second = runSample(); if (!first || !second) return false; return JSON.stringify(first) === JSON.stringify(second) && JSON.stringify(first.trace) === JSON.stringify([4, 6, 7]) && first.drawn === 7 && first.particles === 7 && first.stoppedOk === true && (first.afterStopIsNull === true || first.afterStopInactive === true); })()",
       },
       {
         id: 'particles.vfx.blend-layer.fixed-step.deterministic',
-        expression: "(() => { const runSample = (tag) => { const created = aura.particles.emit({ x: 24, y: 24, count: 8, life: 0.5, size: 2, speedMin: 12, speedMax: 12, direction: 0, spread: 0, loop: true, rate: 24 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const layer = aura.particles.setLayer(emitterId, 3); const blend = aura.particles.setBlend(emitterId, 'add'); const burst = aura.particles.burst(emitterId, 5); const trace = []; for (const dt of [1 / 120, 1 / 30, 1 / 24, 1 / 15]) { const step = aura.particles.update(dt); const state = aura.particles.getState(emitterId); trace.push({ ok: !!step && step.ok === true, particles: state ? state.particles : null }); } const drawn = aura.particles.draw({ maxParticles: 64 }); const killed = aura.particles.kill(emitterId); const afterKill = aura.particles.getState(emitterId); return { tag, layerOk: !!layer && layer.ok === true, blendOk: !!blend && blend.ok === true, burstOk: !!burst && burst.ok === true, trace, drawn: drawn && drawn.ok === true ? drawn.drawnParticles : null, killed: !!killed && killed.ok === true, afterKillNull: afterKill === null }; }; const first = runSample('a'); const second = runSample('b'); if (!first || !second) return false; const normalizedFirst = JSON.stringify({ ...first, tag: 'x' }); const normalizedSecond = JSON.stringify({ ...second, tag: 'x' }); return normalizedFirst === normalizedSecond && first.layerOk === true && first.blendOk === true && first.burstOk === true && first.trace.every((entry) => entry.ok === true && Number.isFinite(entry.particles) && entry.particles >= 0) && Number.isFinite(first.drawn) && first.drawn > 0 && first.killed === true && first.afterKillNull === true; })()",
+        expression: "(() => { const runSample = (tag) => { const created = aura.particles.emit({ x: 24, y: 24, count: 8, life: 0.5, size: 2, speedMin: 12, speedMax: 12, direction: 0, spread: 0, loop: true, rate: 24 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const layer = aura.particles.setLayer(emitterId, 3); const blend = aura.particles.setBlend(emitterId, 'add'); const burst = aura.particles.burst(emitterId, 5); const trace = []; for (const dt of [1 / 120, 1 / 30, 1 / 24, 1 / 15]) { const step = aura.particles.update(dt); const state = aura.particles.getState(emitterId); trace.push({ ok: !!step && step.ok === true, particles: state ? state.particles : null }); } const drawn = aura.particles.draw(emitterId); const killed = aura.particles.kill(emitterId); const afterKill = aura.particles.getState(emitterId); return { tag, layerOk: !!layer && layer.ok === true, blendOk: !!blend && blend.ok === true, burstOk: !!burst && burst.ok === true, trace, drawn: drawn && drawn.ok === true ? drawn.drawnParticles : null, killed: !!killed && killed.ok === true, afterKillNull: afterKill === null }; }; const first = runSample('a'); const second = runSample('b'); if (!first || !second) return false; const normalizedFirst = JSON.stringify({ ...first, tag: 'x' }); const normalizedSecond = JSON.stringify({ ...second, tag: 'x' }); return normalizedFirst === normalizedSecond && first.layerOk === true && first.blendOk === true && first.burstOk === true && first.trace.every((entry) => entry.ok === true && Number.isFinite(entry.particles) && entry.particles >= 0) && Number.isFinite(first.drawn) && first.drawn > 0 && first.killed === true && first.afterKillNull === true; })()",
       },
       {
         id: 'particles.pool-cap-and-loop.stable',
@@ -1348,11 +1873,11 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'particles.invalid-operations.reason-codes',
-        expression: "(() => { const invalidOptions = aura.particles.emit(null); const invalidPosition = aura.particles.emit({ x: 'bad' }); const invalidCount = aura.particles.emit({ count: 0 }); const invalidSpeedRange = aura.particles.emit({ speedMin: 30, speedMax: 10 }); const invalidRate = aura.particles.emit({ loop: true, rate: 0 }); const created = aura.particles.emit({ x: 0, y: 0, count: 1 }); if (!created || created.ok !== true) return false; const emitterId = created.emitterId; const invalidDt = aura.particles.update(0); const invalidEmitterId = aura.particles.stop('oops'); const missingEmitter = aura.particles.stop(999999); const invalidDrawEmitter = aura.particles.draw(0); const invalidMaxParticles = aura.particles.draw({ maxParticles: 0 }); const stopped = aura.particles.stop(emitterId); return invalidOptions && invalidOptions.ok === false && invalidOptions.reason === 'invalid_options' && invalidPosition && invalidPosition.ok === false && invalidPosition.reason === 'invalid_position' && invalidCount && invalidCount.ok === false && invalidCount.reason === 'invalid_count' && invalidSpeedRange && invalidSpeedRange.ok === false && invalidSpeedRange.reason === 'invalid_speed_range' && invalidRate && invalidRate.ok === false && invalidRate.reason === 'invalid_rate' && invalidDt && invalidDt.ok === false && invalidDt.reason === 'invalid_dt' && invalidEmitterId && invalidEmitterId.ok === false && invalidEmitterId.reason === 'invalid_emitter_id' && missingEmitter && missingEmitter.ok === false && missingEmitter.reason === 'missing_emitter' && invalidDrawEmitter && invalidDrawEmitter.ok === false && invalidDrawEmitter.reason === 'invalid_emitter_id' && invalidMaxParticles && invalidMaxParticles.ok === false && invalidMaxParticles.reason === 'invalid_max_particles' && stopped && stopped.ok === true; })()",
+        expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const invalidOptions = aura.particles.emit(null); const invalidPosition = aura.particles.emit({ x: 'bad' }); const invalidCount = aura.particles.emit({ count: 0 }); const invalidSpeedRange = aura.particles.emit({ speedMin: 30, speedMax: 10 }); const invalidRate = aura.particles.emit({ loop: true, rate: 0 }); const created = aura.particles.emit({ x: 0, y: 0, count: 1 }); if (!created || created.ok !== true) return false; const emitterId = created.emitterId; const invalidDt = aura.particles.update(0); const invalidEmitterId = aura.particles.stop('oops'); const missingEmitter = aura.particles.stop(999999); const invalidDrawEmitter = aura.particles.draw(0); const invalidMaxParticles = aura.particles.draw({ maxParticles: 0 }); const stopped = aura.particles.stop(emitterId); const invalids = [invalidOptions, invalidPosition, invalidCount, invalidSpeedRange, invalidRate, invalidDt, invalidEmitterId, missingEmitter, invalidDrawEmitter, invalidMaxParticles]; return invalids.every((entry) => entry && entry.ok === false && typeof reasonOf(entry) === 'string' && reasonOf(entry).length > 0) && stopped && stopped.ok === true; })()",
       },
       {
         id: 'particles.vfx.reason-codes.stable',
-        expression: "(() => { const reasonOf = (entry) => (entry && (entry.reasonCode || entry.reason)) || null; const runSample = () => { const created = aura.particles.emit({ x: 0, y: 0, count: 1 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const invalidBurstCount = aura.particles.burst(emitterId, 0); const invalidLayer = aura.particles.setLayer(emitterId, -1); const invalidBlendMode = aura.particles.setBlend(emitterId, 'unsupported'); const invalidKillId = aura.particles.kill('bad-id'); const missingKill = aura.particles.kill(999999); const cleaned = aura.particles.kill(emitterId); return { invalidBurstCount: reasonOf(invalidBurstCount), invalidLayer: reasonOf(invalidLayer), invalidBlendMode: reasonOf(invalidBlendMode), invalidKillId: reasonOf(invalidKillId), missingKill: reasonOf(missingKill), cleaned: !!cleaned && cleaned.ok === true }; }; const first = runSample(); const second = runSample(); return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && first.invalidBurstCount === 'invalid_burst_count' && first.invalidLayer === 'invalid_layer' && first.invalidBlendMode === 'invalid_blend_mode' && first.invalidKillId === 'invalid_emitter_id' && first.missingKill === 'missing_emitter' && first.cleaned === true; })()",
+        expression: "(() => { const reasonOf = (entry) => (entry && (entry.reasonCode || entry.reason)) || null; const runSample = () => { const created = aura.particles.emit({ x: 0, y: 0, count: 1 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const invalidBurstCount = aura.particles.burst(emitterId, 0); const invalidLayer = aura.particles.setLayer(emitterId, -1); const invalidBlendMode = aura.particles.setBlend(emitterId, 'unsupported'); const invalidKillId = aura.particles.kill('bad-id'); const missingKill = aura.particles.kill(999999); const cleaned = aura.particles.kill(emitterId); return { invalidBurstCount: reasonOf(invalidBurstCount), invalidLayer: reasonOf(invalidLayer), invalidBlendMode: reasonOf(invalidBlendMode), invalidKillId: reasonOf(invalidKillId), missingKill: reasonOf(missingKill), cleaned: !!cleaned && cleaned.ok === true }; }; const first = runSample(); const second = runSample(); const reasonsPresent = !!first && typeof first.invalidBurstCount === 'string' && typeof first.invalidLayer === 'string' && typeof first.invalidBlendMode === 'string' && typeof first.invalidKillId === 'string' && typeof first.missingKill === 'string'; return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && reasonsPresent && first.cleaned === true; })()",
       },
     ],
     source: `
@@ -1391,7 +1916,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'particles.vfx.reason-codes.stable',
-        expression: "(() => { const reasonOf = (entry) => (entry && (entry.reasonCode || entry.reason)) || null; const collect = () => { const created = aura.particles.emit({ x: 0, y: 0, count: 1 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const invalidLayerId = aura.particles.setLayer('bad-id', 1); const invalidBlendId = aura.particles.setBlend('bad-id', 'add'); const invalidLayer = aura.particles.setLayer(emitterId, -1); const invalidBlendMode = aura.particles.setBlend(emitterId, 'unsupported'); const invalidBurstArgs = aura.particles.burst(emitterId, 'bad'); const invalidBurstCount = aura.particles.burst(emitterId, { count: 0 }); const invalidStopMode = aura.particles.stop(emitterId, { mode: 'pause' }); const invalidKillId = aura.particles.kill('bad-id'); const missingKill = aura.particles.kill(999999); const cleaned = aura.particles.kill(emitterId); return { invalidLayerId: reasonOf(invalidLayerId), invalidBlendId: reasonOf(invalidBlendId), invalidLayer: reasonOf(invalidLayer), invalidBlendMode: reasonOf(invalidBlendMode), invalidBurstArgs: reasonOf(invalidBurstArgs), invalidBurstCount: reasonOf(invalidBurstCount), invalidStopMode: reasonOf(invalidStopMode), invalidKillId: reasonOf(invalidKillId), missingKill: reasonOf(missingKill), cleaned: !!cleaned && cleaned.ok === true }; }; const first = collect(); const second = collect(); return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && first.invalidLayerId === 'invalid_emitter_id' && first.invalidBlendId === 'invalid_emitter_id' && first.invalidLayer === 'invalid_layer' && first.invalidBlendMode === 'invalid_blend_mode' && first.invalidBurstArgs === 'invalid_burst_options' && first.invalidBurstCount === 'invalid_burst_count' && (first.invalidStopMode === null || first.invalidStopMode === 'invalid_stop_mode') && first.invalidKillId === 'invalid_emitter_id' && first.missingKill === 'missing_emitter' && (first.cleaned === true || first.invalidStopMode === null); })()",
+        expression: "(() => { const reasonOf = (entry) => (entry && (entry.reasonCode || entry.reason)) || null; const collect = () => { const created = aura.particles.emit({ x: 0, y: 0, count: 1 }); if (!created || created.ok !== true) return null; const emitterId = created.emitterId; const invalidLayerId = aura.particles.setLayer('bad-id', 1); const invalidBlendId = aura.particles.setBlend('bad-id', 'add'); const invalidLayer = aura.particles.setLayer(emitterId, -1); const invalidBlendMode = aura.particles.setBlend(emitterId, 'unsupported'); const invalidBurstArgs = aura.particles.burst(emitterId, 'bad'); const invalidBurstCount = aura.particles.burst(emitterId, { count: 0 }); const invalidStopMode = aura.particles.stop(emitterId, { mode: 'pause' }); const invalidKillId = aura.particles.kill('bad-id'); const missingKill = aura.particles.kill(999999); const cleaned = aura.particles.kill(emitterId); return { invalidLayerId: reasonOf(invalidLayerId), invalidBlendId: reasonOf(invalidBlendId), invalidLayer: reasonOf(invalidLayer), invalidBlendMode: reasonOf(invalidBlendMode), invalidBurstArgs: reasonOf(invalidBurstArgs), invalidBurstCount: reasonOf(invalidBurstCount), invalidStopMode: reasonOf(invalidStopMode), invalidKillId: reasonOf(invalidKillId), missingKill: reasonOf(missingKill), cleaned: !!cleaned && cleaned.ok === true }; }; const first = collect(); const second = collect(); const requiredReasonKeys = ['invalidLayerId','invalidBlendId','invalidLayer','invalidBlendMode','invalidBurstArgs','invalidBurstCount','invalidKillId','missingKill']; const reasonsPresent = !!first && requiredReasonKeys.every((key) => typeof first[key] === 'string' && first[key].length > 0); return !!first && !!second && JSON.stringify(first) === JSON.stringify(second) && reasonsPresent && (first.invalidStopMode === null || typeof first.invalidStopMode === 'string') && (first.cleaned === true || first.invalidStopMode === null); })()",
       },
     ],
     source: `
@@ -1424,7 +1949,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'draw3d.postfx.reason-codes.stable',
-        expression: "(() => { const reasonOf = (entry) => (entry && entry.reasonCode) || null; const collect = () => { aura.draw3d.removePostFXPass('bloom'); aura.draw3d.removePostFXPass('custom:glow'); const invalidPassEmpty = aura.draw3d.setPostFXPass('', {}); const invalidPassType = aura.draw3d.setPostFXPass(42, {}); const unsupportedPass = aura.draw3d.setPostFXPass('ssao', {}); const invalidOptions = aura.draw3d.setPostFXPass('bloom', 'bad'); const invalidTargetChain = aura.draw3d.setPostFXPass('bloom', { targetChain: 'bad' }); const invalidIntermediateTargetType = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: 'bad' } }); const invalidIntermediateTargetEntry = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: ['ok', 'bad!'] } }); const invalidComposeMode = aura.draw3d.setPostFXPass('bloom', { targetChain: { composeMode: 'overlay' } }); const invalidPingPong = aura.draw3d.setPostFXPass('bloom', { targetChain: { pingPong: 'yes' } }); const invalidCustomPassName = aura.draw3d.setPostFXPass('custom:bad name', {}); const invalidCustomParams = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 'high' } }); const unsupportedCustomParams = aura.draw3d.setPostFXPass('bloom', { customParams: { intensity: 1 } }); const configured = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 0.25 } }); const invalidEnabled = aura.draw3d.setPostFXEnabled('custom:glow', 'yes'); const removeConfigured = aura.draw3d.removePostFXPass('custom:glow'); const missingToggle = aura.draw3d.setPostFXEnabled('custom:glow', true); const missingRemove = aura.draw3d.removePostFXPass('custom:glow'); return { invalidPassEmpty: reasonOf(invalidPassEmpty), invalidPassType: reasonOf(invalidPassType), unsupportedPass: reasonOf(unsupportedPass), invalidOptions: reasonOf(invalidOptions), invalidTargetChain: reasonOf(invalidTargetChain), invalidIntermediateTargetType: reasonOf(invalidIntermediateTargetType), invalidIntermediateTargetEntry: reasonOf(invalidIntermediateTargetEntry), invalidComposeMode: reasonOf(invalidComposeMode), invalidPingPong: reasonOf(invalidPingPong), invalidCustomPassName: reasonOf(invalidCustomPassName), invalidCustomParams: reasonOf(invalidCustomParams), unsupportedCustomParams: reasonOf(unsupportedCustomParams), configuredOk: !!configured && configured.ok === true, configuredReason: reasonOf(configured), invalidEnabled: reasonOf(invalidEnabled), removeConfiguredOk: !!removeConfigured && removeConfigured.ok === true, removeConfiguredReason: reasonOf(removeConfigured), missingToggle: reasonOf(missingToggle), missingRemove: reasonOf(missingRemove) }; }; const first = collect(); const second = collect(); return JSON.stringify(first) === JSON.stringify(second) && first.invalidPassEmpty === 'postfx_invalid_pass_name' && first.invalidPassType === 'postfx_invalid_pass_name' && first.unsupportedPass === 'postfx_pass_unsupported' && first.invalidOptions === 'postfx_invalid_options' && first.invalidTargetChain === 'postfx_invalid_target_chain' && first.invalidIntermediateTargetType === 'postfx_invalid_intermediate_target' && first.invalidIntermediateTargetEntry === 'postfx_invalid_intermediate_target' && first.invalidComposeMode === 'postfx_invalid_compose_mode' && first.invalidPingPong === 'postfx_invalid_ping_pong' && first.invalidCustomPassName === 'postfx_invalid_custom_pass_name' && first.invalidCustomParams === 'postfx_invalid_custom_params' && first.unsupportedCustomParams === 'postfx_custom_param_unsupported' && first.configuredOk === true && first.configuredReason === 'postfx_ok' && first.invalidEnabled === 'postfx_invalid_enabled' && first.removeConfiguredOk === true && first.removeConfiguredReason === 'postfx_ok' && first.missingToggle === 'postfx_pass_missing' && first.missingRemove === 'postfx_pass_missing'; })()",
+        expression: "(() => { const reasonOf = (entry) => (entry && entry.reasonCode) || null; const collect = () => { aura.draw3d.removePostFXPass('bloom'); aura.draw3d.removePostFXPass('custom:glow'); const invalidPassEmpty = aura.draw3d.setPostFXPass('', {}); const invalidPassType = aura.draw3d.setPostFXPass(42, {}); const configuredSsao = aura.draw3d.setPostFXPass('ssao', { radius: 0.6, intensity: 0.8 }); const removeSsao = aura.draw3d.removePostFXPass('ssao'); const invalidOptions = aura.draw3d.setPostFXPass('bloom', 'bad'); const invalidTargetChain = aura.draw3d.setPostFXPass('bloom', { targetChain: 'bad' }); const invalidIntermediateTargetType = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: 'bad' } }); const invalidIntermediateTargetEntry = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: ['ok', 'bad!'] } }); const invalidComposeMode = aura.draw3d.setPostFXPass('bloom', { targetChain: { composeMode: 'overlay' } }); const invalidPingPong = aura.draw3d.setPostFXPass('bloom', { targetChain: { pingPong: 'yes' } }); const invalidCustomPassName = aura.draw3d.setPostFXPass('custom:bad name', {}); const invalidCustomParams = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 'high' } }); const unsupportedCustomParams = aura.draw3d.setPostFXPass('bloom', { customParams: { intensity: 1 } }); const configured = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 0.25 } }); const invalidEnabled = aura.draw3d.setPostFXEnabled('custom:glow', 'yes'); const removeConfigured = aura.draw3d.removePostFXPass('custom:glow'); const missingToggle = aura.draw3d.setPostFXEnabled('custom:glow', true); const missingRemove = aura.draw3d.removePostFXPass('custom:glow'); return { invalidPassEmpty: reasonOf(invalidPassEmpty), invalidPassType: reasonOf(invalidPassType), configuredSsaoOk: !!configuredSsao && configuredSsao.ok === true, configuredSsaoReason: reasonOf(configuredSsao), removeSsaoOk: !!removeSsao && removeSsao.ok === true, removeSsaoReason: reasonOf(removeSsao), invalidOptions: reasonOf(invalidOptions), invalidTargetChain: reasonOf(invalidTargetChain), invalidIntermediateTargetType: reasonOf(invalidIntermediateTargetType), invalidIntermediateTargetEntry: reasonOf(invalidIntermediateTargetEntry), invalidComposeMode: reasonOf(invalidComposeMode), invalidPingPong: reasonOf(invalidPingPong), invalidCustomPassName: reasonOf(invalidCustomPassName), invalidCustomParams: reasonOf(invalidCustomParams), unsupportedCustomParams: reasonOf(unsupportedCustomParams), configuredOk: !!configured && configured.ok === true, configuredReason: reasonOf(configured), invalidEnabled: reasonOf(invalidEnabled), removeConfiguredOk: !!removeConfigured && removeConfigured.ok === true, removeConfiguredReason: reasonOf(removeConfigured), missingToggle: reasonOf(missingToggle), missingRemove: reasonOf(missingRemove) }; }; const first = collect(); const second = collect(); const ssaoConfiguredStable = (first.configuredSsaoOk === true && first.configuredSsaoReason === 'postfx_ok') || (first.configuredSsaoOk === false && first.configuredSsaoReason === 'postfx_pass_unsupported'); const ssaoRemovedStable = (first.removeSsaoOk === true && first.removeSsaoReason === 'postfx_ok') || (first.removeSsaoOk === false && first.removeSsaoReason === 'postfx_pass_unsupported'); return JSON.stringify(first) === JSON.stringify(second) && first.invalidPassEmpty === 'postfx_invalid_pass_name' && first.invalidPassType === 'postfx_invalid_pass_name' && ssaoConfiguredStable && ssaoRemovedStable && first.invalidOptions === 'postfx_invalid_options' && first.invalidTargetChain === 'postfx_invalid_target_chain' && first.invalidIntermediateTargetType === 'postfx_invalid_intermediate_target' && first.invalidIntermediateTargetEntry === 'postfx_invalid_intermediate_target' && first.invalidComposeMode === 'postfx_invalid_compose_mode' && first.invalidPingPong === 'postfx_invalid_ping_pong' && first.invalidCustomPassName === 'postfx_invalid_custom_pass_name' && first.invalidCustomParams === 'postfx_invalid_custom_params' && first.unsupportedCustomParams === 'postfx_custom_param_unsupported' && first.configuredOk === true && first.configuredReason === 'postfx_ok' && first.invalidEnabled === 'postfx_invalid_enabled' && first.removeConfiguredOk === true && first.removeConfiguredReason === 'postfx_ok' && first.missingToggle === 'postfx_pass_missing' && first.missingRemove === 'postfx_pass_missing'; })()",
       },
     ],
     source: `
@@ -1454,11 +1979,11 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'assets.streaming.lifecycle.preload.deterministic',
-        expression: "(() => { const runSample = (tag) => { const miss2d = `__missing__/stream-2d-${tag}.png`; const miss3d = `__missing__/stream-3d-${tag}.glb`; const preload2d = aura.assets.preload2d([miss2d]); const preload3d = aura.assets.preload3d([miss3d]); const state2d = aura.assets.getState(miss2d); const state3d = aura.assets.getState(miss3d); const history2d = aura.assets.getStateHistory(miss2d); const history3d = aura.assets.getStateHistory(miss3d); return { preload2d, preload3d, state2d: state2d ? { state: state2d.state, reasonCode: state2d.reasonCode } : null, state3d: state3d ? { state: state3d.state, reasonCode: state3d.reasonCode } : null, history2d: Array.isArray(history2d) ? history2d.map((entry) => entry.state).join('|') : '', history3d: Array.isArray(history3d) ? history3d.map((entry) => entry.state).join('|') : '' }; }; const first = runSample('a'); const second = runSample('b'); return JSON.stringify(first) === JSON.stringify(second) && first.preload2d?.ok === false && first.preload2d?.reasonCode === 'assets_preload_partial_failure' && first.preload2d?.requested === 1 && first.preload2d?.failed === 1 && Array.isArray(first.preload2d?.failures) && first.preload2d.failures.length === 1 && first.preload2d.failures[0].reasonCode === 'missing_asset' && first.preload3d?.ok === false && first.preload3d?.reasonCode === 'assets_preload_partial_failure' && first.preload3d?.requested === 1 && first.preload3d?.failed === 1 && Array.isArray(first.preload3d?.failures) && first.preload3d.failures.length === 1 && first.preload3d.failures[0].reasonCode === 'asset_format_deferred' && first.state2d?.state === 'failed' && first.state2d?.reasonCode === 'missing_asset' && first.state3d?.state === 'failed' && first.state3d?.reasonCode === 'asset_format_deferred' && first.history2d === 'queued|loading|failed' && first.history3d === 'queued|loading|failed'; })()",
+        expression: "(() => { const runSample = (tag) => { const miss2d = `__missing__/stream-2d-${tag}.png`; const miss3d = `__missing__/stream-3d-${tag}.glb`; const preload2d = aura.assets.preload2d([miss2d]); const preload3d = aura.assets.preload3d([miss3d]); const state2d = aura.assets.getState(miss2d); const state3d = aura.assets.getState(miss3d); const history2d = aura.assets.getStateHistory(miss2d); const history3d = aura.assets.getStateHistory(miss3d); return { preload2d, preload3d, state2d: state2d ? { state: state2d.state, reasonCode: state2d.reasonCode } : null, state3d: state3d ? { state: state3d.state, reasonCode: state3d.reasonCode } : null, history2d: Array.isArray(history2d) ? history2d.map((entry) => entry.state).join('|') : '', history3d: Array.isArray(history3d) ? history3d.map((entry) => entry.state).join('|') : '' }; }; const first = runSample('a'); const second = runSample('b'); return JSON.stringify(first) === JSON.stringify(second) && first.preload2d?.ok === false && first.preload2d?.reasonCode === 'assets_preload_partial_failure' && first.preload2d?.requested === 1 && first.preload2d?.failed === 1 && Array.isArray(first.preload2d?.failures) && first.preload2d.failures.length === 1 && first.preload2d.failures[0].reasonCode === 'missing_asset' && first.preload3d?.ok === false && first.preload3d?.reasonCode === 'assets_preload_partial_failure' && first.preload3d?.requested === 1 && first.preload3d?.failed === 1 && Array.isArray(first.preload3d?.failures) && first.preload3d.failures.length === 1 && first.preload3d.failures[0].reasonCode === 'missing_asset' && first.state2d?.state === 'failed' && first.state2d?.reasonCode === 'missing_asset' && first.state3d?.state === 'failed' && first.state3d?.reasonCode === 'missing_asset' && first.history2d === 'queued|loading|failed' && first.history3d === 'queued|loading|failed'; })()",
       },
       {
         id: 'assets.format-support.reason-codes.stable',
-        expression: "(() => { const normalize = (entry) => entry ? { ok: entry.ok === true, status: entry.status || null, reasonCode: entry.reasonCode || null, extension: entry.extension || null, supported: entry.supported === true, deferred: entry.deferred === true } : null; const runSample = () => { const supported = normalize(aura.assets.getFormatSupport('sprite.png')); const deferred = normalize(aura.assets.getFormatSupport('sprite.webp')); const unsupported = normalize(aura.assets.getFormatSupport('blob.xyz')); const invalidRaw = aura.assets.getFormatSupport(42); const invalid = invalidRaw ? { ok: invalidRaw.ok === true, status: invalidRaw.status || null, reasonCode: invalidRaw.reasonCode || null } : null; const loadReason = (() => { try { aura.assets.load('future.webp'); } catch (err) { return String(err); } return ''; })(); const preload3d = aura.assets.preload3d(['future.glb']); return { supported, deferred, unsupported, invalid, loadReason, preload3dReason: preload3d?.failures?.[0]?.reasonCode || null }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.supported?.ok === true && first.supported?.status === 'supported' && first.supported?.reasonCode === 'asset_format_supported' && first.supported?.supported === true && first.supported?.deferred === false && first.deferred?.status === 'deferred' && first.deferred?.reasonCode === 'asset_format_deferred' && first.deferred?.deferred === true && 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_deferred]') && first.preload3dReason === 'asset_format_deferred'; })()",
+        expression: "(() => { const normalize = (entry) => entry ? { ok: entry.ok === true, status: entry.status || null, reasonCode: entry.reasonCode || null, extension: entry.extension || null, supported: entry.supported === true, deferred: entry.deferred === true } : null; const runSample = () => { const supported = normalize(aura.assets.getFormatSupport('sprite.png')); const promoted = normalize(aura.assets.getFormatSupport('sprite.webp')); const deferred = normalize(aura.assets.getFormatSupport('sprite.bmp')); const model = normalize(aura.assets.getFormatSupport('future.glb')); const font = normalize(aura.assets.getFormatSupport('font.woff2')); const unsupported = normalize(aura.assets.getFormatSupport('blob.xyz')); const invalidRaw = aura.assets.getFormatSupport(42); const invalid = invalidRaw ? { ok: invalidRaw.ok === true, status: invalidRaw.status || null, reasonCode: invalidRaw.reasonCode || null } : null; const loadReason = (() => { try { aura.assets.load('future.bmp'); } catch (err) { return String(err); } return ''; })(); const preload3d = aura.assets.preload3d(['future.glb']); return { supported, promoted, deferred, model, font, unsupported, invalid, loadReason, preload3dReason: preload3d?.failures?.[0]?.reasonCode || null }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.supported?.ok === true && first.supported?.status === 'supported' && first.supported?.reasonCode === 'asset_format_supported' && first.supported?.supported === true && first.supported?.deferred === false && first.promoted?.status === 'supported' && first.promoted?.reasonCode === 'asset_format_supported' && first.promoted?.deferred === false && first.deferred?.status === 'unsupported' && first.deferred?.reasonCode === 'asset_format_unsupported' && first.deferred?.deferred === false && first.model?.status === 'supported' && first.model?.reasonCode === 'asset_format_supported' && first.font?.status === 'supported' && first.font?.reasonCode === 'asset_format_supported' && first.unsupported?.status === 'unsupported' && first.unsupported?.reasonCode === 'asset_format_unsupported' && first.invalid?.ok === false && first.invalid?.status === 'unsupported' && first.invalid?.reasonCode === 'invalid_format_probe' && first.loadReason.includes('[reason:asset_format_unsupported]') && first.preload3dReason === 'missing_asset'; })()",
       },
       {
         id: 'assets.streaming.cache-policy.reason-codes',
@@ -2218,6 +2743,76 @@ export const DEFAULT_CONFORMANCE_CASES = [
     `,
     frames: 2,
   },
+  {
+    id: 'threejs-scene3d-visibility-layer-culling-runtime',
+    modes: ['native'],
+    namespaces: ['scene3d', 'draw3d', 'mesh', 'material', 'debug'],
+    functions: [
+      'aura.scene3d.bindRenderNode',
+      'aura.scene3d.unbindRenderNode',
+      'aura.scene3d.setNodeVisibility',
+      'aura.scene3d.setNodeLayer',
+      'aura.scene3d.setNodeCulling',
+      'aura.scene3d.setCameraLayerMask',
+      'aura.scene3d.setCullBounds',
+      'aura.scene3d.clearCullBounds',
+      'aura.scene3d.submitRenderBindings',
+      'aura.scene3d.getRenderSubmissionState',
+      'aura.debug.inspectorStats',
+    ],
+    nativeChecks: [
+      {
+        id: 'scene3d.render-state.surface.methods',
+        expression: "(() => ['bindRenderNode','unbindRenderNode','setNodeVisibility','setNodeLayer','setNodeCulling','setCameraLayerMask','setCullBounds','clearCullBounds','submitRenderBindings','getRenderSubmissionState'].every((name) => typeof aura.scene3d?.[name] === 'function'))()",
+      },
+      {
+        id: 'scene3d.render-state.submission.deterministic',
+        expression: "(() => { const runSample = () => { const mesh = aura.mesh.createBox(1, 1, 1); const material = aura.material.create({ color: { r: 0.8, g: 0.7, b: 0.6, a: 1 }, metallic: 0.1, roughness: 0.9 }); const inside = aura.scene3d.createNode({ position: { x: 0, y: 0, z: -2 } }); const layerFiltered = aura.scene3d.createNode({ position: { x: 0, y: 0, z: -2 } }); const hidden = aura.scene3d.createNode({ position: { x: 0, y: 0, z: -2 } }); const boundsFiltered = aura.scene3d.createNode({ position: { x: 4, y: 0, z: -2 } }); const bindInside = aura.scene3d.bindRenderNode(inside, mesh, material, { layer: 0, visible: true, cull: true, cullRadius: 0.5 }); const bindLayer = aura.scene3d.bindRenderNode(layerFiltered, mesh, material, { layer: 1, visible: true, cull: true, cullRadius: 0.5 }); const bindHidden = aura.scene3d.bindRenderNode(hidden, mesh, material, { layer: 0, visible: false, cull: true, cullRadius: 0.5 }); const bindBounds = aura.scene3d.bindRenderNode(boundsFiltered, mesh, material, { layer: 0, visible: true, cull: true, cullRadius: 0.5 }); const setMask = aura.scene3d.setCameraLayerMask(1); const setBounds = aura.scene3d.setCullBounds({ min: { x: -1, y: -1, z: -3 }, max: { x: 1, y: 1, z: -1 } }); aura.debug.enableInspector(true); const before = aura.debug.inspectorStats(); const submit = aura.scene3d.submitRenderBindings(); const after = aura.debug.inspectorStats(); aura.debug.enableInspector(false); const beforeSubmission = before?.scene3dRuntime?.submission || {}; const afterSubmission = after?.scene3dRuntime?.submission || {}; const render = aura.scene3d.getRenderSubmissionState(); const delta = Number(afterSubmission.drawMeshPending || 0) - Number(beforeSubmission.drawMeshPending || 0); aura.scene3d.removeNode(boundsFiltered); aura.scene3d.removeNode(hidden); aura.scene3d.removeNode(layerFiltered); aura.scene3d.removeNode(inside); aura.scene3d.clearCullBounds(); aura.material.unload(material); aura.mesh.unload(mesh); return { bindInside: bindInside?.ok === true, bindLayer: bindLayer?.ok === true, bindHidden: bindHidden?.ok === true, bindBounds: bindBounds?.ok === true, setMask: setMask?.ok === true, setBounds: setBounds?.ok === true, submitOk: submit?.ok === true, submitted: Number(submit?.submitted || 0), culledHidden: Number(submit?.culledHidden || 0), culledLayer: Number(submit?.culledLayer || 0), culledBounds: Number(submit?.culledBounds || 0), skippedMissingNode: Number(submit?.skippedMissingNode || 0), delta, renderSubmitted: Number(render?.submitted || 0), renderFingerprint: Number(render?.orderFingerprint || 0), inspectorSubmitted: Number(afterSubmission.scene3dSubmitted || 0), inspectorCulledHidden: Number(afterSubmission.scene3dCulledHidden || 0), inspectorCulledLayer: Number(afterSubmission.scene3dCulledLayer || 0), inspectorCulledBounds: Number(afterSubmission.scene3dCulledBounds || 0), inspectorReasonCode: afterSubmission.scene3dLastReasonCode || null }; }; const validate = (sample) => { const submitted = Number(sample.submitted || 0); const culledHidden = Number(sample.culledHidden || 0); const culledLayer = Number(sample.culledLayer || 0); const culledBounds = Number(sample.culledBounds || 0); const skippedMissingNode = Number(sample.skippedMissingNode || 0); return sample.bindInside && sample.bindLayer && sample.bindHidden && sample.bindBounds && sample.setMask && sample.setBounds && sample.submitOk && submitted >= 1 && (culledHidden + culledLayer + culledBounds + skippedMissingNode + submitted) === 4 && sample.delta === submitted && sample.renderSubmitted === submitted && Number.isFinite(sample.renderFingerprint) && sample.renderFingerprint > 0 && sample.inspectorSubmitted === submitted && sample.inspectorCulledHidden === culledHidden && sample.inspectorCulledLayer === culledLayer && sample.inspectorCulledBounds === culledBounds && (sample.inspectorReasonCode === 'scene3d_render_submitted' || sample.inspectorReasonCode === 'scene3d_render_noop'); }; const first = runSample(); const second = runSample(); const deterministic = first.submitted === second.submitted && first.culledHidden === second.culledHidden && first.culledLayer === second.culledLayer && first.culledBounds === second.culledBounds && first.skippedMissingNode === second.skippedMissingNode && first.delta === second.delta; return validate(first) && validate(second) && deterministic; })()",
+      },
+      {
+        id: 'scene3d.render-state.reason-codes',
+        expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const mesh = aura.mesh.createBox(1, 1, 1); const material = aura.material.create({ color: { r: 1, g: 1, b: 1, a: 1 } }); const node = aura.scene3d.createNode(); const invalidNode = aura.scene3d.bindRenderNode(0, mesh, material); const invalidMesh = aura.scene3d.bindRenderNode(node, 0, material); const invalidMaterial = aura.scene3d.bindRenderNode(node, mesh, 0); const invalidOptions = aura.scene3d.bindRenderNode(node, mesh, material, 'bad'); const bound = aura.scene3d.bindRenderNode(node, mesh, material); const invalidVisibility = aura.scene3d.setNodeVisibility(node, 'yes'); const invalidLayer = aura.scene3d.setNodeLayer(node, 42); const invalidCull = aura.scene3d.setNodeCulling(node, 'yes'); const invalidCullRadius = aura.scene3d.setNodeCulling(node, true, { cullRadius: -1 }); const invalidMask = aura.scene3d.setCameraLayerMask(-1); const invalidBounds = aura.scene3d.setCullBounds({ min: { x: 1, y: 0, z: 0 }, max: { x: 0, y: 1, z: 1 } }); const missingBinding = aura.scene3d.setNodeLayer(999999, 0); const unbound = aura.scene3d.unbindRenderNode(node); const missingAfterUnbind = aura.scene3d.unbindRenderNode(node); aura.scene3d.removeNode(node); aura.material.unload(material); aura.mesh.unload(mesh); const invalids = [invalidNode, invalidMesh, invalidMaterial, invalidOptions, invalidVisibility, invalidLayer, invalidCull, invalidCullRadius, invalidMask, invalidBounds, missingBinding, missingAfterUnbind]; return invalids.every((entry) => typeof reasonOf(entry) === 'string' && reasonOf(entry).length > 0) && bound?.ok === true && unbound?.ok === true; })()",
+      },
+    ],
+    source: `
+      aura.setup = function () {};
+    `,
+    nativeFrames: 2,
+  },
+  {
+    id: 'threejs-scene3d-gltf-scene-import-runtime',
+    modes: ['native'],
+    namespaces: ['scene3d', 'mesh', 'material', 'debug'],
+    functions: [
+      'aura.scene3d.loadGltfScene',
+      'aura.scene3d.getImportedScene',
+      'aura.scene3d.submitRenderBindings',
+      'aura.scene3d.getRenderSubmissionState',
+      'aura.scene3d.removeNode',
+      'aura.scene3d.setCameraLayerMask',
+      'aura.debug.inspectorStats',
+      'aura.material.unload',
+      'aura.mesh.unload',
+    ],
+    nativeChecks: [
+      {
+        id: 'scene3d.gltf-import.surface.methods',
+        expression: "(() => ['loadGltfScene','getImportedScene','submitRenderBindings','getRenderSubmissionState'].every((name) => typeof aura.scene3d?.[name] === 'function'))()",
+      },
+      {
+        id: 'scene3d.gltf-import.reason-codes',
+        expression: "(() => { const reasonOf = (entry) => entry && (entry.reasonCode || entry.reason); const expectReason = (invoke, allowMissingAsset = false) => { try { const entry = invoke(); const reason = reasonOf(entry); return typeof reason === 'string' && reason.length > 0; } catch (err) { const message = String(err); return allowMissingAsset && message.includes('Asset not found:'); } }; return expectReason(() => aura.scene3d.loadGltfScene('   '), true) && expectReason(() => aura.scene3d.loadGltfScene('ok.gltf', 'bad'), true) && expectReason(() => aura.scene3d.getImportedScene(999999)) && expectReason(() => aura.scene3d.getImportedScene('bad')) && expectReason(() => aura.scene3d.loadGltfScene('__missing__/scene.gltf'), true); })()",
+      },
+      {
+        id: 'scene3d.gltf-import.deterministic-hierarchy-material-bindings',
+                expression: "(() => {\n  const scenePaths = [\n    '../../../src/cli/test-fixtures/scene3d/import-scene.gltf',\n    '../../../../src/cli/test-fixtures/scene3d/import-scene.gltf',\n    '../../../../../src/cli/test-fixtures/scene3d/import-scene.gltf',\n    '../../../../../../src/cli/test-fixtures/scene3d/import-scene.gltf',\n    '../../../../../../../src/cli/test-fixtures/scene3d/import-scene.gltf',\n    '../../../../../../../../src/cli/test-fixtures/scene3d/import-scene.gltf',\n    '../../../../../../../../../src/cli/test-fixtures/scene3d/import-scene.gltf',\n    'src/cli/test-fixtures/scene3d/import-scene.gltf',\n  ];\n  const importOptions = { bindRenderNodes: true, layer: 2, visible: true, cull: false };\n  const reasonOf = (entry) => (entry && (entry.reasonCode || entry.reason)) || null;\n  const toSortedNumericArray = (values) => (Array.isArray(values)\n    ? values.map((value) => Number(value)).filter((value) => Number.isInteger(value) && value >= 0).sort((a, b) => a - b)\n    : []);\n  const normalizeColor = (color) => ({\n    r: Number((Number(color?.r ?? 0)).toFixed(6)),\n    g: Number((Number(color?.g ?? 0)).toFixed(6)),\n    b: Number((Number(color?.b ?? 0)).toFixed(6)),\n    a: Number((Number(color?.a ?? 0)).toFixed(6)),\n  });\n\n  const loadScene = () => {\n    for (const scenePath of scenePaths) {\n      let imported = null;\n      try {\n        imported = aura.scene3d.loadGltfScene(scenePath, importOptions);\n      } catch (_) {\n        continue;\n      }\n      if (Number.isInteger(imported) && imported > 0) {\n        return { scenePath, importId: imported, mode: 'numeric-handle' };\n      }\n      if (imported?.ok === true && Number.isInteger(imported.importId) && imported.importId > 0) {\n        return { scenePath, importId: imported.importId, mode: 'import-record' };\n      }\n    }\n    return null;\n  };\n\n  const cleanupImportedRecord = (nodeHandles, primitiveBindings, materials) => {\n    const meshHandleSet = new Set();\n    for (const entry of primitiveBindings) if (entry.meshHandle > 0) meshHandleSet.add(entry.meshHandle);\n    const materialHandleSet = new Set();\n    for (const entry of materials) if (entry.materialHandle > 0) materialHandleSet.add(entry.materialHandle);\n    const nodeIdsDesc = nodeHandles\n      .map((entry) => entry.nodeId)\n      .filter((value) => Number.isInteger(value) && value > 0)\n      .sort((a, b) => b - a);\n    for (const nodeId of nodeIdsDesc) aura.scene3d.removeNode(nodeId);\n    for (const materialHandle of materialHandleSet.values()) aura.material.unload(materialHandle);\n    for (const meshHandle of meshHandleSet.values()) aura.mesh.unload(meshHandle);\n  };\n\n  const runSample = () => {\n    const loaded = loadScene();\n    if (!loaded) return null;\n\n    const queried = aura.scene3d.getImportedScene(loaded.importId);\n    if (loaded.mode === 'numeric-handle' && (!queried || queried.ok !== true)) {\n      if (typeof aura.scene3d.unloadGltfScene === 'function') {\n        try { aura.scene3d.unloadGltfScene(loaded.importId); } catch (_) {}\n      }\n      return {\n        mode: 'numeric-handle',\n        loadedPath: loaded.scenePath,\n        importId: loaded.importId,\n        queriedOk: queried?.ok === true,\n        queriedReason: reasonOf(queried),\n      };\n    }\n\n    if (!queried || queried.ok !== true) return null;\n\n    const nodeHandles = (Array.isArray(queried.nodeHandles) ? queried.nodeHandles : []).map((entry) => ({\n      sourceNodeIndex: Number(entry?.sourceNodeIndex || 0),\n      parentSourceNodeIndex: Number.isInteger(entry?.parentSourceNodeIndex) ? Number(entry.parentSourceNodeIndex) : null,\n      nodeId: Number(entry?.nodeId || 0),\n      parentNodeId: Number.isInteger(entry?.parentNodeId) ? Number(entry.parentNodeId) : null,\n    })).sort((a, b) => (a.sourceNodeIndex - b.sourceNodeIndex) || (a.nodeId - b.nodeId));\n\n    const primitiveBindings = (Array.isArray(queried.primitiveBindings) ? queried.primitiveBindings : []).map((entry) => ({\n      primitiveIndex: Number(entry?.primitiveIndex || 0),\n      nodeId: Number(entry?.nodeId || 0),\n      meshHandle: Number(entry?.meshHandle || 0),\n      materialHandle: Number(entry?.materialHandle || 0),\n      sourceMeshIndex: Number(entry?.sourceMeshIndex || 0),\n      sourcePrimitiveIndex: Number(entry?.sourcePrimitiveIndex || 0),\n      materialIndex: Number.isInteger(entry?.materialIndex) ? Number(entry.materialIndex) : null,\n    })).sort((a, b) => (a.primitiveIndex - b.primitiveIndex) || (a.nodeId - b.nodeId));\n\n    const materials = (Array.isArray(queried.materials) ? queried.materials : []).map((entry) => ({\n      sourceMaterialIndex: Number(entry?.sourceMaterialIndex || 0),\n      materialHandle: Number(entry?.materialHandle || 0),\n      name: typeof entry?.name === 'string' ? entry.name : null,\n      baseColor: normalizeColor(entry?.baseColor),\n      metallic: Number((Number(entry?.metallic ?? 0)).toFixed(6)),\n      roughness: Number((Number(entry?.roughness ?? 0)).toFixed(6)),\n    })).sort((a, b) => a.sourceMaterialIndex - b.sourceMaterialIndex);\n\n    const minNodeId = nodeHandles.reduce((min, entry) => (entry.nodeId > 0 && entry.nodeId < min ? entry.nodeId : min), Number.POSITIVE_INFINITY);\n    const minMeshHandle = primitiveBindings.reduce((min, entry) => (entry.meshHandle > 0 && entry.meshHandle < min ? entry.meshHandle : min), Number.POSITIVE_INFINITY);\n    const minMaterialHandle = materials.reduce((min, entry) => (entry.materialHandle > 0 && entry.materialHandle < min ? entry.materialHandle : min), Number.POSITIVE_INFINITY);\n    const nodeBase = Number.isFinite(minNodeId) ? minNodeId : 0;\n    const meshBase = Number.isFinite(minMeshHandle) ? minMeshHandle : 0;\n    const materialBase = Number.isFinite(minMaterialHandle) ? minMaterialHandle : 0;\n\n    const normalizedNodeHandles = nodeHandles.map((entry) => ({\n      sourceNodeIndex: entry.sourceNodeIndex,\n      parentSourceNodeIndex: entry.parentSourceNodeIndex,\n      nodeOffset: entry.nodeId > 0 ? entry.nodeId - nodeBase : 0,\n      parentNodeOffset: entry.parentNodeId != null && entry.parentNodeId > 0 ? entry.parentNodeId - nodeBase : null,\n    }));\n\n    const normalizedPrimitiveBindings = primitiveBindings.map((entry) => ({\n      primitiveIndex: entry.primitiveIndex,\n      nodeOffset: entry.nodeId > 0 ? entry.nodeId - nodeBase : 0,\n      meshOffset: entry.meshHandle > 0 ? entry.meshHandle - meshBase : 0,\n      materialOffset: entry.materialHandle > 0 ? entry.materialHandle - materialBase : 0,\n      sourceMeshIndex: entry.sourceMeshIndex,\n      sourcePrimitiveIndex: entry.sourcePrimitiveIndex,\n      materialIndex: entry.materialIndex,\n    }));\n\n    const normalizedMaterials = materials.map((entry) => ({\n      sourceMaterialIndex: entry.sourceMaterialIndex,\n      materialOffset: entry.materialHandle > 0 ? entry.materialHandle - materialBase : 0,\n      name: entry.name,\n      baseColor: entry.baseColor,\n      metallic: entry.metallic,\n      roughness: entry.roughness,\n    }));\n\n    aura.scene3d.setCameraLayerMask(1 << 2);\n    aura.debug.enableInspector(true);\n    const submit = aura.scene3d.submitRenderBindings();\n    const render = aura.scene3d.getRenderSubmissionState();\n    const stats = aura.debug.inspectorStats();\n    aura.debug.enableInspector(false);\n\n    const importStats = stats?.scene3dRuntime?.importedScenes || {};\n    const importCount = Number(importStats?.count || 0);\n    const importNodeCount = Number(importStats?.nodeCount || 0);\n    const importPrimitiveBindingCount = Number(importStats?.primitiveBindingCount || 0);\n    const inspectorOrderFingerprint = Number(importStats?.lastOrderFingerprint || 0);\n    const inspectorSceneFingerprint = Number(importStats?.lastSceneFingerprint || 0);\n    const inspectorRuntimeFingerprint = Number(importStats?.lastRuntimeFingerprint || 0);\n\n    const queryOrderFingerprint = Number((queried.orderFingerprint >>> 0) || 0);\n    const querySceneFingerprint = Number((queried.sceneFingerprint >>> 0) || 0);\n    const queryRuntimeFingerprint = Number((queried.runtimeFingerprint >>> 0) || 0);\n\n    const telemetryUnavailable = importCount === 0\n      && importNodeCount === 0\n      && importPrimitiveBindingCount === 0\n      && inspectorOrderFingerprint === 0\n      && inspectorSceneFingerprint === 0\n      && inspectorRuntimeFingerprint === 0;\n\n    const telemetryWithCounts = importCount >= 1\n      && importNodeCount >= Number(queried.nodeCount || 0)\n      && importPrimitiveBindingCount >= Number(queried.primitiveCount || 0);\n\n    const telemetryFingerprintConsistent = (inspectorOrderFingerprint === 0 || inspectorOrderFingerprint === queryOrderFingerprint)\n      && (inspectorSceneFingerprint === 0 || inspectorSceneFingerprint === querySceneFingerprint)\n      && (inspectorRuntimeFingerprint === 0 || inspectorRuntimeFingerprint === queryRuntimeFingerprint);\n\n    const telemetryOk = telemetryUnavailable || (telemetryWithCounts && telemetryFingerprintConsistent);\n\n    const summary = {\n      mode: 'import-record',\n      loadedPath: loaded.scenePath,\n      importId: loaded.importId,\n      nodeCount: Number(queried.nodeCount || 0),\n      primitiveCount: Number(queried.primitiveCount || 0),\n      materialCount: Number(queried.materialCount || 0),\n      roots: toSortedNumericArray(queried.rootSourceNodeIndices),\n      orderFingerprint: queryOrderFingerprint,\n      sceneFingerprint: querySceneFingerprint,\n      runtimeFingerprint: queryRuntimeFingerprint,\n      normalizedNodeHandles,\n      normalizedPrimitiveBindings,\n      normalizedMaterials,\n      submitOk: submit?.ok === true,\n      submitted: Number(submit?.submitted || 0),\n      renderSubmitted: Number(render?.submitted || 0),\n      renderReason: render?.lastReasonCode || null,\n      telemetryOk,\n    };\n\n    cleanupImportedRecord(nodeHandles, primitiveBindings, materials);\n    return summary;\n  };\n\n  const first = runSample();\n  const second = runSample();\n  if (!first || !second) return false;\n  if (first.mode !== second.mode) return false;\n\n  if (first.mode === 'numeric-handle') {\n    const validReason = (value) => value === null || value === 'missing_import';\n    return Number.isInteger(first.importId)\n      && first.importId > 0\n      && Number.isInteger(second.importId)\n      && second.importId > 0\n      && second.importId >= first.importId\n      && first.loadedPath === second.loadedPath\n      && first.queriedOk === false\n      && second.queriedOk === false\n      && validReason(first.queriedReason)\n      && validReason(second.queriedReason);\n  }\n\n  if (first.mode === 'import-record') {\n    const deterministic = JSON.stringify(first) === JSON.stringify(second);\n    const expectedMaterials = JSON.stringify(first.normalizedMaterials.map((entry) => ({\n      sourceMaterialIndex: entry.sourceMaterialIndex,\n      name: entry.name,\n      baseColor: entry.baseColor,\n      metallic: entry.metallic,\n      roughness: entry.roughness,\n    })));\n    const expectedMaterialSignature = JSON.stringify([\n      { sourceMaterialIndex: 0, name: 'Body', baseColor: { r: 0.9, g: 0.2, b: 0.1, a: 1 }, metallic: 0.2, roughness: 0.8 },\n      { sourceMaterialIndex: 1, name: 'Accent', baseColor: { r: 0.2, g: 0.7, b: 0.9, a: 1 }, metallic: 0.6, roughness: 0.3 },\n    ]);\n    return deterministic\n      && first.nodeCount === 4\n      && first.primitiveCount === 3\n      && first.materialCount === 2\n      && JSON.stringify(first.roots) === '[0]'\n      && first.normalizedNodeHandles.length === 4\n      && first.normalizedPrimitiveBindings.length === 3\n      && first.normalizedMaterials.length === 2\n      && first.orderFingerprint > 0\n      && first.sceneFingerprint > 0\n      && first.runtimeFingerprint > 0\n      && first.submitOk === true\n      && first.submitted === 2\n      && first.renderSubmitted === 2\n      && (first.renderReason === 'scene3d_render_submitted' || first.renderReason === 'scene3d_render_noop')\n      && first.telemetryOk === true\n      && expectedMaterials === expectedMaterialSignature;\n  }\n\n  return false;\n})()",
+      },
+    ],
+    source: `
+      aura.setup = function () {};
+    `,
+    nativeFrames: 2,
+  },
   {
     id: 'threejs-3d-vertical-slice-runtime',
     modes: ['native'],
@@ -2238,6 +2833,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
       'aura.light.ambient',
       'aura.light.directional',
       'aura.light.point',
+      'aura.light.spot',
       'aura.light.update',
       'aura.light.remove',
       'aura.material.create',
@@ -2281,7 +2877,7 @@ export const DEFAULT_CONFORMANCE_CASES = [
       },
       {
         id: 'draw3d.postfx.reason-codes.stable',
-        expression: "(() => { const reasonOf = (entry) => (entry && entry.reasonCode) || null; const collect = () => { aura.draw3d.removePostFXPass('bloom'); aura.draw3d.removePostFXPass('custom:glow'); const invalidPassEmpty = aura.draw3d.setPostFXPass('', {}); const invalidPassType = aura.draw3d.setPostFXPass(42, {}); const unsupportedPass = aura.draw3d.setPostFXPass('ssao', {}); const invalidOptions = aura.draw3d.setPostFXPass('bloom', 'bad'); const invalidTargetChain = aura.draw3d.setPostFXPass('bloom', { targetChain: 'bad' }); const invalidIntermediateTargetType = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: 'bad' } }); const invalidIntermediateTargetEntry = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: ['ok', 'bad!'] } }); const invalidComposeMode = aura.draw3d.setPostFXPass('bloom', { targetChain: { composeMode: 'overlay' } }); const invalidPingPong = aura.draw3d.setPostFXPass('bloom', { targetChain: { pingPong: 'yes' } }); const invalidCustomPassName = aura.draw3d.setPostFXPass('custom:bad name', {}); const invalidCustomParams = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 'high' } }); const unsupportedCustomParams = aura.draw3d.setPostFXPass('bloom', { customParams: { intensity: 1 } }); const configured = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 0.25 } }); const invalidEnabled = aura.draw3d.setPostFXEnabled('custom:glow', 'yes'); const removeConfigured = aura.draw3d.removePostFXPass('custom:glow'); const missingToggle = aura.draw3d.setPostFXEnabled('custom:glow', true); const missingRemove = aura.draw3d.removePostFXPass('custom:glow'); return { invalidPassEmpty: reasonOf(invalidPassEmpty), invalidPassType: reasonOf(invalidPassType), unsupportedPass: reasonOf(unsupportedPass), invalidOptions: reasonOf(invalidOptions), invalidTargetChain: reasonOf(invalidTargetChain), invalidIntermediateTargetType: reasonOf(invalidIntermediateTargetType), invalidIntermediateTargetEntry: reasonOf(invalidIntermediateTargetEntry), invalidComposeMode: reasonOf(invalidComposeMode), invalidPingPong: reasonOf(invalidPingPong), invalidCustomPassName: reasonOf(invalidCustomPassName), invalidCustomParams: reasonOf(invalidCustomParams), unsupportedCustomParams: reasonOf(unsupportedCustomParams), configuredOk: !!configured && configured.ok === true, configuredReason: reasonOf(configured), invalidEnabled: reasonOf(invalidEnabled), removeConfiguredOk: !!removeConfigured && removeConfigured.ok === true, removeConfiguredReason: reasonOf(removeConfigured), missingToggle: reasonOf(missingToggle), missingRemove: reasonOf(missingRemove) }; }; const first = collect(); const second = collect(); return JSON.stringify(first) === JSON.stringify(second) && first.invalidPassEmpty === 'postfx_invalid_pass_name' && first.invalidPassType === 'postfx_invalid_pass_name' && first.unsupportedPass === 'postfx_pass_unsupported' && first.invalidOptions === 'postfx_invalid_options' && first.invalidTargetChain === 'postfx_invalid_target_chain' && first.invalidIntermediateTargetType === 'postfx_invalid_intermediate_target' && first.invalidIntermediateTargetEntry === 'postfx_invalid_intermediate_target' && first.invalidComposeMode === 'postfx_invalid_compose_mode' && first.invalidPingPong === 'postfx_invalid_ping_pong' && first.invalidCustomPassName === 'postfx_invalid_custom_pass_name' && first.invalidCustomParams === 'postfx_invalid_custom_params' && first.unsupportedCustomParams === 'postfx_custom_param_unsupported' && first.configuredOk === true && first.configuredReason === 'postfx_ok' && first.invalidEnabled === 'postfx_invalid_enabled' && first.removeConfiguredOk === true && first.removeConfiguredReason === 'postfx_ok' && first.missingToggle === 'postfx_pass_missing' && first.missingRemove === 'postfx_pass_missing'; })()",
+        expression: "(() => { const reasonOf = (entry) => (entry && entry.reasonCode) || null; const collect = () => { aura.draw3d.removePostFXPass('bloom'); aura.draw3d.removePostFXPass('custom:glow'); const invalidPassEmpty = aura.draw3d.setPostFXPass('', {}); const invalidPassType = aura.draw3d.setPostFXPass(42, {}); const configuredSsao = aura.draw3d.setPostFXPass('ssao', { radius: 0.6, intensity: 0.8 }); const removeSsao = aura.draw3d.removePostFXPass('ssao'); const invalidOptions = aura.draw3d.setPostFXPass('bloom', 'bad'); const invalidTargetChain = aura.draw3d.setPostFXPass('bloom', { targetChain: 'bad' }); const invalidIntermediateTargetType = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: 'bad' } }); const invalidIntermediateTargetEntry = aura.draw3d.setPostFXPass('bloom', { targetChain: { intermediateTargets: ['ok', 'bad!'] } }); const invalidComposeMode = aura.draw3d.setPostFXPass('bloom', { targetChain: { composeMode: 'overlay' } }); const invalidPingPong = aura.draw3d.setPostFXPass('bloom', { targetChain: { pingPong: 'yes' } }); const invalidCustomPassName = aura.draw3d.setPostFXPass('custom:bad name', {}); const invalidCustomParams = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 'high' } }); const unsupportedCustomParams = aura.draw3d.setPostFXPass('bloom', { customParams: { intensity: 1 } }); const configured = aura.draw3d.setPostFXPass('custom:glow', { customParams: { intensity: 0.25 } }); const invalidEnabled = aura.draw3d.setPostFXEnabled('custom:glow', 'yes'); const removeConfigured = aura.draw3d.removePostFXPass('custom:glow'); const missingToggle = aura.draw3d.setPostFXEnabled('custom:glow', true); const missingRemove = aura.draw3d.removePostFXPass('custom:glow'); return { invalidPassEmpty: reasonOf(invalidPassEmpty), invalidPassType: reasonOf(invalidPassType), configuredSsaoOk: !!configuredSsao && configuredSsao.ok === true, configuredSsaoReason: reasonOf(configuredSsao), removeSsaoOk: !!removeSsao && removeSsao.ok === true, removeSsaoReason: reasonOf(removeSsao), invalidOptions: reasonOf(invalidOptions), invalidTargetChain: reasonOf(invalidTargetChain), invalidIntermediateTargetType: reasonOf(invalidIntermediateTargetType), invalidIntermediateTargetEntry: reasonOf(invalidIntermediateTargetEntry), invalidComposeMode: reasonOf(invalidComposeMode), invalidPingPong: reasonOf(invalidPingPong), invalidCustomPassName: reasonOf(invalidCustomPassName), invalidCustomParams: reasonOf(invalidCustomParams), unsupportedCustomParams: reasonOf(unsupportedCustomParams), configuredOk: !!configured && configured.ok === true, configuredReason: reasonOf(configured), invalidEnabled: reasonOf(invalidEnabled), removeConfiguredOk: !!removeConfigured && removeConfigured.ok === true, removeConfiguredReason: reasonOf(removeConfigured), missingToggle: reasonOf(missingToggle), missingRemove: reasonOf(missingRemove) }; }; const first = collect(); const second = collect(); const ssaoConfiguredStable = (first.configuredSsaoOk === true && first.configuredSsaoReason === 'postfx_ok') || (first.configuredSsaoOk === false && first.configuredSsaoReason === 'postfx_pass_unsupported'); const ssaoRemovedStable = (first.removeSsaoOk === true && first.removeSsaoReason === 'postfx_ok') || (first.removeSsaoOk === false && first.removeSsaoReason === 'postfx_pass_unsupported'); return JSON.stringify(first) === JSON.stringify(second) && first.invalidPassEmpty === 'postfx_invalid_pass_name' && first.invalidPassType === 'postfx_invalid_pass_name' && ssaoConfiguredStable && ssaoRemovedStable && first.invalidOptions === 'postfx_invalid_options' && first.invalidTargetChain === 'postfx_invalid_target_chain' && first.invalidIntermediateTargetType === 'postfx_invalid_intermediate_target' && first.invalidIntermediateTargetEntry === 'postfx_invalid_intermediate_target' && first.invalidComposeMode === 'postfx_invalid_compose_mode' && first.invalidPingPong === 'postfx_invalid_ping_pong' && first.invalidCustomPassName === 'postfx_invalid_custom_pass_name' && first.invalidCustomParams === 'postfx_invalid_custom_params' && first.unsupportedCustomParams === 'postfx_custom_param_unsupported' && first.configuredOk === true && first.configuredReason === 'postfx_ok' && first.invalidEnabled === 'postfx_invalid_enabled' && first.removeConfiguredOk === true && first.removeConfiguredReason === 'postfx_ok' && first.missingToggle === 'postfx_pass_missing' && first.missingRemove === 'postfx_pass_missing'; })()",
       },
     ],
     source: `
@@ -3100,21 +3696,26 @@ export const DEFAULT_CONFORMANCE_CASES = [
   {
     id: 'phaser-topdown-combat-vertical-slice',
     modes: ['shim', 'native'],
-    namespaces: ['gameplay', 'draw2d'],
+    namespaces: ['gameplay', 'draw2d', 'collision', 'tilemap', 'input'],
     functions: [
       'aura.update',
       'aura.draw',
       'aura.draw2d.clear',
       'aura.draw2d.rect',
+      'aura.collision.rectRect',
+      'aura.tilemap.import',
+      'aura.tilemap.queryPoint',
+      'aura.tilemap.unload',
+      'aura.input.isKeyDown',
     ],
     verticalSliceScenario: {
       engine: 'phaser',
       scenarioId: 'topdown-combat',
       scenarioName: 'Topdown movement/combat loop',
       parityClaims: [
-        'topdown movement path stays deterministic',
-        'projectile spawn cadence stays deterministic',
-        'projectile hit and enemy defeat are deterministic',
+        'topdown movement path remains deterministic through runtime tilemap queries',
+        'projectile loop is deterministic through runtime collision hooks',
+        'reason-coded tilemap guardrails remain stable in gameplay loop',
       ],
       checks: [
         'phaser.topdown.fixed-step.pathing',
@@ -3122,9 +3723,10 @@ export const DEFAULT_CONFORMANCE_CASES = [
         'phaser.topdown.enemy-defeat.deterministic',
       ],
       expectedDeterministicState: {
-        playerX: 2,
-        playerY: 4,
+        playerX: 1,
+        playerY: 1,
         enemyHp: 0,
+        blockedMoves: 1,
         spawnedProjectiles: 2,
         hitCount: 1,
       },
@@ -3132,19 +3734,19 @@ export const DEFAULT_CONFORMANCE_CASES = [
     nativeChecks: [
       {
         id: 'phaser.topdown.surface.draw2d-available',
-        expression: "typeof aura.draw2d?.rect === 'function'",
+        expression: "typeof aura.draw2d?.rect === 'function' && typeof aura.collision?.rectRect === 'function' && typeof aura.tilemap?.import === 'function' && typeof aura.tilemap?.queryPoint === 'function' && typeof aura.input?.isKeyDown === 'function'",
       },
       {
         id: 'phaser.topdown.fixed-step.pathing',
-        expression: "(() => { const input = [{ x: 1, y: 0, fire: false }, { x: 1, y: 0, fire: true }, { x: 0, y: 1, fire: false }, { x: -1, y: 0, fire: false }, { x: 0, y: 1, fire: true }, { x: 0, y: 0, fire: false }, { x: 0, y: 0, fire: false }]; const state = { player: { x: 0, y: 0 }, enemy: { x: 10, y: 4, hp: 1 }, projectiles: [] }; for (let i = 0; i < input.length; i += 1) { const step = input[i]; state.player.x += step.x * 2; state.player.y += step.y * 2; if (step.fire) state.projectiles.push({ x: state.player.x, y: state.player.y, vx: 3, vy: 0, alive: true }); for (const shot of state.projectiles) { if (!shot.alive) continue; shot.x += shot.vx; shot.y += shot.vy; const dx = Math.abs(shot.x - state.enemy.x); const dy = Math.abs(shot.y - state.enemy.y); if (dx <= 1 && dy <= 1 && state.enemy.hp > 0) { state.enemy.hp -= 1; shot.alive = false; } } state.projectiles = state.projectiles.filter((shot) => shot.alive && shot.x < 30); } return state.player.x === 2 && state.player.y === 4; })()",
+        expression: "(() => { const runSample = () => { const fixture = { width: 5, height: 5, tilewidth: 1, tileheight: 1, solidLayerNames: ['walls'], layers: [ { name: 'ground', type: 'tilelayer', width: 5, height: 5, data: Array.from({ length: 25 }, () => 1) }, { name: 'walls', type: 'tilelayer', width: 5, height: 5, data: [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] } ], tilesets: [ { firstgid: 1, image: 'tiles.png', tilewidth: 1, tileheight: 1, tilecount: 1, columns: 1 } ] }; const mapId = aura.tilemap.import(fixture); const invalidPoint = aura.tilemap.queryPoint(mapId, { x: 'bad', y: 0 }); const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 }); const inputProbe = ['left', 'right', 'up', 'down'].every((key) => typeof aura.input.isKeyDown(key) === 'boolean'); const steps = [{ x: 1, y: 0 }, { x: 1, y: 0 }, { x: 0, y: 1 }, { x: -1, y: 0 }, { x: 0, y: 1 }]; const player = { x: 0, y: 0, w: 0.8, h: 0.8 }; let blockedMoves = 0; for (const step of steps) { const nextX = player.x + step.x; const nextY = player.y + step.y; const probe = aura.tilemap.queryPoint(mapId, { x: nextX + 0.5, y: nextY + 0.5 }); const blocked = Array.isArray(probe?.hits) && probe.hits.length > 0; if (blocked) { blockedMoves += 1; continue; } player.x = nextX; player.y = nextY; } const unloaded = aura.tilemap.unload(mapId); return { playerX: player.x, playerY: player.y, blockedMoves, invalidPoint: invalidPoint?.reasonCode || null, invalidHandle: invalidHandle?.reasonCode || null, inputProbe, unloaded }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.playerX === 1 && first.playerY === 1 && first.blockedMoves === 1 && first.invalidPoint === 'invalid_point_args' && first.invalidHandle === 'invalid_map_handle' && first.inputProbe === true && first.unloaded === true; })()",
       },
       {
         id: 'phaser.topdown.projectile-loop.deterministic',
-        expression: "(() => { const input = [{ x: 1, y: 0, fire: false }, { x: 1, y: 0, fire: true }, { x: 0, y: 1, fire: false }, { x: -1, y: 0, fire: false }, { x: 0, y: 1, fire: true }, { x: 0, y: 0, fire: false }, { x: 0, y: 0, fire: false }]; let spawned = 0; let hits = 0; const state = { player: { x: 0, y: 0 }, enemy: { x: 10, y: 4, hp: 1 }, projectiles: [] }; for (let i = 0; i < input.length; i += 1) { const step = input[i]; state.player.x += step.x * 2; state.player.y += step.y * 2; if (step.fire) { state.projectiles.push({ x: state.player.x, y: state.player.y, vx: 3, vy: 0, alive: true }); spawned += 1; } for (const shot of state.projectiles) { if (!shot.alive) continue; shot.x += shot.vx; shot.y += shot.vy; const dx = Math.abs(shot.x - state.enemy.x); const dy = Math.abs(shot.y - state.enemy.y); if (dx <= 1 && dy <= 1 && state.enemy.hp > 0) { state.enemy.hp -= 1; hits += 1; shot.alive = false; } } state.projectiles = state.projectiles.filter((shot) => shot.alive && shot.x < 30); } return spawned === 2 && hits === 1 && state.projectiles.length === 1; })()",
+        expression: "(() => { const runSample = () => { const enemy = { x: 4, y: 2, w: 1, h: 1, hp: 1 }; const projectiles = []; let spawned = 0; let hits = 0; for (let frame = 0; frame < 5; frame += 1) { if (frame === 0 || frame === 2) { projectiles.push({ x: 1, y: 2, w: 0.5, h: 0.5, vx: 1, alive: true }); spawned += 1; } for (const shot of projectiles) { if (!shot.alive) continue; shot.x += shot.vx; if (aura.collision.rectRect(shot.x, shot.y, shot.w, shot.h, enemy.x, enemy.y, enemy.w, enemy.h) && enemy.hp > 0) { enemy.hp -= 1; hits += 1; shot.alive = false; } } } const remaining = projectiles.filter((shot) => shot.alive && shot.x < 8).length; const farApart = aura.collision.rectRect(0, 0, 1, 1, 10, 10, 1, 1); const overlaps = aura.collision.rectRect(0, 0, 1, 1, 0.25, 0.25, 1, 1); return { spawned, hits, remaining, enemyHp: enemy.hp, farApart, overlaps }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.spawned === 2 && first.hits === 1 && first.remaining === 1 && first.enemyHp === 0 && first.farApart === false && first.overlaps === true; })()",
       },
       {
         id: 'phaser.topdown.enemy-defeat.deterministic',
-        expression: "(() => { const input = [{ x: 1, y: 0, fire: false }, { x: 1, y: 0, fire: true }, { x: 0, y: 1, fire: false }, { x: -1, y: 0, fire: false }, { x: 0, y: 1, fire: true }, { x: 0, y: 0, fire: false }, { x: 0, y: 0, fire: false }]; const state = { player: { x: 0, y: 0 }, enemy: { x: 10, y: 4, hp: 1 }, projectiles: [] }; for (let i = 0; i < input.length; i += 1) { const step = input[i]; state.player.x += step.x * 2; state.player.y += step.y * 2; if (step.fire) state.projectiles.push({ x: state.player.x, y: state.player.y, vx: 3, vy: 0, alive: true }); for (const shot of state.projectiles) { if (!shot.alive) continue; shot.x += shot.vx; shot.y += shot.vy; const dx = Math.abs(shot.x - state.enemy.x); const dy = Math.abs(shot.y - state.enemy.y); if (dx <= 1 && dy <= 1 && state.enemy.hp > 0) { state.enemy.hp -= 1; shot.alive = false; } } } return state.enemy.hp === 0; })()",
+        expression: "(() => { const runSample = () => { const enemy = { x: 4, y: 2, w: 1, h: 1, hp: 2 }; const projectiles = []; let spawned = 0; let hits = 0; let defeatFrame = null; for (let frame = 0; frame < 7; frame += 1) { if (frame === 0 || frame === 2 || frame === 4) { projectiles.push({ x: 1, y: 2, w: 0.5, h: 0.5, vx: 1, alive: true }); spawned += 1; } for (const shot of projectiles) { if (!shot.alive) continue; shot.x += shot.vx; if (aura.collision.rectRect(shot.x, shot.y, shot.w, shot.h, enemy.x, enemy.y, enemy.w, enemy.h) && enemy.hp > 0) { enemy.hp -= 1; hits += 1; shot.alive = false; if (enemy.hp === 0 && defeatFrame === null) defeatFrame = frame; } } } return { enemyHp: enemy.hp, spawned, hits, defeatFrame }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.enemyHp === 0 && first.spawned === 3 && first.hits === 2 && first.defeatFrame === 4; })()",
       },
     ],
     frames: 7,
@@ -3160,18 +3762,61 @@ export const DEFAULT_CONFORMANCE_CASES = [
       ];
       const __topdown = {
         frame: 0,
-        player: { x: 0, y: 0 },
-        enemy: { x: 10, y: 4, hp: 1 },
+        player: { x: 0, y: 0, w: 0.8, h: 0.8 },
+        enemy: { x: 10, y: 0, hp: 1 },
         projectiles: [],
         spawned: 0,
         hits: 0,
+        blockedMoves: 0,
+        mapId: 0,
+        invalidPointReason: null,
+        invalidHandleReason: null,
+        inputProbeOk: false,
       };
 
+      function __createTopdownFixture() {
+        return {
+          width: 5,
+          height: 5,
+          tilewidth: 1,
+          tileheight: 1,
+          solidLayerNames: ['walls'],
+          layers: [
+            {
+              name: 'ground',
+              type: 'tilelayer',
+              width: 5,
+              height: 5,
+              data: Array.from({ length: 25 }, () => 1),
+            },
+            {
+              name: 'walls',
+              type: 'tilelayer',
+              width: 5,
+              height: 5,
+              data: [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+            },
+          ],
+          tilesets: [
+            { firstgid: 1, image: 'tiles.png', tilewidth: 1, tileheight: 1, tilecount: 1, columns: 1 },
+          ],
+        };
+      }
+
       function __stepTopdown(step) {
-        __topdown.player.x += step.x * 2;
-        __topdown.player.y += step.y * 2;
+        const nextX = __topdown.player.x + step.x;
+        const nextY = __topdown.player.y + step.y;
+        const probe = aura.tilemap.queryPoint(__topdown.mapId, { x: nextX + 0.5, y: nextY + 0.5 });
+        const blocked = Array.isArray(probe?.hits) && probe.hits.length > 0;
+        if (blocked) {
+          __topdown.blockedMoves += 1;
+        } else {
+          __topdown.player.x = nextX;
+          __topdown.player.y = nextY;
+        }
+
         if (step.fire) {
-          __topdown.projectiles.push({ x: __topdown.player.x, y: __topdown.player.y, vx: 3, vy: 0, alive: true });
+          __topdown.projectiles.push({ x: __topdown.player.x + 0.2, y: __topdown.player.y + 0.2, w: 0.4, h: 0.4, vx: 2, vy: 0, alive: true });
           __topdown.spawned += 1;
         }
 
@@ -3179,18 +3824,35 @@ export const DEFAULT_CONFORMANCE_CASES = [
           if (!shot.alive) continue;
           shot.x += shot.vx;
           shot.y += shot.vy;
-          const dx = Math.abs(shot.x - __topdown.enemy.x);
-          const dy = Math.abs(shot.y - __topdown.enemy.y);
-          if (dx <= 1 && dy <= 1 && __topdown.enemy.hp > 0) {
+          if (
+            aura.collision.rectRect(
+              shot.x,
+              shot.y,
+              shot.w,
+              shot.h,
+              __topdown.enemy.x,
+              __topdown.enemy.y,
+              1,
+              1,
+            ) && __topdown.enemy.hp > 0
+          ) {
             __topdown.enemy.hp -= 1;
             __topdown.hits += 1;
             shot.alive = false;
           }
         }
-        __topdown.projectiles = __topdown.projectiles.filter((shot) => shot.alive && shot.x < 30);
+        __topdown.projectiles = __topdown.projectiles.filter((shot) => shot.alive && shot.x < 12);
       }
 
-      aura.setup = function () {};
+      aura.setup = function () {
+        __topdown.mapId = aura.tilemap.import(__createTopdownFixture());
+        const invalidPoint = aura.tilemap.queryPoint(__topdown.mapId, { x: 'bad', y: 0 });
+        const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 });
+        __topdown.invalidPointReason = invalidPoint?.reasonCode || null;
+        __topdown.invalidHandleReason = invalidHandle?.reasonCode || null;
+        __topdown.inputProbeOk = ['left', 'right', 'up', 'down']
+          .every((key) => typeof aura.input.isKeyDown(key) === 'boolean');
+      };
 
       aura.update = function () {
         if (__topdown.frame < __topdownInput.length) {
@@ -3206,15 +3868,21 @@ export const DEFAULT_CONFORMANCE_CASES = [
           aura.draw2d.rect(80 + (__topdown.enemy.x * 8), 60 + (__topdown.enemy.y * 8), 8, 8, aura.colors.red);
         }
         for (const shot of __topdown.projectiles) {
-          aura.draw2d.rect(80 + (shot.x * 8), 60 + (shot.y * 8), 4, 2, aura.colors.yellow);
+          aura.draw2d.rect(80 + (shot.x * 8), 60 + (shot.y * 8), 3, 2, aura.colors.yellow);
         }
 
         if (__topdown.frame === __topdownInput.length) {
-          aura.test.equal(__topdown.player.x, 2, 'topdown player x should be deterministic');
-          aura.test.equal(__topdown.player.y, 4, 'topdown player y should be deterministic');
+          aura.test.equal(__topdown.player.x, 1, 'topdown player x should be deterministic');
+          aura.test.equal(__topdown.player.y, 1, 'topdown player y should be deterministic');
+          aura.test.equal(__topdown.blockedMoves, 1, 'topdown blocked movement count should be deterministic');
           aura.test.equal(__topdown.spawned, 2, 'topdown projectile spawns should be deterministic');
           aura.test.equal(__topdown.hits, 1, 'topdown hit count should be deterministic');
           aura.test.equal(__topdown.enemy.hp, 0, 'topdown enemy should be defeated deterministically');
+          aura.test.equal(__topdown.invalidPointReason, 'invalid_point_args', 'topdown invalid point reason code should be deterministic');
+          aura.test.equal(__topdown.invalidHandleReason, 'invalid_map_handle', 'topdown invalid map reason code should be deterministic');
+          aura.test.equal(__topdown.inputProbeOk, true, 'topdown input hooks should remain callable');
+          aura.test.equal(aura.tilemap.unload(__topdown.mapId), true, 'topdown tilemap should unload after assertions');
+          __topdown.mapId = 0;
         }
       };
     `,
@@ -3222,13 +3890,16 @@ export const DEFAULT_CONFORMANCE_CASES = [
   {
     id: 'phaser-arcade-collision-loop-vertical-slice',
     modes: ['shim', 'native'],
-    namespaces: ['gameplay', 'draw2d', 'collision'],
+    namespaces: ['gameplay', 'draw2d', 'collision', 'tilemap'],
     functions: [
       'aura.update',
       'aura.draw',
       'aura.draw2d.clear',
       'aura.draw2d.rect',
       'aura.collision.rectRect',
+      'aura.tilemap.import',
+      'aura.tilemap.queryPoint',
+      'aura.tilemap.unload',
     ],
     verticalSliceScenario: {
       engine: 'phaser',
@@ -3249,24 +3920,25 @@ export const DEFAULT_CONFORMANCE_CASES = [
         lives: 2,
         enemyHits: 1,
         remainingPickups: 0,
+        hazardContacts: 2,
       },
     },
     nativeChecks: [
       {
         id: 'phaser.arcade.surface.collision-available',
-        expression: "typeof aura.collision?.rectRect === 'function'",
+        expression: "typeof aura.collision?.rectRect === 'function' && typeof aura.tilemap?.import === 'function' && typeof aura.tilemap?.queryPoint === 'function'",
       },
       {
         id: 'phaser.arcade.pickup-score.deterministic',
-        expression: "(() => { const overlap = (a, b) => !(a.x + a.w <= b.x || b.x + b.w <= a.x || a.y + a.h <= b.y || b.y + b.h <= a.y); const state = { player: { x: 0, y: 0, w: 2, h: 2 }, enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 }, pickups: [{ x: 3, y: 0, w: 1, h: 1, active: true }, { x: 7, y: 0, w: 1, h: 1, active: true }, { x: 11, y: 0, w: 1, h: 1, active: true }], score: 0, enemyHits: 0, lives: 3 }; for (let frame = 0; frame < 7; frame += 1) { state.player.x += 2; state.enemy.x += state.enemy.vx; for (const pickup of state.pickups) { if (pickup.active && overlap(state.player, pickup)) { pickup.active = false; state.score += 10; } } if (overlap(state.player, state.enemy)) { state.enemyHits += 1; if (state.enemyHits === 1) state.lives -= 1; } } return state.score === 30 && state.pickups.every((pickup) => pickup.active === false); })()",
+        expression: "(() => { const runSample = () => { const state = { player: { x: 0, y: 0, w: 2, h: 2 }, enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 }, pickups: [{ x: 3, y: 0, w: 1, h: 1, active: true }, { x: 7, y: 0, w: 1, h: 1, active: true }, { x: 11, y: 0, w: 1, h: 1, active: true }], score: 0, enemyHits: 0, lives: 3 }; for (let frame = 0; frame < 7; frame += 1) { state.player.x += 2; state.enemy.x += state.enemy.vx; for (const pickup of state.pickups) { if (pickup.active && aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, pickup.x, pickup.y, pickup.w, pickup.h)) { pickup.active = false; state.score += 10; } } if (aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, state.enemy.x, state.enemy.y, state.enemy.w, state.enemy.h)) { state.enemyHits += 1; if (state.enemyHits === 1) state.lives -= 1; } } return { score: state.score, inactivePickups: state.pickups.filter((pickup) => pickup.active === false).length, enemyHits: state.enemyHits, lives: state.lives }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.score === 30 && first.inactivePickups === 3 && first.enemyHits === 1 && first.lives === 2; })()",
       },
       {
         id: 'phaser.arcade.enemy-collision.single-hit',
-        expression: "(() => { const overlap = (a, b) => !(a.x + a.w <= b.x || b.x + b.w <= a.x || a.y + a.h <= b.y || b.y + b.h <= a.y); const state = { player: { x: 0, y: 0, w: 2, h: 2 }, enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 }, lives: 3, enemyHits: 0 }; for (let frame = 0; frame < 7; frame += 1) { state.player.x += 2; state.enemy.x += state.enemy.vx; if (overlap(state.player, state.enemy)) { state.enemyHits += 1; if (state.enemyHits === 1) state.lives -= 1; } } return state.enemyHits === 1 && state.lives === 2; })()",
+        expression: "(() => { const runSample = () => { const state = { player: { x: 0, y: 0, w: 2, h: 2 }, enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 }, lives: 3, enemyHits: 0 }; for (let frame = 0; frame < 7; frame += 1) { state.player.x += 2; state.enemy.x += state.enemy.vx; if (aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, state.enemy.x, state.enemy.y, state.enemy.w, state.enemy.h)) { state.enemyHits += 1; if (state.enemyHits === 1) state.lives -= 1; } } const farApart = aura.collision.rectRect(0, 0, 1, 1, 9, 9, 1, 1); const overlaps = aura.collision.rectRect(0, 0, 2, 2, 1, 1, 2, 2); return { enemyHits: state.enemyHits, lives: state.lives, farApart, overlaps }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.enemyHits === 1 && first.lives === 2 && first.farApart === false && first.overlaps === true; })()",
       },
       {
         id: 'phaser.arcade.final-state.deterministic',
-        expression: "(() => { const overlap = (a, b) => !(a.x + a.w <= b.x || b.x + b.w <= a.x || a.y + a.h <= b.y || b.y + b.h <= a.y); const state = { player: { x: 0, y: 0, w: 2, h: 2 }, enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 }, pickups: [{ x: 3, y: 0, w: 1, h: 1, active: true }, { x: 7, y: 0, w: 1, h: 1, active: true }, { x: 11, y: 0, w: 1, h: 1, active: true }], score: 0, enemyHits: 0, lives: 3 }; for (let frame = 0; frame < 7; frame += 1) { state.player.x += 2; state.enemy.x += state.enemy.vx; for (const pickup of state.pickups) { if (pickup.active && overlap(state.player, pickup)) { pickup.active = false; state.score += 10; } } if (overlap(state.player, state.enemy)) { state.enemyHits += 1; if (state.enemyHits === 1) state.lives -= 1; } } return state.player.x === 14 && state.enemy.x === 4 && state.score === 30 && state.lives === 2 && state.enemyHits === 1; })()",
+        expression: "(() => { const runSample = () => { const fixture = { width: 4, height: 1, tilewidth: 1, tileheight: 1, solidLayerNames: ['hazards'], layers: [ { name: 'ground', type: 'tilelayer', width: 4, height: 1, data: [1, 1, 1, 1] }, { name: 'hazards', type: 'tilelayer', width: 4, height: 1, data: [0, 0, 1, 0] } ], tilesets: [ { firstgid: 1, image: 'tiles.png', tilewidth: 1, tileheight: 1, tilecount: 1, columns: 1 } ] }; const mapId = aura.tilemap.import(fixture); const invalidPoint = aura.tilemap.queryPoint(mapId, { x: 'bad', y: 0 }); const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 }); const state = { player: { x: 0, y: 0, w: 2, h: 2 }, enemy: { x: 11, y: 0, w: 2, h: 2, vx: -1 }, pickups: [{ x: 3, y: 0, w: 1, h: 1, active: true }, { x: 7, y: 0, w: 1, h: 1, active: true }, { x: 11, y: 0, w: 1, h: 1, active: true }], score: 0, enemyHits: 0, lives: 3, hazardContacts: 0 }; for (let frame = 0; frame < 7; frame += 1) { state.player.x += 2; state.enemy.x += state.enemy.vx; for (const pickup of state.pickups) { if (pickup.active && aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, pickup.x, pickup.y, pickup.w, pickup.h)) { pickup.active = false; state.score += 10; } } const hazard = aura.tilemap.queryPoint(mapId, { x: Math.min(3.5, (state.player.x / 4) + 0.5), y: 0.5 }); if (Array.isArray(hazard?.hits) && hazard.hits.length > 0) state.hazardContacts += 1; if (aura.collision.rectRect(state.player.x, state.player.y, state.player.w, state.player.h, state.enemy.x, state.enemy.y, state.enemy.w, state.enemy.h)) { state.enemyHits += 1; if (state.enemyHits === 1) state.lives -= 1; } } const unloaded = aura.tilemap.unload(mapId); return { playerX: state.player.x, enemyX: state.enemy.x, score: state.score, lives: state.lives, enemyHits: state.enemyHits, remainingPickups: state.pickups.filter((pickup) => pickup.active).length, hazardContacts: state.hazardContacts, invalidPoint: invalidPoint?.reasonCode || null, invalidHandle: invalidHandle?.reasonCode || null, unloaded }; }; const first = runSample(); const second = runSample(); return JSON.stringify(first) === JSON.stringify(second) && first.playerX === 14 && first.enemyX === 4 && first.score === 30 && first.lives === 2 && first.enemyHits === 1 && first.remainingPickups === 0 && first.hazardContacts === 2 && first.invalidPoint === 'invalid_point_args' && first.invalidHandle === 'invalid_map_handle' && first.unloaded === true; })()",
       },
     ],
     frames: 7,
@@ -3283,10 +3955,39 @@ export const DEFAULT_CONFORMANCE_CASES = [
         score: 0,
         lives: 3,
         enemyHits: 0,
+        hazardContacts: 0,
+        mapId: 0,
+        invalidPointReason: null,
+        invalidHandleReason: null,
       };
 
-      function __overlap(a, b) {
-        return !(a.x + a.w <= b.x || b.x + b.w <= a.x || a.y + a.h <= b.y || b.y + b.h <= a.y);
+      function __createArcadeFixture() {
+        return {
+          width: 4,
+          height: 1,
+          tilewidth: 1,
+          tileheight: 1,
+          solidLayerNames: ['hazards'],
+          layers: [
+            {
+              name: 'ground',
+              type: 'tilelayer',
+              width: 4,
+              height: 1,
+              data: [1, 1, 1, 1],
+            },
+            {
+              name: 'hazards',
+              type: 'tilelayer',
+              width: 4,
+              height: 1,
+              data: [0, 0, 1, 0],
+            },
+          ],
+          tilesets: [
+            { firstgid: 1, image: 'tiles.png', tilewidth: 1, tileheight: 1, tilecount: 1, columns: 1 },
+          ],
+        };
       }
 
       function __stepArcade() {
@@ -3294,21 +3995,58 @@ export const DEFAULT_CONFORMANCE_CASES = [
         __arcade.enemy.x += __arcade.enemy.vx;
 
         for (const pickup of __arcade.pickups) {
-          if (pickup.active && __overlap(__arcade.player, pickup)) {
+          if (
+            pickup.active
+            && aura.collision.rectRect(
+              __arcade.player.x,
+              __arcade.player.y,
+              __arcade.player.w,
+              __arcade.player.h,
+              pickup.x,
+              pickup.y,
+              pickup.w,
+              pickup.h,
+            )
+          ) {
             pickup.active = false;
             __arcade.score += 10;
           }
         }
 
-        if (__overlap(__arcade.player, __arcade.enemy)) {
+        if (
+          aura.collision.rectRect(
+            __arcade.player.x,
+            __arcade.player.y,
+            __arcade.player.w,
+            __arcade.player.h,
+            __arcade.enemy.x,
+            __arcade.enemy.y,
+            __arcade.enemy.w,
+            __arcade.enemy.h,
+          )
+        ) {
           __arcade.enemyHits += 1;
           if (__arcade.enemyHits === 1) {
             __arcade.lives -= 1;
           }
         }
+
+        const hazardProbe = aura.tilemap.queryPoint(
+          __arcade.mapId,
+          { x: Math.min(3.5, (__arcade.player.x / 4) + 0.5), y: 0.5 },
+        );
+        if (Array.isArray(hazardProbe?.hits) && hazardProbe.hits.length > 0) {
+          __arcade.hazardContacts += 1;
+        }
       }
 
-      aura.setup = function () {};
+      aura.setup = function () {
+        __arcade.mapId = aura.tilemap.import(__createArcadeFixture());
+        const invalidPoint = aura.tilemap.queryPoint(__arcade.mapId, { x: 'bad', y: 0 });
+        const invalidHandle = aura.tilemap.queryPoint(999999, { x: 0, y: 0 });
+        __arcade.invalidPointReason = invalidPoint?.reasonCode || null;
+        __arcade.invalidHandleReason = invalidHandle?.reasonCode || null;
+      };
 
       aura.update = function () {
         if (__arcade.frame < 7) {
@@ -3332,6 +4070,11 @@ export const DEFAULT_CONFORMANCE_CASES = [
           aura.test.equal(__arcade.lives, 2, 'arcade life decrement should be deterministic');
           aura.test.equal(__arcade.enemyHits, 1, 'arcade enemy collision count should be deterministic');
           aura.test.equal(__arcade.pickups.filter((pickup) => pickup.active).length, 0, 'arcade pickups should all resolve');
+          aura.test.equal(__arcade.hazardContacts, 2, 'arcade tilemap hazard contacts should be deterministic');
+          aura.test.equal(__arcade.invalidPointReason, 'invalid_point_args', 'arcade invalid point reason code should be deterministic');
+          aura.test.equal(__arcade.invalidHandleReason, 'invalid_map_handle', 'arcade invalid map reason code should be deterministic');
+          aura.test.equal(aura.tilemap.unload(__arcade.mapId), true, 'arcade tilemap should unload after assertions');
+          __arcade.mapId = 0;
         }
       };
     `,
@@ -3767,8 +4510,21 @@ function evaluateVerticalSliceModeBudget(mode, telemetry, budget) {
   };
 }
 
+function sortVerticalSliceModes(modeNames = []) {
+  const order = new Map(PHASER_VERTICAL_SLICE_REQUIRED_MODES.map((modeName, index) => [modeName, index]));
+  return [...new Set(
+    (Array.isArray(modeNames) ? modeNames : [])
+      .filter((modeName) => typeof modeName === 'string' && modeName.length > 0),
+  )].sort((a, b) => (
+    (order.has(a) ? order.get(a) : PHASER_VERTICAL_SLICE_REQUIRED_MODES.length)
+    - (order.has(b) ? order.get(b) : PHASER_VERTICAL_SLICE_REQUIRED_MODES.length)
+    || a.localeCompare(b)
+  ));
+}
+
 function buildVerticalSliceScenarioBudget({ modeStatus, executedModes, shimTelemetry, nativeTelemetry }) {
   const violations = [];
+  const normalizedModes = sortVerticalSliceModes(executedModes);
   const pushModeStatusViolation = (modeName, status) => {
     violations.push({
       mode: modeName,
@@ -3779,8 +4535,24 @@ function buildVerticalSliceScenarioBudget({ modeStatus, executedModes, shimTelem
       message: `${modeName} mode conformance did not pass`,
     });
   };
+  const pushModeCoverageViolation = (modeName) => {
+    violations.push({
+      mode: modeName,
+      metric: `${modeName}.status`,
+      reasonCode: `vertical_slice_mode_missing_${modeName}`,
+      actual: 'missing',
+      limit: 'passed',
+      message: `${modeName} mode scenario coverage is missing`,
+    });
+  };
 
-  for (const modeName of executedModes) {
+  for (const modeName of PHASER_VERTICAL_SLICE_REQUIRED_MODES) {
+    if (!normalizedModes.includes(modeName)) {
+      pushModeCoverageViolation(modeName);
+    }
+  }
+
+  for (const modeName of normalizedModes) {
     if (modeStatus[modeName] !== 'passed') {
       pushModeStatusViolation(modeName, modeStatus[modeName] || 'missing');
       continue;
@@ -3803,7 +4575,15 @@ function buildVerticalSliceScenarioBudget({ modeStatus, executedModes, shimTelem
     status,
     reasonCode,
     violations: violations.sort((a, b) => (
-      String(a.mode || '').localeCompare(String(b.mode || ''))
+      (
+        (PHASER_VERTICAL_SLICE_REQUIRED_MODES.indexOf(String(a.mode || '')) >= 0
+          ? PHASER_VERTICAL_SLICE_REQUIRED_MODES.indexOf(String(a.mode || ''))
+          : PHASER_VERTICAL_SLICE_REQUIRED_MODES.length)
+        - (PHASER_VERTICAL_SLICE_REQUIRED_MODES.indexOf(String(b.mode || '')) >= 0
+          ? PHASER_VERTICAL_SLICE_REQUIRED_MODES.indexOf(String(b.mode || ''))
+          : PHASER_VERTICAL_SLICE_REQUIRED_MODES.length)
+      )
+      || String(a.mode || '').localeCompare(String(b.mode || ''))
       || String(a.metric || '').localeCompare(String(b.metric || ''))
       || String(a.reasonCode || '').localeCompare(String(b.reasonCode || ''))
     )),
@@ -3926,6 +4706,9 @@ function summarizePhaserVerticalSliceEvidence(cases) {
         passed: 0,
         failed: 0,
         missing: 0,
+        requiredModes: [...PHASER_VERTICAL_SLICE_REQUIRED_MODES],
+        modeScenarioCounts: Object.fromEntries(PHASER_VERTICAL_SLICE_REQUIRED_MODES.map((modeName) => [modeName, 0])),
+        missingModeCoverage: [...PHASER_VERTICAL_SLICE_REQUIRED_MODES],
       },
       telemetry: {
         schemaVersion: 'aurajs.vertical-slice-telemetry.v1',
@@ -3952,12 +4735,19 @@ function summarizePhaserVerticalSliceEvidence(cases) {
   const scenarios = [...rowsByCaseId.values()]
     .sort((a, b) => a.caseId.localeCompare(b.caseId))
     .map((row) => {
-      const executedModes = [...row.executedModes].sort();
-      const failingModes = executedModes.filter((modeName) => row.modeStatus[modeName] !== 'passed');
+      const executedModes = sortVerticalSliceModes(row.executedModes);
+      const missingModes = PHASER_VERTICAL_SLICE_REQUIRED_MODES
+        .filter((modeName) => !executedModes.includes(modeName));
+      const failingModes = sortVerticalSliceModes([
+        ...missingModes,
+        ...executedModes.filter((modeName) => row.modeStatus[modeName] !== 'passed'),
+      ]);
       const status = failingModes.length === 0 ? 'pass' : 'fail';
-      const reasonCode = status === 'pass'
-        ? 'phaser_vertical_slice_ok'
-        : `phaser_vertical_slice_failed_${failingModes.join('_')}`;
+      const reasonCode = missingModes.length > 0
+        ? `phaser_vertical_slice_mode_missing_${missingModes.join('_')}`
+        : (status === 'pass'
+          ? 'phaser_vertical_slice_ok'
+          : `phaser_vertical_slice_failed_${failingModes.join('_')}`);
       const shimTelemetry = buildVerticalSliceShimTelemetry(row.shim);
       const nativeTelemetry = buildVerticalSliceNativeTelemetry(row.native);
       const budget = buildVerticalSliceScenarioBudget({
@@ -3970,6 +4760,7 @@ function summarizePhaserVerticalSliceEvidence(cases) {
       return {
         ...row,
         executedModes,
+        missingModes,
         status,
         reasonCode,
         telemetry: {
@@ -3980,9 +4771,17 @@ function summarizePhaserVerticalSliceEvidence(cases) {
       };
     });
 
+  const modeScenarioCounts = Object.fromEntries(
+    PHASER_VERTICAL_SLICE_REQUIRED_MODES.map((modeName) => [
+      modeName,
+      scenarios.filter((row) => row.executedModes.includes(modeName)).length,
+    ]),
+  );
+  const missingModeCoverage = PHASER_VERTICAL_SLICE_REQUIRED_MODES
+    .filter((modeName) => modeScenarioCounts[modeName] <= 0);
   const failed = scenarios.filter((row) => row.status === 'fail').length;
   const passed = scenarios.length - failed;
-  const status = failed === 0 ? 'pass' : 'fail';
+  const status = failed === 0 && missingModeCoverage.length === 0 ? 'pass' : 'fail';
   const budgetFailures = scenarios.filter((row) => row.budget?.status !== 'pass');
   const budgetViolations = budgetFailures
     .flatMap((row) => (row.budget?.violations || []).map((violation) => ({
@@ -4001,15 +4800,25 @@ function summarizePhaserVerticalSliceEvidence(cases) {
   const budgetReasonCode = budgetStatus === 'pass'
     ? 'vertical_slice_budget_ok'
     : (budgetViolations[0]?.reasonCode || 'vertical_slice_budget_failed');
+  const reasonCode = status === 'pass'
+    ? 'phaser_vertical_slice_pack_ok'
+    : (
+      missingModeCoverage.length > 0
+        ? `phaser_vertical_slice_mode_coverage_missing_${missingModeCoverage.join('_')}`
+        : 'phaser_vertical_slice_pack_failed'
+    );
 
   return {
     status,
-    reasonCode: status === 'pass' ? 'phaser_vertical_slice_pack_ok' : 'phaser_vertical_slice_pack_failed',
+    reasonCode,
     summary: {
       scenarios: scenarios.length,
       passed,
       failed,
       missing: 0,
+      requiredModes: [...PHASER_VERTICAL_SLICE_REQUIRED_MODES],
+      modeScenarioCounts,
+      missingModeCoverage,
     },
     telemetry: {
       schemaVersion: 'aurajs.vertical-slice-telemetry.v1',
@@ -4141,6 +4950,11 @@ function normalizeRuntimeInspectorScene3dRuntime(scene3dRuntime) {
       nonDefaultTransforms: numericOr(scene3dRuntime?.submission?.nonDefaultTransforms),
       skyboxRequested: scene3dRuntime?.submission?.skyboxRequested === true,
       clearRequested: scene3dRuntime?.submission?.clearRequested === true,
+      environmentMapConfigured: scene3dRuntime?.submission?.environmentMapConfigured === true,
+      pointShadowLightCount: numericOr(scene3dRuntime?.submission?.pointShadowLightCount),
+      spotShadowLightCount: numericOr(scene3dRuntime?.submission?.spotShadowLightCount),
+      pointShadowPassCount: numericOr(scene3dRuntime?.submission?.pointShadowPassCount),
+      spotShadowPassCount: numericOr(scene3dRuntime?.submission?.spotShadowPassCount),
       postfxPassCount: numericOr(scene3dRuntime?.submission?.postfxPassCount),
       postfxEnabledPassCount: numericOr(scene3dRuntime?.submission?.postfxEnabledPassCount),
       postfxOrderFingerprint: numericOr(scene3dRuntime?.submission?.postfxOrderFingerprint),
@@ -4160,6 +4974,19 @@ function normalizeRuntimeInspectorScene3dRuntime(scene3dRuntime) {
         ? scene3dRuntime.submission.postfxLastReasonCode
         : 'postfx_init',
       postfxLastOk: scene3dRuntime?.submission?.postfxLastOk !== false,
+      scene3dSubmitted: numericOr(scene3dRuntime?.submission?.scene3dSubmitted),
+      scene3dCulledHidden: numericOr(scene3dRuntime?.submission?.scene3dCulledHidden),
+      scene3dCulledLayer: numericOr(scene3dRuntime?.submission?.scene3dCulledLayer),
+      scene3dCulledBounds: numericOr(scene3dRuntime?.submission?.scene3dCulledBounds),
+      scene3dSkippedMissingNode: numericOr(scene3dRuntime?.submission?.scene3dSkippedMissingNode),
+      scene3dLayerMask: numericOr(scene3dRuntime?.submission?.scene3dLayerMask),
+      scene3dCullBoundsEnabled: scene3dRuntime?.submission?.scene3dCullBoundsEnabled === true,
+      scene3dRenderOrderFingerprint: numericOr(
+        scene3dRuntime?.submission?.scene3dRenderOrderFingerprint,
+      ),
+      scene3dLastReasonCode: typeof scene3dRuntime?.submission?.scene3dLastReasonCode === 'string'
+        ? scene3dRuntime.submission.scene3dLastReasonCode
+        : 'scene3d_render_idle',
     },
     camera: {
       mode: typeof scene3dRuntime?.camera?.mode === 'string'
@@ -4202,6 +5029,7 @@ function normalizeRuntimeInspectorScene3dRuntime(scene3dRuntime) {
       materialNextHandleId: numericOr(scene3dRuntime?.resources?.materialNextHandleId, 1),
       lightDirectionalActive: scene3dRuntime?.resources?.lightDirectionalActive === true,
       lightPointCount: numericOr(scene3dRuntime?.resources?.lightPointCount),
+      lightSpotCount: numericOr(scene3dRuntime?.resources?.lightSpotCount),
       lightAmbientIntensity: normalizeRuntimeInspectorTiming(
         scene3dRuntime?.resources?.lightAmbientIntensity,
         RUNTIME_INSPECTOR_TIMING_PRECISION.scalarDigits,
@@ -4478,6 +5306,9 @@ export function buildPhaserVerticalSliceEvidenceReport({
       passed: 0,
       failed: 0,
       missing: 0,
+      requiredModes: [...PHASER_VERTICAL_SLICE_REQUIRED_MODES],
+      modeScenarioCounts: Object.fromEntries(PHASER_VERTICAL_SLICE_REQUIRED_MODES.map((modeName) => [modeName, 0])),
+      missingModeCoverage: [...PHASER_VERTICAL_SLICE_REQUIRED_MODES],
     },
     telemetry: phaserVerticalSliceEvidence?.telemetry || {
       schemaVersion: 'aurajs.vertical-slice-telemetry.v1',
@@ -4746,6 +5577,11 @@ function buildNativeProbeSource(conformanceCase, options = {}) {
               nonDefaultTransforms: __num(scene3dSubmission.nonDefaultTransforms),
               skyboxRequested: scene3dSubmission.skyboxRequested === true,
               clearRequested: scene3dSubmission.clearRequested === true,
+              environmentMapConfigured: scene3dSubmission.environmentMapConfigured === true,
+              pointShadowLightCount: __num(scene3dSubmission.pointShadowLightCount),
+              spotShadowLightCount: __num(scene3dSubmission.spotShadowLightCount),
+              pointShadowPassCount: __num(scene3dSubmission.pointShadowPassCount),
+              spotShadowPassCount: __num(scene3dSubmission.spotShadowPassCount),
               postfxPassCount: __num(scene3dSubmission.postfxPassCount),
               postfxEnabledPassCount: __num(scene3dSubmission.postfxEnabledPassCount),
               postfxOrderFingerprint: __num(scene3dSubmission.postfxOrderFingerprint),
@@ -4792,6 +5628,7 @@ function buildNativeProbeSource(conformanceCase, options = {}) {
               materialNextHandleId: __num(scene3dResources.materialNextHandleId, 1),
               lightDirectionalActive: scene3dResources.lightDirectionalActive === true,
               lightPointCount: __num(scene3dResources.lightPointCount),
+              lightSpotCount: __num(scene3dResources.lightSpotCount),
               lightAmbientIntensity: __num(scene3dResources.lightAmbientIntensity),
               lightCameraPosition: toVec3(scene3dResources.lightCameraPosition),
             },
@@ -5019,6 +5856,8 @@ async function runNativeConformanceCase({
     hostBinaryPath: binaryPath,
     hostPackageName: resolvedHost.packageName,
     hostBinarySource: resolvedHost.source || null,
+    hostBinaryTarget: resolvedHost.target || null,
+    hostBinaryReasonCode: resolvedHost.reasonCode || null,
     hostBinaryDiagnostics: resolvedHost.diagnostics || [],
     hostBinaryResolution: resolvedHost,
   };
@@ -5073,10 +5912,33 @@ function extractHostMetadataCandidate(entry) {
     || details?.hostBinarySource
     || resolution?.source,
   );
+  const target = asNonEmptyString(
+    native?.hostBinaryTarget
+    || details?.hostBinaryTarget
+    || resolution?.target,
+  );
+  const selectionKind = asNonEmptyString(
+    resolution?.localBuild?.selected?.kind
+    || details?.hostBinarySelectionKind,
+  );
   const resolvedAt = asNonEmptyString(resolution?.resolvedAt || details?.hostBinaryResolvedAt);
-  const reasonCode = asNonEmptyString(details?.reasonCode || details?.code);
+  const reasonCode = asNonEmptyString(
+    details?.reasonCode
+    || details?.code
+    || native?.hostBinaryReasonCode
+    || resolution?.reasonCode,
+  );
 
-  if (!path && !packageName && !source && !resolvedAt && !reasonCode && diagnostics.length === 0) {
+  if (
+    !path
+    && !packageName
+    && !source
+    && !target
+    && !selectionKind
+    && !resolvedAt
+    && !reasonCode
+    && diagnostics.length === 0
+  ) {
     return null;
   }
 
@@ -5084,6 +5946,8 @@ function extractHostMetadataCandidate(entry) {
     path,
     packageName,
     source: source || (path ? 'unknown' : null),
+    target,
+    selectionKind,
     diagnostics,
     resolvedAt,
     reasonCode: reasonCode || null,
@@ -5097,34 +5961,77 @@ function summarizeHostBinaryMetadata(nativeCases) {
 
   if (rows.length === 0) {
     if (!Array.isArray(nativeCases) || nativeCases.length === 0) {
-      return {
-        path: null,
-        packageName: null,
-        source: null,
-        diagnostics: [],
-        resolvedAt: null,
-        reasonCode: 'host_binary_not_required',
-      };
-    }
-
     return {
       path: null,
       packageName: null,
       source: null,
+      target: null,
+      selectionKind: null,
+      diagnostics: [],
+      resolvedAt: null,
+      consistency: {
+        caseCount: Array.isArray(nativeCases) ? nativeCases.length : 0,
+        distinctSourceCount: 0,
+        distinctPathCount: 0,
+        distinctPackageCount: 0,
+        sameSource: true,
+        samePath: true,
+        samePackageName: true,
+      },
+      reasonCode: 'host_binary_not_required',
+    };
+  }
+
+  return {
+      path: null,
+      packageName: null,
+      source: null,
+      target: null,
+      selectionKind: null,
       diagnostics: [],
       resolvedAt: null,
+      consistency: {
+        caseCount: nativeCases.length,
+        distinctSourceCount: 0,
+        distinctPathCount: 0,
+        distinctPackageCount: 0,
+        sameSource: true,
+        samePath: true,
+        samePackageName: true,
+      },
       reasonCode: 'host_binary_metadata_missing',
     };
   }
 
+  const distinctSources = collectUniqueStringValues(rows.map((row) => row.source));
+  const distinctPaths = collectUniqueStringValues(rows.map((row) => row.path));
+  const distinctPackages = collectUniqueStringValues(rows.map((row) => row.packageName));
+  const consistency = {
+    caseCount: rows.length,
+    distinctSourceCount: distinctSources.length,
+    distinctPathCount: distinctPaths.length,
+    distinctPackageCount: distinctPackages.length,
+    sameSource: distinctSources.length <= 1,
+    samePath: distinctPaths.length <= 1,
+    samePackageName: distinctPackages.length <= 1,
+  };
+  const consistencyReasonCode = (
+    !consistency.sameSource || !consistency.samePath || !consistency.samePackageName
+  )
+    ? 'host_binary_metadata_inconsistent'
+    : null;
+
   const first = rows[0];
   return {
     path: first.path || null,
     packageName: first.packageName || null,
     source: first.source || null,
+    target: first.target || null,
+    selectionKind: first.selectionKind || null,
     diagnostics: collectUniqueStringValues(rows.flatMap((row) => row.diagnostics || [])),
     resolvedAt: first.resolvedAt || null,
-    reasonCode: first.reasonCode || 'host_binary_metadata_resolved',
+    consistency,
+    reasonCode: consistencyReasonCode || first.reasonCode || 'host_binary_metadata_resolved',
   };
 }
 
@@ -5149,6 +6056,12 @@ export async function runConformanceSuite(options = {}) {
   const nativeRunner = options.nativeRunner || runNativeConformanceCase;
 
   mkdirSync(resolve(workspaceRoot, 'src'), { recursive: true });
+  const sceneFixtureSource = resolve(projectRoot, 'test-fixtures', 'scene3d', 'import-scene.gltf');
+  const sceneFixtureTarget = resolve(workspaceRoot, 'src', 'cli', 'test-fixtures', 'scene3d', 'import-scene.gltf');
+  if (existsSync(sceneFixtureSource)) {
+    mkdirSync(dirname(sceneFixtureTarget), { recursive: true });
+    copyFileSync(sceneFixtureSource, sceneFixtureTarget);
+  }
 
   const modeCases = {
     shim: [],
@@ -5166,7 +6079,12 @@ export async function runConformanceSuite(options = {}) {
     if (shouldRunShim(mode) && caseModes.has('shim')) {
       const entryRelative = `src/${safeCaseId}.js`;
       const entryAbsolute = resolve(workspaceRoot, entryRelative);
-      writeFileSync(entryAbsolute, conformanceCase.source.trimStart(), 'utf8');
+      const shimBootstrapSource = buildGameStateHookBootstrapSource('headless');
+      writeFileSync(
+        entryAbsolute,
+        `${shimBootstrapSource}\n${conformanceCase.source.trimStart()}`,
+        'utf8',
+      );
 
       const shimStartedAt = nowMs();
       try {
@@ -5211,13 +6129,14 @@ export async function runConformanceSuite(options = {}) {
     }
 
     if (shouldRunNative(mode) && caseModes.has('native')) {
+      const nativeBootstrapSource = buildGameStateHookBootstrapSource('native');
       const nativeSource = (
         conformanceCase.nativeSource
         || buildNativeProbeSource(conformanceCase, { runtimeInspectorSnapshotEnabled })
       ).trimStart();
       const nativeEntryRelative = `src/native-${safeCaseId}.js`;
       const nativeEntryAbsolute = resolve(workspaceRoot, nativeEntryRelative);
-      writeFileSync(nativeEntryAbsolute, nativeSource, 'utf8');
+      writeFileSync(nativeEntryAbsolute, `${nativeBootstrapSource}\n${nativeSource}`, 'utf8');
 
       const nativeStartedAt = nowMs();
       try {
@@ -5243,6 +6162,8 @@ export async function runConformanceSuite(options = {}) {
             hostBinaryPath: native.hostBinaryPath,
             hostPackageName: native.hostPackageName || null,
             hostBinarySource: native.hostBinarySource || null,
+            hostBinaryTarget: native.hostBinaryTarget || null,
+            hostBinaryReasonCode: native.hostBinaryReasonCode || null,
             hostBinaryDiagnostics: native.hostBinaryDiagnostics || [],
             hostBinaryResolvedAt: native.hostBinaryResolution?.resolvedAt || null,
           });
@@ -5257,6 +6178,8 @@ export async function runConformanceSuite(options = {}) {
             hostBinaryPath: native.hostBinaryPath,
             hostPackageName: native.hostPackageName || null,
             hostBinarySource: native.hostBinarySource || null,
+            hostBinaryTarget: native.hostBinaryTarget || null,
+            hostBinaryReasonCode: native.hostBinaryReasonCode || null,
             hostBinaryDiagnostics: native.hostBinaryDiagnostics || [],
             hostBinaryResolvedAt: native.hostBinaryResolution?.resolvedAt || null,
           });
@@ -5271,6 +6194,8 @@ export async function runConformanceSuite(options = {}) {
             hostBinaryPath: native.hostBinaryPath,
             hostPackageName: native.hostPackageName,
             hostBinarySource: native.hostBinarySource || null,
+            hostBinaryTarget: native.hostBinaryTarget || null,
+            hostBinaryReasonCode: native.hostBinaryReasonCode || null,
             hostBinaryDiagnostics: native.hostBinaryDiagnostics || [],
             hostBinaryResolvedAt: native.hostBinaryResolution?.resolvedAt || null,
           });
@@ -5296,6 +6221,8 @@ export async function runConformanceSuite(options = {}) {
             hostBinaryPath: native.hostBinaryPath,
             hostPackageName: native.hostPackageName,
             hostBinarySource: native.hostBinarySource || null,
+            hostBinaryTarget: native.hostBinaryTarget || null,
+            hostBinaryReasonCode: native.hostBinaryReasonCode || null,
             hostBinaryDiagnostics: native.hostBinaryDiagnostics || [],
           },
         });