@volter/editor-game 0.5.65

package/src/host/projection/dom.ts

@@ -0,0 +1,295 @@
+/**
+ * THE PROJECTOR FOR THE DOM SURFACE — one walk, one index, one set of derived
+ * views, for every authoring adapter that drives a live element tree
+ * (ARCHITECTURE-CORE §The editor protocol, projection family).
+ *
+ * The projection unit is the RUNTIME ELEMENT. Nothing here reads source, an AST
+ * or a document; a walk answers from the tree that is actually mounted, so an
+ * empty projection over a mounted world is a defect rather than a fact.
+ *
+ * ## What this owns, and what it deliberately does not
+ *
+ * OWNS — the two things both DOM authoring classes used to spell separately:
+ *
+ *  - the walk itself ({@link walkDomGraph}), including the "root is not a node"
+ *    rule and the fold-into-the-nearest-admitted-ancestor rule,
+ *  - IDENTITY MINTING, parameterized by scheme ({@link structuralDomIdentity},
+ *    {@link oidDomIdentity}) — the id FORMATS are the schemes', the walk that
+ *    applies them is one.
+ *
+ * DOES NOT own the LANE-SPECIFIC hierarchy VIEW built on top. The first-party
+ * React world adapter overlays portable-CSF / catalog rows on the OID
+ * projection; the ingested React adapter does not. Both read this projection
+ * and derive their rows from it.
+ *
+ * PICKING is not here either. DOM hit-testing is a geometric rect walk over
+ * `getBoundingClientRect` (and must honor design-time `pointer-events`), which
+ * is a derived view the adapters already share by transcription, not a
+ * raycast the projector can own the way {@link ThreeProjector.pick} does.
+ */
+
+import type { ProjectedNode, Projection } from '@volter/editor-core/projection/types';
+
+export type { ProjectedNode, Projection } from '@volter/editor-core/projection/types';
+
+/**
+ * The minimum shape a live DOM walk needs. Deliberately not `Element` so a
+ * headless fixture (plain object, no jsdom) can project the same way a real
+ * element does. A real `Element` satisfies this structurally.
+ */
+export interface DomWalkable {
+  readonly tagName: string;
+  readonly children: ArrayLike<DomWalkable>;
+}
+
+/** Extra surface a scheme needs when identity is an authored attribute. */
+export interface OidWalkable extends DomWalkable {
+  getAttribute(name: string): string | null;
+}
+
+/** One projected authoring node over a live DOM tree. */
+export type DomNode<TEl extends DomWalkable = DomWalkable> = ProjectedNode<TEl>;
+
+export interface DomWalkStats {
+  readonly count: number;
+}
+
+export type DomProjection<TEl extends DomWalkable = DomWalkable> = Projection<TEl, DomWalkStats>;
+
+export const EMPTY_DOM_WALK_STATS: DomWalkStats = { count: 0 };
+
+/**
+ * The IDENTITY seam — how a live element tree is addressed: which elements
+ * are authoring nodes, what their ids are, and how they nest.
+ *
+ * An adapter never mints an id itself. It asks a scheme for a
+ * {@link DomProjection} and drives every provider (hierarchy, selection,
+ * inspector, picking) off that one walk.
+ */
+export interface DomIdentity<TEl extends DomWalkable = DomWalkable> {
+  project(root: TEl): DomProjection<TEl>;
+}
+
+/** Where the walk currently is, for a scheme that mints from position. */
+export interface DomWalkContext<TEl extends DomWalkable = DomWalkable> {
+  /** The nearest ADMITTED ancestor's id — `null` ⇒ this element hangs under
+   *  transparent wrappers only, so a node admitted here is a projection root. */
+  readonly ownerId: string | null;
+  /** Whether anything above already claims this subtree as its parts. */
+  readonly ownedByAncestor: boolean;
+  /** The element whose `.children` this visit came from — the walk root on
+   *  the first level, an already-visited descendant after that. */
+  readonly parent: TEl;
+  /** Index in `siblings`. */
+  readonly siblingIndex: number;
+  /** The parent's element children, in tree order. */
+  readonly siblings: readonly TEl[];
+}
+
+/** The per-lane half of a walk: what to skip, what to admit, what to call it. */
+export interface DomIdentityScheme<TEl extends DomWalkable = DomWalkable> {
+  begin?(): void;
+  /** This element never enters the projection, WITH its descendants. */
+  skip?(el: TEl): boolean;
+  /** This element's id, or `null` when it is not an authoring node — in which
+   *  case its children fold into the nearest admitted ancestor. */
+  identify(el: TEl, context: DomWalkContext<TEl>): string | null;
+  /** Visit this element's children? Defaults to yes. `false` is how an inline
+   *  SVG stays one atomic node instead of exposing its `g`/`path` internals. */
+  descend?(el: TEl): boolean;
+  leave?(el: TEl, id: string | null): void;
+}
+
+const OID_ATTR = 'data-oid';
+
+function tally<TEl extends DomWalkable>(nodes: ReadonlyMap<string, DomNode<TEl>>): DomWalkStats {
+  return { count: nodes.size };
+}
+
+function isSvg(el: DomWalkable): boolean {
+  return el.tagName.toLowerCase() === 'svg';
+}
+
+/**
+ * THE WALK. One DFS over a live DOM root's ELEMENT children. The root itself
+ * is never a node — its element children are the projection roots — matching
+ * both DOM adapters' pre-extraction contract.
+ *
+ * Idempotent for every scheme that mints from the tree's own facts: re-walking
+ * the same tree re-derives the same ids for the same elements.
+ */
+export function walkDomGraph<TEl extends DomWalkable>(
+  root: TEl,
+  scheme: DomIdentityScheme<TEl>,
+): DomProjection<TEl> {
+  const nodes = new Map<string, DomNode<TEl>>();
+  const rootIds: string[] = [];
+  scheme.begin?.();
+
+  const visitChildren = (parent: TEl, ownerId: string | null, ownedByAncestor: boolean): void => {
+    const siblings = Array.from(parent.children) as TEl[];
+    siblings.forEach((el, siblingIndex) => {
+      if (scheme.skip?.(el)) return;
+      const id = scheme.identify(el, {
+        ownerId,
+        ownedByAncestor,
+        parent,
+        siblingIndex,
+        siblings,
+      });
+      if (id !== null) {
+        nodes.set(id, { object: el, id, parentId: ownerId, childIds: [] });
+        if (ownerId === null) rootIds.push(id);
+        else nodes.get(ownerId)?.childIds.push(id);
+      }
+      const nextOwner = id ?? ownerId;
+      const nextOwned = ownedByAncestor || id !== null;
+      if (scheme.descend?.(el) !== false) visitChildren(el, nextOwner, nextOwned);
+      scheme.leave?.(el, id);
+    });
+  };
+
+  visitChildren(root, null, false);
+  return { nodes, rootIds, stats: tally(nodes) };
+}
+
+/**
+ * The STRUCTURAL-PATH scheme. Deterministic from the tree's shape: each
+ * segment is `<tag>[k]` where `k` is the element's index among preceding
+ * SAME-TAG element siblings. Prefixed `rdom:`. This is the scheme for a
+ * graph whose source was never stamped.
+ */
+export function structuralDomIdentity<TEl extends DomWalkable = DomWalkable>(): DomIdentity<TEl> {
+  return {
+    project: (root) => {
+      const pathById = new Map<string, string>();
+      return walkDomGraph(root, {
+        begin: () => pathById.clear(),
+        identify: (el, context) => {
+          const tag = el.tagName.toLowerCase();
+          let k = 0;
+          for (let i = 0; i < context.siblingIndex; i++) {
+            if (context.siblings[i]!.tagName.toLowerCase() === tag) k++;
+          }
+          const segment = `${tag}[${k}]`;
+          const parentPath = context.ownerId ? (pathById.get(context.ownerId) ?? '') : '';
+          const path = parentPath ? `${parentPath}/${segment}` : segment;
+          const id = `rdom:${path}`;
+          pathById.set(id, path);
+          return id;
+        },
+        descend: (el) => !isSvg(el),
+      });
+    },
+  };
+}
+
+/**
+ * The OID scheme. A `data-oid`-stamped element is a node; an unstamped wrapper
+ * is transparent and its children fold into the nearest stamped ancestor.
+ * Repeats of the same oid (one JSX line rendered N times) keep the bare oid
+ * on the first occurrence and suffix `#n` after that.
+ */
+export function oidDomIdentity<TEl extends OidWalkable = OidWalkable>(): DomIdentity<TEl> {
+  return {
+    project: (root) => {
+      const occurrence = new Map<string, number>();
+      return walkDomGraph(root, {
+        begin: () => occurrence.clear(),
+        identify: (el) => {
+          const oid = el.getAttribute(OID_ATTR);
+          if (!oid) return null;
+          const n = occurrence.get(oid) ?? 0;
+          occurrence.set(oid, n + 1);
+          return n === 0 ? oid : `${oid}#${n}`;
+        },
+        descend: (el) => !isSvg(el),
+      });
+    },
+  };
+}
+
+/** Walk a live DOM root under the structural-path scheme. */
+export function projectStructuralDom<TEl extends DomWalkable>(root: TEl): DomProjection<TEl> {
+  return structuralDomIdentity<TEl>().project(root);
+}
+
+/** Walk a live DOM root under the OID scheme. */
+export function projectOidDom<TEl extends OidWalkable>(root: TEl): DomProjection<TEl> {
+  return oidDomIdentity<TEl>().project(root);
+}
+
+/**
+ * The projector: one identity scheme, the index its walk produces, and the
+ * derived views every DOM authoring adapter reads instead of re-walking.
+ */
+export class DomProjector<TEl extends DomWalkable = DomWalkable> {
+  private nodesById = new Map<string, DomNode<TEl>>();
+  private objectsById = new Map<string, TEl>();
+  private idsByObjectIndex = new Map<TEl, string>();
+  private roots: string[] = [];
+  private walkStats: DomWalkStats = EMPTY_DOM_WALK_STATS;
+
+  constructor(private readonly identity: DomIdentity<TEl>) {}
+
+  /**
+   * (Re)walk. `null` is an honest "nothing is mounted" — the projection empties
+   * rather than keeping a stale index, because a hierarchy over a torn-down
+   * world is worse than no hierarchy.
+   */
+  project(root: TEl | null): DomWalkStats {
+    if (!root) {
+      this.nodesById = new Map();
+      this.objectsById = new Map();
+      this.idsByObjectIndex = new Map();
+      this.roots = [];
+      this.walkStats = EMPTY_DOM_WALK_STATS;
+      return this.walkStats;
+    }
+    const { nodes, rootIds, stats } = this.identity.project(root);
+    this.nodesById = nodes;
+    this.objectsById = new Map([...nodes].map(([id, node]) => [id, node.object] as const));
+    this.idsByObjectIndex = new Map([...nodes].map(([id, node]) => [node.object, id] as const));
+    this.roots = rootIds;
+    this.walkStats = stats;
+    return stats;
+  }
+
+  get nodes(): ReadonlyMap<string, DomNode<TEl>> {
+    return this.nodesById;
+  }
+
+  get objects(): ReadonlyMap<string, TEl> {
+    return this.objectsById;
+  }
+
+  get idsByObject(): ReadonlyMap<TEl, string> {
+    return this.idsByObjectIndex;
+  }
+
+  get rootIds(): readonly string[] {
+    return this.roots;
+  }
+
+  get stats(): DomWalkStats {
+    return this.walkStats;
+  }
+
+  node(id: string): DomNode<TEl> | null {
+    return this.nodesById.get(id) ?? null;
+  }
+
+  rootNodes(): DomNode<TEl>[] {
+    return this.roots
+      .map((id) => this.nodesById.get(id))
+      .filter((node): node is DomNode<TEl> => node !== undefined);
+  }
+
+  objectOf(id: string): TEl | null {
+    return this.objectsById.get(id) ?? null;
+  }
+
+  idOf(el: TEl): string | null {
+    return this.idsByObjectIndex.get(el) ?? null;
+  }
+}

