@auraindustry/aurajs 0.0.4 → 0.0.6

package/src/cutscene.mjs

@@ -0,0 +1,205 @@
+function asFiniteNumber(value, fallback = 0) {
+  return Number.isFinite(Number(value)) ? Number(value) : fallback;
+}
+
+function cloneCue(cue, index) {
+  if (!cue || typeof cue !== 'object') {
+    throw new TypeError(`cutscene cue at index ${index} must be an object`);
+  }
+  const time = Number(cue.time);
+  if (!Number.isFinite(time) || time < 0) {
+    throw new TypeError(`cutscene cue at index ${index} requires a non-negative finite time`);
+  }
+  const type = typeof cue.type === 'string' && cue.type.trim().length > 0
+    ? cue.type.trim()
+    : 'event';
+  const id = typeof cue.id === 'string' && cue.id.trim().length > 0
+    ? cue.id.trim()
+    : `${type}:${index}`;
+  return {
+    ...cue,
+    id,
+    type,
+    time,
+  };
+}
+
+function normalizeCues(cues) {
+  if (!Array.isArray(cues)) return [];
+  return cues
+    .map((cue, index) => cloneCue(cue, index))
+    .sort((a, b) => (a.time - b.time) || a.id.localeCompare(b.id));
+}
+
+function collectCueIdsUpTo(cues, time) {
+  const ids = new Set();
+  for (const cue of cues) {
+    if (cue.time <= time) ids.add(cue.id);
+  }
+  return ids;
+}
+
+export class VideoCutsceneController {
+  constructor(videoApi, handle, options = {}) {
+    if (!videoApi || typeof videoApi !== 'object') {
+      throw new TypeError('VideoCutsceneController requires an aura.video-compatible API object.');
+    }
+    const requiredMethods = ['play', 'pause', 'stop', 'seek', 'getInfo'];
+    for (const method of requiredMethods) {
+      if (typeof videoApi[method] !== 'function') {
+        throw new TypeError(`VideoCutsceneController requires videoApi.${method}()`);
+      }
+    }
+    const numericHandle = Number(handle);
+    if (!Number.isInteger(numericHandle) || numericHandle <= 0) {
+      throw new TypeError('VideoCutsceneController requires a positive integer video handle.');
+    }
+
+    this.videoApi = videoApi;
+    this.handle = numericHandle;
+    this.options = {
+      cues: normalizeCues(options.cues),
+      onCue: typeof options.onCue === 'function' ? options.onCue : null,
+      onSubtitle: typeof options.onSubtitle === 'function' ? options.onSubtitle : null,
+      onCheckpoint: typeof options.onCheckpoint === 'function' ? options.onCheckpoint : null,
+      onStateChange: typeof options.onStateChange === 'function' ? options.onStateChange : null,
+      skipTarget: Number.isFinite(Number(options.skipTarget)) ? Math.max(0, Number(options.skipTarget)) : null,
+    };
+    this.firedCueIds = new Set();
+    this.lastInfo = null;
+    this.lastTime = 0;
+    this.lastState = null;
+  }
+
+  getInfo() {
+    return this.videoApi.getInfo(this.handle);
+  }
+
+  getState() {
+    const info = this.getInfo();
+    const currentTime = info ? asFiniteNumber(info.currentTime || info.currentTimeSecs, 0) : 0;
+    const duration = info ? asFiniteNumber(info.duration || info.durationSecs, 0) : 0;
+    const currentCue = this.options.cues.find((cue) => cue.time >= currentTime) || null;
+    return {
+      handle: this.handle,
+      info,
+      currentTime,
+      duration,
+      firedCueCount: this.firedCueIds.size,
+      nextCue: currentCue,
+    };
+  }
+
+  exportCheckpointState() {
+    const info = this.getInfo();
+    return {
+      handle: this.handle,
+      currentTime: info ? asFiniteNumber(info.currentTime || info.currentTimeSecs, 0) : this.lastTime,
+      firedCueIds: [...this.firedCueIds],
+      state: info && typeof info.state === 'string' ? info.state : this.lastState,
+    };
+  }
+
+  restoreCheckpointState(snapshot) {
+    if (!snapshot || typeof snapshot !== 'object') {
+      throw new TypeError('VideoCutsceneController.restoreCheckpointState(snapshot) requires an object snapshot.');
+    }
+    const targetTime = Number(snapshot.currentTime);
+    if (!Number.isFinite(targetTime) || targetTime < 0) {
+      throw new TypeError('VideoCutsceneController.restoreCheckpointState(snapshot) requires a non-negative finite currentTime.');
+    }
+    const firedCueIds = Array.isArray(snapshot.firedCueIds) ? snapshot.firedCueIds : [];
+    this.videoApi.seek(this.handle, targetTime);
+    this.firedCueIds = new Set(firedCueIds.filter((value) => typeof value === 'string' && value.length > 0));
+    this.lastTime = targetTime;
+    this.lastState = typeof snapshot.state === 'string' ? snapshot.state : this.lastState;
+    return this.sync();
+  }
+
+  sync() {
+    const info = this.getInfo();
+    if (!info || typeof info !== 'object') {
+      throw new Error(`VideoCutsceneController could not read info for handle ${this.handle}.`);
+    }
+
+    const nextState = typeof info.state === 'string' ? info.state : 'unknown';
+    const currentTime = asFiniteNumber(info.currentTime || info.currentTimeSecs, 0);
+    if (this.lastInfo && currentTime < this.lastTime) {
+      this.firedCueIds = collectCueIdsUpTo(this.options.cues, currentTime);
+    }
+
+    for (const cue of this.options.cues) {
+      if (cue.time <= currentTime && !this.firedCueIds.has(cue.id)) {
+        this.firedCueIds.add(cue.id);
+        if (this.options.onCue) this.options.onCue(cue, info, this);
+        if (cue.type === 'subtitle' && this.options.onSubtitle) this.options.onSubtitle(cue, info, this);
+        if (cue.type === 'checkpoint' && this.options.onCheckpoint) this.options.onCheckpoint(cue, info, this);
+      }
+    }
+
+    if (nextState !== this.lastState && this.options.onStateChange) {
+      this.options.onStateChange({
+        previousState: this.lastState,
+        state: nextState,
+        info,
+        controller: this,
+      });
+    }
+
+    this.lastInfo = info;
+    this.lastTime = currentTime;
+    this.lastState = nextState;
+    return info;
+  }
+
+  play() {
+    this.videoApi.play(this.handle);
+    return this.sync();
+  }
+
+  pause() {
+    this.videoApi.pause(this.handle);
+    return this.sync();
+  }
+
+  resume() {
+    return this.play();
+  }
+
+  stop() {
+    this.videoApi.stop(this.handle);
+    this.firedCueIds.clear();
+    this.lastTime = 0;
+    return this.sync();
+  }
+
+  seek(timeSecs) {
+    const target = Number(timeSecs);
+    if (!Number.isFinite(target) || target < 0) {
+      throw new TypeError('VideoCutsceneController.seek(timeSecs) requires a non-negative finite time.');
+    }
+    this.videoApi.seek(this.handle, target);
+    this.firedCueIds = collectCueIdsUpTo(this.options.cues, target);
+    this.lastTime = target;
+    return this.sync();
+  }
+
+  skip(targetTime = null) {
+    const info = this.getInfo();
+    const fallbackDuration = info ? asFiniteNumber(info.duration || info.durationSecs, 0) : 0;
+    const resolvedTarget = targetTime != null && Number.isFinite(Number(targetTime))
+      ? Math.max(0, Number(targetTime))
+      : (this.options.skipTarget != null ? this.options.skipTarget : fallbackDuration);
+    return this.seek(resolvedTarget);
+  }
+
+  update() {
+    return this.sync();
+  }
+}
+
+export function createVideoCutsceneController(videoApi, handle, options = {}) {
+  return new VideoCutsceneController(videoApi, handle, options);
+}
+
+export default createVideoCutsceneController;

