@vgai/engine 0.5.17 → 0.5.18

package/dist/adapter/renderer-config.d.ts

@@ -0,0 +1,83 @@
+/**
+ * adapter/renderer-config.ts — the seam a WORLD uses to state how its own frame is rendered.
+ *
+ * It lives in the ADAPTER SEAM, not in a surface entry, because `WorldRendererConfig` IS part of
+ * the root contract: `MountedThreeRoot.rendererConfig` reports it (`./root-adapter.ts`) and
+ * `./root-seam-contract.ts` already lists it as a contract field. The seam defines the shape; the
+ * surface entries and the editor CONFORM to it — `world3d-react/r3f-adapter.tsx` is the declarer,
+ * `runtime/create-runtime.ts` the host, `editor/src/components/ViewportPanel.tsx` the editor's
+ * applier. Do NOT move it back under `world3d-react/`: nothing here touches react, and a core
+ * adapter file reaching into a react entry is exactly what `react-core-import-ban.test.ts` forbids
+ * (that ban carries no type-only carve-out on purpose — unlike its pixi sibling, whose carve-out
+ * exists only because `PIXI.Container` is a third-party type core cannot relocate).
+ *
+ * The host owns the `WebGLRenderer` (`ThreeHostContext.renderer`) and configures it with this
+ * engine's defaults: ACES tone mapping, sRGB output, PCF-soft shadows. Those defaults are right for
+ * a world authored against them and WRONG for a world that was authored against a different
+ * engine's pipeline — an imported Godot 3 GLES2 game does gamma-space lighting with no tonemapper
+ * at all, so ACES quietly desaturates and darkens every colour its author picked.
+ *
+ * So a world may DECLARE the pipeline it was authored for, and `createR3FAdapter` applies it to the
+ * host's renderer for the life of the mount, restoring what it found on dispose. Three properties
+ * of that shape are load-bearing:
+ *
+ *  - **It is per-renderer, never engine-wide.** Every field here is a `WebGLRenderer` instance
+ *    property, and a play root gets its own renderer (`create-runtime.ts`). Nothing here reaches a
+ *    module-level three global, so one world's declaration cannot change how the editor's own
+ *    viewport, another root, or a thumbnail bake renders.
+ *  - **Absent means "leave the host's value alone".** Every field is optional and an omitted one
+ *    is never written, so declaring a tone mapping does not silently reset the clear colour.
+ *  - **It is restored on dispose.** The renderer outlives the mount, so a world that did not put
+ *    back what it found would leak its pipeline into whatever mounts next.
+ *
+ * This is deliberately NOT a general render-settings system. It carries what a world can honestly
+ * state about its own colour pipeline and nothing else; a property the host fixes at CONSTRUCTION
+ * (the WebGL context's `antialias` attribute, and therefore the MSAA sample count) cannot be
+ * declared here, because there would be no honest moment to apply it.
+ */
+import type * as THREE from 'three';
+/** The tone-mapping operators three exposes, named as data rather than as three's numeric enum. */
+export type WorldToneMapping = 'none' | 'linear' | 'reinhard' | 'cineon' | 'aces' | 'agx' | 'neutral';
+/**
+ * The output transfer function the frame is written with.
+ *
+ *  - `srgb` — three's own default and this engine's: linear lighting, sRGB encode on output.
+ *  - `srgb-linear` — NO output transform. This is what a gamma-space renderer needs: the shading
+ *    result is already in display space and encoding it a second time washes the frame out.
+ */
+export type WorldOutputColorSpace = 'srgb' | 'srgb-linear';
+/**
+ * The shadow-map filter, named as data rather than as three's numeric enum.
+ *
+ * This is a renderer INSTANCE property (`WebGLRenderer.shadowMap.type`), not a context attribute,
+ * so unlike MSAA it has an honest moment at which a world can ask for it — which is the whole test
+ * this file's header states. A source engine that declares its own shadow filter (Godot 3's
+ * `rendering/quality/shadows/filter_mode`) would otherwise inherit whatever the host built with.
+ */
+export type WorldShadowMapType = 'basic' | 'pcf' | 'pcf-soft' | 'vsm';
+/** What a world may declare about the renderer that draws it. Every field is optional; see header. */
+export interface WorldRendererConfig {
+    readonly toneMapping?: WorldToneMapping | undefined;
+    readonly toneMappingExposure?: number | undefined;
+    readonly outputColorSpace?: WorldOutputColorSpace | undefined;
+    /**
+     * `WebGLRenderer.shadowMap.type`. Writing it after a shadow map has already been built needs
+     * `shadowMap.needsUpdate`, which this function sets — three caches the compiled depth material
+     * per type and would otherwise keep filtering with the previous one.
+     */
+    readonly shadowMapType?: WorldShadowMapType | undefined;
+    /**
+     * The colour the frame is cleared to, as a CSS hex string. The renderer's existing clear ALPHA
+     * is preserved: a stacked canvas is transparent on purpose (`create-runtime.ts` gives every
+     * non-bottom root `alpha: true`), and forcing it opaque here would hide every layer below.
+     */
+    readonly clearColor?: string | undefined;
+}
+/**
+ * Apply `config` to `renderer`, returning the restore function that puts back what was there.
+ *
+ * `three` is passed in rather than imported for values so the enum constants come from the HOST's
+ * three instance — the same identity rule `r3f-adapter.tsx` follows for the scene and camera.
+ */
+export declare function applyWorldRendererConfig(three: typeof THREE, renderer: THREE.WebGLRenderer, config: WorldRendererConfig): () => void;
+//# sourceMappingURL=renderer-config.d.ts.map

package/dist/adapter/renderer-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer-config.d.ts","sourceRoot":"","sources":["../../src/adapter/renderer-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,mGAAmG;AACnG,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,MAAM,GACN,KAAK,GACL,SAAS,CAAC;AAEd;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,aAAa,CAAC;AAE3D;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,KAAK,GAAG,UAAU,GAAG,KAAK,CAAC;AAEtE,sGAAsG;AACtG,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;IAC9D;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACxD;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,KAAK,EACnB,QAAQ,EAAE,KAAK,CAAC,aAAa,EAC7B,MAAM,EAAE,mBAAmB,GAC1B,MAAM,IAAI,CA+EZ"}

package/dist/adapter/renderer-config.js

