@volter/editor-game 0.5.65

package/src/host/authoring/mount-isolated-pixi-screen.ts

@@ -0,0 +1,250 @@
+/**
+ * DESIGN-TIME isolation of a Pixi screen CLASS — Edit mounts the piece
+ * on the same Scene camera first-party canvas Edit uses
+ * (`canvas-design-mount.ts`).
+ *
+ * The construct keeps its authored stage size. The viewport is a presentation
+ * surface: the editor camera frames it, wheel zooms, and the grid shows
+ * around it. The pane is never the game's output rectangle — that is how a
+ * letterboxed 1280×720 screen made zoom a no-op.
+ *
+ * `new Ctor()`, settle at rest. No ticker, no `show()` (GameScreen.show
+ * starts the match). The live ingest host is not used.
+ */
+
+import type { Application, Container } from 'pixi.js';
+import { type CanvasPixiNamespace, resolveCanvasPixiForEditor } from '../canvas-entry-runtime';
+import { createWithOwnedPixiTickerListeners } from './owned-pixi-ticker-listeners';
+import { initializePixiIsolationAssets } from './pixi-isolation-assets';
+import { fitSceneView, registerStillFramePresenter } from './pixi-still-presentation';
+import type { RootViewController } from '@volter/editor-core/authoring/world-pan-state';
+
+export type IsolatedPixiScreenCtor = (new () => IsolatedPixiScreen) & {
+  readonly assetBundles?: readonly string[];
+};
+
+export type IsolatedPixiScreen = Container & {
+  prepare?(data: unknown): void;
+  resize?(width: number, height: number): void;
+};
+
+const EMPTY_RESULT = { score: 0, popped: 0, combo: 0, powerups: 0, highscore: 0 };
+
+type PoseNode = {
+  x: number;
+  y: number;
+  alpha: number;
+  readonly children?: readonly PoseNode[];
+};
+
+/**
+ * Isolation shows the CONSTRUCT at rest, not the intro tween and not the
+ * running match.
+ *
+ * `prepare` is the game's pre-show hook: Result fills labels; Title parks
+ * intro groups off-screen pending `show()`. Snapshot the constructed pose,
+ * let prepare write data, then restore pose and keep alpha 1. Never call
+ * `show()` — that starts the match / starts tweens.
+ */
+export function settleIsolatedScreen(screen: IsolatedPixiScreen): void {
+  const poses = snapshotPoses(screen as PoseNode);
+  screen.prepare?.(EMPTY_RESULT);
+  restorePoses(screen as PoseNode, poses);
+  screen.alpha = 1;
+}
+
+function snapshotPoses(node: PoseNode): Map<PoseNode, { x: number; y: number; alpha: number }> {
+  const out = new Map<PoseNode, { x: number; y: number; alpha: number }>();
+  const walk = (current: PoseNode) => {
+    out.set(current, { x: current.x, y: current.y, alpha: current.alpha });
+    for (const child of current.children ?? []) walk(child);
+  };
+  walk(node);
+  return out;
+}
+
+function restorePoses(
+  node: PoseNode,
+  poses: Map<PoseNode, { x: number; y: number; alpha: number }>,
+): void {
+  const pose = poses.get(node);
+  if (pose) {
+    node.x = pose.x;
+    node.y = pose.y;
+    node.alpha = pose.alpha;
+  }
+  for (const child of node.children ?? []) restorePoses(child, poses);
+}
+
+/**
+ * Authored stage size — the construct's own units, never the pane.
+ *
+ * Height is the Bubbo HUD's design content height (925). Isolation used to
+ * resize to 720, so `windowHeight - content.height` went negative, the
+ * thin-screen Title sat above the stage, and opening-fit of `getBounds()`
+ * zoomed the camera out around that off-screen wordmark.
+ */
+export const ISOLATED_PIXI_STAGE = { width: 1280, height: 925 } as const;
+
+/** The Scene camera frames this rectangle, not the AABB of every child. */
+export function isolatedStageBounds(): {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+} {
+  return { x: 0, y: 0, width: ISOLATED_PIXI_STAGE.width, height: ISOLATED_PIXI_STAGE.height };
+}
+
+export interface MountedIsolatedPixiScreen {
+  readonly canvas: HTMLCanvasElement;
+  readonly app: Application;
+  readonly screen: IsolatedPixiScreen;
+  /** The namespace this screen was constructed and rendered in — the caller's
+   *  authoring adapter and preview take the SAME one. */
+  readonly pixi: CanvasPixiNamespace;
+  dispose(): void;
+}
+
+export interface MountIsolatedPixiScreenOptions {
+  readonly initAssets?: () => Promise<void>;
+  /** Project-relative identity of the module behind `initAssets`. */
+  readonly assetSourcePath?: string;
+  /** Adapter-declared prerequisite for constructing this isolated piece. */
+  readonly isolationSetup?: () => void | Promise<void>;
+  /** The document's independent Scene camera. Required: isolation is a
+   *  Scene-camera piece, not a letterboxed output. */
+  readonly view: RootViewController;
+  /** Already-mounted document pane the viewport canvas draws into. */
+  readonly layer: HTMLElement;
+}
+
+/** Frame authored bounds in the Scene camera — the shared design-time fit
+ *  (`pixi-still-presentation.ts`), re-exported under this mount's own name for
+ *  its existing callers. */
+export const fitIsolatedSceneView = fitSceneView;
+
+export async function mountIsolatedPixiScreen(
+  Ctor: IsolatedPixiScreenCtor,
+  options: MountIsolatedPixiScreenOptions,
+): Promise<MountedIsolatedPixiScreen> {
+  const { view, layer } = options;
+  const stage = ISOLATED_PIXI_STAGE;
+  // THE namespace: `Ctor` is one of the GAME's own classes, loaded through the
+  // project graph, so its `pixi.js` is the project's under the packaged
+  // runtime. Everything this mount builds around it — the Application that
+  // draws it, the `Assets` bundles it needs, the `Ticker.shared` whose
+  // constructor-time registrations are withheld, the presentation Matrix —
+  // has to be that same one. See `../../vite-plugin-module-doorways.ts`.
+  const pixi = await resolveCanvasPixiForEditor();
+  const app = new pixi.Application();
+  await app.init({
+    autoStart: false,
+    sharedTicker: false,
+    backgroundAlpha: 0,
+    width: stage.width,
+    height: stage.height,
+    antialias: true,
+    preserveDrawingBuffer: true,
+  });
+  const canvas = app.canvas as HTMLCanvasElement;
+  canvas.dataset['vgaiCanvasSceneSurface'] = 'true';
+  canvas.style.position = 'absolute';
+  canvas.style.inset = '0';
+  canvas.style.width = '100%';
+  canvas.style.height = '100%';
+  canvas.style.display = 'block';
+  layer.appendChild(canvas);
+
+  if (options.initAssets) {
+    await initializePixiIsolationAssets(
+      options.assetSourcePath ?? options.initAssets.name,
+      options.initAssets,
+    );
+  }
+  if (Ctor.assetBundles && Ctor.assetBundles.length > 0) {
+    await pixi.Assets.loadBundle([...Ctor.assetBundles]);
+  }
+  await options.isolationSetup?.();
+  const ownedScreen = createWithOwnedPixiTickerListeners(() => {
+    const isolated = new Ctor();
+    // `prepare` is part of constructing the at-rest authoring document and may
+    // schedule delayed GSAP work (Bubbo's Porthole does). Keep it inside the
+    // owned-clock window so teardown can kill that work before Play begins.
+    settleIsolatedScreen(isolated);
+    return isolated;
+  }, pixi);
+  const screen = ownedScreen.value;
+  app.stage.addChild(screen);
+  // World size once. The pane is the camera, not a second resolution.
+  screen.resize?.(stage.width, stage.height);
+
+  const resizeRenderer = (): void => {
+    const rect = layer.getBoundingClientRect();
+    if (rect.width < 2 || rect.height < 2) return;
+    const renderer = app.renderer;
+    if (renderer.screen.width !== rect.width || renderer.screen.height !== rect.height) {
+      renderer.resize(rect.width, rect.height);
+    }
+  };
+
+  const renderScene = (): boolean => {
+    const renderer = app.renderer;
+    if (!renderer) return false;
+    resizeRenderer();
+    const pose = view.get();
+    renderer.render({
+      container: app.stage,
+      transform: new pixi.Matrix(pose.zoom, 0, 0, pose.zoom, pose.x, pose.y),
+    });
+    return true;
+  };
+
+  const unregisterPresented = registerStillFramePresenter(canvas, renderScene);
+
+  let frame = 0;
+  let disposed = false;
+  const draw = (): void => {
+    frame = requestAnimationFrame(draw);
+    if (disposed) return;
+    renderScene();
+  };
+  frame = requestAnimationFrame(draw);
+
+  const observer = new ResizeObserver(() => {
+    if (disposed) return;
+    renderScene();
+  });
+  observer.observe(layer);
+
+  let openingFit = 0;
+  let openingAttempts = 0;
+  let openingCancelled = false;
+  const stopOpeningOnNavigation = view.subscribe(() => {
+    openingCancelled = true;
+  });
+  const tryOpeningFit = (): void => {
+    if (openingCancelled || disposed || openingAttempts++ > 180) return;
+    if (fitIsolatedSceneView(layer, isolatedStageBounds(), view)) return;
+    openingFit = requestAnimationFrame(tryOpeningFit);
+  };
+  openingFit = requestAnimationFrame(tryOpeningFit);
+
+  return {
+    canvas,
+    app,
+    screen,
+    pixi,
+    dispose() {
+      disposed = true;
+      cancelAnimationFrame(frame);
+      cancelAnimationFrame(openingFit);
+      stopOpeningOnNavigation();
+      observer.disconnect();
+      unregisterPresented();
+      ownedScreen.dispose();
+      app.destroy(true, { children: true });
+      canvas.remove();
+    },
+  };
+}

