@volter/editor-core 0.5.57

package/src/entity-lod.ts

@@ -0,0 +1,31 @@
+import type * as THREE from 'three';
+import { isEntityObject } from './entity-object';
+
+/**
+ * The selected object when it is itself a live THREE.LOD (the native R3F
+ * shape), otherwise the entity's live THREE.LOD preview object, or null while
+ * an async asset is still loading. A subtree search skips child authoring
+ * nodes so a nested LOD entity can never shadow this one's.
+ *
+ * Format-neutral: reads the caller's native-node membership answer and
+ * Three's own `isLOD` marker, never a scene descriptor. The default retains
+ * stamp-based compatibility for first-party callers. `editor-viewport.ts`'s
+ * per-frame forced-LOD-level enforcement is the only caller.
+ */
+export function findEntityLod(
+  obj: THREE.Object3D,
+  isNestedAuthoringNode: (object: THREE.Object3D) => boolean = isEntityObject,
+): THREE.LOD | null {
+  // Adapter-backed worlds can expose the native LOD itself as the selected
+  // authored row (for example Drei Detailed), rather than wrapping it in the
+  // old entity preview object this helper was originally extracted for.
+  if ((obj as THREE.LOD).isLOD) return obj as THREE.LOD;
+  const stack = [...obj.children];
+  while (stack.length > 0) {
+    const node = stack.pop()!;
+    if (isNestedAuthoringNode(node)) continue; // nested entity subtree
+    if ((node as THREE.LOD).isLOD) return node as THREE.LOD;
+    stack.push(...node.children);
+  }
+  return null;
+}

package/src/entity-object.ts

@@ -0,0 +1,91 @@
+/**
+ * One answer to "which live `Object3D` is this entity id?", for every editor
+ * surface that needs one.
+ *
+ * There are TWO places an id can resolve, and neither is a superset of the
+ * other. The ACTIVE ADAPTER's `hierarchy.object3D` is authoritative: a
+ * source-backed component may select one identity and render its transform on a
+ * child, and an ADOPTED live scene (play mode) is walked by the adapter, so its
+ * ids exist there and nowhere else. `EditorShellStore.objectMap` is the shell's
+ * own map, which the adapter's answer falls back to.
+ *
+ * Asking only the store is how `editor.frame(id)` came to refuse an entity the
+ * same session had just selected and drawn a cage around. Measured live
+ * (2026-08-14, the translated platformer in play mode): `editor.status()`
+ * listed `r3f:world:o4a7fjmzo`, `editor.select` on it put a bracket cage on the
+ * coin — and `editor.frame` on that same id answered
+ * `Entity not found: r3f:world:o4a7fjmzo`, because the adopted play scene's
+ * nodes live in the adapter's walk and not in `objectMap`. A verb's EXISTENCE
+ * CHECK has to be the resolver its ACTION uses, or the refusal is about a
+ * different question than the one asked.
+ *
+ * ## The REVERSE direction lives here too, and that is the point
+ *
+ * `userData.entityId` is the stamp an adapter's walk writes when it ADMITS an
+ * object as an authoring node (`projection/three.ts`,
+ * `R3fSourceAuthoringAdapter.indexGraph`). Reading that stamp is the node → id
+ * half of the very same question `entityObject3D` answers id → node, so both
+ * halves are spelled once, here — and the surfaces that used to reach for
+ * `getUserData(object, 'entityId')` themselves (the viewport gizmo and its
+ * surface-snap, the raycast climb, the store's adoption index, the LOD walk)
+ * ask this module instead.
+ *
+ * Presence of the stamp is also the ADMISSION answer: an object the walk
+ * skipped (an editor helper, a library-built internal folded into its owner)
+ * carries none, which is exactly what {@link isEntityObject} and
+ * {@link nearestEntityObject} read. Do not re-derive that from a type test, a
+ * name convention or a layer — those disagree with the walk, and a surface that
+ * disagrees with the walk is the "one id, three answers" defect.
+ */
+
+import type { AuthoringAdapter } from '@volter/editor-project/adapter';
+import { getUserData, setUserData } from '@volter/editor-threejs/ecs/user-data';
+import type * as THREE from 'three';
+
+/** The live object `id` names, or `null` when nothing in this session answers to it. */
+export function entityObject3D(
+  adapter: AuthoringAdapter,
+  objectMap: ReadonlyMap<string, THREE.Object3D>,
+  id: string,
+): THREE.Object3D | null {
+  return adapter.hierarchy.object3D?.(id) ?? objectMap.get(id) ?? null;
+}
+
+/**
+ * The id `object` answers to, or `undefined` when no adapter walk has admitted
+ * it as an authoring node.
+ */
+export function entityIdOf(object: THREE.Object3D | null | undefined): string | undefined {
+  const id = getUserData(object, 'entityId');
+  return typeof id === 'string' && id ? id : undefined;
+}
+
+/** Whether `object` is an admitted authoring node — see {@link entityIdOf}. */
+export function isEntityObject(object: THREE.Object3D | null | undefined): boolean {
+  return entityIdOf(object) !== undefined;
+}
+
+/**
+ * The nearest ancestor-or-self of `object` that is an admitted authoring node,
+ * or `null` when the climb reaches the top without finding one.
+ *
+ * This is what a raycast hit has to do: the ray lands on whatever geometry is
+ * in front, which is routinely a library-built part folded INTO a node rather
+ * than the node itself.
+ */
+export function nearestEntityObject(
+  object: THREE.Object3D | null | undefined,
+): THREE.Object3D | null {
+  let cursor: THREE.Object3D | null = object ?? null;
+  while (cursor && !isEntityObject(cursor)) cursor = cursor.parent;
+  return cursor;
+}
+
+/**
+ * Record that `object` is the authoring node `id` — called by the adapter walk
+ * that MINTED the id, and by nothing else. Every reader above is the other side
+ * of this one write.
+ */
+export function stampEntityId(object: THREE.Object3D, id: string): void {
+  setUserData(object, 'entityId', id);
+}

