@auraindustry/aurajs 0.0.5 → 0.0.6

package/src/build-contract.mjs

@@ -14,6 +14,8 @@ import { extname, relative, resolve, sep } from 'node:path';
 export const BUILD_MANIFEST_SCHEMA = 'aurajs.build-manifest.v1';
 export const WEB_BUILD_MANIFEST_SCHEMA = 'aurajs.web-build-manifest.v1';
 export const WEB_RUNTIME_CONFIG_SCHEMA = 'aurajs.web-runtime-config.v1';
+export const WEB_CAPABILITY_DECLARATION_SCHEMA = 'aurajs.web-capability-declaration.v1';
+const PROJECT_CAPABILITY_DECLARATION_FILE = 'aura.capabilities.json';
 
 export function writeBuildManifest(options = {}) {
   const outRoot = resolve(options.outRoot || process.cwd());
@@ -76,9 +78,14 @@ export function writeWebBuildArtifacts(options = {}) {
     outRoot,
   });
 
+  const capabilityDeclaration = readProjectCapabilityDeclaration({
+    projectRoot,
+    modules: options.modules || {},
+  });
   const runtimeConfig = buildRuntimeConfig({
     windowConfig: options.windowConfig || {},
     modules: options.modules || {},
+    capabilityDeclaration,
   });
   const runtimeConfigPath = resolve(outRoot, 'runtime-config.json');
   writeCanonicalJson(runtimeConfigPath, runtimeConfig);
