@forgeax/engine-app 0.1.4 → 0.1.6

package/src/errors.ts

@@ -1,8 +1,8 @@
-// @forgeax/engine-app -- AppError + closed AppErrorCode union (14 members) +
+// @forgeax/engine-app -- AppError + closed AppErrorCode union (12 members) +
 // APP_ERROR_HINTS / APP_EXPECTED + discriminated AppErrorDetail per code.
 //
 // Shape:
-//   - AppErrorCode = closed union 14 members (charter P4 closed-union
+//   - AppErrorCode = closed union 12 members (charter P4 closed-union
 //     exhaustive switch needs no default fallback; tsc strict mode guards
 //     completeness; AGENTS.md "Errors are structured" + AC-07).
 //     Members:
@@ -35,7 +35,7 @@
 //     non-canonical fields like `{ state: 'running' }` on the
 //     'app-already-running' arm.
 //
-//   - APP_ERROR_HINTS / APP_EXPECTED are 14-key Records keyed by AppErrorCode;
+//   - APP_ERROR_HINTS / APP_EXPECTED are 12-key Records keyed by AppErrorCode;
 //     one private policy owner supplies both projections. The focused policy-owner
 //     proof asserts that every code has the exact expected and hint strings.
 //
@@ -50,18 +50,17 @@ import type { RhiError } from '@forgeax/engine-rhi/errors';
 import type { ExecutionCapabilityName, ExecutionTier } from './execution/types';
 
 /**
- * Closed AppErrorCode union (14 members).
+ * Closed AppErrorCode union (12 members).
  *
  * | code | trigger |
  * |:--|:--|
  * | `'app-not-started'` | `stop()` / `pause()` / `resume()` invoked while the rAF loop is in the terminal `'idle'` or `'stopped'` state (post-device-lost terminal sink). The handle has no live frame to interrupt; AI users either call `start()` first or accept that this handle is dead and rebuild via `createApp({...})`. |
  * | `'app-already-running'` | second `start()` invocation against an already-running handle; the call is a no-op state-machine-wise (state preserved). |
  * | `'app-canvas-detached'` | `createApp(canvas)` thin wrapper found `canvas.isConnected === false` at entry. Detail carries optional `canvasId` so the host can surface the offending canvas in a multi-canvas page (D-2 minor). |
- * | `'app-invalid-canvas-pixel-ratio'` | canvas-form Host policy supplied a non-finite or non-positive `maxCanvasPixelRatio`. Detail carries the rejected value. |
  * | `'app-system-update-failed'` | World update, renderer draw, or a frame-loop callback failed; the original failure value is forwarded on `detail.cause`. `detail.systemName` is optional when the call site can name the failing owner. |
  * | `'app-pointer-lock-failed'` | `attachInputAuto`'s `onLockError` callback received a lock failure from the input backend. `detail.path` carries `'w3c'` (W3C `requestPointerLock` rejection) or `'provider'` (host-injected `lockProvider.requestLock` throw/reject). `detail.cause` carries the original rejection value verbatim. The host recovers by remaining in unlocked state; the next trusted click will retry the lock request. |
  *
- * Plan-strategy D-4 locked the original lifecycle subset; device-lost rides RhiErrorCode.
+ * Plan-strategy D-4 locked the count at 6; device-lost rides RhiErrorCode.
  */
 export type AppErrorCode = keyof typeof appErrorPolicy;
 
@@ -76,11 +75,6 @@ export interface AppDetailCanvasDetached {
   readonly canvasId?: string | undefined;
 }
 
-/** Invalid host-owned canvas pixel-ratio cap. */
-export interface AppDetailInvalidCanvasPixelRatio {
-  readonly value: number;
-}
-
 /**
  * Detail variant for the `'app-system-update-failed'` arm (plan-strategy D-4).
  *
@@ -174,29 +168,27 @@ export type AppDetailEmpty = Readonly<Record<string, never>>;
  */
 export type AppErrorDetailFor<C extends AppErrorCode> = C extends 'app-canvas-detached'
   ? AppDetailCanvasDetached