package/src/files/file-provider.ts

@@ -0,0 +1,62 @@
+/**
+ * THE PROJECT'S FILES, WRITTEN THROUGH THE WORKBENCH — the provider it
+ * installs here, and the window before it lands.
+ *
+ * `EditorHost.files` is the door (`packages/editor/src/files/`) —
+ * read/readBytes/write/exists/list/watch over PROJECT-RELATIVE paths, the same
+ * spelling the history door hands over, so both resolve against one workspace
+ * folder.
+ *
+ * WHAT THE PROVIDER BUYS, measured (U5): a vgai write the workbench did not
+ * make is an EXTERNAL change to it — Monaco reloads the file,
+ * `modelService.updateModel` pushes a fresh text element through `EditStack`,
+ * and `IUndoRedoService.pushElement` clears that resource's FUTURE, so a gizmo
+ * drag's redo was lost whenever a text model for that file was open. A write
+ * made THROUGH the workbench is the workbench's own, so no reload fires and
+ * the future survives. That is what this buys, and nothing else.
+ *
+ * IT ARRIVES AFTER THE MOUNT, always: a `ServicesAccessor` is valid only for
+ * the synchronous part of a command, so the contribution cannot build the
+ * provider before the mount it is handed to. Until it does, the door falls
+ * back to the session's transports — a write in that window is a real write
+ * with nowhere else to go.
+ */
+import type { EditorHostFileEvent, EditorHostFileProvider } from '@volter/editor-sdk/host';
+
+export type ProjectFileEvent = EditorHostFileEvent;
+export type ProjectFileProvider = EditorHostFileProvider;
+
+let provider: ProjectFileProvider | null = null;
+const listeners = new Set<() => void>();
+
+/**
+ * Is the provider installed? False until it lands — later than the mount,
+ * because a `ServicesAccessor` is valid only for a command's synchronous part,
+ * so the contribution hands the provider over after the editor is running. In
+ * that window a caller reaches the session's transports instead, which is a
+ * real write with nowhere else to go rather than a refusal.
+ */
+export function filesProviderInstalled(): boolean {
+  return provider !== null;
+}
+
+/** The installed provider, or `null` before it lands. */
+export function filesProvider(): ProjectFileProvider | null {
+  return provider;
+}
+
+/**
+ * Install how the project's files are read and written, or `null` to withdraw
+ * it — the provider is the workbench's, and a workbench that went away takes
+ * it with it.
+ */
+export function setFilesProvider(next: ProjectFileProvider | null): void {
+  if (provider === next) return;
+  provider = next;
+  for (const listener of listeners) listener();
+}
+
+export function subscribeFilesProvider(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}