@@ -156,6 +163,13 @@ function buildRuntimeConfig(options = {}) {
   const modules = options.modules && typeof options.modules === 'object'
     ? options.modules
     : {};
+  const capabilityDeclaration = normalizeWebCapabilityDeclaration(
+    options.capabilityDeclaration,
+    normalizeOptionalModules(modules),
+    options.capabilityDeclaration && typeof options.capabilityDeclaration === 'object'
+      ? options.capabilityDeclaration.source || null
+      : null,
+  );
 
   return {
     schema: WEB_RUNTIME_CONFIG_SCHEMA,
@@ -176,9 +190,79 @@ function buildRuntimeConfig(options = {}) {
       network: modules.network === true,
       multiplayer: modules.multiplayer === true,
     },
+    capabilities: capabilityDeclaration,
+  };
+}
+
+function normalizeRequiredApis(entries) {
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  return [...new Set(entries
+    .filter((entry) => typeof entry === 'string')
+    .map((entry) => entry.trim())
+    .filter(Boolean))]
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function normalizeOptionalModules(modules) {
+  const source = modules && typeof modules === 'object' ? modules : {};
+  return {
+    physics: source.physics === true,
+    network: source.network === true || source.net === true,
+    multiplayer: source.multiplayer === true,
+    steam: source.steam === true,
+  };
+}
+
+function normalizeWebCapabilityDeclaration(value, baseModules = {}, source = null) {
+  const declaration = value && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : {};
+  if (
+    declaration.schema != null
+    && declaration.schema !== 'aurajs.create-capabilities.v1'
+    && declaration.schema !== 'aurajs.capability-declaration.v1'
+    && declaration.schema !== WEB_CAPABILITY_DECLARATION_SCHEMA
+  ) {
+    throw new Error(
+      `${source || 'Capability declaration'} must use `
+      + '`aurajs.create-capabilities.v1`, `aurajs.capability-declaration.v1`, '
+      + `or \`${WEB_CAPABILITY_DECLARATION_SCHEMA}\`.`,
+    );
+  }
+
+  const declaredModules = normalizeOptionalModules(declaration.optionalModules);
+  return {
+    schema: WEB_CAPABILITY_DECLARATION_SCHEMA,
+    source,
+    requiredApis: normalizeRequiredApis(declaration.requiredApis),
+    optionalModules: {
+      physics: baseModules.physics || declaredModules.physics,
+      network: baseModules.network || declaredModules.network,
+      multiplayer: baseModules.multiplayer || declaredModules.multiplayer,
+      steam: baseModules.steam || declaredModules.steam,
+    },
   };
 }
 
+function readProjectCapabilityDeclaration({ projectRoot, modules }) {
+  const declarationPath = resolve(projectRoot, PROJECT_CAPABILITY_DECLARATION_FILE);
+  const baseModules = normalizeOptionalModules(modules);
+  if (!existsSync(declarationPath)) {
+    return normalizeWebCapabilityDeclaration({}, baseModules, null);
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(declarationPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Failed to parse ${PROJECT_CAPABILITY_DECLARATION_FILE}: ${error.message}`);
+  }
+
+  return normalizeWebCapabilityDeclaration(parsed, baseModules, PROJECT_CAPABILITY_DECLARATION_FILE);
+}
+
 function emitWebAssets({ projectRoot, outRoot }) {
   const sourceRoot = resolve(projectRoot, 'assets');
   const assetsOutRoot = resolve(outRoot, 'assets');
@@ -203,6 +287,7 @@ function emitWebAssets({ projectRoot, outRoot }) {
     copyFileSync(sourcePath, outputPath);
     entries.push({
       path: `assets/${outputName}`,
+      sourcePath: sourceRelative,
       bytes: sourceBytes.length,
       sha256: contentHash,
       mediaType: mediaTypeForExtension(extension),
@@ -349,6 +434,7 @@ const WEB_LOADER_SOURCE = `
   };
   let cachedManifest = null;
   let cachedRuntimeConfig = null;
+  let cachedRootUrl = '.';
   let mountedRuntime = null;
   let auraRuntime = null;
 
@@ -392,6 +478,33 @@ const WEB_LOADER_SOURCE = `
     return error;
   }
 
+  function createUnsupportedRuntimeError(namespaceName, methodName, reasonCode, details) {
+    const normalizedDetails = details && typeof details === 'object' ? details : {};
+    return createError(
+      reasonCode,
+      'aura.' + namespaceName + '.' + methodName + '() is not supported in browser runtime. [reason:' + reasonCode + ']',
+      'runtime',
+      false,
+      Object.assign(
+        {
+          runtime: 'web',
+          namespace: namespaceName,
+          method: methodName
+        },
+        normalizedDetails
+      )
+    );
+  }
+
+  function createUnsupportedStateResult(methodName, reasonCode) {
+    return {
+      ok: false,
+      reasonCode: reasonCode,
+      detail: 'aura.state.' + methodName + '() is not supported in browser runtime. [reason:' + reasonCode + ']',
+      runtime: 'web'
+    };
+  }
+
   function normalizeError(error, fallbackReasonCode, fallbackMessage, fallbackLayer, fallbackRetryable) {
     if (error && typeof error === 'object' && typeof error.reasonCode === 'string') {
       return error;
@@ -525,6 +638,45 @@ const WEB_LOADER_SOURCE = `
     return numeric;
   }
 
+  function toFinite(value, fallback) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : fallback;
+  }
+
+  function toPositive(value, fallback) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) && numeric > 0 ? numeric : fallback;
+  }
+
+  function clamp01(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) return 1;
+    if (numeric <= 0) return 0;
+    if (numeric >= 1) return 1;
+    return numeric;
+  }
+
+  function isObject(value) {
+    return value != null && typeof value === 'object';
+  }
+
+  function normalizeMouseButton(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric < 0) return 0;
+    return Math.floor(numeric);
+  }
+
+    function sanitizeAssetSourcePath(value) {
+      return String(value || '')
+        .replace(/\\\\/g, '/')
+        .replace(/^\\.\\//, '')
+        .replace(/^\\/+/, '');
+    }
+
+  function isImageMediaType(value) {
+    return typeof value === 'string' && value.startsWith('image/');
+  }
+
   function normalizeTextAlign(value) {
     if (value === 'center' || value === 'right' || value === 'left') {
       return value;
@@ -614,6 +766,122 @@ const WEB_LOADER_SOURCE = `
     }
   }
 
+  function normalizeCapabilityDeclaration(value) {
+    const declaration = value && typeof value === 'object' ? value : {};
+    const requiredApis = Array.isArray(declaration.requiredApis)
+      ? Array.from(new Set(declaration.requiredApis
+        .filter(function (entry) { return typeof entry === 'string'; })
+        .map(function (entry) { return entry.trim(); })
+        .filter(Boolean)))
+        .sort(function (a, b) { return a.localeCompare(b); })
+      : [];
+    const declaredModules = declaration.optionalModules && typeof declaration.optionalModules === 'object'
+      ? declaration.optionalModules
+      : {};
+    return {
+      schema: typeof declaration.schema === 'string'
+        ? declaration.schema
+        : 'aurajs.web-capability-declaration.v1',
+      source: typeof declaration.source === 'string' ? declaration.source : null,
+      requiredApis: requiredApis,
+      optionalModules: {
+        physics: declaredModules.physics === true,
+        network: declaredModules.network === true,
+        multiplayer: declaredModules.multiplayer === true,
+        steam: declaredModules.steam === true
+      }
+    };
+  }
+
+  function resolveDeclaredApi(root, apiPath) {
+    if (typeof apiPath !== 'string' || apiPath.length === 0) {
+      return { found: false, value: undefined };
+    }
+    const segments = apiPath.split('.').filter(Boolean);
+    let current = root;
+    for (const segment of segments) {
+      if (
+        current == null
+        || (typeof current !== 'object' && typeof current !== 'function')
+        || !(segment in current)
+      ) {
+        return { found: false, value: undefined };
+      }
+      current = current[segment];
+    }
+    return { found: current != null, value: current };
+  }
+
+  function collectCapabilityFailures(runtimeConfig, auraRef) {
+    const declaration = normalizeCapabilityDeclaration(runtimeConfig && runtimeConfig.capabilities);
+    const failures = [];
+    const root = { aura: auraRef && typeof auraRef === 'object' ? auraRef : {} };
+
+    for (const moduleName of ['physics', 'network', 'multiplayer', 'steam']) {
+      if (declaration.optionalModules[moduleName] === true) {
+        failures.push({
+          kind: 'optionalModule',
+          module: moduleName,
+          reasonCode: 'web_optional_module_unsupported'
+        });
+      }
+    }
+
+    for (const apiPath of declaration.requiredApis) {
+      const resolved = resolveDeclaredApi(root, apiPath);
+      if (!resolved.found) {
+        failures.push({
+          kind: 'requiredApi',
+          apiPath: apiPath,
+          reasonCode: 'web_required_api_missing'
+        });
+      }
+    }
+
+    return {
+      declaration: declaration,
+      failures: failures
+    };
+  }
+
+  function ensureCapabilityDeclarationSatisfied(runtimeConfig, auraRef) {
+    const report = collectCapabilityFailures(runtimeConfig, auraRef);
+    if (report.failures.length === 0) {
+      return;
+    }
+
+    const missingRequiredApis = [];
+    const unsupportedOptionalModules = [];
+    for (const failure of report.failures) {
+      if (failure.kind === 'requiredApi') {
+        missingRequiredApis.push(failure.apiPath);
+      } else if (failure.kind === 'optionalModule') {
+        unsupportedOptionalModules.push(failure.module);
+      }
+    }
+
+    let reasonCode = 'web_capability_gate_failed';
+    if (missingRequiredApis.length > 0 && unsupportedOptionalModules.length === 0) {
+      reasonCode = 'web_required_api_missing';
+    } else if (unsupportedOptionalModules.length > 0 && missingRequiredApis.length === 0) {
+      reasonCode = 'web_optional_module_unsupported';
+    }
+
+    throw createError(
+      reasonCode,
+      'Browser runtime does not satisfy the declared capability contract.',
+      'loader',
+      false,
+      {
+        schema: report.declaration.schema,
+        source: report.declaration.source,
+        missingRequiredApis: missingRequiredApis,
+        unsupportedOptionalModules: unsupportedOptionalModules,
+        failures: report.failures
+      }
+    );
+  }
+
   function loadScript(path) {
     return new Promise((resolvePromise, rejectPromise) => {
       const script = document.createElement('script');
@@ -633,6 +901,8 @@ const WEB_LOADER_SOURCE = `
     let currentCanvasConfig = currentRuntimeConfig.canvas && typeof currentRuntimeConfig.canvas === 'object'
       ? currentRuntimeConfig.canvas
       : {};
+    let currentManifest = { assets: [] };
+    let currentRootUrl = '.';
 
     const auraRef = globalRef.aura && typeof globalRef.aura === 'object'
       ? globalRef.aura
@@ -644,7 +914,23 @@ const WEB_LOADER_SOURCE = `
       pendingPressed: new Set(),
       pendingReleased: new Set(),
       framePressed: new Set(),
-      frameReleased: new Set()
+      frameReleased: new Set(),
+      mouseDown: new Set(),
+      pendingMousePressed: new Set(),
+      pendingMouseReleased: new Set(),
+      frameMousePressed: new Set(),
+      frameMouseReleased: new Set(),
+      pendingMouseDeltaX: 0,
+      pendingMouseDeltaY: 0,
+      frameMouseDeltaX: 0,
+      frameMouseDeltaY: 0
+    };
+
+    const assetState = {
+      bySourcePath: new Map(),
+      byOutputPath: new Map(),
+      loaded: new Map(),
+      storageFallback: new Map()
     };
 
     const runtime = {
@@ -658,11 +944,19 @@ const WEB_LOADER_SOURCE = `
       width: normalizeCanvasSize(currentCanvasConfig.width, 1280),
       height: normalizeCanvasSize(currentCanvasConfig.height, 720),
       transformDepth: 0,
+      worldTransformActive: false,
+      cursorVisible: true,
+      cursorLocked: false,
       listenersAttached: false,
       keydownListener: null,
       keyupListener: null,
+      focusListener: null,
       blurListener: null,
-      resizeListener: null
+      resizeListener: null,
+      mousemoveListener: null,
+      mousedownListener: null,
+      mouseupListener: null,
+      wheelListener: null
     };
 
     function ensureStyleObject(node) {
@@ -681,6 +975,292 @@ const WEB_LOADER_SOURCE = `
       return runtime.context2d;
     }
 
+    function normalizeAssetKey(value) {
+      return sanitizeAssetSourcePath(value);
+    }
+
+    function indexManifestAssets(manifest, rootUrl) {
+      currentManifest = manifest && typeof manifest === 'object' ? manifest : { assets: [] };
+      currentRootUrl = typeof rootUrl === 'string' && rootUrl.length > 0
+        ? rootUrl.replace(/\\/$/, '')
+        : '.';
+      assetState.bySourcePath.clear();
+      assetState.byOutputPath.clear();
+      const entries = Array.isArray(currentManifest.assets) ? currentManifest.assets : [];
+      for (const entry of entries) {
+        if (!entry || typeof entry !== 'object') continue;
+        const outputPath = normalizePath(entry.path);
+        if (outputPath.length > 0) {
+          assetState.byOutputPath.set(outputPath, entry);
+        }
+        const sourcePath = normalizeAssetKey(entry.sourcePath || outputPath);
+        if (sourcePath.length > 0) {
+          assetState.bySourcePath.set(sourcePath, entry);
+        }
+      }
+    }
+
+    function buildAssetUrl(entryPath) {
+      const normalized = normalizePath(entryPath);
+      const root = currentRootUrl && currentRootUrl.length > 0 ? currentRootUrl : '.';
+      return root + '/' + normalized;
+    }
+
+    function resolveAssetEntry(source) {
+      const normalizedSource = normalizeAssetKey(source);
+      if (normalizedSource.length === 0) return null;
+      if (assetState.bySourcePath.has(normalizedSource)) {
+        return assetState.bySourcePath.get(normalizedSource);
+      }
+      const outputPath = normalizePath(normalizedSource);
+      if (assetState.byOutputPath.has(outputPath)) {
+        return assetState.byOutputPath.get(outputPath);
+      }
+      return null;
+    }
+
+    function resolveAssetSourcePath(source) {
+      if (typeof source === 'string') {
+        return normalizeAssetKey(source);
+      }
+      if (source && typeof source === 'object') {
+        if (typeof source.sourcePath === 'string') return normalizeAssetKey(source.sourcePath);
+        if (typeof source.path === 'string') return normalizeAssetKey(source.path);
+        if (typeof source.name === 'string') return normalizeAssetKey(source.name);
+      }
+      return '';
+    }
+
+    function resolveLoadedAsset(source) {
+      const key = resolveAssetSourcePath(source);
+      if (key.length === 0) return null;
+      return assetState.loaded.get(key) || null;
+    }
+
+    function rememberLoadedAsset(sourcePath, handle) {
+      const key = normalizeAssetKey(sourcePath);
+      if (key.length === 0 || !handle || typeof handle !== 'object') return handle;
+      handle.sourcePath = key;
+      if (typeof handle.path !== 'string' || handle.path.length === 0) {
+        handle.path = key;
+      }
+      assetState.loaded.set(key, handle);
+      return handle;
+    }
+
+    async function fetchAssetResponse(entry) {
+      if (!entry || typeof entry !== 'object') return null;
+      const assetUrl = buildAssetUrl(entry.path);
+      let response;
+      try {
+        response = await fetch(assetUrl, { cache: 'force-cache' });
+      } catch (_) {
+        return null;
+      }
+      if (!response || response.ok !== true) {
+        return null;
+      }
+      return response;
+    }
+
+    async function readAssetBytes(entry) {
+      const response = await fetchAssetResponse(entry);
+      if (!response || typeof response.arrayBuffer !== 'function') {
+        return null;
+      }
+      try {
+        return new Uint8Array(await response.arrayBuffer());
+      } catch (_) {
+        return null;
+      }
+    }
+
+    async function readAssetText(entry) {
+      const response = await fetchAssetResponse(entry);
+      if (!response || typeof response.text !== 'function') {
+        return null;
+      }
+      try {
+        return await response.text();
+      } catch (_) {
+        return null;
+      }
+    }
+
+    async function loadImageHandle(sourcePath, entry) {
+      const existing = resolveLoadedAsset(sourcePath);
+      if (existing && existing.image) {
+        return existing;
+      }
+      const ImageCtor = typeof globalRef.Image === 'function' ? globalRef.Image : null;
+      const handle = existing || {
+        kind: 'image',
+        path: sourcePath,
+        sourcePath: sourcePath,
+        resolvedPath: entry && typeof entry.path === 'string' ? normalizePath(entry.path) : sourcePath,
+        mediaType: entry && typeof entry.mediaType === 'string' ? entry.mediaType : 'image/png',
+        image: null,
+        width: 0,
+        height: 0
+      };
+      if (!ImageCtor || !entry) {
+        return rememberLoadedAsset(sourcePath, handle);
+      }
+      try {
+        const image = await new Promise(function (resolvePromise, rejectPromise) {
+          const node = new ImageCtor();
+          node.onload = function () { resolvePromise(node); };
+          node.onerror = function () { rejectPromise(new Error('image_load_failed')); };
+          node.src = buildAssetUrl(entry.path);
+        });
+        handle.image = image;
+        handle.width = normalizeCanvasSize(image.naturalWidth || image.width, 1);
+        handle.height = normalizeCanvasSize(image.naturalHeight || image.height, 1);
+      } catch (_) {}
+      return rememberLoadedAsset(sourcePath, handle);
+    }
+
+    function createBrowserSoundHandle(sourcePath, entry, bytes) {
+      return rememberLoadedAsset(sourcePath, {
+        kind: 'sound',
+        path: sourcePath,
+        sourcePath: sourcePath,
+        resolvedPath: entry && typeof entry.path === 'string' ? normalizePath(entry.path) : sourcePath,
+        mediaType: entry && typeof entry.mediaType === 'string' ? entry.mediaType : 'audio/ogg',
+        bytes: bytes instanceof Uint8Array ? bytes : new Uint8Array(),
+        playbackSupported: false,
+        reasonCode: 'web_audio_playback_unsupported',
+        detail: 'Browser runtime resolves sound assets but does not support aura.audio playback. [reason:web_audio_playback_unsupported]'
+      });
+    }
+
+    async function loadAssetRecord(source) {
+      if (Array.isArray(source)) {
+        const loaded = [];
+        for (const entry of source) {
+          const next = await loadAssetRecord(entry);
+          if (next) loaded.push(next);
+        }
+        return loaded;
+      }
+      const sourcePath = resolveAssetSourcePath(source);
+      if (sourcePath.length === 0) return null;
+      const existing = resolveLoadedAsset(sourcePath);
+      if (existing) return existing;
+      const entry = resolveAssetEntry(sourcePath);
+      if (!entry) return null;
+      if (isImageMediaType(entry.mediaType)) {
+        return await loadImageHandle(sourcePath, entry);
+      }
+      const bytes = await readAssetBytes(entry);
+      if (entry.mediaType && entry.mediaType.startsWith('audio/')) {
+        return createBrowserSoundHandle(sourcePath, entry, bytes);
+      }
+      if (!bytes) {
+        return rememberLoadedAsset(sourcePath, {
+          kind: 'asset',
+          path: sourcePath,
+          sourcePath: sourcePath,
+          resolvedPath: normalizePath(entry.path),
+          mediaType: entry.mediaType,
+          bytes: new Uint8Array()
+        });
+      }
+      const handle = {
+        kind: 'asset',
+        path: sourcePath,
+        sourcePath: sourcePath,
+        resolvedPath: normalizePath(entry.path),
+        mediaType: entry.mediaType,
+        bytes: bytes
+      };
+      if (entry.mediaType === 'application/json') {
+        const text = typeof TextDecoder === 'function'
+          ? new TextDecoder('utf-8').decode(bytes)
+          : String.fromCharCode.apply(null, Array.from(bytes));
+        handle.text = text;
+        try {
+          handle.json = JSON.parse(text);
+        } catch (_) {
+          handle.json = null;
+        }
+      } else if (typeof entry.mediaType === 'string' && entry.mediaType.startsWith('text/')) {
+        handle.text = typeof TextDecoder === 'function'
+          ? new TextDecoder('utf-8').decode(bytes)
+          : String.fromCharCode.apply(null, Array.from(bytes));
+      }
+      return rememberLoadedAsset(sourcePath, handle);
+    }
+
+    function normalizeMousePosition(event) {
+      const source = event && typeof event === 'object' ? event : {};
+      if (Number.isFinite(Number(source.offsetX)) && Number.isFinite(Number(source.offsetY))) {
+        return {
+          x: Number(source.offsetX),
+          y: Number(source.offsetY)
+        };
+      }
+      const canvas = runtime.canvas;
+      const rect = canvas && typeof canvas.getBoundingClientRect === 'function'
+        ? canvas.getBoundingClientRect()
+        : null;
+      const clientX = toFinite(source.clientX, auraRef.input.mouse.x);
+      const clientY = toFinite(source.clientY, auraRef.input.mouse.y);
+      if (rect) {
+        return {
+          x: clientX - toFinite(rect.left, 0),
+          y: clientY - toFinite(rect.top, 0)
+        };
+      }
+      return {
+        x: clientX,
+        y: clientY
+      };
+    }
+
+    function syncMousePosition(event) {
+      const point = normalizeMousePosition(event);
+      const movementX = Number(event && event.movementX);
+      const movementY = Number(event && event.movementY);
+      const deltaX = Number.isFinite(movementX) ? movementX : point.x - auraRef.input.mouse.x;
+      const deltaY = Number.isFinite(movementY) ? movementY : point.y - auraRef.input.mouse.y;
+      inputState.pendingMouseDeltaX += deltaX;
+      inputState.pendingMouseDeltaY += deltaY;
+      auraRef.input.mouse.x = point.x;
+      auraRef.input.mouse.y = point.y;
+    }
+
+    function clearMouseDeltaState() {
+      inputState.pendingMouseDeltaX = 0;
+      inputState.pendingMouseDeltaY = 0;
+      inputState.frameMouseDeltaX = 0;
+      inputState.frameMouseDeltaY = 0;
+    }
+
+    function clearTransientInputState() {
+      inputState.pendingPressed.clear();
+      inputState.pendingReleased.clear();
+      inputState.framePressed.clear();
+      inputState.frameReleased.clear();
+      inputState.pendingMousePressed.clear();
+      inputState.pendingMouseReleased.clear();
+      inputState.frameMousePressed.clear();
+      inputState.frameMouseReleased.clear();
+      clearMouseDeltaState();
+    }
+
+    function clearHeldInputState() {
+      inputState.down.clear();
+      inputState.mouseDown.clear();
+      clearTransientInputState();
+    }
+
+    function applyCursorAppearance() {
+      const style = ensureStyleObject(runtime.canvas);
+      if (!style) return;
+      style.cursor = (!runtime.cursorVisible || runtime.cursorLocked) ? 'none' : 'default';
+    }
+
     function syncCanvasSize(notifyResize) {
       let width = runtime.configuredWidth;
       let height = runtime.configuredHeight;
@@ -736,11 +1316,54 @@ const WEB_LOADER_SOURCE = `
         }
       }
       runtime.transformDepth = 0;
+      runtime.worldTransformActive = false;
       ctx.globalAlpha = 1;
       ctx.textAlign = 'left';
       ctx.textBaseline = 'top';
     }
 
