@forgeax/engine-app 0.1.4 → 0.1.6

package/src/internal/assets-world-plugin.ts

@@ -1,79 +1,33 @@
 import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import type { Plugin } from '@forgeax/engine-plugin';
-import type { RenderAssetPort } from '@forgeax/engine-render/internal';
-import type { AssetRuntimeAssembly } from '../assets-runtime-assembly';
 
-const RENDER_ASSET_PORT_RESOURCE_KEY = 'RenderAssetPort' as const;
 const ASSET_REGISTRY_RESOURCE_KEY = 'AssetRegistry' as const;
 
-/** Project the Renderer-owned render-only asset view as a declared service. */
-export function rendererAssetsPlugin(): Plugin {
+/** Project the Renderer-owned AssetRegistry as a declared dependent service. */
+export function rendererAssetsPlugin(assets: AssetRegistry | undefined): Plugin {
   return {
     name: 'renderer-assets',
     inject: ['renderer'],
     provide: 'assets',
     apply(ctx) {
-      if (ctx.renderer === undefined) throw new Error('assets require the renderer service');
-      ctx.provide('assets', ctx.renderer.assets);
+      if (assets !== undefined) ctx.provide('assets', assets);
     },
   };
 }
 
-/** Adapt the Registry and its decoder leases to the App Fiber lifecycle. */
-export function assetRegistryPlugin(assembly: AssetRuntimeAssembly): Plugin {
-  return {
-    name: 'asset-registry',
-    provide: 'assetRegistry',
-    apply(ctx) {
-      ctx.provide('assetRegistry', assembly.registry);
-      ctx.effect(
-        () => () => {
-          assembly.dispose();
-          assembly.registry.dispose();
-        },
-        'assets/registry',
-      );
-    },
-  };
-}
-
-/** Project the render-only view into World resource lookup reversibly. */
+/** Project the realm AssetRegistry into legacy World resource lookup reversibly. */
 export function assetsWorldPlugin(): Plugin {
   return {
     name: 'assets-world',
     inject: ['world', 'assets'],
     apply(ctx) {
+      if (ctx.assets === undefined) return;
       ctx.effect(() => {
-        ctx.world.insertResource(RENDER_ASSET_PORT_RESOURCE_KEY, ctx.assets);
-        return () => {
-          ctx.world.removeResource(RENDER_ASSET_PORT_RESOURCE_KEY);
-        };
-      }, 'assets/world-render-projection');
-    },
-  };
-}
-
-/** Project the App-owned Registry into World resource lookup reversibly. */
-export function assetRegistryWorldPlugin(): Plugin {
-  return {
-    name: 'asset-registry-world',
-    inject: ['world', 'assetRegistry'],
-    apply(ctx) {
-      ctx.effect(() => {
-        ctx.world.insertResource(ASSET_REGISTRY_RESOURCE_KEY, ctx.assetRegistry);
+        ctx.world.insertResource(ASSET_REGISTRY_RESOURCE_KEY, ctx.assets);
         return () => {
           ctx.world.removeResource(ASSET_REGISTRY_RESOURCE_KEY);
         };
-      }, 'assets/world-registry');
+      }, 'assets/world-resource');
     },
   };
 }
-
-declare module '@forgeax/engine-plugin' {
-  interface EngineContextServices {
-    /** Renderer-owned render projection; GameHost owns the load registry separately. */
-    assets?: RenderAssetPort;
-    /** App-owned typed runtime Registry for GUID loads and snapshots. */
-    assetRegistry?: AssetRegistry;
-  }
-}

package/src/internal/browser-remote-bridge.ts

@@ -23,7 +23,6 @@
 // installed path, while @vite-ignore would make a browser resolve the bare
 // specifier from the consumer document root and yield a 500.
 
-import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import { Update, type World } from '@forgeax/engine-ecs';
 import { createEcsImportModule } from './ecs-import';
 