package/src/files/project-files.ts

@@ -0,0 +1,264 @@
+/**
+ * THE ONE FILE API over the open project, in PROJECT-RELATIVE paths — the
+ * editor's half of `@volter/editor-sdk/host`'s `files` door (U5).
+ *
+ * Under the FRAME this is VS Code's `IFileService`/`ITextFileService` over the
+ * workspace folder, installed as a provider by the Code-OSS bridge. Under the
+ * HOST — standalone `vgai edit`, and the hosted browser build — it is today's
+ * transports, and this module is the ONE place that says which transport owns
+ * which path. That statement used to be spread across five files' doc
+ * comments; it is written down once, here, because the fragmentation is the
+ * fact U5 measured:
+ *
+ *   | path class            | the session's route          |
+ *   |-----------------------|------------------------------|
+ *   | read, anything        | Vite `/@fs/<root>/<path>`    |
+ *   | write `public/**`     | `POST /__editor/save-file`   |
+ *   | write `.vgai/**`      | `POST /__editor/vgai-file`   |
+ *   | write `src/**` source | `POST /__ui-source/apply`    | the storage source-write backend |
+ *   | list `public/**`      | `GET /__editor/assets`       | StorageBackend |
+ *   | watch                 | `EventSource /__editor/events` | StorageBackend.watch |
+ *
+ * A path class with no host transport is REFUSED BY NAME, naming the route
+ * that does own it. It is not this door's business to invent a general
+ * project-root write route on the session: each of those routes is
+ * deliberately narrow (`/__editor/vgai-file` accepts only `.vgai/**`,
+ * `/__editor/data-file` only `src/data/**\/*.data.json`), and their own header
+ * comments record that as defence in depth. Under the frame the question does
+ * not arise — the workbench's file service owns the whole folder.
+ *
+ * `StorageBackend`'s paths are NOT this door's paths, and that difference is
+ * the measurement the door exists for: `HttpStorage` is rooted at
+ * `<project>/public/` while a project-rooted backend is rooted at the
+ * project root. Callers that still speak `StorageBackend` keep doing so; what
+ * they get under the frame is `storage/host-files-storage.ts`, a `public/`
+ * view onto this door.
+ */
+
+import { bytesToBase64 } from '../bytes-codec';
+import { getProjectDefinePath } from '../editor-mode';
+import { assertEditorServerAnswered, editorServerJson } from '../editor-server-response';
+import { sourceMutationAttribution } from '../editor-session-attribution';
+import { filesProvider, filesProviderInstalled, type ProjectFileEvent } from './file-provider';
+
+const BASE = '/__editor';
+
+export interface ProjectFileEntry {
+  readonly name: string;
+  readonly path: string;
+  readonly type: 'file' | 'dir';
+}
+
+/** Project-relative, `/`-separated, no leading slash, no `..`. */
+function normalize(path: string): string {
+  return path.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '');
+}
+
+function assertContained(path: string): string {
+  const normalized = normalize(path);
+  if (!normalized || normalized.split('/').includes('..')) {
+    throw new Error(`projectFiles: "${path}" is not a project-relative path.`);
+  }
+  return normalized;
+}
+
+/**
+ * The same containment check for a DIRECTORY, where the empty string is the
+ * project root and therefore legal.
+ *
+ * It exists because `list` ran bare {@link normalize} while every other member
+ * ran {@link assertContained} — so a `..` segment reached the frame's provider
+ * or a session route while the same segment in a `read` was refused here.
+ * `normalize` strips a LEADING slash; it has never removed a `..` segment, and
+ * a caller reading its name could be forgiven for thinking otherwise. The
+ * empty string is the one thing `assertContained` rejects that a directory
+ * legitimately needs (it is how the project root itself is listed), which is
+ * why this is a second function rather than a flag.
+ */
+function assertContainedDir(dir: string): string {
+  const normalized = normalize(dir);
+  if (normalized.split('/').includes('..')) {
+    throw new Error(`projectFiles: "${dir}" is not a project-relative directory.`);
+  }
+  return normalized;
+}
+
+/**
+ * The refusal a host-tier write to a path class no session route owns gets.
+ * It NAMES the owning route rather than failing generically, because the one
+ * thing a caller can do about it is use that route.
+ */
+function noHostWriteRoute(path: string): Error {
+  return new Error(
+    `projectFiles.write("${path}"): the standalone editor has no general project-root write route, ` +
+      'and this door does not invent one. Source files are written through `/__ui-source/apply` ' +
+      '(`ui-source/source-write-backend.ts`), `public/**` through `/__editor/save-file`, `.vgai/**` ' +
+      'through `/__editor/vgai-file`. Under the Code-OSS frame the workbench file service owns the ' +
+      'whole folder and this refusal cannot occur.',
+  );
+}
+
+// ---------------------------------------------------------------------------
+// The HOST fill — today's transports
+// ---------------------------------------------------------------------------
+
+async function hostRead(path: string): Promise<string> {
+  const res = await fetch(`/@fs/${getProjectDefinePath()}/${path}`);
+  if (!res.ok) throw new Error(`projectFiles.read "${path}": HTTP ${res.status}`);
+  return res.text();
+}
+
+async function hostReadBytes(path: string): Promise<Uint8Array> {
+  const res = await fetch(`/@fs/${getProjectDefinePath()}/${path}`);
+  if (!res.ok) throw new Error(`projectFiles.readBytes "${path}": HTTP ${res.status}`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+
+async function hostWrite(path: string, data: string | Uint8Array): Promise<void> {
+  if (path.startsWith('public/')) {
+    const body =
+      typeof data === 'string'
+        ? { path: path.slice('public/'.length), content: data, ...sourceMutationAttribution() }
+        : {
+            path: path.slice('public/'.length),
+            content: bytesToBase64(data),
+            encoding: 'base64' as const,
+            ...sourceMutationAttribution(),
+          };
+    const res = await fetch(`${BASE}/save-file`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    assertEditorServerAnswered(res, `Write ${path} failed`);
+    if (!res.ok) throw new Error(`projectFiles.write "${path}": HTTP ${res.status}`);
+    return;
+  }
+  if (path.startsWith('.vgai/')) {
+    const body =
+      typeof data === 'string'
+        ? { path, content: data, ...sourceMutationAttribution() }
+        : {
+            path,
+            content: bytesToBase64(data),
+            encoding: 'base64' as const,
+            ...sourceMutationAttribution(),
+          };
+    const res = await fetch(`${BASE}/vgai-file`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    assertEditorServerAnswered(res, `Write ${path} failed`);
+    if (!res.ok) throw new Error(`projectFiles.write "${path}": HTTP ${res.status}`);
+    return;
+  }
+  throw noHostWriteRoute(path);
+}
+
+async function hostExists(path: string): Promise<boolean> {
+  try {
+    const res = await fetch(`/@fs/${getProjectDefinePath()}/${path}`, { method: 'HEAD' });
+    // The dev server's SPA fallback answers 200 with `index.html` for a missing
+    // path, so `res.ok` alone cannot tell existence from absence — the same
+    // measured false positive `api/project-source.ts`'s `probeProjectFile`
+    // records. A real file never answers as an HTML DOCUMENT.
+    if (!res.ok) return false;
+    return !(res.headers.get('content-type') ?? '').toLowerCase().includes('text/html');
+  } catch {
+    return false;
+  }
+}
+
+interface ServerAssetEntry {
+  name: string;
+  type: 'file' | 'directory';
+}
+
+async function hostList(dir: string): Promise<readonly ProjectFileEntry[]> {
+  if (!dir.startsWith('public')) {
+    throw new Error(
+      `projectFiles.list("${dir}"): the standalone editor lists only \`public/**\` ` +
+        '(`/__editor/assets`); source trees are listed by glob through ' +
+        "`/__editor/source-files` (`api/project-source.ts`'s `listProjectSourceFiles`).",
+    );
+  }
+  const inner = dir === 'public' ? '' : dir.slice('public/'.length);
+  const res = await fetch(`${BASE}/assets?${new URLSearchParams({ dir: inner })}`);
+  const { entries } = await editorServerJson<{ entries: ServerAssetEntry[] }>(
+    res,
+    `projectFiles.list "${dir}" failed`,
+  );
+  return entries.map((entry) => ({
+    name: entry.name,
+    path: inner ? `public/${inner}/${entry.name}` : `public/${entry.name}`,
+    type: entry.type === 'directory' ? ('dir' as const) : ('file' as const),
+  }));
+}
+
+function hostWatch(listener: (event: ProjectFileEvent) => void): () => void {
+  const source = new EventSource(`${BASE}/events`);
+  const handler = (ev: MessageEvent) => {
+    try {
+      const data = JSON.parse(ev.data) as { type?: string; file?: string; path?: string };
+      const path = data.path ?? data.file;
+      if (!path) return;
+      listener({
+        type: (data.type as ProjectFileEvent['type']) ?? 'update',
+        path: normalize(path),
+      });
+    } catch {
+      // Non-JSON keepalive frame.
+    }
+  };
+  source.addEventListener('message', handler);
+  return () => {
+    source.removeEventListener('message', handler);
+    source.close();
+  };
+}
+
+// ---------------------------------------------------------------------------
+// The door
+// ---------------------------------------------------------------------------
+
+export const projectFiles = {
+  /** True while the workbench's own file service is answering. A caller with
+   *  a transport of its own (the source-write lane) reads this to decide
+   *  whether its write would be EXTERNAL to the workbench. */
+  frameOwned: filesProviderInstalled,
+
+  async read(path: string): Promise<string> {
+    const key = assertContained(path);
+    return filesProvider()?.read(key) ?? hostRead(key);
+  },
+
+  async readBytes(path: string): Promise<Uint8Array> {
+    const key = assertContained(path);
+    const provider = filesProvider();
+    return provider?.readBytes ? provider.readBytes(key) : hostReadBytes(key);
+  },
+
+  async write(path: string, data: string | Uint8Array): Promise<void> {
+    const key = assertContained(path);
+    const provider = filesProvider();
+    if (provider) return provider.write(key, data);
+    return hostWrite(key, data);
+  },
+
+  async exists(path: string): Promise<boolean> {
+    const key = assertContained(path);
+    return filesProvider()?.exists(key) ?? hostExists(key);
+  },
+
+  async list(dir: string): Promise<readonly ProjectFileEntry[]> {
+    const key = assertContainedDir(dir);
+    const provider = filesProvider();
+    return provider?.list ? provider.list(key) : hostList(key);
+  },
+
+  watch(listener: (event: ProjectFileEvent) => void): () => void {
+    const provider = filesProvider();
+    return provider?.watch ? provider.watch(listener) : hostWatch(listener);
+  },
+};

package/src/finders/index.ts

@@ -0,0 +1,136 @@
+/**
+ * THE FINDER NAMESPACE — host-owned discovery algorithms an adapter SELECTS.
+ *
+ * ARCHITECTURE-CORE §The editor protocol, "Zero inference": what zero
+ * inference forbids is the ENGINE running a finder nobody selected. A
+ * convention (`src/scenes/`, a story registration) is legitimate exactly when
+ * it is an adapter's declared finder parameter, and illegitimate as implicit
+ * engine behavior.
+ *
+ * That is enforced MECHANICALLY, not by policy: everything under this
+ * directory has exactly ONE sanctioned importer — the editor's adapter loader
+ * (`packages/editor/src/project-adapter.ts`) — and
+ * `packages/engine/test/finder-import-boundary.test.ts` fails by name when any
+ * other engine/editor file imports it. Do not add a second importer; make the
+ * loader answer instead.
+ *
+ * Dependency direction is one-way: finders import their parameter types from
+ * `../adapter-module`, and `adapter-module.ts` imports nothing from here. That
+ * is what keeps a game's `vgai.adapter.ts` free of finder implementations.
+ */
+
+import {
+  EXPORTED_COMPOSITION_REGIONS,
+  type FinderSelection,
+  type ScenesFromEntrypointSelectionParams,
+} from '@volter/editor-project/adapter/adapter-module';
+import type { FinderResult } from '@volter/editor-project/adapter/finders/finder-result';
+import { registerFinder, runRegisteredFinder } from '@volter/editor-project/adapter/finders/registry';
+import { type ZodType, z } from 'zod';
+import {
+  type ScenesFromEntrypointSelectionInput,
+  scenesFromEntrypointSelection,
+} from './scenes-from-entrypoint-selection';
+
+export type { FinderResult } from '@volter/editor-project/adapter/finders/finder-result';
+export type {
+  FinderContribution,
+  FinderRegistration,
+} from '@volter/editor-project/adapter/finders/registry';
+export {
+  registerContributedFinder,
+  registeredFinderNames,
+  registerFinder,
+  runRegisteredFinder,
+} from '@volter/editor-project/adapter/finders/registry';
+export type {
+  EntrypointSource,
+  ScenesFromEntrypointSelectionInput,
+} from './scenes-from-entrypoint-selection';
+export { scenesFromEntrypointSelection } from './scenes-from-entrypoint-selection';
+
+/** Everything any shipped finder can be handed, gathered once by the loader. */
+/** A project source the host read for a selection's `include` globs. */
+export interface ProjectSourceFile {
+  /** Project-relative path. */
+  readonly path: string;
+  readonly source: string;
+}
+
+/** One entry of the host's project component index. */
+export interface ProjectComponentRef {
+  readonly name: string;
+  /** Project-relative source path of the component's own module. */
+  readonly path: string;
+  /** Region this component's surface belongs to, when the host knows it. */
+  readonly region?: string | null;
+}
+
+export type FinderInput = ScenesFromEntrypointSelectionInput & {
+  /**
+   * The project's component index — what a finder joins its own discovery
+   * against (a prefab's source path and region).
+   *
+   * There is deliberately no `stories` here. `prefabsFromStories` used to be
+   * an engine finder whose story registrations the EDITOR filled, which is how
+   * the editor's adapter loader came to import the story registry and, through
+   * it, Storybook. It is a registered finder that reads its own ledger now
+   * (`packages/editor/src/stories/prefabs-finder.ts`): a finder's data arrives
+   * with the finder.
+   */
+  readonly components?: readonly ProjectComponentRef[];
+  /** The sources matching every selection's `include` globs — empty when
+   *  no selection declares any. A contributed finder reads the project
+   *  through this and {@link FinderInput.files} and nothing else. */
+  readonly sources?: readonly ProjectSourceFile[];
+  /**
+   * The PATHS matching those same globs — every one of them, including the
+   * files `sources` has no text for.
+   *
+   * A finder over BINARY documents needs this and could not use `sources`:
+   * `@volter/editor-blender`'s `modelsFromBlendFiles` lists `.blend` files, and there
+   * is nothing in a `.blend` a text walk could honestly read — the entry IS
+   * the file. Handing it a decoded binary instead would have been the shim.
+   */
+  readonly files?: readonly string[];
+};
+
+/**
+ * Run one adapter-declared selection. The switch is exhaustive over
+ * {@link FinderSelection}: a new finder that forgets a case fails to COMPILE
+ * here rather than silently contributing nothing.
+ */
+export function runFinderSelection(selection: FinderSelection, input: FinderInput): FinderResult {
+  return runRegisteredFinder(selection, input);
+}
+
+// The engine's own finders register here, schemas beside them: what an
+// adapter may select by name is exactly what this registry holds.
+const ScenesFromEntrypointSelectionSchema = z
+  .object({
+    finder: z.literal('scenesFromEntrypointSelection'),
+    regions: z
+      .union([z.array(z.string().min(1)).min(1), z.literal(EXPORTED_COMPOSITION_REGIONS)])
+      .describe('Region ids whose entrypoints carry the selection, or the rule form'),
+    selection: z
+      .string()
+      .min(1)
+      .optional()
+      .describe(
+        "Identifier of the entrypoint's module-level scene selection table; omit for a " +
+          'single-composition entrypoint',
+      ),
+  })
+  .strict()
+  .refine((value) => value.selection === undefined || Array.isArray(value.regions), {
+    message:
+      'scenesFromEntrypointSelection: `selection` names an identifier in ONE entrypoint’s ' +
+      `source, so it cannot be paired with the \`${EXPORTED_COMPOSITION_REGIONS}\` rule — ` +
+      'name the region explicitly (`regions: ["<rootId>"]`).',
+  });
+registerFinder<ScenesFromEntrypointSelectionParams, FinderInput>({
+  name: 'scenesFromEntrypointSelection',
+  schema:
+    ScenesFromEntrypointSelectionSchema as unknown as ZodType<ScenesFromEntrypointSelectionParams>,
+  run: scenesFromEntrypointSelection,
+});