+    function applyWorldTransform() {
+      const ctx = ensureCanvasContext();
+      if (!ctx || runtime.worldTransformActive) return ctx;
+      const camera = auraRef.camera && typeof auraRef.camera === 'object' ? auraRef.camera : null;
+      if (camera) {
+        const zoom = normalizePositiveNumber(camera.zoom, 1);
+        const rotation = Number(camera.rotation) || 0;
+        const x = Number(camera.x) || 0;
+        const y = Number(camera.y) || 0;
+        if (typeof ctx.scale === 'function' && zoom !== 1) {
+          ctx.scale(zoom, zoom);
+        }
+        if (typeof ctx.rotate === 'function' && rotation !== 0) {
+          ctx.rotate(rotation);
+        }
+        if (typeof ctx.translate === 'function' && (x !== 0 || y !== 0)) {
+          ctx.translate(-x, -y);
+        }
+      }
+      runtime.worldTransformActive = true;
+      return ctx;
+    }
+
+    function ensureWorldTransform() {
+      const ctx = ensureCanvasContext();
+      if (!ctx) return null;
+      return runtime.worldTransformActive ? ctx : applyWorldTransform();
+    }
+
+    function normalizeTextOptions(sizeOrOptions, colorMaybe) {
+      if (sizeOrOptions && typeof sizeOrOptions === 'object' && !Array.isArray(sizeOrOptions)) {
+        return sizeOrOptions;
+      }
+      if (Number.isFinite(Number(sizeOrOptions))) {
+        return {
+          size: Number(sizeOrOptions),
+          color: colorMaybe
+        };
+      }
+      return {};
+    }
+
     function applyFont(options) {
       const ctx = ensureCanvasContext();
       const source = options && typeof options === 'object' ? options : {};
@@ -756,6 +1379,505 @@ const WEB_LOADER_SOURCE = `
       return { size, align: normalizeTextAlign(source.align) };
     }
 
+    function withScreenSpace(callback) {
+      const ctx = ensureCanvasContext();
+      if (!ctx || typeof callback !== 'function') return null;
+      if (typeof ctx.save === 'function') {
+        ctx.save();
+      }
+      if (typeof ctx.setTransform === 'function') {
+        ctx.setTransform(runtime.pixelRatio, 0, 0, runtime.pixelRatio, 0, 0);
+      } else {
+        if (typeof ctx.resetTransform === 'function') {
+          ctx.resetTransform();
+        }
+        if (typeof ctx.scale === 'function') {
+          ctx.scale(runtime.pixelRatio, runtime.pixelRatio);
+        }
+      }
+      try {
+        return callback(ctx);
+      } finally {
+        if (typeof ctx.restore === 'function') {
+          ctx.restore();
+        }
+      }
+    }
+
+    function resolveStorageBackend() {
+      return globalRef.localStorage && typeof globalRef.localStorage.getItem === 'function'
+        ? globalRef.localStorage
+        : null;
+    }
+
+    function storageKey(key) {
+      return 'aurajs:' + String(key || '');
+    }
+
+    function readStorage(key) {
+      const normalizedKey = String(key || '');
+      if (normalizedKey.length === 0) return null;
+      const backend = resolveStorageBackend();
+      const namespaced = storageKey(normalizedKey);
+      let raw = null;
+      if (backend) {
+        try {
+          raw = backend.getItem(namespaced);
+        } catch (_) {
+          raw = null;
+        }
+      } else if (assetState.storageFallback.has(namespaced)) {
+        raw = assetState.storageFallback.get(namespaced);
+      }
+      if (raw == null) return null;
+      try {
+        return JSON.parse(raw);
+      } catch (_) {
+        return raw;
+      }
+    }
+
+    function writeStorage(key, value) {
+      const normalizedKey = String(key || '');
+      if (normalizedKey.length === 0) return false;
+      const payload = JSON.stringify(value);
+      const backend = resolveStorageBackend();
+      const namespaced = storageKey(normalizedKey);
+      if (backend) {
+        try {
+          backend.setItem(namespaced, payload);
+          return true;
+        } catch (_) {
+          return false;
+        }
+      }
+      assetState.storageFallback.set(namespaced, payload);
+      return true;
+    }
+
+    function deleteStorage(key) {
+      const normalizedKey = String(key || '');
+      if (normalizedKey.length === 0) return false;
+      const namespaced = storageKey(normalizedKey);
+      const backend = resolveStorageBackend();
+      if (backend) {
+        try {
+          backend.removeItem(namespaced);
+          return true;
+        } catch (_) {
+          return false;
+        }
+      }
+      return assetState.storageFallback.delete(namespaced);
+    }
+
+    const camera = auraRef.camera && typeof auraRef.camera === 'object' ? auraRef.camera : {};
+    let cameraBaseX = Number(camera.x) || 0;
+    let cameraBaseY = Number(camera.y) || 0;
+    let cameraBaseZoom = normalizePositiveNumber(camera.zoom, 1);
+    let cameraBaseRotation = Number(camera.rotation) || 0;
+    let cameraShakeX = 0;
+    let cameraShakeY = 0;
+    let cameraFollowState = null;
+    let cameraDeadzone = null;
+    let cameraBounds = null;
+    let nextCameraEffectId = 1;
+    let nextCameraListenerId = 1;
+    const cameraEffects = [];
+    const cameraEffectListeners = [];
+
+    function applyCameraBounds() {
+      if (!cameraBounds) return;
+      const maxX = cameraBounds.x + cameraBounds.width;
+      const maxY = cameraBounds.y + cameraBounds.height;
+      cameraBaseX = Math.max(cameraBounds.x, Math.min(cameraBaseX, maxX));
+      cameraBaseY = Math.max(cameraBounds.y, Math.min(cameraBaseY, maxY));
+    }
+
+    function normalizeFollowOptions(options) {
+      if (options == null) {
+        return {
+          lerpX: 1,
+          lerpY: 1,
+          offsetX: 0,
+          offsetY: 0
+        };
+      }
+      if (!isObject(options)) return null;
+      return {
+        lerpX: clamp01(options.lerpX),
+        lerpY: clamp01(options.lerpY),
+        offsetX: toFinite(options.offsetX, 0),
+        offsetY: toFinite(options.offsetY, 0)
+      };
+    }
+
+    function normalizeDeadzone(value) {
+      const input = isObject(value) ? value : null;
+      const zoneWidth = toFinite(input && input.width, Number.NaN);
+      const zoneHeight = toFinite(input && input.height, Number.NaN);
+      if (!(zoneWidth > 0) || !(zoneHeight > 0)) return null;
+      return {
+        x: toFinite(input && input.x, 0),
+        y: toFinite(input && input.y, 0),
+        width: zoneWidth,
+        height: zoneHeight
+      };
+    }
+
+    function normalizeBounds(value) {
+      const input = isObject(value) ? value : null;
+      const zoneWidth = toFinite(input && input.width, Number.NaN);
+      const zoneHeight = toFinite(input && input.height, Number.NaN);
+      if (!(zoneWidth >= 0) || !(zoneHeight >= 0)) return null;
+      return {
+        x: toFinite(input && input.x, 0),
+        y: toFinite(input && input.y, 0),
+        width: zoneWidth,
+        height: zoneHeight
+      };
+    }
+
+    function resolveFollowTarget(target) {
+      let source = target;
+      if (typeof source === 'function') {
+        try {
+          source = source();
+        } catch (_) {
+          return null;
+        }
+      }
+      if (!isObject(source)) return null;
+      const x = toFinite(source.x, Number.NaN);
+      const y = toFinite(source.y, Number.NaN);
+      if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+      return { x: x, y: y };
+    }
+
+    function emitCameraEffectEvent(event) {
+      if (cameraEffectListeners.length === 0) return;
+      const ordered = cameraEffectListeners.slice().sort(function (a, b) {
+        return (a.order - b.order) || (a.id - b.id);
+      });
+      for (const listener of ordered) {
+        try {
+          listener.callback(event);
+        } catch (_) {}
+      }
+    }
+
+    Object.defineProperties(camera, {
+      x: {
+        enumerable: true,
+        configurable: false,
+        get: function () { return cameraBaseX + cameraShakeX; },
+        set: function (value) {
+          const numeric = Number(value);
+          if (Number.isFinite(numeric)) cameraBaseX = numeric;
+        }
+      },
+      y: {
+        enumerable: true,
+        configurable: false,
+        get: function () { return cameraBaseY + cameraShakeY; },
+        set: function (value) {
+          const numeric = Number(value);
+          if (Number.isFinite(numeric)) cameraBaseY = numeric;
+        }
+      },
+      zoom: {
+        enumerable: true,
+        configurable: false,
+        get: function () { return cameraBaseZoom; },
+        set: function (value) {
+          const numeric = Number(value);
+          if (Number.isFinite(numeric) && numeric > 0) cameraBaseZoom = numeric;
+        }
+      },
+      rotation: {
+        enumerable: true,
+        configurable: false,
+        get: function () { return cameraBaseRotation; },
+        set: function (value) {
+          const numeric = Number(value);
+          if (Number.isFinite(numeric)) cameraBaseRotation = numeric;
+        }
+      }
+    });
+
+    camera.getState = function () {
+      return {
+        x: cameraBaseX + cameraShakeX,
+        y: cameraBaseY + cameraShakeY,
+        zoom: cameraBaseZoom,
+        rotation: cameraBaseRotation,
+        following: !!cameraFollowState,
+        activeEffects: cameraEffects.length,
+        deadzone: cameraDeadzone ? { x: cameraDeadzone.x, y: cameraDeadzone.y, width: cameraDeadzone.width, height: cameraDeadzone.height } : null,
+        bounds: cameraBounds ? { x: cameraBounds.x, y: cameraBounds.y, width: cameraBounds.width, height: cameraBounds.height } : null
+      };
+    };
+
+    camera.follow = function (target, options) {
+      if (!(typeof target === 'function' || isObject(target))) {
+        return { ok: false, reasonCode: 'invalid_follow_target' };
+      }
+      const normalized = normalizeFollowOptions(options);
+      if (!normalized) return { ok: false, reasonCode: 'invalid_follow_options' };
+      cameraFollowState = {
+        target: target,
+        lerpX: normalized.lerpX,
+        lerpY: normalized.lerpY,
+        offsetX: normalized.offsetX,
+        offsetY: normalized.offsetY
+      };
+      return { ok: true, reasonCode: 'camera_follow_started' };
+    };
+
+    camera.stopFollow = function () {
+      const stopped = !!cameraFollowState;
+      cameraFollowState = null;
+      return { ok: true, stopped: stopped, reasonCode: 'camera_follow_stopped' };
+    };
+
+    camera.setDeadzone = function (value, maybeHeight) {
+      const normalized = isObject(value)
+        ? normalizeDeadzone(value)
+        : normalizeDeadzone({ width: value, height: maybeHeight });
+      if (!normalized) return { ok: false, reasonCode: 'invalid_deadzone' };
+      cameraDeadzone = normalized;
+      return { ok: true, reasonCode: 'camera_deadzone_set' };
+    };
+
+    camera.clearDeadzone = function () {
+      cameraDeadzone = null;
+      return { ok: true, reasonCode: 'camera_deadzone_cleared' };
+    };
+
+    camera.setBounds = function (xOrBounds, y, boundsWidth, boundsHeight) {
+      const normalized = isObject(xOrBounds)
+        ? normalizeBounds(xOrBounds)
+        : normalizeBounds({ x: xOrBounds, y: y, width: boundsWidth, height: boundsHeight });
+      if (!normalized) return { ok: false, reasonCode: 'invalid_bounds' };
+      cameraBounds = normalized;
+      applyCameraBounds();
+      return { ok: true, reasonCode: 'camera_bounds_set' };
+    };
+
+    camera.clearBounds = function () {
+      cameraBounds = null;
+      return { ok: true, reasonCode: 'camera_bounds_cleared' };
+    };
+
+    camera.pan = function (x, y, options) {
+      const targetX = Number(x);
+      const targetY = Number(y);
+      if (!Number.isFinite(targetX) || !Number.isFinite(targetY)) {
+        return { ok: false, reasonCode: 'invalid_pan_target' };
+      }
+      if (options != null && !isObject(options)) return { ok: false, reasonCode: 'invalid_pan_options' };
+      const duration = toPositive(options && options.duration, 0.25);
+      if (!(duration > 0)) return { ok: false, reasonCode: 'invalid_pan_duration' };
+      const effectId = nextCameraEffectId++;
+      cameraEffects.push({
+        id: effectId,
+        type: 'pan',
+        duration: duration,
+        elapsed: 0,
+        startX: cameraBaseX,
+        startY: cameraBaseY,
+        targetX: targetX,
+        targetY: targetY
+      });
+      return { ok: true, effectId: effectId, reasonCode: 'camera_pan_started' };
+    };
+    camera.panTo = camera.pan;
+
+    camera.zoomTo = function (value, options) {
+      const targetZoom = Number(value);
+      if (!Number.isFinite(targetZoom) || !(targetZoom > 0)) {
+        return { ok: false, reasonCode: 'invalid_zoom_target' };
+      }
+      if (options != null && !isObject(options)) return { ok: false, reasonCode: 'invalid_zoom_options' };
+      const duration = toPositive(options && options.duration, 0.25);
+      if (!(duration > 0)) return { ok: false, reasonCode: 'invalid_zoom_duration' };
+      const effectId = nextCameraEffectId++;
+      cameraEffects.push({
+        id: effectId,
+        type: 'zoom',
+        duration: duration,
+        elapsed: 0,
+        startZoom: cameraBaseZoom,
+        targetZoom: targetZoom
+      });
+      return { ok: true, effectId: effectId, reasonCode: 'camera_zoom_started' };
+    };
+
+    camera.rotateTo = function (value, options) {
+      const targetRotation = Number(value);
+      if (!Number.isFinite(targetRotation)) {
+        return { ok: false, reasonCode: 'invalid_rotation_target' };
+      }
+      if (options != null && !isObject(options)) return { ok: false, reasonCode: 'invalid_rotation_options' };
+      const duration = toPositive(options && options.duration, 0.25);
+      if (!(duration > 0)) return { ok: false, reasonCode: 'invalid_rotation_duration' };
+      const effectId = nextCameraEffectId++;
+      cameraEffects.push({
+        id: effectId,
+        type: 'rotate',
+        duration: duration,
+        elapsed: 0,
+        startRotation: cameraBaseRotation,
+        targetRotation: targetRotation
+      });
+      return { ok: true, effectId: effectId, reasonCode: 'camera_rotation_started' };
+    };
+
+    camera.shake = function (options) {
+      const source = options == null ? {} : options;
+      if (!isObject(source)) return { ok: false, reasonCode: 'invalid_shake_options' };
+      const sharedIntensity = Number.isFinite(Number(source.intensity))
+        ? Number(source.intensity)
+        : null;
+      const intensityX = toFinite(source.intensityX, sharedIntensity != null ? sharedIntensity : 6);
+      const intensityY = toFinite(source.intensityY, sharedIntensity != null ? sharedIntensity : 6);
+      if (!(intensityX >= 0) || !(intensityY >= 0)) {
+        return { ok: false, reasonCode: 'invalid_shake_intensity' };
+      }
+      const duration = toPositive(source.duration, 0.3);
+      if (!(duration > 0)) return { ok: false, reasonCode: 'invalid_shake_duration' };
+      const frequency = toPositive(source.frequency, 30);
+      if (!(frequency > 0)) return { ok: false, reasonCode: 'invalid_shake_frequency' };
+      const effectId = nextCameraEffectId++;
+      cameraEffects.push({
+        id: effectId,
+        type: 'shake',
+        duration: duration,
+        elapsed: 0,
+        intensityX: intensityX,
+        intensityY: intensityY,
+        frequency: frequency,
+        seed: effectId * 0.61803398875
+      });
+      return { ok: true, effectId: effectId, reasonCode: 'camera_shake_started' };
+    };
+
+    camera.clearEffects = function () {
+      const cleared = cameraEffects.length;
+      cameraEffects.length = 0;
+      cameraShakeX = 0;
+      cameraShakeY = 0;
+      return { ok: true, cleared: cleared, reasonCode: 'camera_effects_cleared' };
+    };
+
+    camera.onEffectComplete = function (callback, order) {
+      if (typeof callback !== 'function') {
+        return { ok: false, reasonCode: 'invalid_effect_callback' };
+      }
+      const listener = {
+        id: nextCameraListenerId++,
+        callback: callback,
+        order: Number.isFinite(Number(order)) ? Number(order) : 0
+      };
+      cameraEffectListeners.push(listener);
+      return { ok: true, listenerId: listener.id, reasonCode: 'camera_effect_listener_registered' };
+    };
+
+    camera.offEffectComplete = function (listenerId) {
+      if (!Number.isInteger(listenerId) || listenerId <= 0) return false;
+      const index = cameraEffectListeners.findIndex(function (entry) {
+        return entry.id === listenerId;
+      });
+      if (index < 0) return false;
+      cameraEffectListeners.splice(index, 1);
+      return true;
+    };
+
+    camera.update = function (dt) {
+      const delta = Number(dt);
+      if (!Number.isFinite(delta) || !(delta > 0)) {
+        return { ok: false, reasonCode: 'invalid_dt' };
+      }
+
+      cameraShakeX = 0;
+      cameraShakeY = 0;
+
+      if (cameraFollowState) {
+        const targetPoint = resolveFollowTarget(cameraFollowState.target);
+        if (targetPoint) {
+          let targetX = targetPoint.x + cameraFollowState.offsetX;
+          let targetY = targetPoint.y + cameraFollowState.offsetY;
+
+          if (cameraDeadzone) {
+            const left = cameraBaseX + cameraDeadzone.x;
+            const right = left + cameraDeadzone.width;
+            const top = cameraBaseY + cameraDeadzone.y;
+            const bottom = top + cameraDeadzone.height;
+
+            if (targetX < left) targetX = targetX - cameraDeadzone.x;
+            else if (targetX > right) targetX = targetX - cameraDeadzone.x - cameraDeadzone.width;
+            else targetX = cameraBaseX;
+
+            if (targetY < top) targetY = targetY - cameraDeadzone.y;
+            else if (targetY > bottom) targetY = targetY - cameraDeadzone.y - cameraDeadzone.height;
+            else targetY = cameraBaseY;
+          }
+
+          cameraBaseX += (targetX - cameraBaseX) * cameraFollowState.lerpX;
+          cameraBaseY += (targetY - cameraBaseY) * cameraFollowState.lerpY;
+        }
+      }
+
+      const completedEffects = [];
+      for (const effect of cameraEffects) {
+        effect.elapsed += delta;
+        const progress = effect.duration <= 0 ? 1 : Math.min(effect.elapsed / effect.duration, 1);
+        if (effect.type === 'pan') {
+          cameraBaseX = effect.startX + ((effect.targetX - effect.startX) * progress);
+          cameraBaseY = effect.startY + ((effect.targetY - effect.startY) * progress);
+        } else if (effect.type === 'zoom') {
+          cameraBaseZoom = effect.startZoom + ((effect.targetZoom - effect.startZoom) * progress);
+        } else if (effect.type === 'rotate') {
+          cameraBaseRotation = effect.startRotation + ((effect.targetRotation - effect.startRotation) * progress);
+        } else if (effect.type === 'shake') {
+          const amplitude = 1 - progress;
+          const angle = (effect.seed + (effect.elapsed * effect.frequency)) * 6.283185307179586;
+          cameraShakeX += Math.sin(angle) * effect.intensityX * amplitude;
+          cameraShakeY += Math.cos(angle * 1.17) * effect.intensityY * amplitude;
+        }
+        if (progress >= 1) completedEffects.push(effect);
+      }
+
+      if (completedEffects.length > 0) {
+        for (const completed of completedEffects) {
+          const index = cameraEffects.indexOf(completed);
+          if (index >= 0) cameraEffects.splice(index, 1);
+        }
+        completedEffects.sort(function (a, b) { return a.id - b.id; });
+        for (const completed of completedEffects) {
+          emitCameraEffectEvent({
+            type: 'effect_complete',
+            effectType: completed.type,
+            effectId: completed.id,
+            reasonCode: 'camera_effect_complete'
+          });
+        }
+      }
+
+      applyCameraBounds();
+
+      return {
+        ok: true,
+        reasonCode: 'camera_updated',
+        x: cameraBaseX + cameraShakeX,
+        y: cameraBaseY + cameraShakeY,
+        zoom: cameraBaseZoom,
+        rotation: cameraBaseRotation,
+        following: !!cameraFollowState,
+        activeEffects: cameraEffects.length
+      };
+    };
+
     function attachListeners() {
       if (runtime.listenersAttached) return;
       runtime.listenersAttached = true;
@@ -782,12 +1904,44 @@ const WEB_LOADER_SOURCE = `
         }
       };
 