package/src/game-state-runtime.mjs

@@ -28,6 +28,266 @@ export const DEFAULT_STATE_MUTATION_GUARDRAILS = Object.freeze({
   allowlistPrefixes: STATE_MUTATION_ALLOWLIST_PREFIXES,
 });
 
+export function installStateRestoreRuntimeBootstrap(aura) {
+  const schemaVersion = 'aurajs.game-state.v1';
+  const knownTopLevel = Object.freeze(['schemaVersion', 'export', 'state']);
+  const knownStateSections = Object.freeze(['globals', 'camera', 'scene3d', 'physics', 'ecs', 'tilemap']);
+
+  const isObject = (value) => (
+    !!value
+    && typeof value === 'object'
+    && !Array.isArray(value)
+  );
+  const sanitizeJsonValueLocal = (value) => {
+    if (value === null) return null;
+    if (typeof value === 'string' || typeof value === 'boolean') return value;
+    if (typeof value === 'number') {
+      return Number.isFinite(value) ? Number(value) : null;
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => sanitizeJsonValueLocal(entry));
+    }
+    if (isObject(value)) {
+      const out = {};
+      for (const key of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
+        const next = sanitizeJsonValueLocal(value[key]);
+        if (next === undefined) continue;
+        out[key] = next;
+      }
+      return out;
+    }
+    return null;
+  };
+  const sanitizeObjectLocal = (value) => {
+    const out = {};
+    const source = isObject(value) ? value : {};
+    for (const key of Object.keys(source).sort((a, b) => a.localeCompare(b))) {
+      const next = sanitizeJsonValueLocal(source[key]);
+      if (next === undefined) continue;
+      out[key] = next;
+    }
+    return out;
+  };
+  const collectCanonicalStateFromPayloadLocal = (inputState) => {
+    const out = {};
+    out.globals = sanitizeObjectLocal(inputState?.globals || {});
+    for (const sectionName of knownStateSections) {
+      if (sectionName === 'globals') continue;
+      if (!Object.prototype.hasOwnProperty.call(inputState, sectionName)) continue;
+      const value = sanitizeJsonValueLocal(inputState[sectionName]);
+      if (value == null) continue;
+      out[sectionName] = value;
+    }
+    return out;
+  };
+  const resolveGlobalsMapLocal = () => {
+    const storage = aura?.storage && typeof aura.storage === 'object' ? aura.storage : null;
+    if (storage && storage._store instanceof Map) {
+      return storage._store;
+    }
+    if (aura && aura.__gameStateGlobals instanceof Map) {
+      return aura.__gameStateGlobals;
+    }
+    if (aura && typeof aura === 'object') {
+      aura.__gameStateGlobals = new Map();
+      return aura.__gameStateGlobals;
+    }
+    return new Map();
+  };
+  const applyGlobalsSectionLocal = (sectionValue) => {
+    if (!isObject(sectionValue)) {
+      return { ok: false, reasonCode: 'invalid_state_section', detail: 'globals must be an object' };
+    }
+    const globalsMap = resolveGlobalsMapLocal();
+    globalsMap.clear();
+    const normalized = sanitizeObjectLocal(sectionValue);
+    for (const [key, value] of Object.entries(normalized)) {
+      globalsMap.set(key, value);
+    }
+    const storage = aura?.storage && typeof aura.storage === 'object' ? aura.storage : null;
+    if (storage && typeof storage.set === 'function') {
+      for (const [key, value] of globalsMap.entries()) {
+        storage.set(key, value);
+      }
+    }
+    return { ok: true, reasonCode: 'state_apply_ok' };
+  };
+  const applyCameraSectionLocal = (sectionValue) => {
+    if (!isObject(sectionValue)) {
+      return { ok: false, reasonCode: 'invalid_state_section', detail: 'camera must be an object' };
+    }
+    if (!aura?.camera || typeof aura.camera !== 'object') {
+      return { ok: false, reasonCode: 'unsupported_state_section', detail: 'camera surface unavailable' };
+    }
+
+    const nextX = sectionValue.x;
+    const nextY = sectionValue.y;
+    const nextZoom = sectionValue.zoom;
+    const nextRotation = sectionValue.rotation;
+    if (nextX != null && !Number.isFinite(nextX)) {
+      return { ok: false, reasonCode: 'invalid_state_section', detail: 'camera.x must be finite' };
+    }
+    if (nextY != null && !Number.isFinite(nextY)) {
+      return { ok: false, reasonCode: 'invalid_state_section', detail: 'camera.y must be finite' };
+    }
+    if (nextZoom != null && (!Number.isFinite(nextZoom) || nextZoom <= 0)) {
+      return { ok: false, reasonCode: 'invalid_state_section', detail: 'camera.zoom must be > 0' };
+    }
+    if (nextRotation != null && !Number.isFinite(nextRotation)) {
+      return { ok: false, reasonCode: 'invalid_state_section', detail: 'camera.rotation must be finite' };
+    }
+
+    if (nextX != null) aura.camera.x = Number(nextX);
+    if (nextY != null) aura.camera.y = Number(nextY);
+    if (nextZoom != null) aura.camera.zoom = Number(nextZoom);
+    if (nextRotation != null) aura.camera.rotation = Number(nextRotation);
+    return { ok: true, reasonCode: 'state_apply_ok' };
+  };
+  const resolveSectionApplyHandlerLocal = (sectionName) => {
+    const section = aura?.[sectionName];
+    if (!section || typeof section !== 'object') return null;
+    if (typeof section.applyState === 'function') {
+      return (value) => section.applyState(value);
+    }
+    if (typeof section.importState === 'function') {
+      return (value) => section.importState(value);
+    }
+    if (sectionName === 'physics' && typeof section.restoreSnapshot === 'function') {
+      return (value) => section.restoreSnapshot(value);
+    }
+    return null;
+  };
+  const applyStateSectionLocal = (sectionName, sectionValue) => {
+    if (sectionName === 'globals') return applyGlobalsSectionLocal(sectionValue);
+    if (sectionName === 'camera') return applyCameraSectionLocal(sectionValue);
+
+    const handler = resolveSectionApplyHandlerLocal(sectionName);
+    if (!handler) {
+      return { ok: false, reasonCode: 'unsupported_state_section' };
+    }
+    try {
+      const result = handler(sectionValue);
+      if (result === false) {
+        return { ok: false, reasonCode: 'state_apply_failed' };
+      }
+      if (result && typeof result === 'object' && result.ok === false) {
+        return {
+          ok: false,
+          reasonCode: typeof result.reasonCode === 'string' ? result.reasonCode : 'state_apply_failed',
+          detail: result.detail || result.error || null,
+        };
+      }
+      return { ok: true, reasonCode: 'state_apply_ok' };
+    } catch (error) {
+      return {
+        ok: false,
+        reasonCode: 'state_apply_failed',
+        detail: error instanceof Error ? error.message : String(error),
+      };
+    }
+  };
+  const validateApplyPayloadLocal = (payload) => {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+      return { ok: false, reasonCode: 'invalid_schema_payload', detail: 'payload must be an object' };
+    }
+    if (payload.schemaVersion !== schemaVersion) {
+      return {
+        ok: false,
+        reasonCode: 'schema_version_mismatch',
+        detail: `expected ${schemaVersion}`,
+      };
+    }
+    if (!isObject(payload.state)) {
+      return { ok: false, reasonCode: 'invalid_schema_payload', detail: 'state must be an object' };
+    }
+    if (!isObject(payload.export)) {
+      return { ok: false, reasonCode: 'invalid_schema_payload', detail: 'export must be an object' };
+    }
+
+    const unknownTopLevel = Object.keys(payload).filter((key) => !knownTopLevel.includes(key));
+    if (unknownTopLevel.length > 0) {
+      return { ok: false, reasonCode: 'unknown_top_level_key', unknownKeys: unknownTopLevel.sort() };
+    }
+    if (!isObject(payload.state.globals)) {
+      return { ok: false, reasonCode: 'missing_required_field', detail: 'state.globals is required' };
+    }
+
+    const unknownSections = Object.keys(payload.state).filter((key) => !knownStateSections.includes(key));
+    if (unknownSections.length > 0) {
+      return { ok: false, reasonCode: 'unknown_state_section', unknownSections: unknownSections.sort() };
+    }
+
+    return {
+      ok: true,
+      state: collectCanonicalStateFromPayloadLocal(payload.state),
+    };
+  };
+
+  if (!aura || typeof aura !== 'object') {
+    return {
+      apply() {
+        return { ok: false, reasonCode: 'invalid_schema_payload', detail: 'aura runtime unavailable' };
+      },
+    };
+  }
+
+  const stateNamespace = aura.state && typeof aura.state === 'object' ? aura.state : {};
+  if (typeof stateNamespace.apply === 'function' && typeof stateNamespace.applyState === 'function') {
+    stateNamespace.schemaVersion = schemaVersion;
+    aura.state = stateNamespace;
+    return stateNamespace;
+  }
+
+  const applyPayload = (payload, options = {}) => {
+    const validated = validateApplyPayloadLocal(payload);
+    if (!validated.ok) {
+      return validated;
+    }
+    if (options?.dryRun === true) {
+      return {
+        ok: true,
+        reasonCode: 'state_dry_run_ok',
+        appliedSections: [],
+      };
+    }
+
+    const appliedSections = [];
+    for (const sectionName of knownStateSections) {
+      if (!Object.prototype.hasOwnProperty.call(validated.state, sectionName)) continue;
+      const result = applyStateSectionLocal(sectionName, validated.state[sectionName]);
+      if (!result.ok) {
+        return {
+          ok: false,
+          reasonCode: result.reasonCode || 'state_apply_failed',
+          failedSection: sectionName,
+          detail: result.detail || null,
+          appliedSections,
+        };
+      }
+      appliedSections.push(sectionName);
+    }
+    return {
+      ok: true,
+      reasonCode: 'state_apply_ok',
+      appliedSections,
+    };
+  };
+
+  stateNamespace.schemaVersion = schemaVersion;
+  if (typeof stateNamespace.apply !== 'function') {
+    stateNamespace.apply = applyPayload;
+  }
+  if (typeof stateNamespace.applyState !== 'function') {
+    stateNamespace.applyState = applyPayload;
+  }
+  aura.state = stateNamespace;
+  return stateNamespace;
+}
+
+export function buildStateRestoreRuntimeBootstrapSource() {
+  return `(${installStateRestoreRuntimeBootstrap.toString()})(aura);`;
+}
+
 export function createGameStateRuntimeHooks({ aura, mode = 'native' } = {}) {
   if (!aura || typeof aura !== 'object') {
     throw new Error('createGameStateRuntimeHooks requires an aura runtime object.');

package/src/headless-test.mjs

@@ -4,6 +4,7 @@ import vm from 'node:vm';
 
 import { bundleProject } from './bundler.mjs';
 import {
+  GAME_STATE_SCHEMA_VERSION,
   createGameStateRuntimeHooks,
   diffCanonicalGameState,
   applyCanonicalStatePatch,
@@ -163,13 +164,13 @@ export async function runHeadlessStateExport(options = {}) {
     });
   }
 
-  if (!aura.state || typeof aura.state !== 'object' || typeof aura.state.export !== 'function') {
-    throw new HeadlessTestError('Headless state export failed: aura.state.export hook is unavailable.');
+  if (!aura.state || typeof aura.state !== 'object' || typeof aura.state.exportState !== 'function') {
+    throw new HeadlessTestError('Headless state export failed: aura.state.exportState hook is unavailable.');
   }
 
   let exportResult;
   try {
-    exportResult = aura.state.export({
+    exportResult = aura.state.exportState({
       mode: options.mode,
       seed: options.seed,
       frameIndex: options.frameIndex ?? frames,
@@ -274,15 +275,15 @@ export async function runHeadlessStateApply(options = {}) {
   if (!aura.state || typeof aura.state !== 'object') {
     throw new HeadlessTestError('Headless state apply failed: aura.state surface is unavailable.');
   }
-  if (typeof aura.state.export !== 'function') {
-    throw new HeadlessTestError('Headless state apply failed: aura.state.export hook is unavailable.');
+  if (typeof aura.state.exportState !== 'function') {
+    throw new HeadlessTestError('Headless state apply failed: aura.state.exportState hook is unavailable.');
   }
   if (typeof aura.state.apply !== 'function') {
     throw new HeadlessTestError('Headless state apply failed: aura.state.apply hook is unavailable.');
   }
 
   const captureExport = () => {
-    const result = aura.state.export({
+    const result = aura.state.exportState({
       mode: options.mode,
       seed: options.seed,
       frameIndex: options.frameIndex ?? frames,
@@ -631,7 +632,7 @@ function createRuntimeContext(aura, testState) {
   };
 }
 
-function createHeadlessAura({ width, height, testState }) {
+export function createHeadlessAura({ width, height, testState }) {
   const drawNoop = () => {
     testState.drawCalls += 1;
   };
@@ -3059,9 +3060,21 @@ function createHeadlessAura({ width, height, testState }) {
   let nextMaterialHandle = 1;
   const defaultMaterialState = Object.freeze({
     color: { r: 1, g: 1, b: 1, a: 1 },
+    emissive: { r: 0, g: 0, b: 0 },
     metallic: 0,
     roughness: 1,
     texture: null,
+    metallicRoughnessTexture: null,
+    occlusionTexture: null,
+    emissiveTexture: null,
+    alphaMode: 'opaque',
+    alphaCutoff: 0.5,
+    doubleSided: false,
+    clearcoat: 0,
+    clearcoatRoughness: 0,
+    sheenColor: { r: 0, g: 0, b: 0 },
+    sheenRoughness: 0,
+    occlusionStrength: 1,
   });
   const materialStore = new Map([[0, { ...defaultMaterialState }]]);
   const normalizeMaterialHandle = (value) => (
@@ -3073,6 +3086,21 @@ function createHeadlessAura({ width, height, testState }) {
     if (![r, g, b, a].every((entry) => Number.isFinite(entry))) return null;
     return { r: Number(r), g: Number(g), b: Number(b), a: Number(a) };
   };
+  const normalizeMaterialRgb = (value) => {
+    if (!value || typeof value !== 'object') return null;
+    const { r, g, b } = value;
+    if (![r, g, b].every((entry) => Number.isFinite(entry))) return null;
+    return { r: Number(r), g: Number(g), b: Number(b) };
+  };
+  const normalizeTexturePath = (value) => (
+    typeof value === 'string' && value.length > 0 ? value : null
+  );
+  const normalizeAlphaMode = (value) => {
+    if (typeof value !== 'string') return defaultMaterialState.alphaMode;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'mask' || normalized === 'blend') return normalized;
+    return 'opaque';
+  };
   const clampUnit = (value, fallback) => {
     if (!Number.isFinite(value)) return fallback;
     return Math.max(0, Math.min(1, Number(value)));
@@ -3089,9 +3117,27 @@ function createHeadlessAura({ width, height, testState }) {
     }
     return {
       color: normalizeMaterialColor(options.color) || { ...defaultMaterialState.color },
+      emissive: normalizeMaterialRgb(options.emissive) || { ...defaultMaterialState.emissive },
       metallic: clampUnit(options.metallic, defaultMaterialState.metallic),
       roughness: clampUnit(options.roughness, defaultMaterialState.roughness),
-      texture: typeof options.texture === 'string' && options.texture.length > 0 ? options.texture : null,
+      texture: normalizeTexturePath(options.texture),
+      metallicRoughnessTexture: normalizeTexturePath(options.metallicRoughnessTexture),
+      occlusionTexture: normalizeTexturePath(options.aoTexture ?? options.occlusionTexture),
+      emissiveTexture: normalizeTexturePath(options.emissiveTexture),
+      alphaMode: normalizeAlphaMode(options.alphaMode),
+      alphaCutoff: clampUnit(options.alphaCutoff, defaultMaterialState.alphaCutoff),
+      doubleSided: options.doubleSided === true,
+      clearcoat: clampUnit(options.clearcoat, defaultMaterialState.clearcoat),
+      clearcoatRoughness: clampUnit(
+        options.clearcoatRoughness,
+        defaultMaterialState.clearcoatRoughness,
+      ),
+      sheenColor: normalizeMaterialRgb(options.sheenColor) || { ...defaultMaterialState.sheenColor },
+      sheenRoughness: clampUnit(options.sheenRoughness, defaultMaterialState.sheenRoughness),
+      occlusionStrength: clampUnit(
+        options.occlusionStrength ?? options.aoStrength,
+        defaultMaterialState.occlusionStrength,
+      ),
     };
   };
 
@@ -4293,6 +4339,8 @@ function createHeadlessAura({ width, height, testState }) {
         aura.window.height = Number(h) || aura.window.height;
       },
       setFullscreen: () => {},
+      setCursorVisible: () => {},
+      setCursorLocked: () => {},
       getSize: () => ({ width: aura.window.width, height: aura.window.height }),
       getPixelRatio: () => aura.window.pixelRatio,
       getFPS: () => aura.window.fps,
@@ -4375,9 +4423,21 @@ function createHeadlessAura({ width, height, testState }) {
         const material = getMaterialState(handle);
         if (!material) return;
         material.color = { ...defaultMaterialState.color };
+        material.emissive = { ...defaultMaterialState.emissive };
         material.metallic = defaultMaterialState.metallic;
         material.roughness = defaultMaterialState.roughness;
         material.texture = defaultMaterialState.texture;
+        material.metallicRoughnessTexture = defaultMaterialState.metallicRoughnessTexture;
+        material.occlusionTexture = defaultMaterialState.occlusionTexture;
+        material.emissiveTexture = defaultMaterialState.emissiveTexture;
+        material.alphaMode = defaultMaterialState.alphaMode;
+        material.alphaCutoff = defaultMaterialState.alphaCutoff;
+        material.doubleSided = defaultMaterialState.doubleSided;
+        material.clearcoat = defaultMaterialState.clearcoat;
+        material.clearcoatRoughness = defaultMaterialState.clearcoatRoughness;
+        material.sheenColor = { ...defaultMaterialState.sheenColor };
+        material.sheenRoughness = defaultMaterialState.sheenRoughness;
+        material.occlusionStrength = defaultMaterialState.occlusionStrength;
       },
       clone: (handle) => {
         const material = getMaterialState(handle);
@@ -4385,9 +4445,21 @@ function createHeadlessAura({ width, height, testState }) {
         const newHandle = nextMaterialHandle++;
         materialStore.set(newHandle, {
           color: { ...material.color },
+          emissive: { ...material.emissive },
           metallic: material.metallic,
           roughness: material.roughness,
           texture: material.texture,
+          metallicRoughnessTexture: material.metallicRoughnessTexture,
+          occlusionTexture: material.occlusionTexture,
+          emissiveTexture: material.emissiveTexture,
+          alphaMode: material.alphaMode,
+          alphaCutoff: material.alphaCutoff,
+          doubleSided: material.doubleSided,
+          clearcoat: material.clearcoat,
+          clearcoatRoughness: material.clearcoatRoughness,
+          sheenColor: { ...material.sheenColor },
+          sheenRoughness: material.sheenRoughness,
+          occlusionStrength: material.occlusionStrength,
         });
         return newHandle;
       },
@@ -4421,6 +4493,7 @@ function createHeadlessAura({ width, height, testState }) {
       isMousePressed: (...args) => aura.input.mouse.isPressed(...args),
       isMouseReleased: (...args) => aura.input.mouse.isReleased(...args),
       getMousePosition: () => ({ x: aura.input.mouse.x, y: aura.input.mouse.y }),
+      getMouseDelta: () => ({ x: 0, y: 0 }),
       isGamepadConnected: () => Boolean(aura.input.gamepad.connected),
       mouse: {
         x: 0,
@@ -4780,8 +4853,18 @@ function createHeadlessAura({ width, height, testState }) {
 
   const gameStateHooks = createGameStateRuntimeHooks({ aura, mode: 'headless' });
   aura.state = {
-    export: (options = {}) => gameStateHooks.exportState(options),
+    schemaVersion: GAME_STATE_SCHEMA_VERSION,
+    export: (options = {}) => {
+      const result = gameStateHooks.exportState(options);
+      return result && result.ok === true ? result.payload : result;
+    },
     apply: (payload, options = {}) => gameStateHooks.applyState(payload, options),
+    diff: (beforePayload, afterPayload) => gameStateHooks.diffState(beforePayload, afterPayload),
+    patch: (payload, patchPayload, options = {}) => gameStateHooks.patchState(payload, patchPayload, options),
+    exportState: (options = {}) => gameStateHooks.exportState(options),
+    applyState: (payload, options = {}) => gameStateHooks.applyState(payload, options),
+    diffState: (beforePayload, afterPayload) => gameStateHooks.diffState(beforePayload, afterPayload),
+    patchState: (payload, patchPayload, options = {}) => gameStateHooks.patchState(payload, patchPayload, options),
   };
 
   return aura;