-  : C extends 'app-invalid-canvas-pixel-ratio'
-    ? AppDetailInvalidCanvasPixelRatio
-    : C extends 'app-frame-step-invalid'
-      ? AppDetailFrameStepInvalid
-      : C extends 'app-system-update-failed'
-        ? AppDetailSystemUpdateFailed
-        : C extends 'app-pointer-lock-failed'
-          ? AppDetailPointerLockFailed
-          : C extends 'app-plugin-activation-failed'
-            ? AppDetailPluginActivationFailed
-            : C extends 'app-execution-tier-unavailable'
-              ? AppDetailExecutionTierUnavailable
-              : C extends 'app-execution-bootstrap-failed'
-                ? AppDetailExecutionBootstrapFailed
-                : C extends 'app-execution-deadline-exceeded'
-                  ? AppDetailExecutionDeadlineExceeded
-                  : C extends 'app-execution-kernel-failed'
-                    ? AppDetailExecutionKernelFailed
-                    : C extends 'app-execution-stale-world'
-                      ? AppDetailExecutionStaleWorld
-                      : C extends 'app-execution-rebuild-failed'
-                        ? AppDetailExecutionRebuildFailed
-                        : AppDetailEmpty;
+  : C extends 'app-frame-step-invalid'
+    ? AppDetailFrameStepInvalid
+    : C extends 'app-system-update-failed'
+      ? AppDetailSystemUpdateFailed
+      : C extends 'app-pointer-lock-failed'
+        ? AppDetailPointerLockFailed
+        : C extends 'app-plugin-activation-failed'
+          ? AppDetailPluginActivationFailed
+          : C extends 'app-execution-tier-unavailable'
+            ? AppDetailExecutionTierUnavailable
+            : C extends 'app-execution-bootstrap-failed'
+              ? AppDetailExecutionBootstrapFailed
+              : C extends 'app-execution-deadline-exceeded'
+                ? AppDetailExecutionDeadlineExceeded
+                : C extends 'app-execution-kernel-failed'
+                  ? AppDetailExecutionKernelFailed
+                  : C extends 'app-execution-stale-world'
+                    ? AppDetailExecutionStaleWorld
+                    : C extends 'app-execution-rebuild-failed'
+                      ? AppDetailExecutionRebuildFailed
+                      : AppDetailEmpty;
 
 /**
  * Tagged union of `.detail` payloads carried by structured AppError.
@@ -353,7 +345,7 @@ export const AppError: AppErrorConstructor = AppErrorClass as unknown as AppErro
  * code surfaces. AI users read this as the L2 detail (charter F2 priority
  * text); `.hint` carries the recovery action.
  *
- * 14 keys; the focused policy-owner proof locks the exact key set and values.
+ * 12 keys; the focused policy-owner proof locks the exact key set and values.
  * locks the count and non-emptiness of every entry.
  */
 type AppErrorPolicy = { readonly expected: string; readonly hint: string };
@@ -373,10 +365,6 @@ const appErrorPolicy = {
     expected: 'canvas.isConnected === true at createApp(canvas) entry',
     hint: 'append the canvas to the document tree before calling createApp(canvas), or use the assemble entry createApp({ renderer, world }) when the host already manages canvas lifetime',
   },
-  'app-invalid-canvas-pixel-ratio': {
-    expected: 'maxCanvasPixelRatio is finite and greater than 0',
-    hint: 'omit maxCanvasPixelRatio to keep the device pixel ratio, or pass a finite value > 0 from the Host policy',
-  },
   'app-frame-step-invalid': {
     expected:
       'stepFrame(deltaSeconds) runs only while the App is paused and deltaSeconds is finite and non-negative',

package/src/execution/attached-world-swap.ts

@@ -12,56 +12,22 @@ export class SerializedRebuildQueue {
   }
 }
 