+      runtime.mousemoveListener = function (event) {
+        syncMousePosition(event);
+      };
+
+      runtime.mousedownListener = function (event) {
+        syncMousePosition(event);
+        const button = normalizeMouseButton(event && event.button);
+        if (!inputState.mouseDown.has(button)) {
+          inputState.pendingMousePressed.add(button);
+        }
+        inputState.mouseDown.add(button);
+      };
+
+      runtime.mouseupListener = function (event) {
+        syncMousePosition(event);
+        const button = normalizeMouseButton(event && event.button);
+        inputState.mouseDown.delete(button);
+        inputState.pendingMouseReleased.add(button);
+      };
+
+      runtime.wheelListener = function (event) {
+        if (event && Number.isFinite(Number(event.deltaY))) {
+          auraRef.input.mouse.scroll += Number(event.deltaY);
+        }
+      };
+
+      runtime.focusListener = function () {
+        clearMouseDeltaState();
+        if (typeof auraRef.onFocus === 'function') {
+          auraRef.onFocus();
+        }
+      };
+
       runtime.blurListener = function () {
-        inputState.down.clear();
-        inputState.pendingPressed.clear();
-        inputState.pendingReleased.clear();
-        inputState.framePressed.clear();
-        inputState.frameReleased.clear();
+        clearHeldInputState();
+        if (typeof auraRef.onBlur === 'function') {
+          auraRef.onBlur();
+        }
       };
 
       runtime.resizeListener = function () {
@@ -797,6 +1951,11 @@ const WEB_LOADER_SOURCE = `
       if (typeof globalRef.addEventListener === 'function') {
         globalRef.addEventListener('keydown', runtime.keydownListener);
         globalRef.addEventListener('keyup', runtime.keyupListener);
+        globalRef.addEventListener('focus', runtime.focusListener);
+        globalRef.addEventListener('mousemove', runtime.mousemoveListener);
+        globalRef.addEventListener('mousedown', runtime.mousedownListener);
+        globalRef.addEventListener('mouseup', runtime.mouseupListener);
+        globalRef.addEventListener('wheel', runtime.wheelListener);
         globalRef.addEventListener('blur', runtime.blurListener);
         globalRef.addEventListener('resize', runtime.resizeListener);
       }
@@ -808,6 +1967,11 @@ const WEB_LOADER_SOURCE = `
       if (typeof globalRef.removeEventListener === 'function') {
         globalRef.removeEventListener('keydown', runtime.keydownListener);
         globalRef.removeEventListener('keyup', runtime.keyupListener);
+        globalRef.removeEventListener('focus', runtime.focusListener);
+        globalRef.removeEventListener('mousemove', runtime.mousemoveListener);
+        globalRef.removeEventListener('mousedown', runtime.mousedownListener);
+        globalRef.removeEventListener('mouseup', runtime.mouseupListener);
+        globalRef.removeEventListener('wheel', runtime.wheelListener);
         globalRef.removeEventListener('blur', runtime.blurListener);
         globalRef.removeEventListener('resize', runtime.resizeListener);
       }
@@ -824,6 +1988,9 @@ const WEB_LOADER_SOURCE = `
     auraRef.rgba = function (r, g, b, a) {
       return createUnitColor(r, g, b, a == null ? 1 : a);
     };
+    auraRef.rgb = function (r, g, b) {
+      return createUnitColor(r, g, b, 1);
+    };
     auraRef.color = auraRef.rgba;
     auraRef.Color = auraRef.Color && typeof auraRef.Color === 'object'
       ? auraRef.Color
@@ -844,6 +2011,19 @@ const WEB_LOADER_SOURCE = `
         transparent: createByteColor(0, 0, 0, 0)
       };
 