package/src/host/authoring/mounted-authoring.ts

@@ -0,0 +1,41 @@
+import type { AuthoringAdapter } from '@volter/editor-project/adapter';
+import type * as THREE from 'three';
+import type { EditorShellStore } from '@volter/editor-core/editor-shell-store';
+import { stampEntityId } from '@volter/editor-core/entity-object';
+
+/**
+ * Selection is editor-global UI state. A mounted adapter may deliberately own
+ * selection; when it does not, connect its semantic ids to the shared editor
+ * selection rather than requiring project code to know about EditorShellStore.
+ */
+export function withStoreSelection(
+  authoring: AuthoringAdapter,
+  store: EditorShellStore,
+): AuthoringAdapter {
+  if (authoring.selection) return authoring;
+  const selection = {
+    get: () => [...store.selectedEntityIds],
+    set: (ids: string[]) => store.selectMultiple(ids),
+  };
+  return new Proxy(authoring, {
+    get(target, property) {
+      if (property === 'selection') return selection;
+      const value = Reflect.get(target, property, target) as unknown;
+      return typeof value === 'function' ? value.bind(target) : value;
+    },
+  });
+}
+
+/**
+ * Make the adopted Three scene use the mounted adapter's own semantic ids.
+ * The store, viewport raycast, gizmo and adapter hierarchy must all address an
+ * object by the same id; a later generic live-scene walk preserves these tags.
+ */
+export function stampMountedAuthoringIds(scene: THREE.Scene, authoring: AuthoringAdapter): void {
+  const idForObject3D = authoring.hierarchy.idForObject3D;
+  if (!idForObject3D) return;
+  scene.traverse((object) => {
+    const id = idForObject3D(object);
+    if (id) stampEntityId(object, id);
+  });
+}