-export interface RebuildCleanupFailure {
-  readonly phase: 'candidate' | 'previous';
-  readonly cause: unknown;
-}
-
-/** Primary rebuild failures stay first; cleanup failures are ordered detail. */
-export class RebuildLifecycleError extends Error {
-  readonly primary: unknown;
-  readonly cleanup: readonly RebuildCleanupFailure[];
-
-  constructor(primary: unknown, cleanup: readonly RebuildCleanupFailure[]) {
-    super(
-      'World rebuild failed; cleanup details are attached without replacing the primary cause.',
-    );
-    this.name = 'RebuildLifecycleError';
-    this.primary = primary;
-    this.cleanup = cleanup;
-  }
-}
-
-export async function disposeWithOrderedDetail(
-  phase: RebuildCleanupFailure['phase'],
-  dispose: () => Promise<void> | void,
-  failures: RebuildCleanupFailure[],
-): Promise<void> {
-  try {
-    await dispose();
-  } catch (cause) {
-    failures.push({ phase, cause });
-  }
-}
-
 /** Transactionally replace one Renderer-attached World. */
 export async function commitAttachedWorld(
-  renderer: Pick<Renderer, 'attachWorld' | 'detachWorld'>,
-  previousWorld: World | undefined,
+  renderer: Pick<Renderer, 'attach'>,
   nextWorld: World,
   initializeCandidate: () => Promise<boolean>,
 ): Promise<boolean> {
-  const attached = renderer.attachWorld(nextWorld);
+  const attached = renderer.attach(nextWorld);
   if (!attached.ok) throw attached.error;
   try {
     if (!(await initializeCandidate())) {
-      renderer.detachWorld(nextWorld);
+      attached.value.dispose();
       return false;
     }
   } catch (cause) {
-    renderer.detachWorld(nextWorld);
+    attached.value.dispose();
     throw cause;
   }
-  if (previousWorld !== undefined) renderer.detachWorld(previousWorld);
   return true;
 }

package/src/execution/bootstrap-url.ts

@@ -0,0 +1,25 @@
+import { err, ok, type Result } from '@forgeax/engine-types';
+import { APP_ERROR_HINTS, APP_EXPECTED, AppError, type AppError as AppErrorType } from '../errors';
+
+/** Normalize a bootstrap module before any realm probing or worker startup. */
+export function normalizeExecutionBootstrapUrl(
+  bootstrap: string | URL,
+): Result<string, AppErrorType> {
+  const moduleUrl = typeof bootstrap === 'string' ? bootstrap : bootstrap.href;
+  try {
+    return ok(new URL(bootstrap, globalThis.location?.href).href);
+  } catch (cause) {
+    return err(
+      new AppError({
+        code: 'app-execution-bootstrap-failed',
+        expected: APP_EXPECTED['app-execution-bootstrap-failed'],
+        hint: APP_ERROR_HINTS['app-execution-bootstrap-failed'],
+        detail: {
+          phase: 'prepare',
+          moduleUrl,
+          cause: cause instanceof TypeError ? cause : new TypeError(String(cause)),
+        },
+      }),
+    );
+  }
+}

package/src/execution/control.ts

@@ -15,8 +15,6 @@ export interface LocalExecutionControl extends ExecutionControl {
 export interface LocalExecutionReportProviders {
   readonly audio?: () => AudioState;
   readonly world?: () => ExecutionReport['world'];
-  /** Host-owned poisoned-World replacement transaction. */
-  readonly rebuild?: ExecutionControl['rebuild'];
 }
 
 export function createLocalExecutionControl(
@@ -34,9 +32,8 @@ export function createLocalExecutionControl(
         world: providers.world?.() ?? current.world,
         audio: executionAudioReport(providers.audio?.()),
       }),
-    rebuild: async () => {
-      if (providers.rebuild !== undefined) return providers.rebuild();
-      return err(
+    rebuild: async () =>
+      err(
         new AppError({
           code: 'app-execution-rebuild-failed',
           expected: APP_EXPECTED['app-execution-rebuild-failed'],
@@ -46,7 +43,6 @@ export function createLocalExecutionControl(
             cause: new Error('This local assembly has no bootstrap module.'),
           },
         }),
-      );
-    },
+      ),
   };
 }

package/src/execution/engine-worker-runtime.ts