@@ -0,0 +1,121 @@
+/**
+ * adapter/renderer-config.ts — the seam a WORLD uses to state how its own frame is rendered.
+ *
+ * It lives in the ADAPTER SEAM, not in a surface entry, because `WorldRendererConfig` IS part of
+ * the root contract: `MountedThreeRoot.rendererConfig` reports it (`./root-adapter.ts`) and
+ * `./root-seam-contract.ts` already lists it as a contract field. The seam defines the shape; the
+ * surface entries and the editor CONFORM to it — `world3d-react/r3f-adapter.tsx` is the declarer,
+ * `runtime/create-runtime.ts` the host, `editor/src/components/ViewportPanel.tsx` the editor's
+ * applier. Do NOT move it back under `world3d-react/`: nothing here touches react, and a core
+ * adapter file reaching into a react entry is exactly what `react-core-import-ban.test.ts` forbids
+ * (that ban carries no type-only carve-out on purpose — unlike its pixi sibling, whose carve-out
+ * exists only because `PIXI.Container` is a third-party type core cannot relocate).
+ *
+ * The host owns the `WebGLRenderer` (`ThreeHostContext.renderer`) and configures it with this
+ * engine's defaults: ACES tone mapping, sRGB output, PCF-soft shadows. Those defaults are right for
+ * a world authored against them and WRONG for a world that was authored against a different
+ * engine's pipeline — an imported Godot 3 GLES2 game does gamma-space lighting with no tonemapper
+ * at all, so ACES quietly desaturates and darkens every colour its author picked.
+ *
+ * So a world may DECLARE the pipeline it was authored for, and `createR3FAdapter` applies it to the
+ * host's renderer for the life of the mount, restoring what it found on dispose. Three properties
+ * of that shape are load-bearing:
+ *
+ *  - **It is per-renderer, never engine-wide.** Every field here is a `WebGLRenderer` instance
+ *    property, and a play root gets its own renderer (`create-runtime.ts`). Nothing here reaches a
+ *    module-level three global, so one world's declaration cannot change how the editor's own
+ *    viewport, another root, or a thumbnail bake renders.
+ *  - **Absent means "leave the host's value alone".** Every field is optional and an omitted one
+ *    is never written, so declaring a tone mapping does not silently reset the clear colour.
+ *  - **It is restored on dispose.** The renderer outlives the mount, so a world that did not put
+ *    back what it found would leak its pipeline into whatever mounts next.
+ *
+ * This is deliberately NOT a general render-settings system. It carries what a world can honestly
+ * state about its own colour pipeline and nothing else; a property the host fixes at CONSTRUCTION
+ * (the WebGL context's `antialias` attribute, and therefore the MSAA sample count) cannot be
+ * declared here, because there would be no honest moment to apply it.
+ */
+/**
+ * Apply `config` to `renderer`, returning the restore function that puts back what was there.
+ *
+ * `three` is passed in rather than imported for values so the enum constants come from the HOST's
+ * three instance — the same identity rule `r3f-adapter.tsx` follows for the scene and camera.
+ */
+export function applyWorldRendererConfig(three, renderer, config) {
+    // A host that mounts a world WITHOUT rasterizing it hands the adapter a duck-typed renderer —
+    // the editor's design session (`createDesignTimeRenderer`: four members, deliberately never
+    // widened) and jsdom test harnesses both do. Such a surface has no colour pipeline to configure:
+    // the frame the user sees is drawn by a DIFFERENT renderer (the editor's own), so applying the
+    // world's config there is meaningless — and calling `getClearColor` on it is a TypeError that
+    // unmounts the whole world at edit time (measured: every Godot port's edit viewport blanked with
+    // '"world" failed to mount — renderer.getClearColor is not a function'). Detect the real
+    // `WebGLRenderer` surface by the one method this function must call, and no-op otherwise.
+    if (typeof renderer.getClearColor !== 'function') {
+        return () => { };
+    }
+    const toneMappings = {
+        none: three.NoToneMapping,
+        linear: three.LinearToneMapping,
+        reinhard: three.ReinhardToneMapping,
+        cineon: three.CineonToneMapping,
+        aces: three.ACESFilmicToneMapping,
+        agx: three.AgXToneMapping,
+        neutral: three.NeutralToneMapping,
+    };
+    const colorSpaces = {
+        srgb: three.SRGBColorSpace,
+        'srgb-linear': three.LinearSRGBColorSpace,
+    };
+    const shadowMapTypes = {
+        basic: three.BasicShadowMap,
+        pcf: three.PCFShadowMap,
+        'pcf-soft': three.PCFSoftShadowMap,
+        vsm: three.VSMShadowMap,
+    };
+    const restores = [];
+    if (config.toneMapping !== undefined) {
+        const previous = renderer.toneMapping;
+        renderer.toneMapping = toneMappings[config.toneMapping];
+        restores.push(() => {
+            renderer.toneMapping = previous;
+        });
+    }
+    if (config.toneMappingExposure !== undefined) {
+        const previous = renderer.toneMappingExposure;
+        renderer.toneMappingExposure = config.toneMappingExposure;
+        restores.push(() => {
+            renderer.toneMappingExposure = previous;
+        });
+    }
+    if (config.outputColorSpace !== undefined) {
+        const previous = renderer.outputColorSpace;
+        renderer.outputColorSpace = colorSpaces[config.outputColorSpace];
+        restores.push(() => {
+            renderer.outputColorSpace = previous;
+        });
+    }
+    if (config.shadowMapType !== undefined && renderer.shadowMap !== undefined) {
+        const previous = renderer.shadowMap.type;
+        renderer.shadowMap.type = shadowMapTypes[config.shadowMapType];
+        renderer.shadowMap.needsUpdate = true;
+        restores.push(() => {
+            renderer.shadowMap.type = previous;
+            renderer.shadowMap.needsUpdate = true;
+        });
+    }
+    if (config.clearColor !== undefined) {
+        const previousColor = new three.Color();
+        renderer.getClearColor(previousColor);
+        // Alpha is READ BACK and re-passed, never assumed: see `clearColor`'s doc above.
+        const alpha = renderer.getClearAlpha();
+        renderer.setClearColor(new three.Color(config.clearColor), alpha);
+        restores.push(() => {
+            renderer.setClearColor(previousColor, alpha);
+        });
+    }
+    return () => {
+        // Reverse order, so a field written twice (it cannot be, today) unwinds correctly.
+        for (let i = restores.length - 1; i >= 0; i--)
+            restores[i]?.();
+    };
+}

package/dist/adapter/root-adapter.d.ts

@@ -8,10 +8,10 @@
  */
 import type { Container } from 'pixi.js';
 import type * as THREE from 'three';
-import type { WorldRendererConfig } from '../world3d-react/renderer-config';
 import type { AdapterSurface } from './adapter-surface';
 import type { AuthoringAdapter } from './authoring';
 import type { HostContextFor } from './host-context';
+import type { WorldRendererConfig } from './renderer-config';
 import type { SystemAdapters } from './system-adapter';
 /**
  * The ingested-world observation contract (T7.4 slice 2, "the
@@ -91,7 +91,7 @@ export interface MountedThreeRoot extends MountedRootBase {
     /**
      * The colour pipeline this world was authored for, REPORTED rather than
      * applied — the adapter has already applied it to the renderer its own host
-     * handed it (`world3d-react/renderer-config.ts`).
+     * handed it (`./renderer-config.ts`).
      *
      * It is here because the host that MOUNTS a world is not always the host
      * that DRAWS it. The editor's design session mounts against a

package/dist/adapter/root-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/root-adapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"root-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/root-adapter.ts"],"names":[],"mappings":"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"}

package/dist/manifest/schema.js

@@ -483,7 +483,7 @@ export const GameManifestSchema = z
         antialias: z
             .boolean()
             .describe('Whether every three root is built with a multisampled drawing buffer. This is the ' +
-            'ONE render property a world cannot declare for itself (world3d-react/' +
+            'ONE render property a world cannot declare for itself (adapter/' +
             'renderer-config.ts): a WebGL context fixes its sample count at CREATION from this ' +
             'boolean, long before a world mounts, so it belongs to the PROJECT. The runtime ' +
             'reader is mount-manifest.ts, which threads it into createHostRenderer for each ' +

package/dist/runtime/mount-manifest.js

@@ -234,7 +234,7 @@ export async function mountManifestRoots(opts) {
         headless: opts.headless,
         // `rendering.antialias` reaches the WebGL context at CONSTRUCTION and can be honoured
         // nowhere else — see the manifest schema's own `rendering` block and
-        // `world3d-react/renderer-config.ts`'s header for why it is not a world-level declaration.
+        // `adapter/renderer-config.ts`'s header for why it is not a world-level declaration.
         ...(manifest.rendering === undefined ? {} : { antialias: manifest.rendering.antialias }),
         seed: resolvedSeed,
         playtest: opts.playtest,

package/dist/world3d-react/index.d.ts

@@ -39,9 +39,9 @@
  * should pull it into its graph; a deep import keeps this barrel's peer
  * contract to `react`/`@react-three/fiber`/`three` alone.
  */