package/src/host/authoring/owned-pixi-ticker-listeners.ts

@@ -0,0 +1,96 @@
+import type { Container, TickerCallback } from 'pixi.js';
+import * as shellPixi from 'pixi.js';
+import type { CanvasPixiNamespace } from '../canvas-entry-runtime';
+import { currentGameRealmMountId, gameRealmForMountId } from '../gated-globals';
+
+/** The part of a GSAP instance this reads: its global timeline's live work. */
+interface GsapAnimation {
+  kill(): unknown;
+}
+interface GameGsap {
+  readonly globalTimeline: {
+    getChildren(nested: boolean, tweens: boolean, timelines: boolean): GsapAnimation[];
+  };
+}
+
+/**
+ * THE GAME'S OWN GSAP, when it has one. GSAP installs itself as `gsap` on the
+ * global its code runs against — the game realm's, or the page's — so the
+ * animations a game's widgets start are read from the instance the GAME
+ * loaded. The editor carries no GSAP of its own.
+ */
+function gameGsap(): GameGsap | null {
+  const mountId = currentGameRealmMountId();
+  const realmGlobal = mountId === null ? null : gameRealmForMountId(mountId).globalThis;
+  const candidate =
+    (realmGlobal as { gsap?: unknown } | null)?.gsap ?? (globalThis as { gsap?: unknown }).gsap;
+  const timeline = (candidate as Partial<GameGsap> | undefined)?.globalTimeline;
+  return typeof timeline?.getChildren === 'function' ? (candidate as GameGsap) : null;
+}
+
+function liveGsapAnimations(gsap: GameGsap | null): GsapAnimation[] {
+  return gsap ? gsap.globalTimeline.getChildren(true, true, true) : [];
+}
+
+function newGsapAnimations(
+  gsap: GameGsap | null,
+  before: ReadonlySet<GsapAnimation>,
+): GsapAnimation[] {
+  return liveGsapAnimations(gsap).filter((animation) => !before.has(animation));
+}
+
+/**
+ * Construct one short-lived Pixi object while withholding shared-ticker
+ * listeners installed synchronously by its constructor.
+ *
+ * `@pixi/ui` FancyButton installs an anonymous `Ticker.shared` callback for
+ * each animated button and exposes no matching disposer. That is harmless for
+ * the original page-lifetime game, but editor isolation deliberately mounts
+ * and destroys the same classes repeatedly. Registering the callback and only
+ * removing it at teardown is too late: while this preview is alive it advances
+ * the package-global tween group, including stale tweens from a preview React
+ * just destroyed. Edit is contractually static, so constructor-time ownership
+ * of a wall-clock shared ticker is withheld at the isolation boundary. Play
+ * never uses this helper and keeps the game's original clock unchanged.
+ *
+ * `pixi` is the namespace `create()` CONSTRUCTS IN, because `Ticker.shared` is
+ * a module-global: the shell's is a different clock from the project's, and
+ * withholding registrations on the wrong one withholds nothing at all — the
+ * `@pixi/ui` callbacks this exists to intercept install on whichever
+ * `Ticker.shared` the constructed class imported. Absent ⇒ this bundle's own
+ * copy (see `../../vite-plugin-module-doorways.ts`).
+ */
+export function createWithOwnedPixiTickerListeners<T extends Container>(
+  create: () => T,
+  pixi: CanvasPixiNamespace = shellPixi,
+): {
+  readonly value: T;
+  dispose(): void;
+} {
+  const ticker = pixi.Ticker.shared;
+  const originalAdd = ticker.add;
+  const gsap = gameGsap();
+  const animationsBefore = new Set(liveGsapAnimations(gsap));
+  ticker.add = ((_fn: TickerCallback<unknown>, _context?: unknown, _priority?: number) =>
+    ticker) as typeof ticker.add;
+
+  try {
+    const value = create();
+    // Game interaction is not an authoring gesture. Besides keeping Edit
+    // static, disabling the isolated subtree prevents @pixi/ui hover handlers
+    // from enqueueing tweedle animations that would survive React teardown in
+    // the package-global group and crash when Play later advances it.
+    value.eventMode = 'none';
+    const ownedAnimations = newGsapAnimations(gsap, animationsBefore);
+    // A delayed GSAP call is already live once construction returns. Waiting
+    // until disposal lets it mutate the supposedly held document for its whole
+    // visible lifetime, so remove construction-owned work immediately.
+    for (const animation of ownedAnimations) animation.kill();
+    return { value, dispose: () => {} };
+  } catch (error) {
+    for (const animation of newGsapAnimations(gsap, animationsBefore)) animation.kill();
+    throw error;
+  } finally {
+    ticker.add = originalAdd;
+  }
+}