@@ -35,7 +34,7 @@ type ExecuteModule = {
     ctx: {
       world: unknown;
       renderer: unknown;
-      assets: AssetRegistry;
+      assets: unknown;
       rhiCapture?: unknown;
       profiler?: unknown;
       execution?: unknown;
@@ -73,7 +72,7 @@ function canonicalRuntimeModule(moduleValue: unknown, world: World): unknown {
 export interface BrowserRemoteBridgeDeps {
   readonly world: World;
   readonly renderer: unknown;
-  readonly assets: AssetRegistry;
+  readonly assets: unknown;
   /** The host's already-loaded runtime namespace; preserves component-token identity. */
   readonly runtimeModule: unknown;
   readonly rhiCapture?: unknown;

package/src/internal/browser-rhi-debug-runtime.ts

@@ -15,7 +15,7 @@ export interface BrowserRhiDebugRuntime {
     import('@forgeax/engine-types').Result<RhiDevice, unknown>
   >;
   readonly createShaderModule: CreateShaderModuleFn;
-  readonly rhiInstrumentation: import('@forgeax/engine-render/internal').RhiBackendInstrumentation;
+  readonly rhiInstrumentation: import('@forgeax/engine-render/internal/construct-renderer').RhiBackendInstrumentation;
   attachRenderer(renderer: Renderer): () => void;
 }
 

package/src/internal/debug-draw.ts

@@ -0,0 +1,38 @@
+import type { DebugDraw } from '@forgeax/engine-debug-draw';
+import { createDebugDraw } from '@forgeax/engine-debug-draw';
+import type { RendererHostAssembly } from '@forgeax/engine-render/internal/construct-renderer';
+import type { TextureFormat } from '@forgeax/engine-rhi';
+import { selectSwapChainFormat } from '../../../render/src/record/render-context';
+
+export type RendererDebugDrawHost = Pick<
+  RendererHostAssembly['debugDrawHost'],
+  'initialization' | 'device' | '_internal_createShaderModule' | '_internal_setRenderOverlay'
+>;
+
+/** Create the App-owned debug overlay after the renderer has initialized. */
+export async function createDebugDrawOnReady(
+  context: RendererDebugDrawHost,
+  format?: TextureFormat,
+): Promise<DebugDraw> {
+  const ready = await context.initialization;
+  if (!ready.ok) throw ready.error;
+
+  const resolvedFormat =
+    format ??
+    (selectSwapChainFormat(context.device.caps.storageBuffer).view as unknown as TextureFormat);
+  const result = await createDebugDraw({
+    device: context.device,
+    queue: context.device.queue,
+    createShaderModule: context._internal_createShaderModule,
+    format: resolvedFormat,
+  });
+  if (!result.ok) throw result.error;
+  context._internal_setRenderOverlay(result.value);
+  return result.value;
+}
+
+/** Release the App-owned debug overlay and clear its Render capability. */
+export function releaseDebugDraw(context: RendererDebugDrawHost, debugDraw: DebugDraw): void {
+  context._internal_setRenderOverlay(undefined);
+  debugDraw.destroy();
+}

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

@@ -1,10 +1,9 @@
+import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
 import type { Plugin } from '@forgeax/engine-plugin';
 import type { Renderer } from '@forgeax/engine-render';
 
-import type { AssetRuntimeAssembly } from '../assets-runtime-assembly';
-
 export interface EngineProfileBase {
   readonly renderer: Renderer;
-  readonly assetAssembly?: AssetRuntimeAssembly;
+  readonly assets?: AssetRegistry;
   readonly extensions?: readonly Plugin[];
 }

package/src/internal/frame-loop.ts

@@ -1,7 +1,6 @@
 import type { World } from '@forgeax/engine-ecs';
 import type { ProfileFrameToken, Profiler, RecorderSession } from '@forgeax/engine-profiler';
-import type { Renderer } from '@forgeax/engine-render';
-import type { RhiError } from '@forgeax/engine-rhi/errors';
+import type { RenderError, Renderer, RenderWorldLease } from '@forgeax/engine-render';
 import { err, ok, type Result } from '@forgeax/engine-types';
 
 import type { AppErrorCode, AppErrorDetailFor } from '../errors';
@@ -13,7 +12,9 @@ export type FrameState = 'idle' | 'running' | 'paused' | 'stopped';
 export interface FrameLoopOptions {
   readonly world: World;
   readonly renderer: Renderer;
-  readonly onError?: (e: AppError | RhiError) => void;
+  readonly onError?: (e: AppError | RenderError) => void;
+  /** Optional dev-only RHI recorder hook; called once after each frame draw. */
+  readonly debugRhi?: { onFrameEnd(): void };
   readonly now?: () => number;
   readonly raf?: (cb: (t: number) => void) => number;
   readonly caf?: (id: number) => void;
@@ -29,7 +30,7 @@ export interface FrameLoopHandle {
   pause(): Result<void, AppError>;
   resume(): Result<void, AppError>;
   /** Run one complete update/draw frame through this loop while paused. */
-  stepFrame(deltaSeconds: number): Result<void, AppError | RhiError>;
+  stepFrame(deltaSeconds: number): Result<void, AppError | RenderError>;
   /** Replace the per-frame world routing pull without replacing the loop. */
   setDrawSource(drawSource: FrameLoopOptions['drawSource']): void;
   getState(): FrameState;
@@ -102,7 +103,7 @@ function makeWorldUpdateError(cause: unknown): AppError {
 
 function fireWorldUpdateResult(
   result: ReturnType<World['update']>,
-  fireError: ((e: AppError | RhiError) => void) | undefined,
+  fireError: ((e: AppError | RenderError) => void) | undefined,
 ): boolean {
   if (!result.ok && fireError !== undefined) {
     fireError(makeWorldUpdateError(result.error));
@@ -114,7 +115,7 @@ function updateInjectedWorlds(
   worlds: readonly World[],
   ownWorld: World,
   deltaSeconds: number,
-  fireError: ((e: AppError | RhiError) => void) | undefined,
+  fireError: ((e: AppError | RenderError) => void) | undefined,
   attachedWorlds: ReadonlySet<World>,
   updatedWorlds: Set<World>,
 ): void {
@@ -163,7 +164,6 @@ function resolveCaf(opts: FrameLoopOptions): (id: number) => void {
 
 export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
   const { world, renderer } = opts;
-  const primaryDrawWorlds: readonly World[] = [world];
   const phaseCatalogRegistration = opts.profiler?.registerPhaseCatalog('app', APP_PHASE_CATALOG);
   let releasePhaseCatalog =
     phaseCatalogRegistration?.ok === true ? phaseCatalogRegistration.value : undefined;
@@ -177,16 +177,14 @@ export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
   let pendingFrameId = 0;
   let profilerFrameId = 0;
   let profilerCaptureId: string | undefined;
-  let primaryAttached = false;
-  let activeInjectedWorlds: Set<World> | undefined;
-  let nextInjectedWorlds: Set<World> | undefined;
+  const leases = new Map<World, RenderWorldLease>();
 
-  function attachPrimary(fireError: (e: AppError | RhiError) => void): void {
-    if (primaryAttached) return;
+  function attachPrimary(fireError: (e: AppError | RenderError) => void): void {
+    if (leases.has(world)) return;
     try {
-      const result = renderer.attachWorld(world);
-      primaryAttached = result.ok;
-      if (!result.ok) fireError(result.error);
+      const result = renderer.attach(world);
+      if (result.ok) leases.set(world, result.value);
+      else fireError(result.error);
     } catch (cause: unknown) {
       fireError(makeWorldUpdateError(cause));
     }
@@ -194,42 +192,41 @@ export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
 
   function syncInjectedAttachments(
     worlds: readonly World[] | undefined,
-    fireError?: (e: AppError | RhiError) => void,
+    fireError?: (e: AppError | RenderError) => void,
   ): ReadonlySet<World> | undefined {
     if (worlds === undefined) {
-      if (activeInjectedWorlds !== undefined) {
-        for (const attached of activeInjectedWorlds) renderer.detachWorld(attached);
-        activeInjectedWorlds.clear();
+      for (const [attached, lease] of leases) {
+        if (attached !== world) {
+          lease.dispose();
+          leases.delete(attached);
+        }
       }
       return undefined;
     }
 
-    const next = nextInjectedWorlds ?? new Set<World>();
-    nextInjectedWorlds = next;
-    next.clear();
-    const active = activeInjectedWorlds;
+    const next = new Set<World>();
     for (const candidate of worlds) {
       if (candidate === world || next.has(candidate)) continue;
-      if (active?.has(candidate) === true) {
+      if (leases.has(candidate)) {
         next.add(candidate);
         continue;
       }
       try {
-        const result = renderer.attachWorld(candidate);
-        if (result.ok) next.add(candidate);
-        else fireError?.(result.error);
+        const result = renderer.attach(candidate);
+        if (result.ok) {
+          leases.set(candidate, result.value);
+          next.add(candidate);
+        } else fireError?.(result.error);
       } catch (cause: unknown) {
         fireError?.(makeWorldUpdateError(cause));
       }
     }
-    if (active !== undefined) {
-      for (const attached of active) {
-        if (!next.has(attached)) renderer.detachWorld(attached);
+    for (const [attached, lease] of leases) {
+      if (attached !== world && !next.has(attached)) {
+        lease.dispose();
+        leases.delete(attached);
       }
-      active.clear();
     }
-    activeInjectedWorlds = next;
-    nextInjectedWorlds = active;
     return next;
   }
 
@@ -239,9 +236,11 @@ export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
 
   function releaseAttachments(): void {
     releaseInjectedAttachments();
-    if (!primaryAttached) return;
-    renderer.detachWorld(world);
-    primaryAttached = false;
+    const lease = leases.get(world);
+    if (lease !== undefined) {
+      lease.dispose();
+      leases.delete(world);
+    }
   }
 
   function runProfiledPhase<T>(
@@ -257,12 +256,12 @@ export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
     }
   }
 
-  function runFrame(deltaSeconds: number): Result<void, AppError | RhiError> {
+  function runFrame(deltaSeconds: number): Result<void, AppError | RenderError> {
     const session = opts.profiler?.activeSession();
     let profileFrame: ProfileFrameToken | undefined;
-    let frameError: AppError | RhiError | undefined;
+    let frameError: AppError | RenderError | undefined;
     let primaryUpdated = false;
-    const reportError = (error: AppError | RhiError): void => {
+    const reportError = (error: AppError | RenderError): void => {
       frameError ??= error;
       opts.onError?.(error);
     };
@@ -304,7 +303,7 @@ export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
 
       const attachedInjectedWorlds = syncInjectedAttachments(injected?.worlds, reportError);
       const updatedWorlds = injected === undefined ? undefined : new Set<World>();
-      if (updatedWorlds !== undefined && primaryUpdated && primaryAttached) {
+      if (updatedWorlds !== undefined && primaryUpdated && leases.has(world)) {
         updatedWorlds.add(world);
       }
 
@@ -327,32 +326,46 @@ export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
 
       runProfiledPhase(session, 'renderer-draw', () => {
         try {
-          const profileOptions = profileFrame === undefined ? {} : { profileFrame };
           let drawResult: ReturnType<Renderer['draw']>;
           if (injected === undefined) {
-            if (!primaryUpdated || !primaryAttached) return;
-            drawResult = renderer.draw(primaryDrawWorlds, {
-              cameraOwner: 0,
-              resourceOwner: 0,
-              ...profileOptions,
+            const primaryLease = leases.get(world);
+            if (!primaryUpdated || primaryLease === undefined) return;
+            drawResult = renderer.draw({
+              leases: [primaryLease],
+              camera: { lease: primaryLease },
+              environment: { lease: primaryLease },
+              ...(profileFrame === undefined ? {} : { profileFrame }),
             });
           } else {
             if (updatedWorlds === undefined) return;
-            const readyWorlds = injected.worlds.filter((candidate) => updatedWorlds.has(candidate));
+            const readyEntries = injected.worlds
+              .filter((candidate) => updatedWorlds.has(candidate))
+              .map((candidate) => ({ candidate, lease: leases.get(candidate) }))
+              .filter(
+                (entry): entry is { candidate: World; lease: RenderWorldLease } =>
+                  entry.lease !== undefined,
+              );
+            const readyLeases = readyEntries.map((entry) => entry.lease);
             const cameraWorld = injected.worlds[injected.cameraOwner];
-            const resourceWorld = injected.worlds[injected.resourceOwner];
-            const cameraOwner = cameraWorld === undefined ? -1 : readyWorlds.indexOf(cameraWorld);
-            const resourceOwner =
-              resourceWorld === undefined ? -1 : readyWorlds.indexOf(resourceWorld);
-            if (readyWorlds.length === 0 || cameraOwner < 0 || resourceOwner < 0) return;
-            drawResult = renderer.draw(readyWorlds, {
-              cameraOwner,
-              resourceOwner,
-              ...profileOptions,
+            const environmentWorld = injected.worlds[injected.resourceOwner];
+            if (cameraWorld === undefined || environmentWorld === undefined) return;
+            const cameraLease = leases.get(cameraWorld);
+            const environmentLease = leases.get(environmentWorld);
+            if (
+              readyLeases.length === 0 ||
+              cameraLease === undefined ||
+              environmentLease === undefined
+            )
+              return;
+            drawResult = renderer.draw({
+              leases: readyLeases,
+              camera: { lease: cameraLease },
+              environment: { lease: environmentLease },
+              ...(profileFrame === undefined ? {} : { profileFrame }),
             });
           }
           if (drawResult !== undefined) {
-            const result = drawResult as { ok: boolean; error?: RhiError };
+            const result = drawResult as { ok: boolean; error?: RenderError };
             if (!result.ok && result.error !== undefined) {
               reportError(result.error);
             }
@@ -363,6 +376,12 @@ export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
       });
     });
     endFrame(session);
+    try {
+      opts.debugRhi?.onFrameEnd();
+    } catch {
+      // Debug capture is an observational bridge. A recorder failure must not
+      // change the App frame result or make the host loop stop.
+    }
     return frameError === undefined ? ok(undefined) : err(frameError);
   }
 
@@ -374,11 +393,6 @@ export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
     // Renderer.recover() rebuild, but freeze simulation so recovery does not
     // advance the World against frames that cannot be submitted. The next
     // tick observes `alive` and resumes the normal update/draw sequence.
-    if (renderer.health?.().reason === 'device-lost') {
-      pendingFrameId = raf(tick);
-      return;
-    }
-
     const timestamp = now();
     const deltaSeconds = (timestamp - lastTimestamp) / 1000;
     lastTimestamp = timestamp;
@@ -397,7 +411,7 @@ export function createFrameLoop(opts: FrameLoopOptions): FrameLoopHandle {
       if (drawSource !== nextDrawSource) syncInjectedAttachments(undefined);
       drawSource = nextDrawSource;
     },
-    stepFrame(deltaSeconds): Result<void, AppError | RhiError> {
+    stepFrame(deltaSeconds): Result<void, AppError | RenderError> {
       const reason =
         state !== 'paused'
           ? 'state'

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

@@ -11,22 +11,23 @@ import {
   ownedInputBackendPlugin,
 } from '@forgeax/engine-input';
 import type { Plugin } from '@forgeax/engine-plugin';
-import { ownedRendererPlugin, renderComponentsPlugin } from '@forgeax/engine-render';
-import { createDebugDrawOnReady, releaseDebugDraw } from '@forgeax/engine-render/internal';
+import { renderComponentsPlugin } from '@forgeax/engine-render';
 import { scenePlugin } from '@forgeax/engine-scene';
 import { statePlugin } from '@forgeax/engine-state';
-
 import { inputMapPlugin } from '../input-map-plugin';
 import { inputPlugin } from '../input-plugin';
 import {
-  assetRegistryPlugin,
-  assetRegistryWorldPlugin,
-  assetsWorldPlugin,
-  rendererAssetsPlugin,
-} from './assets-world-plugin';
+  ownedRendererPlugin,
+  type RenderFeatureHost,
+  renderFeatureHostPlugin,
+} from '../renderer-plugin';
+import { assetsWorldPlugin, rendererAssetsPlugin } from './assets-world-plugin';
+import { createDebugDrawOnReady, type RendererDebugDrawHost, releaseDebugDraw } from './debug-draw';
 import type { EngineProfileBase } from './engine-profile-common';
 
 export interface MainEngineProfileOptions extends EngineProfileBase {
+  readonly rendererDebugDrawHost?: RendererDebugDrawHost;
+  readonly rendererFeatureHost?: RenderFeatureHost;
   readonly animationPayloads: AnimationPayloadLookup;
   readonly onDebugDrawReady?: (debugDraw: DebugDraw) => void;
   readonly input?: InputBackend;
@@ -34,16 +35,17 @@ export interface MainEngineProfileOptions extends EngineProfileBase {
   readonly inputMap?: readonly ActionConfig[];
 }
 
-function debugDrawPlugin(onReady: (debugDraw: DebugDraw) => void): Plugin {
+function debugDrawPlugin(
+  context: RendererDebugDrawHost,
+  onReady: (debugDraw: DebugDraw) => void,
+): Plugin {
   return {
     name: 'debug-draw',
-    inject: ['renderer'],
     async apply(ctx) {
-      if (ctx.renderer === undefined) throw new Error('debug draw requires the renderer service');
       try {
-        const debugDraw = await createDebugDrawOnReady(ctx.renderer);
+        const debugDraw = await createDebugDrawOnReady(context);
         onReady(debugDraw);
-        ctx.effect(() => () => releaseDebugDraw(debugDraw), 'render/debug-draw');
+        ctx.effect(() => () => releaseDebugDraw(context, debugDraw), 'render/debug-draw');
       } catch {
         // DebugDraw is optional; renderer error reporting owns creation failures.
       }
@@ -56,10 +58,10 @@ export function mainEngineProfile(options: MainEngineProfileOptions): Plugin[] {
   return [
     ownedRendererPlugin(options.renderer),
     renderComponentsPlugin(),
-    rendererAssetsPlugin(),
-    ...(options.assetAssembly === undefined
+    ...(options.rendererFeatureHost === undefined
       ? []
-      : [assetRegistryPlugin(options.assetAssembly), assetRegistryWorldPlugin()]),
+      : [renderFeatureHostPlugin(options.rendererFeatureHost)]),
+    rendererAssetsPlugin(options.assets),
     assetsWorldPlugin(),
     ...(options.input === undefined
       ? []
@@ -72,7 +74,9 @@ export function mainEngineProfile(options: MainEngineProfileOptions): Plugin[] {
     animationPayloadsPlugin(options.animationPayloads),
     animationRuntimePlugin(),
     statePlugin(),
-    ...(options.onDebugDrawReady === undefined ? [] : [debugDrawPlugin(options.onDebugDrawReady)]),
+    ...(options.onDebugDrawReady === undefined || options.rendererDebugDrawHost === undefined
+      ? []
+      : [debugDrawPlugin(options.rendererDebugDrawHost, options.onDebugDrawReady)]),
     ...(options.input === undefined ? [] : [inputPlugin()]),
     ...(options.inputMap === undefined ? [] : [inputMapPlugin(options.inputMap)]),
     ...(options.extensions ?? []),

package/src/internal/remote-serve-flag.ts

@@ -1,16 +1,13 @@
 // @forgeax/engine-app/internal/remote-serve-flag -- FORGEAX_ENGINE_REMOTE_SERVE
 // dual-source resolution (plan-strategy secondary D-7).
 //
-// The remote eval server is auto-started in dev mode on Node hosts (vite's
-// import.meta.env.DEV) and production builds skip it. Browsers never start this
-// server: it owns a Node WebSocket listener and the browser has a separate
-// opt-in bridge. Headless/dawn-node can opt in via the
+// The remote eval server is auto-started in dev mode (vite's import.meta.env.DEV)
+// and production builds skip it. Headless/dawn-node can opt in via the
 // FORGEAX_ENGINE_REMOTE_SERVE=1 env var.
 //
 // Dual sources (mirrors rhi-debug-flag.ts pattern):
 //   browser (vite): import.meta.env.DEV is statically replaced by vite
-//     (true in dev server, false in production build), but the browser guard
-//     below keeps the Node-only server import out of the page.
+//     (true in dev server, false in production build).
 //   dawn-node     : import.meta may be undefined; fallback to
 //     globalThis.process.env.FORGEAX_ENGINE_REMOTE_SERVE === '1'.
 //
@@ -26,24 +23,18 @@ interface RemoteServeEnv {
  * Resolve whether the remote eval server should be started.
  *
  * Returns `true` when:
- *   - a Node host is in vite dev mode (import.meta.env.DEV === true), OR
+ *   - vite dev mode (import.meta.env.DEV === true), OR
  *   - headless/dawn-node with FORGEAX_ENGINE_REMOTE_SERVE=1 opt-in
  *
- * Returns `false` in browsers, production builds, and headless hosts without
- * explicit opt-in. The browser path must not even request the Node-only
- * `@forgeax/engine-remote/server` module: Vite would otherwise discover it
- * during the first Play boot and refresh the live dependency graph.
+ * Returns `false` in production builds and headless without explicit opt-in.
  *
  * @param isDev flag from import.meta.env.DEV (undefined when import.meta absent)
  * @param processEnv globalThis.process?.env when present, else undefined
- * @param isBrowser true for the DOM canvas host; false for Node/headless hosts
  */
 export function resolveRemoteServeFlag(
   isDev: boolean | undefined,
   processEnv: RemoteServeEnv | undefined,
-  isBrowser = false,
 ): boolean {
-  if (isBrowser) return false;
   if (isDev === true) return true;
   if (processEnv?.FORGEAX_ENGINE_REMOTE_SERVE === '1') return true;
   return false;

package/src/internal/rhi-capture.ts

@@ -1,4 +1,4 @@
-import type { RhiBackendInstrumentation } from '@forgeax/engine-render/internal';
+import type { RhiBackendInstrumentation } from '@forgeax/engine-render/internal/construct-renderer';
 import { RhiError } from '@forgeax/engine-rhi';
 import type {
   CaptureFrameOptions,

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

@@ -6,23 +6,23 @@ import {
 import { type AudioBackend, audioBackendPlugin } from '@forgeax/engine-audio';
 import { type InputBackend, inputBackendPlugin } from '@forgeax/engine-input';
 import type { Plugin } from '@forgeax/engine-plugin';
-import { ownedRendererPlugin, renderComponentsPlugin } from '@forgeax/engine-render';
+import { renderComponentsPlugin } from '@forgeax/engine-render';
 import { scenePlugin } from '@forgeax/engine-scene';
 import { statePlugin } from '@forgeax/engine-state';
-
 import { inputPlugin } from '../input-plugin';
 import {
-  assetRegistryPlugin,
-  assetRegistryWorldPlugin,
-  assetsWorldPlugin,
-  rendererAssetsPlugin,
-} from './assets-world-plugin';
+  ownedRendererPlugin,
+  type RenderFeatureHost,
+  renderFeatureHostPlugin,
+} from '../renderer-plugin';
+import { assetsWorldPlugin, rendererAssetsPlugin } from './assets-world-plugin';
 import type { EngineProfileBase } from './engine-profile-common';
 
 export interface WorkerEngineProfileOptions extends EngineProfileBase {
   readonly animationPayloads: AnimationPayloadLookup;
   readonly input: InputBackend;
   readonly audio: AudioBackend;
+  readonly rendererFeatureHost?: RenderFeatureHost;
 }
 
 /** Static Engine Worker selection; Host-only acquisition stays outside this realm. */
@@ -30,10 +30,10 @@ export function workerEngineProfile(options: WorkerEngineProfileOptions): Plugin
   return [
     ownedRendererPlugin(options.renderer),
     renderComponentsPlugin(),
-    rendererAssetsPlugin(),
-    ...(options.assetAssembly === undefined
+    ...(options.rendererFeatureHost === undefined
       ? []
-      : [assetRegistryPlugin(options.assetAssembly), assetRegistryWorldPlugin()]),
+      : [renderFeatureHostPlugin(options.rendererFeatureHost)]),
+    rendererAssetsPlugin(options.assets),
     assetsWorldPlugin(),
     inputBackendPlugin(options.input),
     audioBackendPlugin(options.audio),