package/src/host/projection/pixi.ts

@@ -0,0 +1,288 @@
+/**
+ * THE PROJECTOR FOR THE CANVAS SURFACE — one live display-tree walk, one
+ * identity index, and the picking/bounds views derived from it.
+ *
+ * `AuthoringAdapter2D` remains the Pixi truth backend: it applies transforms,
+ * reflected properties, and session overlays. This class owns the PROJECTION
+ * currency that every canvas authoring view reads. The split is deliberate:
+ * the projector answers what exists and where it is; a write target answers
+ * where an edit lands.
+ */
+
+import type { AuthoringAdapter2D, EditorNode2D } from '@volter/game-runtime/pixi/authoring';
+import type { DOMRectLike } from '@volter/editor-project/adapter';
+import type { Container, PointData } from 'pixi.js';
+import type { ProjectedNode, Projection } from '@volter/editor-core/projection/types';
+
+export type PixiNode = ProjectedNode<Container>;
+
+export interface PixiWalkStats {
+  readonly count: number;
+  readonly sprites: number;
+}
+
+export type PixiProjection = Projection<Container, PixiWalkStats>;
+
+export const EMPTY_PIXI_WALK_STATS: PixiWalkStats = { count: 0, sprites: 0 };
+
+export interface PixiSurfaceMapping {
+  readonly surface: () => HTMLElement | null;
+  readonly pointFromClient?: (clientX: number, clientY: number, rect: DOMRect) => PointData | null;
+}
+
+/**
+ * Project a live Pixi stage through the identity scheme held by
+ * {@link AuthoringAdapter2D}. The backend is injected so projection and truth
+ * share the exact same object index; neither side can mint a second id.
+ */
+export class PixiProjector {
+  private current: PixiProjection = {
+    nodes: new Map(),
+    rootIds: [],
+    stats: EMPTY_PIXI_WALK_STATS,
+  };
+
+  /** True while {@link current} may be reused instead of re-walked. Closed at
+   *  the next microtask checkpoint by {@link scheduleWindowClose}. */
+  private projectionFresh = false;
+
+  constructor(
+    private readonly root: Container,
+    private readonly index: AuthoringAdapter2D,
+    private readonly mapping?: PixiSurfaceMapping,
+    /** Injected by the unit test that drives the coalescing window by hand;
+     *  the editor always uses the microtask checkpoint. */
+    private readonly scheduleWindowClose: (close: () => void) => void = (close) =>
+      queueMicrotask(close),
+  ) {
+    this.refresh();
+  }
+
+  /** Rewalk identity and reapply the truth backend's saved overlay. */
+  refresh(): PixiWalkStats {
+    const stats = this.index.refresh();
+    this.current = this.readProjection(stats);
+    this.openProjectionWindow();
+    return stats;
+  }
+
+  /**
+   * Rewalk identity only, then publish one immutable projection snapshot —
+   * AT MOST ONCE PER SYNCHRONOUS TURN.
+   *
+   * The read is still the refresh point: a world that commits nodes after the
+   * adapter was handed its root is still picked up on the next read, because
+   * the window this coalesces over closes at the next microtask checkpoint.
+   * What it removes is the RE-walk inside one derivation — measured
+   * 2026-08-20 on a 1822-node canvas world, one projection is 70ms and a
+   * single coverage/status pass asked for eight of them, because every
+   * `hierarchy.roots()`, every `pickable.candidates()` and every composite
+   * group-node read projects again.
+   *
+   * The window is only sound while nothing moves the display list behind it.
+   * Two kinds of mover exist and BOTH have a door: this adapter's own write
+   * paths call {@link reproject}, and the GAME — a world that commits its own
+   * nodes when an atlas or a resource load resolves — is caught by the owner's
+   * `childAdded`/`childRemoved` watcher, which calls {@link invalidate} the
+   * synchronous instant pixi fires. Without that second door a read landing in
+   * the same turn as the game's own commit answers from the stale walk, which
+   * is exactly the late-commit defect the watcher exists to prevent.
+   */
+  project(): PixiProjection {
+    if (this.projectionFresh) return this.current;
+    return this.reproject();
+  }
+
+  /** Project unconditionally — the write paths' door, for a caller that has
+   *  just mutated the display list and must not read its own stale window. */
+  reproject(): PixiProjection {
+    const stats = this.index.reindex();
+    this.current = this.readProjection(stats);
+    this.openProjectionWindow();
+    return this.current;
+  }
+
+  /**
+   * Close the coalescing window WITHOUT walking — the door for a mutation this
+   * projector cannot see coming (the game's own commit, reported by its
+   * owner's display-list watcher). The next read re-walks; a burst of commits
+   * with no read between them still costs one walk, so the measured win of the
+   * window survives intact.
+   */
+  invalidate(): void {
+    this.projectionFresh = false;
+  }
+
+  /** Hold this projection for the rest of the current synchronous turn. */
+  private openProjectionWindow(): void {
+    if (this.projectionFresh) return;
+    this.projectionFresh = true;
+    this.scheduleWindowClose(() => {
+      this.projectionFresh = false;
+    });
+  }
+
+  projection(): PixiProjection {
+    return this.current;
+  }
+
+  /**
+   * The live container for `id`, or null.
+   *
+   * A DESTROYED container is not a live object. A survivor-style game destroys
+   * entities every frame and this map is only refreshed by the next walk, so
+   * between a destroy and that walk every consumer here would be handed a
+   * husk whose `children`, `effects`, `pivot` and `anchor` are nulled — and
+   * Pixi's own recursive bounds walk plus the editor's origin read both crash
+   * on it mid-React-render (`Cannot read properties of null` reading 'length'
+   * then 'x'; runhuman passes 115 and 119, two call sites of the same husk).
+   * Answering null here is what stops the next reader from being the third.
+   */
+  object(id: string): Container | null {
+    const object = this.current.nodes.get(id)?.object ?? null;
+    return object === null || object.destroyed ? null : object;
+  }
+
+  node(id: string): EditorNode2D | null {
+    const projected = this.current.nodes.get(id);
+    if (!projected) return null;
+    const native = this.index.node(id);
+    if (!native) return null;
+    return {
+      ...native,
+      parentId: projected.parentId,
+      childIds: [...projected.childIds],
+    };
+  }
+
+  roots(): EditorNode2D[] {
+    return this.current.rootIds
+      .map((id) => this.node(id))
+      .filter((node): node is EditorNode2D => node !== null);
+  }
+
+  pick(clientX: number, clientY: number, excluded: (id: string) => boolean): string | null {
+    return this.candidates(clientX, clientY, excluded)[0] ?? null;
+  }
+
+  candidates(clientX: number, clientY: number, excluded: (id: string) => boolean): string[] {
+    const point = this.pointFromClient(clientX, clientY);
+    if (!point) return [];
+    this.project();
+    return this.hitIds(point, excluded);
+  }
+
+  private pointFromClient(clientX: number, clientY: number): PointData | null {
+    const surface = this.mapping?.surface() ?? null;
+    if (!surface) return null;
+    const rect = surface.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0) return null;
+    const mapped = this.mapping?.pointFromClient?.(clientX, clientY, rect) ?? null;
+    if (this.mapping?.pointFromClient) return mapped;
+    const logicalWidth = Number(surface.dataset?.['vgaiStageWidth'] ?? rect.width);
+    const logicalHeight = Number(surface.dataset?.['vgaiStageHeight'] ?? rect.height);
+    if (!(logicalWidth > 0) || !(logicalHeight > 0)) return null;
+    return {
+      x: (clientX - rect.left) * (logicalWidth / rect.width),
+      y: (clientY - rect.top) * (logicalHeight / rect.height),
+    };
+  }
+
+  private hitIds(point: PointData, excluded: (id: string) => boolean): string[] {
+    const visual: Container[] = [];
+    const hitAreas: Container[] = [];
+    this.collectHits(this.root, point, 'visual', visual);
+    this.collectHits(this.root, point, 'hitArea', hitAreas);
+
+    const ids: string[] = [];
+    const seen = new Set<string>();
+    for (const object of [...visual, ...hitAreas]) {
+      const id = (object as Container & { __authId?: string }).__authId;
+      if (id && !excluded(id) && !seen.has(id)) {
+        seen.add(id);
+        ids.push(id);
+      }
+    }
+    return ids;
+  }
+
+  rect(id: string): DOMRectLike | null {
+    const object = this.object(id);
+    if (!object || typeof object.getBounds !== 'function') return null;
+    const bounds = object.getBounds();
+    if (!(bounds.width > 0) || !(bounds.height > 0)) return null;
+    return { x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height };
+  }
+
+  contextRects(id: string): { parent?: DOMRectLike; siblings: DOMRectLike[] } {
+    const node = this.node(id);
+    if (!node) return { siblings: [] };
+    const siblingIds = node.parentId
+      ? (this.node(node.parentId)?.childIds ?? [])
+      : this.current.rootIds;
+    const parent = node.parentId ? this.rect(node.parentId) : null;
+    return {
+      ...(parent ? { parent } : {}),
+      siblings: siblingIds
+        .filter((siblingId) => siblingId !== id)
+        .map((siblingId) => this.rect(siblingId))
+        .filter((rect): rect is DOMRectLike => rect !== null),
+    };
+  }
+
+  private readProjection(stats: PixiWalkStats): PixiProjection {
+    const nodes = new Map<string, PixiNode>();
+    const rootIds: string[] = [];
+    const visit = (native: EditorNode2D): void => {
+      const object = this.index.displayObject(native.id);
+      if (!object) return;
+      const node: PixiNode = {
+        object,
+        id: native.id,
+        parentId: native.parentId,
+        childIds: [...native.childIds],
+      };
+      nodes.set(native.id, node);
+      for (const childId of native.childIds) {
+        const child = this.index.node(childId);
+        if (child) visit(child);
+      }
+    };
+    for (const root of this.index.roots()) {
+      rootIds.push(root.id);
+      visit(root);
+    }
+    return { nodes, rootIds, stats };
+  }
+
+  /** Pixi paint order, frontmost first; rendered geometry precedes hit areas. */
+  private collectHits(
+    parent: Container,
+    point: PointData,
+    mode: 'visual' | 'hitArea',
+    hits: Container[],
+  ): void {
+    const children = parent.children ?? [];
+    for (let index = children.length - 1; index >= 0; index--) {
+      const child = children[index] as Container;
+      if (!child.visible || !child.renderable) continue;
+      child.updateLocalTransform();
+      const local: PointData = { x: 0, y: 0 };
+      child.localTransform.applyInverse(point, local);
+      this.collectHits(child, local, mode, hits);
+      if (this.contains(child, local, mode)) hits.push(child);
+    }
+  }
+
+  private contains(object: Container, local: PointData, mode: 'visual' | 'hitArea'): boolean {
+    if (!(object as Container & { __authId?: string }).__authId) return false;
+    const shaped = object as Container & {
+      hitArea?: { contains(x: number, y: number): boolean } | null;
+      containsPoint?: (point: PointData) => boolean;
+    };
+    if (mode === 'hitArea') {
+      return shaped.hitArea ? shaped.hitArea.contains(local.x, local.y) : false;
+    }
+    return typeof shaped.containsPoint === 'function' ? shaped.containsPoint(local) : false;
+  }
+}