+export { applyWorldRendererConfig, type WorldOutputColorSpace, type WorldRendererConfig, type WorldToneMapping, } from '../adapter/renderer-config';
 export { EngineBridge, type EngineBridgeValue, useGameContext } from './engine-bridge';
 export { type CreateR3FAdapterOptions, createR3FAdapter } from './r3f-adapter';
 export { r3fRootFactory, resolveR3FEntryAdapter } from './r3f-root-factory';
-export { applyWorldRendererConfig, type WorldOutputColorSpace, type WorldRendererConfig, type WorldToneMapping, } from './renderer-config';
 export { createR3FRootContext, DEFAULT_INPUT_MAP_PATH, type R3FGameContext, type R3FRootContextOptions, type R3FRootRuntime, } from './world-context';
 //# sourceMappingURL=index.d.ts.map

package/dist/world3d-react/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/world3d-react/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACvF,OAAO,EAAE,KAAK,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EACL,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,GACpB,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/world3d-react/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EACL,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACvF,OAAO,EAAE,KAAK,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,GACpB,MAAM,iBAAiB,CAAC"}

package/dist/world3d-react/index.js

@@ -39,8 +39,8 @@
  * should pull it into its graph; a deep import keeps this barrel's peer
  * contract to `react`/`@react-three/fiber`/`three` alone.
  */
+export { applyWorldRendererConfig, } from '../adapter/renderer-config';
 export { EngineBridge, useGameContext } from './engine-bridge';
 export { createR3FAdapter } from './r3f-adapter';
 export { r3fRootFactory, resolveR3FEntryAdapter } from './r3f-root-factory';
-export { applyWorldRendererConfig, } from './renderer-config';
 export { createR3FRootContext, DEFAULT_INPUT_MAP_PATH, } from './world-context';

package/dist/world3d-react/r3f-adapter.d.ts

@@ -20,7 +20,7 @@
  */
 import { type ReactNode } from 'react';
 import type { RootAdapter } from '../adapter';