+    auraRef.math = auraRef.math && typeof auraRef.math === 'object' ? auraRef.math : {};
+    auraRef.math.clamp = typeof auraRef.math.clamp === 'function'
+      ? auraRef.math.clamp
+      : function (value, min, max) {
+        const numeric = Number(value);
+        const minValue = Number(min);
+        const maxValue = Number(max);
+        if (!Number.isFinite(numeric) || !Number.isFinite(minValue) || !Number.isFinite(maxValue)) {
+          return Number.isFinite(numeric) ? numeric : 0;
+        }
+        return Math.min(maxValue, Math.max(minValue, numeric));
+      };
+
     auraRef.window = auraRef.window && typeof auraRef.window === 'object' ? auraRef.window : {};
     auraRef.window.width = runtime.width;
     auraRef.window.height = runtime.height;
@@ -864,6 +2044,26 @@ const WEB_LOADER_SOURCE = `
     auraRef.window.setFullscreen = function () {
       return false;
     };
+    auraRef.window.setCursorVisible = function (visible) {
+      runtime.cursorVisible = !!visible;
+      applyCursorAppearance();
+      return true;
+    };
+    auraRef.window.setCursorLocked = function (locked) {
+      runtime.cursorLocked = !!locked;
+      clearMouseDeltaState();
+      applyCursorAppearance();
+      if (runtime.canvas && typeof runtime.canvas.requestPointerLock === 'function' && runtime.cursorLocked) {
+        runtime.canvas.requestPointerLock();
+      } else if (
+        !runtime.cursorLocked &&
+        globalRef.document &&
+        typeof globalRef.document.exitPointerLock === 'function'
+      ) {
+        globalRef.document.exitPointerLock();
+      }
+      return true;
+    };
     auraRef.window.getSize = function () {
       return { width: runtime.width, height: runtime.height };
     };
@@ -884,6 +2084,8 @@ const WEB_LOADER_SOURCE = `
     auraRef.collide = auraRef.collide && typeof auraRef.collide === 'object' ? auraRef.collide : auraRef.collision;
     auraRef.collide.rectRect = auraRef.collision.rectRect;
 