package/src/host/r3f-entry-runtime.ts

@@ -0,0 +1,77 @@
+/**
+ * Resolve the R3F entry factory from the same module graph as project worlds.
+ * The packaged editor's UI is prebuilt with its own React/Fiber instances,
+ * while project modules are transformed by a separate project-rooted Vite
+ * server. Building a project component's adapter with the UI bundle's factory
+ * crosses those graphs and crashes Fiber hooks on a null React dispatcher.
+ */
+
+import { resolveR3FEntryAdapter } from '@volter/game-runtime/world3d-react';
+import type { RootAdapter, ThreeHostContext } from '@volter/editor-project/adapter';
+import type * as THREE from 'three';
+import {
+  R3F_ENTRY_RUNTIME_PATH,
+  R3F_RUNTIME_PATH,
+} from '@volter/editor-sdk/host';
+import { isPackagedRuntime } from '@volter/editor-core/packaged-runtime';
+
+type R3FEntryResolver = typeof resolveR3FEntryAdapter;
+
+interface PackagedR3FRuntime {
+  readonly resolve: R3FEntryResolver;
+  readonly projectThree: typeof THREE;
+}
+
+let cachedPackagedRuntime: Promise<PackagedR3FRuntime> | null = null;
+
+async function packagedRuntime(): Promise<PackagedR3FRuntime> {
+  const [entry, mod] = await Promise.all([
+    import(/* @vite-ignore */ R3F_ENTRY_RUNTIME_PATH) as Promise<{
+      resolveR3FEntryAdapter?: unknown;
+    }>,
+    import(/* @vite-ignore */ R3F_RUNTIME_PATH) as Promise<{ projectThree?: unknown }>,
+  ]);
+  if (typeof entry.resolveR3FEntryAdapter !== 'function') {
+    throw new Error(
+      "The packaged runtime's synthetic R3F entry module did not export " +
+        '`resolveR3FEntryAdapter` — see R3F_ENTRY_DOORWAY in vite-plugin-module-doorways.ts.',
+    );
+  }
+  if (typeof mod.projectThree !== 'object' || mod.projectThree === null) {
+    throw new Error(
+      "The packaged runtime's synthetic R3F module did not export " +
+        '`projectThree` — see R3F_DOORWAY in vite-plugin-module-doorways.ts.',
+    );
+  }
+  return {
+    resolve: entry.resolveR3FEntryAdapter as R3FEntryResolver,
+    projectThree: mod.projectThree as typeof THREE,
+  };
+}
+
+/**
+ * The packaged editor shell and project modules are separate Vite graphs. The
+ * adapter itself comes from the project graph, so its Three host namespace
+ * must come from there too: Fiber seeds its intrinsic catalogue from
+ * `host.three`, and mixing in the shell's constructors makes applyProps turn a
+ * typed `DirectionalLight.color` into the raw JSX string.
+ */
+export function withPackagedProjectThree(
+  adapter: RootAdapter,
+  projectThree: typeof THREE,
+): RootAdapter {
+  return {
+    id: adapter.id,
+    mount(host: ThreeHostContext) {
+      return adapter.mount({ ...host, three: projectThree });
+    },
+  };
+}
+
+export async function resolveR3FEntryAdapterForEditor(entryModule: unknown, rootId: string) {
+  if (!(await isPackagedRuntime())) return resolveR3FEntryAdapter(entryModule, rootId);
+  if (!cachedPackagedRuntime) cachedPackagedRuntime = packagedRuntime();
+  const runtime = await cachedPackagedRuntime;
+  const adapter = runtime.resolve(entryModule, rootId);
+  return adapter ? withPackagedProjectThree(adapter, runtime.projectThree) : null;
+}