package/src/host/authoring/phaser-live-authoring-adapter.ts

@@ -0,0 +1,265 @@
+/**
+ * A structural authoring projection over a live Phaser 3 game.
+ *
+ * Phaser belongs behind the generic `canvas` surface: this adapter never
+ * imports Phaser and never asks the host to become a Phaser runtime. It reads
+ * the public shape of the game instance the editor's realm holds, projects
+ * active scenes and their display lists into ordinary EditorNodes, and writes
+ * the native object's own transform/visibility fields directly. The game
+ * remains the entity model; no mirror tree or editor scene is fabricated.
+ */
+
+import type {
+  AuthoringAdapter,
+  AuthoringCapabilities,
+  AuthoringProvenance,
+  EditorNode,
+  PropertyDescriptor,
+  Transform,
+} from '@volter/editor-project/adapter';
+import type { EditorShellStore } from '@volter/editor-core/editor-shell-store';
+import { createEphemeralPersistence } from './ephemeral-persistence';
+
+export interface PhaserGameObjectLike {
+  name?: string;
+  type?: string;
+  active?: boolean;
+  visible?: boolean;
+  alpha?: number;
+  depth?: number;
+  x?: number;
+  y?: number;
+  rotation?: number;
+  scaleX?: number;
+  scaleY?: number;
+  list?: PhaserGameObjectLike[];
+  constructor?: { name?: string };
+}
+
+export interface PhaserSceneLike {
+  sys?: { settings?: { key?: string; active?: boolean } };
+  children?: { list?: PhaserGameObjectLike[] };
+}
+
+export interface PhaserGameLike {
+  scene?: { getScenes?: (activeOnly?: boolean) => PhaserSceneLike[] };
+  canvas?: HTMLCanvasElement;
+  destroy?: (removeCanvas?: boolean, noReturn?: boolean) => void;
+}
+
+type IndexedValue =
+  | { kind: 'scene'; scene: PhaserSceneLike; node: EditorNode }
+  | { kind: 'object'; object: PhaserGameObjectLike; node: EditorNode };
+
+function angleToQuat(angle: number): [number, number, number, number] {
+  return [0, 0, Math.sin(angle / 2), Math.cos(angle / 2)];
+}
+
+function quatToAngle(q: [number, number, number, number]): number {
+  return 2 * Math.atan2(q[2], q[3]);
+}
+
+function cleanSegment(value: string): string {
+  return encodeURIComponent(value || 'unnamed');
+}
+
+function objectChildren(object: PhaserGameObjectLike): PhaserGameObjectLike[] {
+  return Array.isArray(object.list) ? object.list : [];
+}
+
+export class PhaserLiveAuthoringAdapter implements AuthoringAdapter {
+  readonly capabilities: AuthoringCapabilities = {
+    transform: true,
+    inspectorFields: true,
+    persist: false,
+  };
+
+  readonly provenance: AuthoringProvenance = {
+    source: 'foreign',
+    label: 'live-only',
+    detail:
+      'Live Phaser scene/display lists projected directly — edits apply to native game objects for this session only.',
+  };
+
+  readonly persistence = {
+    ...createEphemeralPersistence(),
+    destination: 'live-only (not saved)',
+  };
+
+  private readonly indexed = new Map<string, IndexedValue>();
+  private readonly listeners = new Set<() => void>();
+
+  constructor(
+    private readonly game: PhaserGameLike,
+    private readonly store: EditorShellStore,
+  ) {}
+
+  refresh(): { scenes: number; objects: number } {
+    this.reindex();
+    let scenes = 0;
+    let objects = 0;
+    for (const value of this.indexed.values()) {
+      if (value.kind === 'scene') scenes++;
+      else objects++;
+    }
+    return { scenes, objects };
+  }
+
+  private scenes(): PhaserSceneLike[] {
+    const getScenes = this.game.scene?.getScenes;
+    if (typeof getScenes !== 'function') return [];
+    const active = getScenes.call(this.game.scene, true);
+    return Array.isArray(active) ? active : [];
+  }
+
+  private reindex(): void {
+    this.indexed.clear();
+    for (const [sceneIndex, scene] of this.scenes().entries()) {
+      const sceneName = scene.sys?.settings?.key || `Scene ${sceneIndex + 1}`;
+      const sceneId = `phaser:scene:${sceneIndex}:${cleanSegment(sceneName)}`;
+      const roots = Array.isArray(scene.children?.list) ? scene.children.list : [];
+      const sceneNode: EditorNode = {
+        id: sceneId,
+        label: sceneName,
+        role: 'root',
+        kind: 'phaser-scene',
+        typeLabel: 'Phaser.Scene',
+        parentId: null,
+        childIds: [],
+      };
+      this.indexed.set(sceneId, { kind: 'scene', scene, node: sceneNode });
+      sceneNode.childIds = roots.map((object, index) =>
+        this.indexObject(object, sceneId, `${sceneIndex}/${index}`),
+      );
+    }
+  }
+
+  private indexObject(object: PhaserGameObjectLike, parentId: string, path: string): string {
+    const nativeType = object.type || object.constructor?.name || 'GameObject';
+    const label = object.name || nativeType;
+    // Structural path only: renaming a native object must not change the id
+    // the editor selection and undo surfaces use for it.
+    const id = `phaser:object:${path}`;
+    const node: EditorNode = {
+      id,
+      label,
+      role: 'entity',
+      kind: `phaser-${nativeType.toLowerCase()}`,
+      // Bundled Phaser classes are routinely minified (`c`, `a`, ...). Its
+      // public GameObject `type` is the stable player-facing type name.
+      typeLabel: nativeType,
+      parentId,
+      childIds: [],
+    };
+    this.indexed.set(id, { kind: 'object', object, node });
+    node.childIds = objectChildren(object).map((child, index) =>
+      this.indexObject(child, id, `${path}/${index}`),
+    );
+    return id;
+  }
+
+  readonly hierarchy = {
+    roots: (): EditorNode[] => {
+      this.reindex();
+      return [...this.indexed.values()]
+        .filter((value) => value.kind === 'scene')
+        .map((value) => value.node);
+    },
+    node: (id: string): EditorNode | null => {
+      this.reindex();
+      return this.indexed.get(id)?.node ?? null;
+    },
+  };
+
+  readonly selection = {
+    get: (): string[] => [...this.store.selectedEntityIds],
+    set: (ids: string[]): void => {
+      this.store.selectMultiple(ids);
+      this.notify();
+    },
+  };
+
+  readonly transforms = {
+    dimensions: (id: string): '2d' | null => {
+      this.reindex();
+      return this.indexed.get(id)?.kind === 'object' ? '2d' : null;
+    },
+    get: (id: string): Transform => {
+      this.reindex();
+      const value = this.indexed.get(id);
+      if (!value || value.kind !== 'object') {
+        return { position: [0, 0, 0], rotation: [0, 0, 0, 1], scale: [1, 1, 1] };
+      }
+      const object = value.object;
+      return {
+        position: [object.x ?? 0, object.y ?? 0, object.depth ?? 0],
+        rotation: angleToQuat(object.rotation ?? 0),
+        scale: [object.scaleX ?? 1, object.scaleY ?? 1, 1],
+      };
+    },
+    beginEdit: (_id: string): void => {},
+    apply: (id: string, transform: Transform): void => {
+      this.reindex();
+      const value = this.indexed.get(id);
+      if (!value || value.kind !== 'object') return;
+      value.object.x = transform.position[0];
+      value.object.y = transform.position[1];
+      value.object.depth = transform.position[2];
+      value.object.rotation = quatToAngle(transform.rotation);
+      value.object.scaleX = transform.scale[0];
+      value.object.scaleY = transform.scale[1];
+      this.notify();
+    },
+    endEdit: (_id: string): void => {},
+  };
+
+  readonly inspector = {
+    properties: (id: string): PropertyDescriptor[] => {
+      this.reindex();
+      const value = this.indexed.get(id);
+      if (!value) return [];
+      if (value.kind === 'scene') {
+        return [{ path: 'key', label: 'Scene key', type: 'string', readonly: true }];
+      }
+      return [
+        { path: 'type', label: 'Type', type: 'string', readonly: true },
+        { path: 'name', label: 'Name', type: 'string' },
+        { path: 'active', label: 'Active', type: 'boolean' },
+        { path: 'visible', label: 'Visible', type: 'boolean' },
+        { path: 'alpha', label: 'Alpha', type: 'number' },
+        { path: 'depth', label: 'Depth', type: 'number' },
+      ];
+    },
+    get: (id: string, path: string): unknown => {
+      this.reindex();
+      const value = this.indexed.get(id);
+      if (!value) return undefined;
+      if (value.kind === 'scene')
+        return path === 'key' ? value.scene.sys?.settings?.key : undefined;
+      if (path === 'type') return value.object.type || value.object.constructor?.name;
+      return value.object[path as keyof PhaserGameObjectLike];
+    },
+    set: (id: string, path: string, value: unknown): void => {
+      this.reindex();
+      const indexed = this.indexed.get(id);
+      if (!indexed || indexed.kind !== 'object' || path === 'type') return;
+      (indexed.object as unknown as Record<string, unknown>)[path] = value;
+      this.notify();
+    },
+  };
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  dispose(): void {
+    this.listeners.clear();
+    this.indexed.clear();
+  }
+
+  private notify(): void {
+    for (const listener of this.listeners) listener();
+    this.store.notifyIngestEdit();
+  }
+}