-import { type WorldRendererConfig } from './renderer-config';
+import { type WorldRendererConfig } from '../adapter/renderer-config';
 /** What {@link createR3FAdapter} needs to build one `RootAdapter`. */
 export interface CreateR3FAdapterOptions {
     /** Stable id (telemetry/registry/conformance) — `RootAdapter.id`. */
@@ -45,7 +45,7 @@ export interface CreateR3FAdapterOptions {
     /** The colour pipeline this world was AUTHORED for, applied to the host's renderer for the life
      *  of the mount and restored on dispose. Omit it (every world here does) to keep the host's own
      *  defaults; declare it when the world's colours were picked against a different engine's
-     *  pipeline — see `./renderer-config.ts`. */
+     *  pipeline — see `../adapter/renderer-config.ts`. */
     readonly renderer?: WorldRendererConfig | undefined;
 }
 /**

package/dist/world3d-react/r3f-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"r3f-adapter.d.ts","sourceRoot":"","sources":["../../src/world3d-react/r3f-adapter.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAWH,OAAO,EAA2B,KAAK,SAAS,EAAsB,MAAM,OAAO,CAAC;AACpF,OAAO,KAAK,EAAoB,WAAW,EAAoB,MAAM,YAAY,CAAC;AAgBlF,OAAO,EAA4B,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAgDvF,sEAAsE;AACtE,MAAM,WAAW,uBAAuB;IACtC,qEAAqE;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;uBAEmB;IACnB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B;;;;0CAIsC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClD;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7C;;;iDAG6C;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACrD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,WAAW,CA2kB9E"}
+{"version":3,"file":"r3f-adapter.d.ts","sourceRoot":"","sources":["../../src/world3d-react/r3f-adapter.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAWH,OAAO,EAA2B,KAAK,SAAS,EAAsB,MAAM,OAAO,CAAC;AACpF,OAAO,KAAK,EAAoB,WAAW,EAAoB,MAAM,YAAY,CAAC;AAClF,OAAO,EAA4B,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AA+DhG,sEAAsE;AACtE,MAAM,WAAW,uBAAuB;IACtC,qEAAqE;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;uBAEmB;IACnB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B;;;;0CAIsC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClD;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7C;;;0DAGsD;IACtD,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CACrD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,WAAW,CA2kB9E"}

package/dist/world3d-react/r3f-adapter.js

@@ -20,6 +20,7 @@
  */
 import { advance, createRoot, extend, flushSync, events as pointerEvents, useFrame, } from '@react-three/fiber';
 import { createElement, Fragment, useEffect, useMemo } from 'react';
+import { applyWorldRendererConfig } from '../adapter/renderer-config';
 import { registerRenderVitals } from '../dev/register-render-vitals';
 import { createRenderDebugAdapter, frameCaptureContextFor, } from '../dev/render-debug-adapter';
 import { collectRenderMemory } from '../dev/render-memory';
@@ -30,7 +31,6 @@ import { createSoftParticleDepthPass } from '../render/soft-particle-depth';
 import { getDebugRegistry } from '../runtime/debug-registry';
 import { devBuildEnabled } from '../runtime/dev-build';
 import { EngineBridge } from './engine-bridge';
-import { applyWorldRendererConfig } from './renderer-config';
 import { createR3FRootContext, DEFAULT_INPUT_MAP_PATH, wireGameInputSeams } from './world-context';
 /**
  * Scene depth for any soft-particle system this world mounted, drawn between

package/dist/world3d-react/renderer-config.d.ts

@@ -1,73 +1,11 @@
 /**
- * world3d-react/renderer-config.ts — the seam a WORLD uses to state how its own frame is rendered.
+ * `@engine/world3d-react/renderer-config` — a published entry point.
  *
- * The host owns the `WebGLRenderer` (`ThreeHostContext.renderer`) and configures it with this
- * engine's defaults: ACES tone mapping, sRGB output, PCF-soft shadows. Those defaults are right for
- * a world authored against them and WRONG for a world that was authored against a different
- * engine's pipeline — an imported Godot 3 GLES2 game does gamma-space lighting with no tonemapper
- * at all, so ACES quietly desaturates and darkens every colour its author picked.
- *
- * So a world may DECLARE the pipeline it was authored for, and `createR3FAdapter` applies it to the
- * host's renderer for the life of the mount, restoring what it found on dispose. Three properties
- * of that shape are load-bearing:
- *
- *  - **It is per-renderer, never engine-wide.** Every field here is a `WebGLRenderer` instance
- *    property, and a play root gets its own renderer (`create-runtime.ts`). Nothing here reaches a
- *    module-level three global, so one world's declaration cannot change how the editor's own
- *    viewport, another root, or a thumbnail bake renders.
- *  - **Absent means "leave the host's value alone".** Every field is optional and an omitted one
- *    is never written, so declaring a tone mapping does not silently reset the clear colour.
- *  - **It is restored on dispose.** The renderer outlives the mount, so a world that did not put
- *    back what it found would leak its pipeline into whatever mounts next.
- *
- * This is deliberately NOT a general render-settings system. It carries what a world can honestly
- * state about its own colour pipeline and nothing else; a property the host fixes at CONSTRUCTION
- * (the WebGL context's `antialias` attribute, and therefore the MSAA sample count) cannot be
- * declared here, because there would be no honest moment to apply it.
- */
-import type * as THREE from 'three';
-/** The tone-mapping operators three exposes, named as data rather than as three's numeric enum. */
-export type WorldToneMapping = 'none' | 'linear' | 'reinhard' | 'cineon' | 'aces' | 'agx' | 'neutral';
-/**
- * The output transfer function the frame is written with.
- *
- *  - `srgb` — three's own default and this engine's: linear lighting, sRGB encode on output.
- *  - `srgb-linear` — NO output transform. This is what a gamma-space renderer needs: the shading
- *    result is already in display space and encoding it a second time washes the frame out.
- */
-export type WorldOutputColorSpace = 'srgb' | 'srgb-linear';
-/**
- * The shadow-map filter, named as data rather than as three's numeric enum.
- *
- * This is a renderer INSTANCE property (`WebGLRenderer.shadowMap.type`), not a context attribute,
- * so unlike MSAA it has an honest moment at which a world can ask for it — which is the whole test
- * this file's header states. A source engine that declares its own shadow filter (Godot 3's
- * `rendering/quality/shadows/filter_mode`) would otherwise inherit whatever the host built with.
- */
-export type WorldShadowMapType = 'basic' | 'pcf' | 'pcf-soft' | 'vsm';
-/** What a world may declare about the renderer that draws it. Every field is optional; see header. */
-export interface WorldRendererConfig {
-    readonly toneMapping?: WorldToneMapping | undefined;
-    readonly toneMappingExposure?: number | undefined;
-    readonly outputColorSpace?: WorldOutputColorSpace | undefined;
-    /**
-     * `WebGLRenderer.shadowMap.type`. Writing it after a shadow map has already been built needs
-     * `shadowMap.needsUpdate`, which this function sets — three caches the compiled depth material
-     * per type and would otherwise keep filtering with the previous one.
-     */
-    readonly shadowMapType?: WorldShadowMapType | undefined;
-    /**
-     * The colour the frame is cleared to, as a CSS hex string. The renderer's existing clear ALPHA
-     * is preserved: a stacked canvas is transparent on purpose (`create-runtime.ts` gives every
-     * non-bottom root `alpha: true`), and forcing it opaque here would hide every layer below.
-     */
-    readonly clearColor?: string | undefined;
-}
-/**
- * Apply `config` to `renderer`, returning the restore function that puts back what was there.
- *
- * `three` is passed in rather than imported for values so the enum constants come from the HOST's
- * three instance — the same identity rule `r3f-adapter.tsx` follows for the scene and camera.
+ * The engine package's export map is the wildcard `"./*"`, so every file under
+ * `packages/engine/src/` is an entry point a game outside this repo can import by path. The module
+ * itself now lives in the adapter seam (`@engine/adapter/renderer-config`, which its header
+ * explains), and this file keeps the path that shipped resolving to it. Import the seam path in
+ * new code.
  */
-export declare function applyWorldRendererConfig(three: typeof THREE, renderer: THREE.WebGLRenderer, config: WorldRendererConfig): () => void;
+export * from '../adapter/renderer-config';
 //# sourceMappingURL=renderer-config.d.ts.map

package/dist/world3d-react/renderer-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer-config.d.ts","sourceRoot":"","sources":["../../src/world3d-react/renderer-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,mGAAmG;AACnG,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,MAAM,GACN,KAAK,GACL,SAAS,CAAC;AAEd;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,aAAa,CAAC;AAE3D;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,KAAK,GAAG,UAAU,GAAG,KAAK,CAAC;AAEtE,sGAAsG;AACtG,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;IAC9D;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACxD;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,KAAK,EACnB,QAAQ,EAAE,KAAK,CAAC,aAAa,EAC7B,MAAM,EAAE,mBAAmB,GAC1B,MAAM,IAAI,CA+EZ"}
+{"version":3,"file":"renderer-config.d.ts","sourceRoot":"","sources":["../../src/world3d-react/renderer-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,cAAc,4BAA4B,CAAC"}

package/dist/world3d-react/renderer-config.js

@@ -1,111 +1,10 @@
 /**
- * world3d-react/renderer-config.ts — the seam a WORLD uses to state how its own frame is rendered.
+ * `@engine/world3d-react/renderer-config` — a published entry point.
  *
- * The host owns the `WebGLRenderer` (`ThreeHostContext.renderer`) and configures it with this
- * engine's defaults: ACES tone mapping, sRGB output, PCF-soft shadows. Those defaults are right for
- * a world authored against them and WRONG for a world that was authored against a different
- * engine's pipeline — an imported Godot 3 GLES2 game does gamma-space lighting with no tonemapper
- * at all, so ACES quietly desaturates and darkens every colour its author picked.
- *
- * So a world may DECLARE the pipeline it was authored for, and `createR3FAdapter` applies it to the
- * host's renderer for the life of the mount, restoring what it found on dispose. Three properties
- * of that shape are load-bearing:
- *
- *  - **It is per-renderer, never engine-wide.** Every field here is a `WebGLRenderer` instance
- *    property, and a play root gets its own renderer (`create-runtime.ts`). Nothing here reaches a
- *    module-level three global, so one world's declaration cannot change how the editor's own
- *    viewport, another root, or a thumbnail bake renders.
- *  - **Absent means "leave the host's value alone".** Every field is optional and an omitted one
- *    is never written, so declaring a tone mapping does not silently reset the clear colour.
- *  - **It is restored on dispose.** The renderer outlives the mount, so a world that did not put
- *    back what it found would leak its pipeline into whatever mounts next.
- *
- * This is deliberately NOT a general render-settings system. It carries what a world can honestly
- * state about its own colour pipeline and nothing else; a property the host fixes at CONSTRUCTION
- * (the WebGL context's `antialias` attribute, and therefore the MSAA sample count) cannot be
- * declared here, because there would be no honest moment to apply it.
- */
-/**
- * Apply `config` to `renderer`, returning the restore function that puts back what was there.
- *
- * `three` is passed in rather than imported for values so the enum constants come from the HOST's
- * three instance — the same identity rule `r3f-adapter.tsx` follows for the scene and camera.
+ * The engine package's export map is the wildcard `"./*"`, so every file under
+ * `packages/engine/src/` is an entry point a game outside this repo can import by path. The module
+ * itself now lives in the adapter seam (`@engine/adapter/renderer-config`, which its header
+ * explains), and this file keeps the path that shipped resolving to it. Import the seam path in
+ * new code.
  */
-export function applyWorldRendererConfig(three, renderer, config) {
-    // A host that mounts a world WITHOUT rasterizing it hands the adapter a duck-typed renderer —
-    // the editor's design session (`createDesignTimeRenderer`: four members, deliberately never
-    // widened) and jsdom test harnesses both do. Such a surface has no colour pipeline to configure:
-    // the frame the user sees is drawn by a DIFFERENT renderer (the editor's own), so applying the
-    // world's config there is meaningless — and calling `getClearColor` on it is a TypeError that
-    // unmounts the whole world at edit time (measured: every Godot port's edit viewport blanked with
-    // '"world" failed to mount — renderer.getClearColor is not a function'). Detect the real
-    // `WebGLRenderer` surface by the one method this function must call, and no-op otherwise.
-    if (typeof renderer.getClearColor !== 'function') {
-        return () => { };
-    }
-    const toneMappings = {
-        none: three.NoToneMapping,
-        linear: three.LinearToneMapping,
-        reinhard: three.ReinhardToneMapping,
-        cineon: three.CineonToneMapping,
-        aces: three.ACESFilmicToneMapping,
-        agx: three.AgXToneMapping,
-        neutral: three.NeutralToneMapping,
-    };
-    const colorSpaces = {
-        srgb: three.SRGBColorSpace,
-        'srgb-linear': three.LinearSRGBColorSpace,
-    };
-    const shadowMapTypes = {
-        basic: three.BasicShadowMap,
-        pcf: three.PCFShadowMap,
-        'pcf-soft': three.PCFSoftShadowMap,
-        vsm: three.VSMShadowMap,
-    };
-    const restores = [];
-    if (config.toneMapping !== undefined) {
-        const previous = renderer.toneMapping;
-        renderer.toneMapping = toneMappings[config.toneMapping];
-        restores.push(() => {
-            renderer.toneMapping = previous;
-        });
-    }
-    if (config.toneMappingExposure !== undefined) {
-        const previous = renderer.toneMappingExposure;
-        renderer.toneMappingExposure = config.toneMappingExposure;
-        restores.push(() => {
-            renderer.toneMappingExposure = previous;
-        });
-    }
-    if (config.outputColorSpace !== undefined) {
-        const previous = renderer.outputColorSpace;
-        renderer.outputColorSpace = colorSpaces[config.outputColorSpace];
-        restores.push(() => {
-            renderer.outputColorSpace = previous;
-        });
-    }
-    if (config.shadowMapType !== undefined && renderer.shadowMap !== undefined) {
-        const previous = renderer.shadowMap.type;
-        renderer.shadowMap.type = shadowMapTypes[config.shadowMapType];
-        renderer.shadowMap.needsUpdate = true;
-        restores.push(() => {
-            renderer.shadowMap.type = previous;
-            renderer.shadowMap.needsUpdate = true;
-        });
-    }
-    if (config.clearColor !== undefined) {
-        const previousColor = new three.Color();
-        renderer.getClearColor(previousColor);
-        // Alpha is READ BACK and re-passed, never assumed: see `clearColor`'s doc above.
-        const alpha = renderer.getClearAlpha();
-        renderer.setClearColor(new three.Color(config.clearColor), alpha);
-        restores.push(() => {
-            renderer.setClearColor(previousColor, alpha);
-        });
-    }
-    return () => {
-        // Reverse order, so a field written twice (it cannot be, today) unwinds correctly.
-        for (let i = restores.length - 1; i >= 0; i--)
-            restores[i]?.();
-    };
-}
+export * from '../adapter/renderer-config';

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vgai/engine",
   "author": "Volter AI, Inc.",
   "license": "Apache-2.0",
-  "version": "0.5.17",
+  "version": "0.5.18",
   "description": "Readable TypeScript game engine and universal host for Three.js, PixiJS, and React games.",
   "keywords": [
     "game-engine",

package/schemas/engine-capabilities.json

@@ -73,7 +73,7 @@
       "notes": "Limits: ARCHITECTURE-CORE.md. Any editor capability a mount does not reach stands warned per capability until it works.",
       "evidenceHashes": {
         "vendor/games/verify-unaltered.mjs": "257a362030a10f4d72a3280815069fbd83f436e1619391635b6f8df2ddd6c339",
-        "packages/engine/src/manifest/schema.ts": "2847dc09a55de1d9c0750872773b355c74ee33cf1542d1b082242f346c42cbd0"
+        "packages/engine/src/manifest/schema.ts": "ce385bc9181b82f9d5044da6a41a025a5cb8ba1fc7156263665080c9fdf2b11c"
       }
     },
     {

package/schemas/vgai-project.schema.json

@@ -331,7 +331,7 @@
       "properties": {
         "antialias": {
           "type": "boolean",
-          "description": "Whether every three root is built with a multisampled drawing buffer. This is the ONE render property a world cannot declare for itself (world3d-react/renderer-config.ts): a WebGL context fixes its sample count at CREATION from this boolean, long before a world mounts, so it belongs to the PROJECT. The runtime reader is mount-manifest.ts, which threads it into createHostRenderer for each three root. WebGL exposes no sample COUNT — the implementation picks one (4x on every desktop browser measured), so a source engine that authored 8x/16x gets multisampling but not its exact count."
+          "description": "Whether every three root is built with a multisampled drawing buffer. This is the ONE render property a world cannot declare for itself (adapter/renderer-config.ts): a WebGL context fixes its sample count at CREATION from this boolean, long before a world mounts, so it belongs to the PROJECT. The runtime reader is mount-manifest.ts, which threads it into createHostRenderer for each three root. WebGL exposes no sample COUNT — the implementation picks one (4x on every desktop browser measured), so a source engine that authored 8x/16x gets multisampling but not its exact count."
         }
       },
       "required": [

package/src/adapter/renderer-config.ts

@@ -0,0 +1,178 @@
+/**
+ * adapter/renderer-config.ts — the seam a WORLD uses to state how its own frame is rendered.
+ *
+ * It lives in the ADAPTER SEAM, not in a surface entry, because `WorldRendererConfig` IS part of
+ * the root contract: `MountedThreeRoot.rendererConfig` reports it (`./root-adapter.ts`) and
+ * `./root-seam-contract.ts` already lists it as a contract field. The seam defines the shape; the
+ * surface entries and the editor CONFORM to it — `world3d-react/r3f-adapter.tsx` is the declarer,
+ * `runtime/create-runtime.ts` the host, `editor/src/components/ViewportPanel.tsx` the editor's
+ * applier. Do NOT move it back under `world3d-react/`: nothing here touches react, and a core
+ * adapter file reaching into a react entry is exactly what `react-core-import-ban.test.ts` forbids
+ * (that ban carries no type-only carve-out on purpose — unlike its pixi sibling, whose carve-out
+ * exists only because `PIXI.Container` is a third-party type core cannot relocate).
+ *
+ * The host owns the `WebGLRenderer` (`ThreeHostContext.renderer`) and configures it with this
+ * engine's defaults: ACES tone mapping, sRGB output, PCF-soft shadows. Those defaults are right for
+ * a world authored against them and WRONG for a world that was authored against a different
+ * engine's pipeline — an imported Godot 3 GLES2 game does gamma-space lighting with no tonemapper
+ * at all, so ACES quietly desaturates and darkens every colour its author picked.
+ *
+ * So a world may DECLARE the pipeline it was authored for, and `createR3FAdapter` applies it to the
+ * host's renderer for the life of the mount, restoring what it found on dispose. Three properties
+ * of that shape are load-bearing:
+ *
+ *  - **It is per-renderer, never engine-wide.** Every field here is a `WebGLRenderer` instance
+ *    property, and a play root gets its own renderer (`create-runtime.ts`). Nothing here reaches a
+ *    module-level three global, so one world's declaration cannot change how the editor's own
+ *    viewport, another root, or a thumbnail bake renders.
+ *  - **Absent means "leave the host's value alone".** Every field is optional and an omitted one
+ *    is never written, so declaring a tone mapping does not silently reset the clear colour.
+ *  - **It is restored on dispose.** The renderer outlives the mount, so a world that did not put
+ *    back what it found would leak its pipeline into whatever mounts next.
+ *
+ * This is deliberately NOT a general render-settings system. It carries what a world can honestly
+ * state about its own colour pipeline and nothing else; a property the host fixes at CONSTRUCTION
+ * (the WebGL context's `antialias` attribute, and therefore the MSAA sample count) cannot be
+ * declared here, because there would be no honest moment to apply it.
+ */
+
+import type * as THREE from 'three';
+
+/** The tone-mapping operators three exposes, named as data rather than as three's numeric enum. */
+export type WorldToneMapping =
+  | 'none'
+  | 'linear'
+  | 'reinhard'
+  | 'cineon'
+  | 'aces'
+  | 'agx'
+  | 'neutral';
+
+/**
+ * The output transfer function the frame is written with.
+ *
+ *  - `srgb` — three's own default and this engine's: linear lighting, sRGB encode on output.
+ *  - `srgb-linear` — NO output transform. This is what a gamma-space renderer needs: the shading
+ *    result is already in display space and encoding it a second time washes the frame out.
+ */
+export type WorldOutputColorSpace = 'srgb' | 'srgb-linear';
+
+/**
+ * The shadow-map filter, named as data rather than as three's numeric enum.
+ *
+ * This is a renderer INSTANCE property (`WebGLRenderer.shadowMap.type`), not a context attribute,
+ * so unlike MSAA it has an honest moment at which a world can ask for it — which is the whole test
+ * this file's header states. A source engine that declares its own shadow filter (Godot 3's
+ * `rendering/quality/shadows/filter_mode`) would otherwise inherit whatever the host built with.
+ */
+export type WorldShadowMapType = 'basic' | 'pcf' | 'pcf-soft' | 'vsm';
+
+/** What a world may declare about the renderer that draws it. Every field is optional; see header. */
+export interface WorldRendererConfig {
+  readonly toneMapping?: WorldToneMapping | undefined;
+  readonly toneMappingExposure?: number | undefined;
+  readonly outputColorSpace?: WorldOutputColorSpace | undefined;
+  /**
+   * `WebGLRenderer.shadowMap.type`. Writing it after a shadow map has already been built needs
+   * `shadowMap.needsUpdate`, which this function sets — three caches the compiled depth material
+   * per type and would otherwise keep filtering with the previous one.
+   */
+  readonly shadowMapType?: WorldShadowMapType | undefined;
+  /**
+   * The colour the frame is cleared to, as a CSS hex string. The renderer's existing clear ALPHA
+   * is preserved: a stacked canvas is transparent on purpose (`create-runtime.ts` gives every
+   * non-bottom root `alpha: true`), and forcing it opaque here would hide every layer below.
+   */
+  readonly clearColor?: string | undefined;
+}
+
+/**
+ * Apply `config` to `renderer`, returning the restore function that puts back what was there.
+ *
+ * `three` is passed in rather than imported for values so the enum constants come from the HOST's
+ * three instance — the same identity rule `r3f-adapter.tsx` follows for the scene and camera.
+ */
+export function applyWorldRendererConfig(
+  three: typeof THREE,
+  renderer: THREE.WebGLRenderer,
+  config: WorldRendererConfig,
+): () => void {
+  // A host that mounts a world WITHOUT rasterizing it hands the adapter a duck-typed renderer —
+  // the editor's design session (`createDesignTimeRenderer`: four members, deliberately never
+  // widened) and jsdom test harnesses both do. Such a surface has no colour pipeline to configure:
+  // the frame the user sees is drawn by a DIFFERENT renderer (the editor's own), so applying the
+  // world's config there is meaningless — and calling `getClearColor` on it is a TypeError that
+  // unmounts the whole world at edit time (measured: every Godot port's edit viewport blanked with
+  // '"world" failed to mount — renderer.getClearColor is not a function'). Detect the real
+  // `WebGLRenderer` surface by the one method this function must call, and no-op otherwise.
+  if (typeof renderer.getClearColor !== 'function') {
+    return () => {};
+  }
+  const toneMappings: Record<WorldToneMapping, THREE.ToneMapping> = {
+    none: three.NoToneMapping,
+    linear: three.LinearToneMapping,
+    reinhard: three.ReinhardToneMapping,
+    cineon: three.CineonToneMapping,
+    aces: three.ACESFilmicToneMapping,
+    agx: three.AgXToneMapping,
+    neutral: three.NeutralToneMapping,
+  };
+  const colorSpaces: Record<WorldOutputColorSpace, THREE.ColorSpace> = {
+    srgb: three.SRGBColorSpace,
+    'srgb-linear': three.LinearSRGBColorSpace,
+  };
+  const shadowMapTypes: Record<WorldShadowMapType, THREE.ShadowMapType> = {
+    basic: three.BasicShadowMap,
+    pcf: three.PCFShadowMap,
+    'pcf-soft': three.PCFSoftShadowMap,
+    vsm: three.VSMShadowMap,
+  };
+
+  const restores: (() => void)[] = [];
+
+  if (config.toneMapping !== undefined) {
+    const previous = renderer.toneMapping;
+    renderer.toneMapping = toneMappings[config.toneMapping];
+    restores.push(() => {
+      renderer.toneMapping = previous;
+    });
+  }
+  if (config.toneMappingExposure !== undefined) {
+    const previous = renderer.toneMappingExposure;
+    renderer.toneMappingExposure = config.toneMappingExposure;
+    restores.push(() => {
+      renderer.toneMappingExposure = previous;
+    });
+  }
+  if (config.outputColorSpace !== undefined) {
+    const previous = renderer.outputColorSpace;
+    renderer.outputColorSpace = colorSpaces[config.outputColorSpace];
+    restores.push(() => {
+      renderer.outputColorSpace = previous;
+    });
+  }
+  if (config.shadowMapType !== undefined && renderer.shadowMap !== undefined) {
+    const previous = renderer.shadowMap.type;
+    renderer.shadowMap.type = shadowMapTypes[config.shadowMapType];
+    renderer.shadowMap.needsUpdate = true;
+    restores.push(() => {
+      renderer.shadowMap.type = previous;
+      renderer.shadowMap.needsUpdate = true;
+    });
+  }
+  if (config.clearColor !== undefined) {
+    const previousColor = new three.Color();
+    renderer.getClearColor(previousColor);
+    // Alpha is READ BACK and re-passed, never assumed: see `clearColor`'s doc above.
+    const alpha = renderer.getClearAlpha();
+    renderer.setClearColor(new three.Color(config.clearColor), alpha);
+    restores.push(() => {
+      renderer.setClearColor(previousColor, alpha);
+    });
+  }
+
+  return () => {
+    // Reverse order, so a field written twice (it cannot be, today) unwinds correctly.
+    for (let i = restores.length - 1; i >= 0; i--) restores[i]?.();
+  };
+}

package/src/adapter/root-adapter.ts

@@ -9,10 +9,10 @@
 
 import type { Container } from 'pixi.js';
 import type * as THREE from 'three';
-import type { WorldRendererConfig } from '../world3d-react/renderer-config';
 import type { AdapterSurface } from './adapter-surface';
 import type { AuthoringAdapter } from './authoring';
 import type { HostContextFor } from './host-context';
+import type { WorldRendererConfig } from './renderer-config';
 import type { SystemAdapters } from './system-adapter';
 
 /**
@@ -98,7 +98,7 @@ export interface MountedThreeRoot extends MountedRootBase {
   /**
    * The colour pipeline this world was authored for, REPORTED rather than
    * applied — the adapter has already applied it to the renderer its own host
-   * handed it (`world3d-react/renderer-config.ts`).
+   * handed it (`./renderer-config.ts`).
    *
    * It is here because the host that MOUNTS a world is not always the host
    * that DRAWS it. The editor's design session mounts against a

package/src/manifest/schema.ts

@@ -573,7 +573,7 @@ export const GameManifestSchema = z
           .boolean()
           .describe(
             'Whether every three root is built with a multisampled drawing buffer. This is the ' +
-              'ONE render property a world cannot declare for itself (world3d-react/' +
+              'ONE render property a world cannot declare for itself (adapter/' +
               'renderer-config.ts): a WebGL context fixes its sample count at CREATION from this ' +
               'boolean, long before a world mounts, so it belongs to the PROJECT. The runtime ' +
               'reader is mount-manifest.ts, which threads it into createHostRenderer for each ' +

package/src/runtime/mount-manifest.ts

@@ -412,7 +412,7 @@ export async function mountManifestRoots(opts: MountManifestOptions): Promise<Ga
     headless: opts.headless,
     // `rendering.antialias` reaches the WebGL context at CONSTRUCTION and can be honoured
     // nowhere else — see the manifest schema's own `rendering` block and
-    // `world3d-react/renderer-config.ts`'s header for why it is not a world-level declaration.
+    // `adapter/renderer-config.ts`'s header for why it is not a world-level declaration.
     ...(manifest.rendering === undefined ? {} : { antialias: manifest.rendering.antialias }),
     seed: resolvedSeed,
     playtest: opts.playtest,

package/src/world3d-react/index.ts

@@ -40,15 +40,15 @@
  * contract to `react`/`@react-three/fiber`/`three` alone.
  */
 
-export { EngineBridge, type EngineBridgeValue, useGameContext } from './engine-bridge';
-export { type CreateR3FAdapterOptions, createR3FAdapter } from './r3f-adapter';
-export { r3fRootFactory, resolveR3FEntryAdapter } from './r3f-root-factory';
 export {
   applyWorldRendererConfig,
   type WorldOutputColorSpace,
   type WorldRendererConfig,
   type WorldToneMapping,
-} from './renderer-config';
+} from '../adapter/renderer-config';
+export { EngineBridge, type EngineBridgeValue, useGameContext } from './engine-bridge';
+export { type CreateR3FAdapterOptions, createR3FAdapter } from './r3f-adapter';
+export { r3fRootFactory, resolveR3FEntryAdapter } from './r3f-root-factory';
 export {
   createR3FRootContext,
   DEFAULT_INPUT_MAP_PATH,

package/src/world3d-react/r3f-adapter.tsx

@@ -30,6 +30,7 @@ import {
 } from '@react-three/fiber';
 import { createElement, Fragment, type ReactNode, useEffect, useMemo } from 'react';
 import type { MountedThreeRoot, RootAdapter, ThreeHostContext } from '../adapter';
+import { applyWorldRendererConfig, type WorldRendererConfig } from '../adapter/renderer-config';
 import type { SystemAdapters } from '../adapter/system-adapter';
 import { type RenderVitalsRegistration, registerRenderVitals } from '../dev/register-render-vitals';
 import {
@@ -45,7 +46,6 @@ import { createSoftParticleDepthPass } from '../render/soft-particle-depth';
 import { getDebugRegistry } from '../runtime/debug-registry';
 import { devBuildEnabled } from '../runtime/dev-build';
 import { EngineBridge, type EngineBridgeValue } from './engine-bridge';
-import { applyWorldRendererConfig, type WorldRendererConfig } from './renderer-config';
 import { createR3FRootContext, DEFAULT_INPUT_MAP_PATH, wireGameInputSeams } from './world-context';
 
 /** The slice of `WebGLRenderer.info` the vitals reporter reads. Declared
@@ -117,7 +117,7 @@ export interface CreateR3FAdapterOptions {
   /** The colour pipeline this world was AUTHORED for, applied to the host's renderer for the life
    *  of the mount and restored on dispose. Omit it (every world here does) to keep the host's own
    *  defaults; declare it when the world's colours were picked against a different engine's
-   *  pipeline — see `./renderer-config.ts`. */
+   *  pipeline — see `../adapter/renderer-config.ts`. */
   readonly renderer?: WorldRendererConfig | undefined;
 }
 

package/src/world3d-react/renderer-config.ts

@@ -1,168 +1,11 @@
 /**
- * world3d-react/renderer-config.ts — the seam a WORLD uses to state how its own frame is rendered.
+ * `@engine/world3d-react/renderer-config` — a published entry point.
  *
- * The host owns the `WebGLRenderer` (`ThreeHostContext.renderer`) and configures it with this
- * engine's defaults: ACES tone mapping, sRGB output, PCF-soft shadows. Those defaults are right for
- * a world authored against them and WRONG for a world that was authored against a different
- * engine's pipeline — an imported Godot 3 GLES2 game does gamma-space lighting with no tonemapper
- * at all, so ACES quietly desaturates and darkens every colour its author picked.
- *
- * So a world may DECLARE the pipeline it was authored for, and `createR3FAdapter` applies it to the
- * host's renderer for the life of the mount, restoring what it found on dispose. Three properties
- * of that shape are load-bearing:
- *
- *  - **It is per-renderer, never engine-wide.** Every field here is a `WebGLRenderer` instance
- *    property, and a play root gets its own renderer (`create-runtime.ts`). Nothing here reaches a
- *    module-level three global, so one world's declaration cannot change how the editor's own
- *    viewport, another root, or a thumbnail bake renders.
- *  - **Absent means "leave the host's value alone".** Every field is optional and an omitted one
- *    is never written, so declaring a tone mapping does not silently reset the clear colour.
- *  - **It is restored on dispose.** The renderer outlives the mount, so a world that did not put
- *    back what it found would leak its pipeline into whatever mounts next.
- *
- * This is deliberately NOT a general render-settings system. It carries what a world can honestly
- * state about its own colour pipeline and nothing else; a property the host fixes at CONSTRUCTION
- * (the WebGL context's `antialias` attribute, and therefore the MSAA sample count) cannot be
- * declared here, because there would be no honest moment to apply it.
- */
-
-import type * as THREE from 'three';
-
-/** The tone-mapping operators three exposes, named as data rather than as three's numeric enum. */
-export type WorldToneMapping =
-  | 'none'
-  | 'linear'
-  | 'reinhard'
-  | 'cineon'
-  | 'aces'
-  | 'agx'
-  | 'neutral';
-
-/**
- * The output transfer function the frame is written with.
- *
- *  - `srgb` — three's own default and this engine's: linear lighting, sRGB encode on output.
- *  - `srgb-linear` — NO output transform. This is what a gamma-space renderer needs: the shading
- *    result is already in display space and encoding it a second time washes the frame out.
- */
-export type WorldOutputColorSpace = 'srgb' | 'srgb-linear';
-
-/**
- * The shadow-map filter, named as data rather than as three's numeric enum.
- *
- * This is a renderer INSTANCE property (`WebGLRenderer.shadowMap.type`), not a context attribute,
- * so unlike MSAA it has an honest moment at which a world can ask for it — which is the whole test
- * this file's header states. A source engine that declares its own shadow filter (Godot 3's
- * `rendering/quality/shadows/filter_mode`) would otherwise inherit whatever the host built with.
- */
-export type WorldShadowMapType = 'basic' | 'pcf' | 'pcf-soft' | 'vsm';
-
-/** What a world may declare about the renderer that draws it. Every field is optional; see header. */
-export interface WorldRendererConfig {
-  readonly toneMapping?: WorldToneMapping | undefined;
-  readonly toneMappingExposure?: number | undefined;
-  readonly outputColorSpace?: WorldOutputColorSpace | undefined;
-  /**
-   * `WebGLRenderer.shadowMap.type`. Writing it after a shadow map has already been built needs
-   * `shadowMap.needsUpdate`, which this function sets — three caches the compiled depth material
-   * per type and would otherwise keep filtering with the previous one.
-   */
-  readonly shadowMapType?: WorldShadowMapType | undefined;
-  /**
-   * The colour the frame is cleared to, as a CSS hex string. The renderer's existing clear ALPHA
-   * is preserved: a stacked canvas is transparent on purpose (`create-runtime.ts` gives every
-   * non-bottom root `alpha: true`), and forcing it opaque here would hide every layer below.
-   */
-  readonly clearColor?: string | undefined;
-}
-
-/**
- * Apply `config` to `renderer`, returning the restore function that puts back what was there.
- *
- * `three` is passed in rather than imported for values so the enum constants come from the HOST's
- * three instance — the same identity rule `r3f-adapter.tsx` follows for the scene and camera.
+ * The engine package's export map is the wildcard `"./*"`, so every file under
+ * `packages/engine/src/` is an entry point a game outside this repo can import by path. The module
+ * itself now lives in the adapter seam (`@engine/adapter/renderer-config`, which its header
+ * explains), and this file keeps the path that shipped resolving to it. Import the seam path in
+ * new code.
  */
-export function applyWorldRendererConfig(
-  three: typeof THREE,
-  renderer: THREE.WebGLRenderer,
-  config: WorldRendererConfig,
-): () => void {
-  // A host that mounts a world WITHOUT rasterizing it hands the adapter a duck-typed renderer —
-  // the editor's design session (`createDesignTimeRenderer`: four members, deliberately never
-  // widened) and jsdom test harnesses both do. Such a surface has no colour pipeline to configure:
-  // the frame the user sees is drawn by a DIFFERENT renderer (the editor's own), so applying the
-  // world's config there is meaningless — and calling `getClearColor` on it is a TypeError that
-  // unmounts the whole world at edit time (measured: every Godot port's edit viewport blanked with
-  // '"world" failed to mount — renderer.getClearColor is not a function'). Detect the real
-  // `WebGLRenderer` surface by the one method this function must call, and no-op otherwise.
-  if (typeof renderer.getClearColor !== 'function') {
-    return () => {};
-  }
-  const toneMappings: Record<WorldToneMapping, THREE.ToneMapping> = {
-    none: three.NoToneMapping,
-    linear: three.LinearToneMapping,
-    reinhard: three.ReinhardToneMapping,
-    cineon: three.CineonToneMapping,
-    aces: three.ACESFilmicToneMapping,
-    agx: three.AgXToneMapping,
-    neutral: three.NeutralToneMapping,
-  };
-  const colorSpaces: Record<WorldOutputColorSpace, THREE.ColorSpace> = {
-    srgb: three.SRGBColorSpace,
-    'srgb-linear': three.LinearSRGBColorSpace,
-  };
-  const shadowMapTypes: Record<WorldShadowMapType, THREE.ShadowMapType> = {
-    basic: three.BasicShadowMap,
-    pcf: three.PCFShadowMap,
-    'pcf-soft': three.PCFSoftShadowMap,
-    vsm: three.VSMShadowMap,
-  };
-
-  const restores: (() => void)[] = [];
-
-  if (config.toneMapping !== undefined) {
-    const previous = renderer.toneMapping;
-    renderer.toneMapping = toneMappings[config.toneMapping];
-    restores.push(() => {
-      renderer.toneMapping = previous;
-    });
-  }
-  if (config.toneMappingExposure !== undefined) {
-    const previous = renderer.toneMappingExposure;
-    renderer.toneMappingExposure = config.toneMappingExposure;
-    restores.push(() => {
-      renderer.toneMappingExposure = previous;
-    });
-  }
-  if (config.outputColorSpace !== undefined) {
-    const previous = renderer.outputColorSpace;
-    renderer.outputColorSpace = colorSpaces[config.outputColorSpace];
-    restores.push(() => {
-      renderer.outputColorSpace = previous;
-    });
-  }
-  if (config.shadowMapType !== undefined && renderer.shadowMap !== undefined) {
-    const previous = renderer.shadowMap.type;
-    renderer.shadowMap.type = shadowMapTypes[config.shadowMapType];
-    renderer.shadowMap.needsUpdate = true;
-    restores.push(() => {
-      renderer.shadowMap.type = previous;
-      renderer.shadowMap.needsUpdate = true;
-    });
-  }
-  if (config.clearColor !== undefined) {
-    const previousColor = new three.Color();
-    renderer.getClearColor(previousColor);
-    // Alpha is READ BACK and re-passed, never assumed: see `clearColor`'s doc above.
-    const alpha = renderer.getClearAlpha();
-    renderer.setClearColor(new three.Color(config.clearColor), alpha);
-    restores.push(() => {
-      renderer.setClearColor(previousColor, alpha);
-    });
-  }
 
-  return () => {
-    // Reverse order, so a field written twice (it cannot be, today) unwinds correctly.
-    for (let i = restores.length - 1; i >= 0; i--) restores[i]?.();
-  };
-}
+export * from '../adapter/renderer-config';