@@ -1,15 +1,14 @@
-import { createAssetRegistry, createCatalogSource } from '@forgeax/engine-assets-runtime';
 import { type AudioIntent, createAudioIntentBackend } from '@forgeax/engine-audio';
 import { createWorldContext, World } from '@forgeax/engine-ecs';
 import type { SharedKernelExecutor } from '@forgeax/engine-ecs/shared';
 import type { InputBackend, InputBackendSample } from '@forgeax/engine-input';
 import type { Context, Plugin } from '@forgeax/engine-plugin';
 import type { Renderer } from '@forgeax/engine-render';
-import { createRenderer } from '@forgeax/engine-runtime';
+import { constructRuntimeRendererHost } from '@forgeax/engine-runtime/internal/renderer-host';
 import { createAnimationPayloadLookup } from '../animation-asset-lookup';
-import { type AssetRuntimeAssembly, assembleAssetRuntime } from '../assets-runtime-assembly';
 import { syncCameraAspect } from '../canvas-policy';
 import { workerEngineProfile } from '../internal/worker-engine-profile';
+import { createRenderFeatureHost } from '../renderer-plugin';
 import { commitAttachedWorld, SerializedRebuildQueue } from './attached-world-swap';
 import {
   executionBootstrapHostPlugin,
@@ -32,6 +31,7 @@ const scope = globalThis as unknown as {
 };
 
 let renderer: Renderer | undefined;
+let assets: import('@forgeax/engine-assets-runtime').AssetRegistry | undefined;
 let currentSample: InputBackendSample = {
   downKeys: new Set(),
   upKeys: new Set(),
@@ -54,6 +54,7 @@ interface WorkerRealm {
 
 let realm: WorkerRealm | undefined;
 const rebuildQueue = new SerializedRebuildQueue();
+
 const inputBackend: InputBackend = {
   sample: () => currentSample,
   detach: () => {},
@@ -96,13 +97,6 @@ function serializableDetail(cause: unknown): unknown {
   if (cause instanceof Error) return serializableCause(cause);
   if (Array.isArray(cause)) return cause.map(serializableDetail);
   if (typeof cause === 'object' && cause !== null) {
-    const named = cause as { readonly name?: unknown; readonly message?: unknown };
-    if (typeof named.name === 'string' || typeof named.message === 'string') {
-      return {
-        name: typeof named.name === 'string' ? named.name : 'Error',
-        message: typeof named.message === 'string' ? named.message : String(cause),
-      };
-    }
     return Object.fromEntries(
       Object.entries(cause).map(([key, value]) => [key, serializableDetail(value)]),
     );
@@ -168,7 +162,6 @@ async function createRealm(init: ExecutionInitMessage): Promise<boolean> {
     emit: (intent) => candidate.pendingAudioIntents.push(intent),
   });
   let candidateRenderer: Renderer | undefined;
-  let assetAssembly: AssetRuntimeAssembly | undefined;
   let rendererLifecycleTransferred = false;
   const previousRenderer = renderer;
   let previousSurfaceReleased = false;
@@ -178,35 +171,26 @@ async function createRealm(init: ExecutionInitMessage): Promise<boolean> {
       if (!released.ok) throw released.error;
       previousSurfaceReleased = true;
     }
-    candidateRenderer = await createRenderer(
+    const constructed = await constructRuntimeRendererHost(
       init.canvas,
       prepared.features === undefined ? {} : { features: prepared.features },
       init.shaderManifestUrl === undefined
         ? undefined
         : { shaderManifestUrl: init.shaderManifestUrl },
     );
-    const ready = await candidateRenderer.ready;
-    if (!ready.ok) throw ready.error;
+    if (!constructed.ok) throw constructed.error;
+    candidateRenderer = constructed.value.renderer;
+    assets = constructed.value.assets;
     rendererLifecycleTransferred = true;
-    const assetRegistry = createAssetRegistry({
-      catalog: createCatalogSource({
-        url: new URL('pack-index.json', globalThis.location?.href ?? 'http://localhost/').href,
-      }),
-    });
-    const assembledAssets = assembleAssetRuntime(assetRegistry, []);
-    if (!assembledAssets.ok) {
-      assetRegistry.dispose();
-      throw assembledAssets.error;
-    }
-    assetAssembly = assembledAssets.value;
     const pluginContext = await createWorldContext(
       nextWorld,
       workerEngineProfile({
         renderer: candidateRenderer,
-        assetAssembly,
+        rendererFeatureHost: createRenderFeatureHost(constructed.value.featureHost),
+        assets,
         input: inputBackend,
         audio: audioBackend,
-        animationPayloads: createAnimationPayloadLookup(candidateRenderer.assets),
+        animationPayloads: createAnimationPayloadLookup(assets),
         extensions: [
           ...(init.tier === 'shared' ? [sharedKernelPlugin(candidate)] : []),
           executionBootstrapHostPlugin({
@@ -226,15 +210,10 @@ async function createRealm(init: ExecutionInitMessage): Promise<boolean> {
     candidate.pluginContext = pluginContext;
     const activeRenderer = candidateRenderer;
     const previousRealm = realm;
-    const committed = await commitAttachedWorld(
-      candidateRenderer,
-      previousRealm?.world,
-      nextWorld,
-      async () => {
-        await candidate.kernelPool?.ready();
-        return true;
-      },
-    );
+    const committed = await commitAttachedWorld(candidateRenderer, nextWorld, async () => {
+      await candidate.kernelPool?.ready();
+      return true;
+    });
     if (!committed) {
       await disposeRealm(candidate);
       if (previousSurfaceReleased) previousRenderer?.restoreSurface();
@@ -247,8 +226,6 @@ async function createRealm(init: ExecutionInitMessage): Promise<boolean> {
     return true;
   } catch (cause) {
     await disposeRealm(candidate);
-    assetAssembly?.dispose();
-    assetAssembly?.registry.dispose();
     if (!rendererLifecycleTransferred) candidateRenderer?.dispose();
     if (previousSurfaceReleased) previousRenderer?.restoreSurface();
     throw cause;
@@ -314,8 +291,14 @@ function runFrame(message: ExecutionFrameMessage): void {
       return;
     }
     const updateFinished = performance.now();
-    const draw = renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-    if (draw !== undefined && !draw.ok) throw draw.error;
+    const attached = renderer.attach(world);
+    if (!attached.ok) throw attached.error;
+    const draw = renderer.draw({
+      leases: [attached.value],
+      camera: { lease: attached.value },
+      environment: { lease: attached.value },
+    });
+    if (!draw.ok) throw draw.error;
     lastFrameId = message.frameId;
     const kernelDispatch = activeRealm.kernelPool?.takeLastDispatch() ?? null;
     const audioIntents = activeRealm.pendingAudioIntents;

package/src/execution/engine-worker.ts

@@ -22,6 +22,7 @@ export interface StartEngineWorkerOptions {
   readonly bootstrapUrl: string;
   readonly bootstrapData?: import('./types').ExecutionBootstrapValue;
   readonly bootstrapPort?: MessagePort;
+  readonly assetCatalog?: import('./types').ExecutionAssetCatalog;
   readonly shaderManifestUrl?: string;
   readonly time?: import('@forgeax/engine-ecs').TimePolicy;
   readonly timeoutMs: number;
@@ -130,6 +131,7 @@ export async function startEngineWorker(
     bootstrapUrl: options.bootstrapUrl,
     ...(options.bootstrapData === undefined ? {} : { bootstrapData: options.bootstrapData }),
     ...(options.bootstrapPort === undefined ? {} : { bootstrapPort: options.bootstrapPort }),
+    ...(options.assetCatalog === undefined ? {} : { assetCatalog: options.assetCatalog }),
     ...(options.shaderManifestUrl !== undefined
       ? { shaderManifestUrl: options.shaderManifestUrl }
       : {}),

package/src/execution/host-controller.ts

@@ -10,6 +10,7 @@ import {
   type CreateAppOptions,
   type ExecutionApp,
 } from '../types';
+import { normalizeExecutionBootstrapUrl } from './bootstrap-url';
 import { cloneExecutionReport } from './control';
 import { type EngineWorkerSession, startEngineWorker } from './engine-worker';
 import { createMeasurementSeries } from './measurement';
@@ -73,10 +74,12 @@ export async function createWorkerExecutionApp(
 ): Promise<Result<ExecutionApp, AppErrorType>> {
   const executionOptions = options.appOptions.execution;
   if (executionOptions === undefined) throw new Error('execution options are required');
-  const syncCanvas = options.syncCanvas;
-  const bootstrapUrl = new URL(executionOptions.bootstrap, globalThis.location?.href).href;
+  const normalizedBootstrap = normalizeExecutionBootstrapUrl(executionOptions.bootstrap);
+  if (!normalizedBootstrap.ok) return normalizedBootstrap;
+  const bootstrapUrl = normalizedBootstrap.value;
   const startupTimeoutMs = executionOptions.startupTimeoutMs ?? 10_000;
   const frameTimeoutMs = executionOptions.frameTimeoutMs ?? 2_000;
+  const syncCanvas = options.syncCanvas;
   const started = await startEngineWorker({
     canvas: options.canvas,
     bootstrapUrl,
@@ -86,6 +89,9 @@ export async function createWorkerExecutionApp(
     ...(executionOptions.bootstrapPort === undefined
       ? {}
       : { bootstrapPort: executionOptions.bootstrapPort }),
+    ...(executionOptions.assetCatalog === undefined
+      ? {}
+      : { assetCatalog: executionOptions.assetCatalog }),
     ...(options.bundler?.shaderManifestUrl !== undefined
       ? { shaderManifestUrl: options.bundler.shaderManifestUrl }
       : {}),

package/src/execution/index.ts

@@ -19,6 +19,7 @@ export { createExecutionReport } from './report';
 export { EXECUTION_REPORT_SCHEMA_VERSION, isExecutionReport } from './schema';
 export { type ExecutionSelectionInput, selectExecutionTier } from './selector';
 export type {
+  ExecutionAssetCatalog,
   ExecutionBootstrapValue,
   ExecutionCapabilities,
   ExecutionCapabilityFact,

package/src/execution/protocol.ts

@@ -1,6 +1,7 @@
 import type { AudioIntent } from '@forgeax/engine-audio';
 import type { InputBackendSample } from '@forgeax/engine-input';
 import type { CanvasDrawingBufferSize } from '../types';
+import type { ExecutionAssetCatalog } from './types';
 
 export interface ExecutionFrameMessage {
   readonly kind: 'frame';
@@ -40,7 +41,7 @@ export class FrameCreditLedger {
   issue(
     deltaSeconds: number,
     sampleInput: () => InputBackendSample,
-    canvasSize: CanvasDrawingBufferSize,
+    canvasSize: CanvasDrawingBufferSize = { width: 0, height: 0 },
   ): ExecutionFrameMessage | undefined {
     if (this.inFlight !== null) return undefined;
     const frameId = this.nextFrameId;
@@ -77,6 +78,8 @@ export interface ExecutionInitMessage {
   readonly bootstrapUrl: string;
   readonly bootstrapData?: import('./types').ExecutionBootstrapValue;
   readonly bootstrapPort?: MessagePort;
+  /** Realm-serializable asset catalog configuration. */
+  readonly assetCatalog?: ExecutionAssetCatalog;
   readonly shaderManifestUrl?: string;
   readonly time?: import('@forgeax/engine-ecs').TimePolicy;
   readonly tier: import('./types').ExecutionTier;

package/src/execution/types.ts

@@ -1,5 +1,5 @@
 import type { WorldExecutionHealth } from '@forgeax/engine-ecs/shared';
-import type { Result } from '@forgeax/engine-types';
+import type { Result, RuntimeAssetBinding } from '@forgeax/engine-types';
 import type { AppError } from '../errors';
 
 export const EXECUTION_TIERS = ['main-serial', 'engine-worker', 'shared'] as const;
@@ -83,6 +83,16 @@ export interface ExecutionAudioReport {
   } | null;
 }
 
+/**
+ * Serializable asset-catalog configuration copied into the selected Engine
+ * realm. The URL is resolved by that realm, so a Worker never closes over a
+ * Host-side CatalogSource or Registry instance.
+ */
+export interface ExecutionAssetCatalog {
+  readonly url: string;
+  readonly expectedScope?: Pick<RuntimeAssetBinding, 'scopeId' | 'generation'>;
+}
+
 export interface ExecutionReport {
   readonly schemaVersion: 1;
   readonly requestedTier: ExecutionRequestedTier;
@@ -128,6 +138,13 @@ export interface ExecutionOptions {
    * to a Worker when needed and otherwise preserves the same port contract.
    */
   readonly bootstrapPort?: MessagePort;
+  /**
+   * Serializable CatalogSource configuration constructed inside the selected
+   * execution realm. This is the asset delivery seam for Worker execution;
+   * `CreateAppOptions.assetCatalog` remains realm-bound and is rejected when
+   * execution is requested.
+   */
+  readonly assetCatalog?: ExecutionAssetCatalog;
   readonly startupTimeoutMs?: number;
   readonly frameTimeoutMs?: number;
 }

package/src/game-context.ts

@@ -70,7 +70,7 @@ export interface GameHost {
   readonly canvas: HTMLCanvasElement;
   /** The WebGPU Renderer (optional — some hosts may not expose it). */
   readonly renderer?: Renderer;
-  /** The AssetRegistry owned by the App realm. */
+  /** The AssetRegistry owned by the Renderer. */
   readonly assets: AssetRegistry;
   /** The App handle for lifecycle introspection. */
   readonly app: App;

package/src/index.ts

@@ -36,10 +36,9 @@ export type {
 } from '@forgeax/engine-plugin';
 export { Context } from '@forgeax/engine-plugin';
 export {
-  type AssetRuntimeAssembly,
-  type AssetRuntimeAssemblyError,
-  assembleAssetRuntime,
-} from './assets-runtime-assembly';
+  createFullscreenRenderFeature,
+  type FullscreenRenderFeatureOptions,
+} from '@forgeax/engine-render/authoring';
 export { createApp, measureCanvasDrawingBuffer, syncCanvasDrawingBuffer } from './create-app';
 export type {
   AppDetailCanvasDetached,
@@ -63,6 +62,7 @@ export {
   isAppError,
 } from './errors';
 export type {
+  ExecutionAssetCatalog,
   ExecutionBootstrapEntry,
   ExecutionBootstrapHost,
   ExecutionBootstrapValue,
@@ -110,6 +110,13 @@ export type {
 } from './game-context';
 export { gameHostPlugin } from './game-context';
 export { inputPlugin } from './plugin-factories';
+export type { RenderFeatureHost } from './renderer-plugin';
+export {
+  ownedRendererPlugin,
+  rendererPlugin,
+  renderFeatureHostPlugin,
+  renderFeaturePlugin,
+} from './renderer-plugin';
 
 import {
   isLoadGameError,

package/src/internal/assembled-engine-profile.ts

@@ -1,21 +1,13 @@
 import type { Plugin } from '@forgeax/engine-plugin';
-import { rendererPlugin } from '@forgeax/engine-render';
-import {
-  assetRegistryPlugin,
-  assetRegistryWorldPlugin,
-  assetsWorldPlugin,
-  rendererAssetsPlugin,
-} from './assets-world-plugin';
+import { rendererPlugin } from '../renderer-plugin';
+import { assetsWorldPlugin, rendererAssetsPlugin } from './assets-world-plugin';
 import type { EngineProfileBase } from './engine-profile-common';
 
 /** Assemble-form roots plus explicitly selected host capabilities. */
 export function assembledEngineProfile(options: EngineProfileBase): Plugin[] {
   return [
     rendererPlugin(options.renderer),
-    rendererAssetsPlugin(),
-    ...(options.assetAssembly === undefined
-      ? []
-      : [assetRegistryPlugin(options.assetAssembly), assetRegistryWorldPlugin()]),
+    rendererAssetsPlugin(options.assets),
     assetsWorldPlugin(),
     ...(options.extensions ?? []),
   ];