+    auraRef.camera = camera;
+
     auraRef.input = auraRef.input && typeof auraRef.input === 'object' ? auraRef.input : {};
     auraRef.input.isDown = function (name) {
       const key = normalizeKeyName(name);
@@ -906,39 +2108,390 @@ const WEB_LOADER_SOURCE = `
     auraRef.input.isKeyReleased = function (name) {
       return auraRef.input.isReleased(name);
     };
+    auraRef.input.isGamepadConnected = typeof auraRef.input.isGamepadConnected === 'function'
+      ? auraRef.input.isGamepadConnected
+      : function () { return false; };
     auraRef.input.mouse = auraRef.input.mouse && typeof auraRef.input.mouse === 'object' ? auraRef.input.mouse : {};
     auraRef.input.mouse.x = Number(auraRef.input.mouse.x) || 0;
     auraRef.input.mouse.y = Number(auraRef.input.mouse.y) || 0;
     auraRef.input.mouse.scroll = Number(auraRef.input.mouse.scroll) || 0;
-    auraRef.input.mouse.isDown = function () { return false; };
-    auraRef.input.mouse.isPressed = function () { return false; };
-    auraRef.input.mouse.isReleased = function () { return false; };
+    auraRef.input.mouse.isDown = function (button) {
+      return inputState.mouseDown.has(normalizeMouseButton(button));
+    };
+    auraRef.input.mouse.isPressed = function (button) {
+      return inputState.frameMousePressed.has(normalizeMouseButton(button));
+    };
+    auraRef.input.mouse.isReleased = function (button) {
+      return inputState.frameMouseReleased.has(normalizeMouseButton(button));
+    };
+    auraRef.input.isMouseDown = function (button) {
+      return auraRef.input.mouse.isDown(button);
+    };
+    auraRef.input.isMousePressed = function (button) {
+      return auraRef.input.mouse.isPressed(button);
+    };
+    auraRef.input.isMouseReleased = function (button) {
+      return auraRef.input.mouse.isReleased(button);
+    };
     auraRef.input.getMousePosition = function () {
       return { x: auraRef.input.mouse.x, y: auraRef.input.mouse.y };
     };
+    auraRef.input.getMouseDelta = function () {
+      return { x: inputState.frameMouseDeltaX, y: inputState.frameMouseDeltaY };
+    };
+
+    auraRef.state = auraRef.state && typeof auraRef.state === 'object' ? auraRef.state : {};
+    auraRef.state.export = typeof auraRef.state.export === 'function'
+      ? auraRef.state.export
+      : function () {
+        return createUnsupportedStateResult('export', 'web_state_export_unsupported');
+      };
+    auraRef.state.apply = typeof auraRef.state.apply === 'function'
+      ? auraRef.state.apply
+      : function () {
+        return createUnsupportedStateResult('apply', 'web_state_apply_unsupported');
+      };
+    auraRef.state.diff = typeof auraRef.state.diff === 'function'
+      ? auraRef.state.diff
+      : function () {
+        return createUnsupportedStateResult('diff', 'web_state_diff_unsupported');
+      };
+    auraRef.state.patch = typeof auraRef.state.patch === 'function'
+      ? auraRef.state.patch
+      : function () {
+        return createUnsupportedStateResult('patch', 'web_state_patch_unsupported');
+      };
+    auraRef.state.exportState = typeof auraRef.state.exportState === 'function'
+      ? auraRef.state.exportState
+      : function (options) {
+        return auraRef.state.export(options);
+      };
+    auraRef.state.applyState = typeof auraRef.state.applyState === 'function'
+      ? auraRef.state.applyState
+      : function (payload, options) {
+        return auraRef.state.apply(payload, options);
+      };
+    auraRef.state.diffState = typeof auraRef.state.diffState === 'function'
+      ? auraRef.state.diffState
+      : function (beforePayload, afterPayload) {
+        return auraRef.state.diff(beforePayload, afterPayload);
+      };
+    auraRef.state.patchState = typeof auraRef.state.patchState === 'function'
+      ? auraRef.state.patchState
+      : function (payload, patchPayload, options) {
+        return auraRef.state.patch(payload, patchPayload, options);
+      };
+
+    auraRef.net = auraRef.net && typeof auraRef.net === 'object' ? auraRef.net : {};
+    auraRef.net.connect = typeof auraRef.net.connect === 'function'
+      ? auraRef.net.connect
+      : function () {
+        throw createUnsupportedRuntimeError('net', 'connect', 'web_net_connect_unsupported');
+      };
+    auraRef.net.websocket = typeof auraRef.net.websocket === 'function'
+      ? auraRef.net.websocket
+      : function () {
+        throw createUnsupportedRuntimeError('net', 'websocket', 'web_net_websocket_unsupported');
+      };
+    auraRef.net.fetch = typeof auraRef.net.fetch === 'function'
+      ? auraRef.net.fetch
+      : function () {
+        throw createUnsupportedRuntimeError('net', 'fetch', 'web_net_fetch_unsupported');
+      };
+    auraRef.net.get = typeof auraRef.net.get === 'function'
+      ? auraRef.net.get
+      : function () {
+        throw createUnsupportedRuntimeError('net', 'get', 'web_net_get_unsupported');
+      };
+    auraRef.net.post = typeof auraRef.net.post === 'function'
+      ? auraRef.net.post
+      : function () {
+        throw createUnsupportedRuntimeError('net', 'post', 'web_net_post_unsupported');
+      };
+
+    auraRef.storage = auraRef.storage && typeof auraRef.storage === 'object' ? auraRef.storage : {};
+    auraRef.storage.save = typeof auraRef.storage.save === 'function'
+      ? auraRef.storage.save
+      : function (key, value) { return writeStorage(key, value); };
+    auraRef.storage.load = typeof auraRef.storage.load === 'function'
+      ? auraRef.storage.load
+      : function (key) { return readStorage(key); };
+    auraRef.storage.delete = typeof auraRef.storage.delete === 'function'
+      ? auraRef.storage.delete
+      : function (key) { return deleteStorage(key); };
+    auraRef.storage.keys = typeof auraRef.storage.keys === 'function'
+      ? auraRef.storage.keys
+      : function () {
+        const prefix = 'aurajs:';
+        const backend = resolveStorageBackend();
+        const keys = [];
+        if (backend && Number.isInteger(backend.length) && typeof backend.key === 'function') {
+          for (let index = 0; index < backend.length; index += 1) {
+            const nextKey = backend.key(index);
+            if (typeof nextKey === 'string' && nextKey.startsWith(prefix)) {
+              keys.push(nextKey.slice(prefix.length));
+            }
+          }
+          keys.sort(function (a, b) { return a.localeCompare(b); });
+          return keys;
+        }
+        for (const key of assetState.storageFallback.keys()) {
+          if (key.startsWith(prefix)) {
+            keys.push(key.slice(prefix.length));
+          }
+        }
+        keys.sort(function (a, b) { return a.localeCompare(b); });
+        return keys;
+      };
+    auraRef.storage.set = typeof auraRef.storage.set === 'function'
+      ? auraRef.storage.set
+      : function (key, value) { return writeStorage(key, value); };
+    auraRef.storage.get = typeof auraRef.storage.get === 'function'
+      ? auraRef.storage.get
+      : function (key, fallback) {
+        const value = readStorage(key);
+        return value == null ? fallback : value;
+      };
+
+    auraRef.audio = auraRef.audio && typeof auraRef.audio === 'object' ? auraRef.audio : {};
+    if (auraRef.audio.supported !== true) {
+      auraRef.audio.supported = false;
+    }
+    if (typeof auraRef.audio.reasonCode !== 'string') {
+      auraRef.audio.reasonCode = 'web_audio_playback_unsupported';
+    }
+    if (typeof auraRef.audio.runtime !== 'string') {
+      auraRef.audio.runtime = 'web';
+    }
+    auraRef.audio.play = typeof auraRef.audio.play === 'function'
+      ? auraRef.audio.play
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'play', 'web_audio_play_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.stop = typeof auraRef.audio.stop === 'function'
+      ? auraRef.audio.stop
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'stop', 'web_audio_stop_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.pause = typeof auraRef.audio.pause === 'function'
+      ? auraRef.audio.pause
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'pause', 'web_audio_pause_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.resume = typeof auraRef.audio.resume === 'function'
+      ? auraRef.audio.resume
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'resume', 'web_audio_resume_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.setVolume = typeof auraRef.audio.setVolume === 'function'
+      ? auraRef.audio.setVolume
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'setVolume', 'web_audio_set_volume_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.setMasterVolume = typeof auraRef.audio.setMasterVolume === 'function'
+      ? auraRef.audio.setMasterVolume
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'setMasterVolume', 'web_audio_set_master_volume_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.stopAll = typeof auraRef.audio.stopAll === 'function'
+      ? auraRef.audio.stopAll
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'stopAll', 'web_audio_stop_all_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.setBusVolume = typeof auraRef.audio.setBusVolume === 'function'
+      ? auraRef.audio.setBusVolume
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'setBusVolume', 'web_audio_set_bus_volume_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.assignBus = typeof auraRef.audio.assignBus === 'function'
+      ? auraRef.audio.assignBus
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'assignBus', 'web_audio_assign_bus_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.fadeTrack = typeof auraRef.audio.fadeTrack === 'function'
+      ? auraRef.audio.fadeTrack
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'fadeTrack', 'web_audio_fade_track_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.fadeBus = typeof auraRef.audio.fadeBus === 'function'
+      ? auraRef.audio.fadeBus
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'fadeBus', 'web_audio_fade_bus_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.crossfade = typeof auraRef.audio.crossfade === 'function'
+      ? auraRef.audio.crossfade
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'crossfade', 'web_audio_crossfade_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.update = typeof auraRef.audio.update === 'function'
+      ? auraRef.audio.update
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'update', 'web_audio_update_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.clearEnvelopes = typeof auraRef.audio.clearEnvelopes === 'function'
+      ? auraRef.audio.clearEnvelopes
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'clearEnvelopes', 'web_audio_clear_envelopes_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.getMixerState = typeof auraRef.audio.getMixerState === 'function'
+      ? auraRef.audio.getMixerState
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'getMixerState', 'web_audio_get_mixer_state_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.play3d = typeof auraRef.audio.play3d === 'function'
+      ? auraRef.audio.play3d
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'play3d', 'web_audio_play3d_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.setListenerTransform = typeof auraRef.audio.setListenerTransform === 'function'
+      ? auraRef.audio.setListenerTransform
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'setListenerTransform', 'web_audio_set_listener_transform_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.attachListener = typeof auraRef.audio.attachListener === 'function'
+      ? auraRef.audio.attachListener
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'attachListener', 'web_audio_attach_listener_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.detachListener = typeof auraRef.audio.detachListener === 'function'
+      ? auraRef.audio.detachListener
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'detachListener', 'web_audio_detach_listener_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.setEmitterTransform = typeof auraRef.audio.setEmitterTransform === 'function'
+      ? auraRef.audio.setEmitterTransform
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'setEmitterTransform', 'web_audio_set_emitter_transform_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.attachEmitter = typeof auraRef.audio.attachEmitter === 'function'
+      ? auraRef.audio.attachEmitter
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'attachEmitter', 'web_audio_attach_emitter_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.detachEmitter = typeof auraRef.audio.detachEmitter === 'function'
+      ? auraRef.audio.detachEmitter
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'detachEmitter', 'web_audio_detach_emitter_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.updateSpatial = typeof auraRef.audio.updateSpatial === 'function'
+      ? auraRef.audio.updateSpatial
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'updateSpatial', 'web_audio_update_spatial_unsupported', { playbackSupported: false });
+      };
+    auraRef.audio.getSpatialState = typeof auraRef.audio.getSpatialState === 'function'
+      ? auraRef.audio.getSpatialState
+      : function () {
+        throw createUnsupportedRuntimeError('audio', 'getSpatialState', 'web_audio_get_spatial_state_unsupported', { playbackSupported: false });
+      };
 
     auraRef.assets = auraRef.assets && typeof auraRef.assets === 'object' ? auraRef.assets : {};
     auraRef.assets.load = typeof auraRef.assets.load === 'function'
       ? auraRef.assets.load
-      : async function () { return true; };
+      : async function (source) {
+        return await loadAssetRecord(source);
+      };
     auraRef.assets.exists = typeof auraRef.assets.exists === 'function'
       ? auraRef.assets.exists
-      : function () { return false; };
+      : function (name) {
+        return !!resolveAssetEntry(name);
+      };
     auraRef.assets.image = typeof auraRef.assets.image === 'function'
       ? auraRef.assets.image
-      : function (name) { return { kind: 'image', name: String(name || '') }; };
+      : function (name) {
+        const sourcePath = resolveAssetSourcePath(name);
+        const loaded = resolveLoadedAsset(sourcePath);
+        if (loaded) return loaded;
+        const entry = resolveAssetEntry(sourcePath);
+        return rememberLoadedAsset(sourcePath, {
+          kind: 'image',
+          path: sourcePath,
+          sourcePath: sourcePath,
+          resolvedPath: entry && typeof entry.path === 'string' ? normalizePath(entry.path) : sourcePath,
+          mediaType: entry && typeof entry.mediaType === 'string' ? entry.mediaType : 'image/png',
+          image: null,
+          width: 0,
+          height: 0
+        });
+      };
     auraRef.assets.sound = typeof auraRef.assets.sound === 'function'
       ? auraRef.assets.sound
-      : function (name) { return { kind: 'sound', name: String(name || '') }; };
+      : function (name) {
+        const sourcePath = resolveAssetSourcePath(name);
+        const loaded = resolveLoadedAsset(sourcePath);
+        if (loaded) return loaded;
+        const entry = resolveAssetEntry(sourcePath);
+        return createBrowserSoundHandle(sourcePath, entry, null);
+      };
     auraRef.assets.text = typeof auraRef.assets.text === 'function'
       ? auraRef.assets.text
-      : function () { return ''; };
+      : function (name) {
+        const loaded = resolveLoadedAsset(name);
+        return loaded && typeof loaded.text === 'string' ? loaded.text : '';
+      };
     auraRef.assets.json = typeof auraRef.assets.json === 'function'
       ? auraRef.assets.json
-      : function () { return {}; };
+      : function (name) {
+        const loaded = resolveLoadedAsset(name);
+        return loaded && loaded.json && typeof loaded.json === 'object' ? loaded.json : {};
+      };
     auraRef.assets.bytes = typeof auraRef.assets.bytes === 'function'
       ? auraRef.assets.bytes
-      : function () { return new Uint8Array(); };
+      : function (name) {
+        const loaded = resolveLoadedAsset(name);
+        return loaded && loaded.bytes instanceof Uint8Array ? loaded.bytes : new Uint8Array();
+      };
+    auraRef.assets.loadText = typeof auraRef.assets.loadText === 'function'
+      ? auraRef.assets.loadText
+      : async function (name) {
+        const loaded = await loadAssetRecord(name);
+        return loaded && typeof loaded.text === 'string' ? loaded.text : '';
+      };
+    auraRef.assets.loadJson = typeof auraRef.assets.loadJson === 'function'
+      ? auraRef.assets.loadJson
+      : async function (name) {
+        const loaded = await loadAssetRecord(name);
+        return loaded && loaded.json && typeof loaded.json === 'object' ? loaded.json : null;
+      };
+
+    function drawResolvedImage(source, x, y, options, useSpriteFrame) {
+      const ctx = ensureWorldTransform();
+      if (!ctx || typeof ctx.drawImage !== 'function') return false;
+      const handle = source && typeof source === 'object' && source.image
+        ? source
+        : auraRef.assets.image(source);
+      if (!handle || !handle.image) return false;
+      const opts = options && typeof options === 'object' ? { ...options } : {};
+      const width = normalizePositiveNumber(opts.width, handle.width || handle.image.naturalWidth || handle.image.width || 1);
+      const height = normalizePositiveNumber(opts.height, handle.height || handle.image.naturalHeight || handle.image.height || 1);
+      const alpha = Number.isFinite(Number(opts.alpha)) ? Math.max(0, Math.min(1, Number(opts.alpha))) : 1;
+      const frameX = useSpriteFrame ? Math.max(0, Number(opts.frameX) || 0) : 0;
+      const frameY = useSpriteFrame ? Math.max(0, Number(opts.frameY) || 0) : 0;
+      const frameW = useSpriteFrame
+        ? normalizePositiveNumber(opts.frameW, handle.image.naturalWidth || handle.image.width || width)
+        : (handle.image.naturalWidth || handle.image.width || width);
+      const frameH = useSpriteFrame
+        ? normalizePositiveNumber(opts.frameH, handle.image.naturalHeight || handle.image.height || height)
+        : (handle.image.naturalHeight || handle.image.height || height);
+      const drawX = Number(x) || 0;
+      const drawY = Number(y) || 0;
+      const flipX = opts.flipX === true;
+      const flipY = opts.flipY === true;
+      if (typeof ctx.save === 'function') ctx.save();
+      ctx.globalAlpha = alpha;
+      if (flipX || flipY) {
+        if (typeof ctx.translate === 'function') {
+          ctx.translate(drawX + (flipX ? width : 0), drawY + (flipY ? height : 0));
+        }
+        if (typeof ctx.scale === 'function') {
+          ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
+        }
+        ctx.drawImage(handle.image, frameX, frameY, frameW, frameH, 0, 0, width, height);
+      } else {
+        ctx.drawImage(handle.image, frameX, frameY, frameW, frameH, drawX, drawY, width, height);
+      }
+      if (typeof ctx.restore === 'function') ctx.restore();
+      return true;
+    }
 
     auraRef.draw2d = auraRef.draw2d && typeof auraRef.draw2d === 'object' ? auraRef.draw2d : {};
     auraRef.draw2d.clear = function (colorOrR, g, b, a) {
@@ -951,9 +2504,10 @@ const WEB_LOADER_SOURCE = `
       ctx.clearRect(0, 0, runtime.width, runtime.height);
       ctx.fillStyle = colorToCss(fillColor, createUnitColor(0, 0, 0, 1));
       ctx.fillRect(0, 0, runtime.width, runtime.height);
+      applyWorldTransform();
     };
     auraRef.draw2d.rect = function (x, y, w, h, color) {
-      const ctx = ensureCanvasContext();
+      const ctx = ensureWorldTransform();
       if (!ctx) return;
       ctx.strokeStyle = colorToCss(color, defaultColor);
       ctx.lineWidth = 1;
@@ -961,13 +2515,13 @@ const WEB_LOADER_SOURCE = `
     };
     auraRef.draw2d.rectOutline = auraRef.draw2d.rect;
     auraRef.draw2d.rectFill = function (x, y, w, h, color) {
-      const ctx = ensureCanvasContext();
+      const ctx = ensureWorldTransform();
       if (!ctx) return;
       ctx.fillStyle = colorToCss(color, defaultColor);
       ctx.fillRect(Number(x) || 0, Number(y) || 0, Number(w) || 0, Number(h) || 0);
     };
     auraRef.draw2d.circle = function (x, y, radius, color) {
-      const ctx = ensureCanvasContext();
+      const ctx = ensureWorldTransform();
       if (!ctx) return;
       ctx.beginPath();
       ctx.arc(Number(x) || 0, Number(y) || 0, Math.max(0, Number(radius) || 0), 0, Math.PI * 2);
@@ -976,7 +2530,7 @@ const WEB_LOADER_SOURCE = `
       ctx.stroke();
     };
     auraRef.draw2d.circleFill = function (x, y, radius, color) {
-      const ctx = ensureCanvasContext();
+      const ctx = ensureWorldTransform();
       if (!ctx) return;
       ctx.beginPath();
       ctx.arc(Number(x) || 0, Number(y) || 0, Math.max(0, Number(radius) || 0), 0, Math.PI * 2);
@@ -984,7 +2538,7 @@ const WEB_LOADER_SOURCE = `
       ctx.fill();
     };
     auraRef.draw2d.line = function (x1, y1, x2, y2, color, width) {
-      const ctx = ensureCanvasContext();
+      const ctx = ensureWorldTransform();
       if (!ctx) return;
       ctx.beginPath();
       ctx.moveTo(Number(x1) || 0, Number(y1) || 0);
@@ -993,17 +2547,20 @@ const WEB_LOADER_SOURCE = `
       ctx.lineWidth = normalizePositiveNumber(width, 1);
       ctx.stroke();
     };
