@volter/project 0.5.211 → 0.5.212

package/src/adapter/index.ts

@@ -1,32 +1,10 @@
-/**
- * Adapter interfaces — the seams the engine host and the editor DEPEND ON.
- *
- *   host    → RootAdapter ← { the editor's R3F root mounts, IngestRootAdapter, … }
- *   editor  → AuthoringAdapter ← { ThreeAuthoringAdapter, ReactRootAuthoringAdapter, … }
- *   game    → SystemAdapters (physics/networking/navigation/audio/camera/debug)
- *
- * The first-party Rapier/Colyseus stack is ONE implementer of these
- * interfaces, not the engine's vocabulary.
- *
- * **This module is TYPE-ONLY, and must stay that way (P-6).** It used to
- * value-export its own implementers — `createRapierPhysicsAdapter`,
- * `createColyseusNetworkingAdapter`, `createNavigationAdapter` — so
- * `import type { AuthoringAdapter } from './index'` was the only
- * thing keeping the three/Rapier/Colyseus stack out of a Pixi or React
- * consumer's module graph. A seam that ships its implementers is not a
- * seam. Import an implementer from its OWN path instead:
- *
- *   `@volter/threejs-runtime/adapter/rapier-physics-adapter`    createRapierPhysicsAdapter
- *   `@volter/threejs-runtime/adapter/first-party-navigation-system`       createNavigationAdapter
- */
+/** Project adapter contracts and neutral contract helpers. Implementations live in the integrations that own their library objects. */
 
 export type { AdapterSurface } from './adapter-surface';
 export type {
   AssetDropContext,
   AssetDropProvider,
-  AssetSubjectProvider,
   AuthoringAdapter,
-  AuthoringAssetSubject,
   AuthoringCapabilities,
   AuthoringProvenance,
   AuthoringProviderKey,
@@ -86,38 +64,20 @@ export {
   AUTHORING_PROVIDER_SHAPES,
   HIERARCHY_PROVIDER_SHAPE,
 } from './authoring-seam-contract';
-export type {
-  EntryStaticSurface,
-  ObservationBinding,
-  ProjectBinding,
-  ProjectionBinding,
-  ProtocolFamily,
-  RootBinding,
-  RootBindingParts,
-  RootDeclaration,
-  SubstrateBinding,
-  TruthBinding,
-} from './binding';
-export { createRootBinding } from './binding';
 export type {
   CanvasHostContext,
   DomHostContext,
-  HostContextBase,
   HostContextFor,
   HostSurface,
-  ThreeHostContext,
+  StageHostContext,
 } from './host-context';
-/** The offline-audio contract an `AudioAdapter.renderOffline` implements.
- *  Defined beside the render-mode harness that first needed it; re-exported
- *  here so a world binding the seam imports one name from one place. */
-export type { OfflineAudioRenderer, RenderedAudio } from './render-audio';
 export type {
   MountedCanvasRoot,
   MountedCanvasSubstrate,
   MountedReactRoot,
   MountedRoot,
   MountedRootBase,
-  MountedThreeRoot,
+  MountedStageRoot,
   RootAdapter,
   RootStateObserver,
   SurfaceAdapter,
@@ -127,7 +87,7 @@ export {
   MOUNTED_CANVAS_SURFACE_SHAPE,
   MOUNTED_DOM_SURFACE_SHAPE,
   MOUNTED_ROOT_BASE_SHAPE,
-  MOUNTED_THREE_SURFACE_SHAPE,
+  MOUNTED_STAGE_SURFACE_SHAPE,
   ROOT_ADAPTER_SHAPE,
   ROOT_STATE_OBSERVER_SHAPE,
 } from './root-seam-contract';
@@ -150,44 +110,16 @@ export {
   seamStageAtLeast,
 } from './seam-evidence';
 export type {
-  AudioAdapter,
-  AudioDebugEvent,
-  AudioGraphNode,
-  AudioMeterFrame,
-  AudioMeterHandle,
-  AudioRecordingHandle,
-  AudioTransportState,
   CameraAdapter,
   CameraRuntimeCamera,
   CameraRuntimeSnapshot,
   CameraRuntimeTransition,
-  ConnectionState,
-  DebugAdapter,
-  NavCrowdAgentState,
-  NavigationAdapter,
-  NavPoint,
-  NetConditioning,
-  NetMessageEvent,
-  NetPeer,
-  NetPlayerIdentity,
-  NetConditioningLimits,
-  NetRates,
-  NetServerClient,
-  NetServerInspection,
-  NetServerRoom,
-  NetTypeTraffic,
-  NetEntityTraffic,
-  NetServerConfig,
-  NetworkingAdapter,
   PhysicsAdapter,
   PhysicsCarrier,
   PhysicsColliderShape,
   PhysicsColliderSnapshot,
   PhysicsJointSnapshot,
   PhysicsJointType,
-  RenderDebugAdapter,
-  ReplicationStats,
-  RoomInfo,
   SystemAdapters,
   Unsubscribe,
 } from './system-adapter';
@@ -195,14 +127,9 @@ export type {
  *  `PhysicsAdapter`'s comment for why it is tagged at all. */
 export { displayKeyedPhysics, nodeKeyedPhysics, physicsOwnerOf } from './system-adapter';
 export {
-  AUDIO_ADAPTER_SHAPE,
   CAMERA_ADAPTER_SHAPE,
-  DEBUG_ADAPTER_SHAPE,
-  NAVIGATION_ADAPTER_SHAPE,
-  NETWORKING_ADAPTER_SHAPE,
   PHYSICS_2D_ADAPTER_SHAPE,
   PHYSICS_ADAPTER_SHAPE,
-  RENDER_DEBUG_ADAPTER_SHAPE,
   SYSTEM_ADAPTERS_SHAPE,
   SYSTEM_PROVIDER_SHAPES,
 } from './system-seam-contract';

package/src/adapter/manifest-interpreter.ts

@@ -1,27 +1,12 @@
 /**
- * The manifest's SOLE INTERPRETER (owner ruling, 2026-08-20 — see
- * docs/ARCHITECTURE-CORE.md §adapter). `volter.project.json` is static
- * inventory; the adapter seam is the ONE layer that turns it into execution
- * bindings, and host code consumes the manifest through THESE derivations —
- * never by reading `manifest.roots` directly (the guard is
- * `packages/engine/test/manifest-sole-interpreter.test.ts`).
+ * Pure manifest interpretation shared by host consumers. These functions
+ * turn loaded inventory into adapter bindings without evaluating project
+ * modules. Their structural input types accept resolved or lenient edit-mode
+ * manifest views.
  *
- * Why a doorway and not a convention: one deriver means one direction of
- * truth (manifest → adapter → host). When the project's own `editor/volter.adapter.ts`
- * later interposes on a derivation, every host path that asked the
- * interpreter gets the project's answer for free; a path that read the raw
- * field would silently keep the mechanical one.
- *
- * The module-free audiences named by the ruling (a bundled CLI's raw
- * discovery over unvalidated files, Vite config time, synchronous
- * dep-optimization, and the loader that CONSTRUCTS the resolution) remain
- * direct readers by design; everything else asks here.
- *
- * These functions are pure and synchronous over an already-loaded manifest —
- * interpreting inventory never evaluates project modules, so any host realm
- * may import this. They are structurally generic so both the loader's
- * `ResolvedGameManifest` and the editor's lenient `EditModeManifest` view
- * flow through the same doorway.
+ * Raw discovery, config-time dependency optimization and the loader that
+ * constructs resolution read inventory directly; execution hosts use these
+ * derivations.
  */
 
 /**
@@ -34,31 +19,3 @@ export function declaredRoots<Root>(manifest: {
 }): readonly Root[] {
   return manifest.roots;
 }
-
-/** The root declaring `id`, or undefined — never a silent first-wins pick. */
-export function rootById<Root extends { readonly id: string }>(
-  manifest: { readonly roots: readonly Root[] },
-  id: string,
-): Root | undefined {
-  return manifest.roots.find((root) => root.id === id);
-}
-
-/** Whether any declared root mounts on `surface` (e.g. the editor's
- *  "does this project have a Three world" gates). The parameter is the closed
- *  surface union, not `string` — a typo'd literal must stay a compile error,
- *  not a silent forever-false. */
-export function hasRootOnSurface(
-  manifest: { readonly roots: readonly { readonly surface: string }[] },
-  surface: 'three' | 'canvas' | 'dom',
-): boolean {
-  return manifest.roots.some((root) => root.surface === surface);
-}
-
-/** The declared ingest roots (`adapter.type === 'ingest'`), in mount order.
- *  Composite-manifest rules (exactly one, ≥2 is a loud named error) belong to
- *  the call sites that state them. */
-export function ingestRoots<
-  Root extends { readonly adapter: { readonly type: string } },
->(manifest: { readonly roots: readonly Root[] }): Root[] {
-  return manifest.roots.filter((root) => root.adapter.type === 'ingest');
-}

package/src/adapter/physics-adapter-2d.ts

@@ -1,27 +1,10 @@
 /**
- * The canvas surface's physics seam, keyed by the substrate's display object
- * (`D`, opaque by default). The implementer names its own display type
- * (`@volter/editor-game/runtime/pixi/system-adapters` is `PhysicsAdapter2D<Container>`).
- */
-
-/**
- * PhysicsAdapter2D — the Pixi analog of the 3D PhysicsAdapter (rapier-physics-adapter).
- * Lets the editor coordinate editing of a Rapier-2D-driven entity WITHOUT owning the
- * simulation: report transform ownership, then freeze → commit → unfreeze so a drag
- * sticks instead of being stomped by the next physics step.
- *
- * KEYED BY THE DISPLAY OBJECT, and that is this surface's own vocabulary rather
- * than a shortcut: the canvas gizmo's real caller
- * (`editor/src/authoring/pixi-live-write-target.ts`) resolves node id → display
- * itself before it asks, so there is no node-id hop on this lane at all.
- *
- * `keyedBy` is REQUIRED here and optional on the 3D {@link PhysicsAdapter} —
- * see that interface's doc comment for why the union has to be tagged, and why
- * the newcomer is the shape obliged to say so.
+ * Coordinate canvas physics edits through freeze, commit and unfreeze, keyed by the native
+ * display object. The canvas caller resolves node ids before entering this seam. The required
+ * display tag distinguishes it from the node-id physics contract in system-adapter.ts.
  */
 export interface PhysicsAdapter2D<D = unknown> {
-  /** Discriminates this shape from the node-id-keyed {@link PhysicsAdapter}
-   *  inside `SystemAdapters['physics']`. */
+  /** Discriminates this display-keyed shape inside SystemAdapters.physics. */
   readonly keyedBy: 'display';
   ownerOf(display: D): 'physics' | 'none';
   freeze(display: D): void;

package/src/adapter/root-adapter.ts

@@ -2,7 +2,7 @@
  * RootAdapter — the host ⇄ runtime contract. A ROOT is *anything that mounts*.
  *
  * This is the interface the host depends on. First-party content and
- * unmodified external games are peer root adapters. A game is the
+ * unmodified external projects are peer root adapters. A project is the
  * manifest's complete roots array, while each adapter owns exactly one
  * root.
  */
@@ -10,131 +10,78 @@
 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
- * must-answer"). Cross-world data flow with a
- * foreign game is observation via an adapter-provided interface, not ordinary
- * shared state (that's D7's answer for first-party↔first-party flow).
- * Optional on {@link MountedThreeRoot} —
- * absence means the adapter has nothing genuinely observable to expose (the
- * anti-shim rule: never fabricate state), and the world takes the honest
- * "no state bridge" tier hit (see `Game.registerRoot` in `runtime/game.ts`)
- * rather than silently offering an `undefined`-forever subscription.
+ * An adapter-provided observation interface for a mounted root’s state.
+ * Optional absence means the root exposes no state bridge. Consumers report
+ * that absence rather than fabricating state or an undefined-only subscription.
  */
 export interface RootStateObserver {
   /**
-   * Notified at most once per frame IF the adapter can hook the game's own
-   * update (`loop: 'gated'` roots, §(d)); self-driven roots (`loop:
+   * Notified at most once per frame IF the adapter can hook the project's own
+   * update (`loop: 'gated'` roots); self-driven roots (`loop:
    * 'self-driven'`, raw-rAF) may notify on their OWN rAF cadence instead —
    * consumers must not assume our frame timing. Returns an unsubscribe
    * function.
    */
   subscribe(onChange: () => void): () => void;
   /**
-   * A cheap, adapter-chosen snapshot of this world's observable state.
-   * Returns a STABLE reference while nothing has changed (so a selector run
-   * over it can cheaply bail out by reference, same spirit as
-   * `GameStateBridge`'s frame-version cache). Shape is adapter-defined —
-   * not centrally schematized in v1.
+   * A cheap snapshot of the root’s observable state. Preserve its reference
+   * while unchanged so selectors can skip recomputation. The adapter owns
+   * the snapshot’s shape.
    */
   snapshot(): unknown;
 }
 
 /**
  * Everything a mounted world provides except its render surface. Tagged
- * mounted-root variants carry their native surface fields: a Three scene and
+ * mounted-root variants carry their native surface fields: a stage scene and
  * camera, a declared canvas substrate root, or a DOM container.
  */
 export interface MountedRootBase {
   /**
-   * Loop model:
-   *  - `false` (host-driven): first-party + "clean" externals. The host ticks
-   *    `update(dt)` in its loop.
-   *  - `true` (self-driven): an unmodified game that owns its renderer + rAF.
-   *    The host does NOT tick it. Pause/step control is a DECLARED CAPABILITY,
-   *    not a promise: implement `setPaused`/`step` only where the game exposes
-   *    a sanctioned pause/step mechanism. Gating a raw-rAF loop from outside
-   *    was demonstrated and REJECTED (D5 — it halts the loop rather than
-   *    pausing it). Where `setPaused` is absent the host reports the
-   *    shortfall loudly, naming the mechanism that would close it (T7.6).
+   * Loop ownership: host-driven roots receive `update(dt)` from the host;
+   * self-driven roots own their rendering loop and are not ticked by the host.
+   * Expose pause/step only when the project supplies those operations. Missing
+   * pause support is reported as a capability shortfall.
    */
   readonly drivesOwnLoop: boolean;
 
   /**
-   * Which host clock owns an opaque mounted root's single `update(dt)` hook.
-   *
-   * `fixed` (the default) preserves the adapter seam's original contract:
-   * the callback runs once per consumed simulation substep. `display` is for
-   * a reconciler whose one native advance is inseparably BOTH its callbacks
-   * and its draw (React Three Fiber's `advance()` is the measured case). The
-   * real host then withholds it from fixed catch-up substeps and invokes it
-   * exactly once from the display pass. A direct/offline `runFrame` that does
-   * not skip render phases still invokes it once, preserving capture and
-   * explicit-tick semantics.
-   *
-   * Absent means `fixed`. This changes no foreign/ingest adapter unless that
-   * adapter opts in explicitly.
+   * Host clock for the mounted root’s `update(dt)` hook.
+   * `fixed` requests simulation substeps. `display` requests one update per
+   * display pass for reconcilers whose advance combines callbacks and drawing.
    */
   readonly updateCadence?: 'fixed' | 'display';
 
   update?(dt: number): void; // host-driven only
   fixedUpdate?(dt: number): void;
-  setPaused?(paused: boolean): void; // capability, not promise — see loop-model note above
+  setPaused?(paused: boolean): void; // optional adapter-owned pause operation
   step?(): void;
 
   resize?(width: number, height: number): void;
-  /** Does this world claim a pointer at (x, y), in CSS pixels from its surface's top-left? The input
-   *  router asks it of a world stacked above the bottom one (a 2D layer's interactive Pixi objects).
-   *  Absent: such a world claims no point, and input falls through to the bottom world. */
-  hitTest?(x: number, y: number): boolean;
   dispose(): void;
   /** Resolves after an asynchronous native reconciler has run every component
    * cleanup started by {@link dispose}. Omitted by synchronously-disposing
-   * roots. Hosts use this before auditing/reclaiming realm-owned resources. */
+   * roots. */
   readonly disposeComplete?: Promise<void>;
 
   /** Optional capability providers — absence = "not supported", host degrades. */
   readonly authoring?: AuthoringAdapter;
   readonly systems?: SystemAdapters;
-  /** Adapter-owned evaluation identity used to bind static system factories. */
-  readonly systemScope?: object;
-  /** Optional state-observation capability (T7.4 slice 2, §4) — absent means
-   *  "no state bridge"; `Game.registerRoot` reports this loudly, once, for
-   *  self-driven mount. A host-driven mount ticks inside the game's frame,
-   *  where the editor reads it directly, so it needs none. */
+  /** Optional state-observation capability. Absence means no state bridge. */
   readonly observe?: RootStateObserver;
 }
 
-/** A live, mounted Three world. The host obtains `scene`/`camera` to render
- * and author it; they are opaque here, and `@volter/editor-threejs` names the
- * Three-typed root. */
-export interface MountedThreeRoot<Scene = unknown, Camera = unknown> extends MountedRootBase {
-  readonly kind: 'three';
+/** A live, mounted `stage` world. The host obtains `scene`/`camera` to render
+ * and author it; they are opaque here, and a runtime extends the root with its
+ * own types. */
+export interface MountedStageRoot<Scene = unknown, Camera = unknown> extends MountedRootBase {
+  readonly kind: 'stage';
   /** The live scene + camera the editor inspects/renders for authoring. */
   readonly scene: Scene;
   readonly camera: Camera;
-  /**
-   * 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 (`./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
-   * non-rasterizing renderer on purpose and then draws the mounted scene with
-   * the editor viewport's own `WebGLRenderer`, so the world's declaration
-   * lands on a surface with no pixels while the surface with pixels never
-   * hears it. Reporting the declaration is what lets that host apply the same
-   * config, through the same `applyWorldRendererConfig`, to the renderer that
-   * actually produces the frame.
-   *
-   * Absent means the world declared nothing and the drawing host should leave
-   * its own configuration alone — the same "absent = don't touch" rule the
-   * config's own fields follow.
-   */
-  readonly rendererConfig?: WorldRendererConfig | undefined;
 }
 
 /**
@@ -145,10 +92,6 @@ export interface MountedThreeRoot<Scene = unknown, Camera = unknown> extends Mou
 export interface MountedCanvasSubstrate<T = unknown> {
   readonly name: string;
   readonly root: T;
-  /** The substrate's own module namespace when authoring needs constructors
-   * (for example Babylon's native GizmoManager). Omitted when the projection
-   * only needs the root itself, as Pixi's does. */
-  readonly api?: unknown;
 }
 
 /** A live, mounted canvas world. The host owns the canvas and lifecycle; the
@@ -161,23 +104,20 @@ export interface MountedCanvasRoot extends MountedRootBase {
   readonly substrate: MountedCanvasSubstrate;
 }
 
-/** A live, mounted react world (T6.2) — the react analog of
- *  {@link MountedThreeRoot}. `container` is the DOM-root layer the host
- *  handed the adapter's `mount` (the SAME element `RootInstance.reactRoot()`
- *  returns) — a react world's tree renders into it via `createRoot`. */
+/** A mounted DOM world. Its container is the same host-owned element supplied to mount. */
 export interface MountedReactRoot extends MountedRootBase {
   readonly kind: 'dom';
   readonly container: HTMLElement;
 }
 
 /** Every kind of live, mounted world. */
-export type MountedRoot = MountedThreeRoot | MountedCanvasRoot | MountedReactRoot;
+export type MountedRoot = MountedStageRoot | MountedCanvasRoot | MountedReactRoot;
 
 /** Map a {@link AdapterSurface} to its mounted-world shape — lets generic
  *  code over
  *  `K extends AdapterSurface` name the right surface without a manual union. */
-export type MountedRootFor<K extends AdapterSurface> = K extends 'three'
-  ? MountedThreeRoot
+export type MountedRootFor<K extends AdapterSurface> = K extends 'stage'
+  ? MountedStageRoot
   : K extends 'canvas'
     ? MountedCanvasRoot
     : K extends 'dom'
@@ -185,27 +125,13 @@ export type MountedRootFor<K extends AdapterSurface> = K extends 'three'
       : never;
 
 /**
- * The interface every root implements to run on the host. Generic over
- * {@link AdapterSurface} so `mount` receives and returns its native surface
- * types. Bare `RootAdapter` denotes the first-party Three surface.
- *
- * `K` parameterizes both halves of `mount`: `HostContextFor<K>` selects the
- * host context and `MountedRootFor<K>` selects the mounted result. Production
- * adapters are genuine `RootAdapter<K>` subtypes —
- * `Pixi2DRootAdapter extends RootAdapter<'canvas'>`, `ReactRootAdapter extends
- * RootAdapter<'dom'>` (`runtime/create-runtime.ts`).
- */
-/**
- * The `= 'three'` default is type-level only: an author who writes bare
- * `RootAdapter` for
- * a pixi root gets a compile error on `mount`'s return type, because
- * `MountedRootFor<'three'>` demands `scene`/`camera` a `MountedCanvasRoot` has
- * not got.
+ * A root adapter's surface selects both its host context and mounted result. The type-level
+ * default is stage; a canvas or DOM adapter declares its own surface to receive that context.
  */
-export interface RootAdapter<K extends AdapterSurface = 'three'> {
+export interface RootAdapter<K extends AdapterSurface = 'stage'> {
   /** Stable id (telemetry/registry/conformance). */
   readonly id: string;
-  /** Build/start the game against the host context for ITS surface; return the
+  /** Build/start the project against the host context for ITS surface; return the
    *  handle. */
   mount(host: HostContextFor<K>): Promise<MountedRootFor<K>>;
 }
@@ -215,11 +141,11 @@ export interface RootAdapter<K extends AdapterSurface = 'three'> {
  *
  * A resolver that turns a manifest root into a mountable
  * adapter handles every surface in one function, so its return type has to
- * span all three. Returning the bare union `RootAdapter<'three'> |
+ * span all three. Returning the bare union `RootAdapter<'stage'> |
  * RootAdapter<'canvas'> | RootAdapter<'dom'>` does NOT work — a union of
  * function types INTERSECTS its parameters, so `.mount(host)` becomes
  * uncallable with any single host value (no one object is simultaneously a
- * `ThreeHostContext`, a `CanvasHostContext` and a `DomHostContext`).
+ * `StageHostContext`, a `CanvasHostContext` and a `DomHostContext`).
  *
  * Carrying the tag ALONGSIDE the adapter fixes that structurally: this is a
  * discriminated union on `surface`, so `switch (resolved.surface)` narrows
@@ -234,10 +160,10 @@ export type SurfaceAdapterFor<K extends AdapterSurface> = {
 
 /** Every surface's {@link SurfaceAdapterFor}, as one discriminated union.
  *  Written out member-by-member (rather than as a distributive conditional)
- *  so `assertNever` sees exactly three variants and a hypothetical 4th
+ *  so an exhaustive switch sees exactly three variants and a hypothetical 4th
  *  `AdapterSurface` member fails to compile HERE, at the vocabulary, rather
  *  than silently widening every consumer's exhaustiveness guard. */
 export type SurfaceAdapter =
-  | SurfaceAdapterFor<'three'>
+  | SurfaceAdapterFor<'stage'>
   | SurfaceAdapterFor<'canvas'>
   | SurfaceAdapterFor<'dom'>;

package/src/adapter/root-seam-contract.ts

@@ -5,7 +5,7 @@ import type {
   MountedCanvasRoot,
   MountedReactRoot,
   MountedRootBase,
-  MountedThreeRoot,
+  MountedStageRoot,
   RootAdapter,
   RootStateObserver,
 } from './root-adapter';
@@ -24,12 +24,10 @@ export const MOUNTED_ROOT_BASE_SHAPE = defineSeamShape<MountedRootBase>()({
   setPaused: { optional: true, kind: 'function', required: 'effect' },
   step: { optional: true, kind: 'function', required: 'effect' },
   resize: { optional: true, kind: 'function', required: 'effect' },
-  hitTest: { optional: true, kind: 'function', required: 'operation' },
   dispose: { optional: false, kind: 'function', required: 'effect' },
   disposeComplete: { optional: true, kind: 'value', required: 'effect' },
   authoring: { optional: true, kind: 'value', required: 'operation' },
   systems: { optional: true, kind: 'value', required: 'operation' },
-  systemScope: { optional: true, kind: 'value', required: 'operation' },
   observe: { optional: true, kind: 'value', required: 'effect' },
 });
 
@@ -38,15 +36,14 @@ export const ROOT_STATE_OBSERVER_SHAPE = defineSeamShape<RootStateObserver>()({
   snapshot: { optional: false, kind: 'function', required: 'operation' },
 });
 
-type ThreeSurface = Omit<MountedThreeRoot<object, object>, keyof MountedRootBase>;
+type StageSurface = Omit<MountedStageRoot<object, object>, keyof MountedRootBase>;
 type CanvasSurface = Omit<MountedCanvasRoot, keyof MountedRootBase>;
 type DomSurface = Omit<MountedReactRoot, keyof MountedRootBase>;
 
-export const MOUNTED_THREE_SURFACE_SHAPE = defineSeamShape<ThreeSurface>()({
+export const MOUNTED_STAGE_SURFACE_SHAPE = defineSeamShape<StageSurface>()({
   kind: { optional: false, kind: 'value', required: 'shape' },
   scene: { optional: false, kind: 'value', required: 'effect' },
   camera: { optional: false, kind: 'value', required: 'effect' },
-  rendererConfig: { optional: true, kind: 'value', required: 'shape' },
 });
 
 export const MOUNTED_CANVAS_SURFACE_SHAPE = defineSeamShape<CanvasSurface>()({

package/src/adapter/root-stacking.ts

@@ -1,35 +1,18 @@
 /**
- * WHICH ROOT OWNS A POINT — the pure half of D5 §2a, a rule about how several
- * adapter roots share one surface, so it belongs beside the other seam
- * contracts rather than inside the runtime that first needed it.
- *
- * Two callers with nothing else in common depend on it: the engine's
- * `runtime/input-router.ts`, which wires it to real canvases and forwards
- * claimed events; and the EDITOR, which asks the same question at design time
- * with no game running (`authoring/layered-pick.ts` picks through stacked
- * authoring layers, `authoring/design-time-layers.ts` orders the layers it
- * mounts). That second caller is why the file moved here 2026-09-18
- * (WORK.md §The open-source launch, phase 1 unit 7): the host may import the
- * adapter CONTRACT and must not import the game runtime, and this was the one
- * `runtime/` module left in its closure. No DOM, no canvas, no mount.
+ * Pure stacking and point-ownership rules for adapter roots. Runtime and
+ * design-time authoring use the same z-order decisions without depending on
+ * DOM, canvas or mounting implementations.
  */
 
 /** The pure decision inputs — no DOM. */
 export interface ClaimEntry {
   readonly id: string;
   readonly zOrder: number;
-  /**
-   * Optional claim predicate over a point RELATIVE TO THE CONTAINER. Absent
-   * means: "this world claims only if it is the bottom (lowest zOrder)
-   * world" — D5 §2a's stated default ("transparent upper roots do not
-   * claim, the bottom world claims everything").
-   */
-  readonly hitTest?: ((x: number, y: number) => boolean) | undefined;
 }
 
 /**
  * Bottom-to-top paint order: ascending `zOrder`, ties -> original array
- * order — the SAME rule `manifest/load.ts`'s `loadGameManifest` sorts
+ * order — the SAME rule `manifest/load.ts`'s `loadProjectManifest` sorts
  * roots by, so a world's DOM stacking position always matches its
  * manifest-resolved zOrder. The last element is the topmost (visually on
  * top / highest z-index).
@@ -40,28 +23,3 @@ export function stackOrder<T extends ClaimEntry>(entries: readonly T[]): T[] {
     .sort((a, b) => a.entry.zOrder - b.entry.zOrder || a.index - b.index)
     .map(({ entry }) => entry);
 }
-
-/**
- * Resolve which world's id claims a container-relative point `(x, y)` — D5
- * §2a: walk top-down (topmost first); the first world whose `hitTest`
- * returns true wins ("topmost-claim wins"). A world with no `hitTest` never
- * claims UNLESS it is the bottom-most world, which claims unconditionally
- * (or via its own `hitTest`, if it declares one) — "no-claim falls to
- * bottom". Returns `null` only when `entries` is empty.
- */
-export function resolveClaimingRoot(
-  entries: readonly ClaimEntry[],
-  x: number,
-  y: number,
-): string | null {
-  if (entries.length === 0) return null;
-  const order = stackOrder(entries); // bottom -> top
-  for (let i = order.length - 1; i >= 1; i--) {
-    const entry = order[i]!;
-    if (entry.hitTest?.(x, y)) return entry.id;
-  }
-  // No upper world claimed (or there is only one world) -> the bottom world
-  // claims — honoring its own hitTest if it declares one (rare: the bottom
-  // world usually claims everything unconditionally per D5 §2a's default).
-  return order[0]!.id;
-}

package/src/adapter/seam-evidence.ts

@@ -178,22 +178,6 @@ export class SeamEvidenceLedger {
     );
   }
 
-  verdict(options: {
-    readonly seam: string;
-    readonly subject: string;
-    readonly epoch: string;
-    readonly required: SeamProofStage;
-    readonly notApplicable?: string | undefined;
-  }): SeamEvidenceVerdict {
-    return gradeSeamEvidence({ ...options, receipts: this.#receipts });
-  }
-
-  clearSubject(subject: string): void {
-    for (let index = this.#receipts.length - 1; index >= 0; index -= 1) {
-      if (this.#receipts[index]?.subject === subject) this.#receipts.splice(index, 1);
-    }
-  }
-
   clear(): void {
     this.#receipts.length = 0;
   }