-    auraRef.draw2d.text = function (text, x, y, options) {
-      const ctx = ensureCanvasContext();
-      if (!ctx) return;
-      const config = applyFont(options);
-      const source = options && typeof options === 'object' ? options : {};
-      ctx.fillStyle = colorToCss(source.color, defaultColor);
-      ctx.textAlign = config.align;
-      ctx.textBaseline = 'top';
-      ctx.fillText(String(text == null ? '' : text), Number(x) || 0, Number(y) || 0);
+    auraRef.draw2d.text = function (text, x, y, sizeOrOptions, colorMaybe) {
+      const options = normalizeTextOptions(sizeOrOptions, colorMaybe);
+      return withScreenSpace(function (ctx) {
+        const config = applyFont(options);
+        const source = options && typeof options === 'object' ? options : {};
+        ctx.fillStyle = colorToCss(source.color, defaultColor);
+        ctx.textAlign = config.align;
+        ctx.textBaseline = 'top';
+        ctx.fillText(String(text == null ? '' : text), Number(x) || 0, Number(y) || 0);
+        return true;
+      });
     };
-    auraRef.draw2d.measureText = function (text, options) {
+    auraRef.draw2d.measureText = function (text, sizeOrOptions, colorMaybe) {
+      const options = normalizeTextOptions(sizeOrOptions, colorMaybe);
       const source = options && typeof options === 'object' ? options : {};
       const size = normalizePositiveNumber(source.size, 16);
       const ctx = ensureCanvasContext();
@@ -1011,21 +2568,27 @@ const WEB_LOADER_SOURCE = `
         const fallbackWidth = String(text == null ? '' : text).length * size * 0.6;
         return { width: Number(fallbackWidth.toFixed(3)), height: size };
       }
-      applyFont(options);
-      const metrics = ctx.measureText(String(text == null ? '' : text));
-      const measuredWidth = Number.isFinite(metrics && metrics.width)
-        ? metrics.width
-        : String(text == null ? '' : text).length * size * 0.6;
-      return { width: Number(measuredWidth.toFixed(3)), height: size };
+      const measuredWidth = withScreenSpace(function () {
+        applyFont(options);
+        const metrics = ctx.measureText(String(text == null ? '' : text));
+        return Number.isFinite(metrics && metrics.width)
+          ? metrics.width
+          : String(text == null ? '' : text).length * size * 0.6;
+      });
+      return { width: Number(Number(measuredWidth || 0).toFixed(3)), height: size };
     };
     auraRef.draw2d.image = typeof auraRef.draw2d.image === 'function'
       ? auraRef.draw2d.image
-      : function () { return true; };
+      : function (source, x, y, options) {
+        return drawResolvedImage(source, x, y, options, false);
+      };
     auraRef.draw2d.sprite = typeof auraRef.draw2d.sprite === 'function'
       ? auraRef.draw2d.sprite
-      : function () { return true; };
+      : function (source, x, y, options) {
+        return drawResolvedImage(source, x, y, options, true);
+      };
     auraRef.draw2d.pushTransform = function () {
-      const ctx = ensureCanvasContext();
+      const ctx = ensureWorldTransform();
       if (!ctx || typeof ctx.save !== 'function') return;
       runtime.transformDepth += 1;
       ctx.save();
@@ -1039,20 +2602,20 @@ const WEB_LOADER_SOURCE = `
     auraRef.draw2d.push = auraRef.draw2d.pushTransform;
     auraRef.draw2d.pop = auraRef.draw2d.popTransform;
     auraRef.draw2d.translate = function (x, y) {
-      const ctx = ensureCanvasContext();
+      const ctx = ensureWorldTransform();
       if (!ctx || typeof ctx.translate !== 'function') return;
       ctx.translate(Number(x) || 0, Number(y) || 0);
     };
     auraRef.draw2d.rotate = function (angle) {
-      const ctx = ensureCanvasContext();
+      const ctx = ensureWorldTransform();
       if (!ctx || typeof ctx.rotate !== 'function') return;
       ctx.rotate(Number(angle) || 0);
     };
     auraRef.draw2d.scale = function (x, y) {
-      const ctx = ensureCanvasContext();
+      const ctx = ensureWorldTransform();
       if (!ctx || typeof ctx.scale !== 'function') return;
-      const scaleX = normalizePositiveNumber(x, 1);
-      const scaleY = normalizePositiveNumber(y, scaleX);
+      const scaleX = Number.isFinite(Number(x)) ? Number(x) : 1;
+      const scaleY = Number.isFinite(Number(y)) ? Number(y) : scaleX;
       ctx.scale(scaleX, scaleY);
     };
 
@@ -1068,6 +2631,9 @@ const WEB_LOADER_SOURCE = `
         runtime.resizeMode = currentCanvasConfig.resizeMode === 'fixed' ? 'fixed' : 'fit-container';
         syncCanvasSize(false);
       },
+      setManifest(nextManifest, rootUrl) {
+        indexManifestAssets(nextManifest, rootUrl);
+      },
       mount(canvas, mountTarget) {
         runtime.canvas = canvas || runtime.canvas;
         runtime.mountTarget = mountTarget || runtime.mountTarget;
@@ -1075,14 +2641,15 @@ const WEB_LOADER_SOURCE = `
         syncCanvasSize(false);
         resetDrawState();
         attachListeners();
-        inputState.down.clear();
-        inputState.pendingPressed.clear();
-        inputState.pendingReleased.clear();
-        inputState.framePressed.clear();
-        inputState.frameReleased.clear();
+        clearHeldInputState();
+        auraRef.input.mouse.scroll = 0;
+        applyCursorAppearance();
         if (runtime.canvas && typeof runtime.canvas.focus === 'function') {
           runtime.canvas.focus();
         }
+        if (typeof auraRef.onFocus === 'function') {
+          auraRef.onFocus();
+        }
         return true;
       },
       beginFrame() {
@@ -1090,6 +2657,14 @@ const WEB_LOADER_SOURCE = `
         inputState.frameReleased = new Set(inputState.pendingReleased);
         inputState.pendingPressed.clear();
         inputState.pendingReleased.clear();
+        inputState.frameMousePressed = new Set(inputState.pendingMousePressed);
+        inputState.frameMouseReleased = new Set(inputState.pendingMouseReleased);
+        inputState.pendingMousePressed.clear();
+        inputState.pendingMouseReleased.clear();
+        inputState.frameMouseDeltaX = inputState.pendingMouseDeltaX;
+        inputState.frameMouseDeltaY = inputState.pendingMouseDeltaY;
+        inputState.pendingMouseDeltaX = 0;
+        inputState.pendingMouseDeltaY = 0;
         resetDrawState();
       },
       endFrame() {
@@ -1103,15 +2678,17 @@ const WEB_LOADER_SOURCE = `
       },
       unmount() {
         detachListeners();
-        inputState.down.clear();
-        inputState.pendingPressed.clear();
-        inputState.pendingReleased.clear();
-        inputState.framePressed.clear();
-        inputState.frameReleased.clear();
+        clearHeldInputState();
+        runtime.cursorLocked = false;
+        if (globalRef.document && typeof globalRef.document.exitPointerLock === 'function') {
+          globalRef.document.exitPointerLock();
+        }
+        applyCursorAppearance();
         runtime.mountTarget = null;
         runtime.canvas = null;
         runtime.context2d = null;
         runtime.transformDepth = 0;
+        runtime.worldTransformActive = false;
         return true;
       }
     };
@@ -1293,6 +2870,7 @@ const WEB_LOADER_SOURCE = `
           const rootUrl = typeof opts.rootUrl === 'string' && opts.rootUrl.length > 0
             ? opts.rootUrl.replace(/\\/$/, '')
             : '.';
+          cachedRootUrl = rootUrl;
           setState('loading', null, null);
 
           cachedManifest = await readJson(rootUrl + '/web-build-manifest.json', 'web_manifest_missing', 'web_manifest_parse_failed');
@@ -1305,6 +2883,9 @@ const WEB_LOADER_SOURCE = `
           } else if (typeof auraRuntime.setRuntimeConfig === 'function') {
             auraRuntime.setRuntimeConfig(cachedRuntimeConfig);
           }
+          if (auraRuntime && typeof auraRuntime.setManifest === 'function') {
+            auraRuntime.setManifest(cachedManifest, cachedRootUrl);
+          }
 
           const bundleEntry = normalizePath(cachedManifest.entrypoints.bundle);
           if (bundleEntry.length === 0) {
@@ -1350,6 +2931,13 @@ const WEB_LOADER_SOURCE = `
           if (!auraRuntime) {
             auraRuntime = createBrowserAuraSurface(cachedRuntimeConfig || {});
           }
+          if (auraRuntime && typeof auraRuntime.setManifest === 'function') {
+            auraRuntime.setManifest(cachedManifest || {}, cachedRootUrl);
+          }
+          ensureCapabilityDeclarationSatisfied(
+            cachedRuntimeConfig || {},
+            auraRuntime && auraRuntime.aura ? auraRuntime.aura : globalRef.aura,
+          );
           if (typeof auraRuntime.mount === 'function') {
             auraRuntime.mount(canvas, targetNode);
           }