@vgai/editor-sdk 0.5.16 → 0.5.18

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vgai/editor-sdk",
   "author": "Volter AI, Inc.",
   "license": "Apache-2.0",
-  "version": "0.5.16",
+  "version": "0.5.18",
   "type": "module",
   "repository": {
     "type": "git",
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "@types/three": "^0.180.0",
-    "@vgai/sdk": "0.5.16"
+    "@vgai/sdk": "0.5.18"
   },
   "peerDependencies": {
     "@vgai/engine": "*",

package/src/client.ts

@@ -404,21 +404,11 @@ export class EditorClient {
    * `vgai eval` could recover these frames while `vgai screenshot` could not.
    * Off by default: a caller who does not ask must never be handed a frame
    * that only exists because the capture drove the game.
-   *
-   * `opts.devLayers` puts the game's DEV LAYERS (`dev: true` roots — its own
-   * in-game dev GUI) INTO the frame. Also off by default, for the mirror-image
-   * reason: a panel frame at the moment of a failure is strong evidence, and a
-   * "does the game look right" frame with the panel painted over it is
-   * worthless — so the contamination only happens when someone asks for it.
    */
-  async captureGame(opts?: {
-    refreshStarvedFrame?: boolean;
-    devLayers?: boolean;
-  }): Promise<GameCapture> {
+  async captureGame(opts?: { refreshStarvedFrame?: boolean }): Promise<GameCapture> {
     const data = await this.command<GameCapture>({
       type: 'bridge-screenshot',
       ...(opts?.refreshStarvedFrame === true ? { refreshStarvedFrame: true } : {}),
-      ...(opts?.devLayers === true ? { devLayers: true } : {}),
     });
     const layers = data.layers;
     const flatness = data.flatness;
@@ -446,7 +436,6 @@ export class EditorClient {
     return this.command<GameplayRecordingStarted>({
       type: 'bridge-recording-start',
       ...(options.fps !== undefined ? { fps: options.fps } : {}),
-      ...(options.devLayers === true ? { devLayers: true } : {}),
     });
   }
 

package/src/contributions.ts

@@ -321,6 +321,28 @@ export interface ToolContributionSurfaces {
   readonly Object3DAuthoring: import('react').ComponentType<ToolObject3DAuthoringProps>;
 }
 
+/**
+ * The live game a contribution is looking at, or `null` when nothing is
+ * playing.
+ *
+ * A dev-GUI contribution's whole subject is the RUNNING game — its stats,
+ * cheats, tuning handles and event stream all hang off the live `Game`, and
+ * there is no other door to it from a contribution (the editor's own state is
+ * not the game's). It is `unknown` deliberately: `@vgai/engine`'s `Game` is
+ * the project's dependency, not this package's, so a contribution narrows it
+ * with its own import rather than making every consumer of this SDK carry the
+ * engine's types.
+ *
+ * `instanceId` is the mount id the editor's runtime instruments are pointed
+ * at (the Inspect selector). With several seats live that is the ONLY thing
+ * distinguishing two mounts of the same project, so a contribution that
+ * caches per-game state keys it on this and re-reads when it changes.
+ */
+export interface ToolContributionPlay {
+  readonly game: unknown;
+  readonly instanceId: string;
+}
+
 export interface ToolContributionProps {
   /** The exact registered callable this contribution presents. */
   readonly tool: ProjectToolCatalogEntry;
@@ -332,13 +354,42 @@ export interface ToolContributionProps {
   readonly surfaces: ToolContributionSurfaces;
   /** Sanitized product-account projection. Never contains an access token. */
   readonly account: GenerationAccountProjection;
+  /** The inspected play instance, or `null` while nothing is playing. */
+  readonly play: ToolContributionPlay | null;
   /** Present when mounted as a workspace document contribution. */
   readonly documentId?: string;
   /** Whether that workspace document is the active center subject. */
   readonly active?: boolean;
 }
 
-export interface ToolInspectorContributionProps extends ToolContributionProps {
+/**
+ * A `workspace.utility`'s props — the shared shape, except that `tool` may be
+ * absent.
+ *
+ * It is its own type rather than a relaxation of {@link ToolContributionProps}
+ * because only the two PRESENTING points earn the relaxation (this one and
+ * {@link ToolInspectorContributionProps}): a record-reading drawer panel (a
+ * log, a run timeline) presents what HAPPENED rather than one callable's
+ * output, so there is no honest name to put there and the loader stopped
+ * demanding a false one. Widening the shared props instead would hand every
+ * RUNNING contribution a `tool` it must now null-check while its own point
+ * still guarantees one.
+ */
+export interface ToolUtilityContributionProps extends Omit<ToolContributionProps, 'tool'> {
+  /** The callable this utility declared, when it declared one at all. */
+  readonly tool?: ProjectToolCatalogEntry;
+}
+
+/**
+ * A `selection.inspector`'s props. `tool` is OPTIONAL here for the same reason
+ * it is on a utility: a section may present state the editor already has —
+ * readings, verbs a game registered as debug commands — and drive no single
+ * registered callable at all. A section that DOES commit through one still
+ * declares it and still gets the resolved entry.
+ */
+export interface ToolInspectorContributionProps extends Omit<ToolContributionProps, 'tool'> {
+  /** The callable this section declared, when it declared one at all. */
+  readonly tool?: ProjectToolCatalogEntry;
   readonly node: ToolContributionNode | null;
   readonly nodeId: string | null;
 }
@@ -380,9 +431,31 @@ export type ToolGenerationResultContributionMatch = (
   result: unknown,
 ) => boolean;
 
+/**
+ * What the inspector is showing AROUND the node a `selection.inspector`
+ * contribution is being matched against.
+ *
+ * It exists for one question a `node`/`adapter` pair cannot answer: with
+ * NOTHING selected, `node` is `null` on every surface alike — an open Asset
+ * Lab document's empty state and the play surface's Game subject are the same
+ * two arguments. A contribution that matches `node === null` therefore matched
+ * BOTH, and the empty-state subject of whatever document happened to be open
+ * grew sections belonging to another surface entirely.
+ *
+ * `nullSubjectId` is the id of the empty-state subject actually being composed
+ * (`inspection/null-subject.ts`), so a contribution scopes itself POSITIVELY —
+ * `ctx.nullSubjectId === 'game'` — rather than by guessing from the adapter.
+ * It is `null` whenever a node IS selected, which is the honest answer: there
+ * is no empty-state subject in that composition.
+ */
+export interface ToolInspectorContributionMatchContext {
+  readonly nullSubjectId: string | null;
+}
+
 /** Optional named export required by `selection.inspector` contributions. */
 export type ToolInspectorContributionMatch = (
   node: ToolContributionNode | null,
   /** Adapter-native API. Import its concrete type when a contribution needs it. */
   adapter: unknown,
+  context: ToolInspectorContributionMatchContext,
 ) => boolean;

package/src/types.ts

@@ -104,9 +104,6 @@ export interface GameCapture {
 export interface GameplayRecordingOptions {
   /** Requested real-time capture cadence. Defaults to 30; range 1–60. */
   fps?: number;
-  /** Include `dev: true` game layers. Off by default so ordinary evidence is
-   * the player-visible game, not its debugging overlay. */
-  devLayers?: boolean;
 }
 
 /** Facts fixed when a gameplay recording starts. */
@@ -385,6 +382,8 @@ export interface EditorState {
   activeViewportTab: ViewportTab;
   /** The actual active center document, including tool/source documents. */
   activeDocumentId?: string | null;
+  /** Every center document the editor currently has open, by stable registry id. */
+  openDocumentIds?: string[];
   activeTabKey: string;
   showGrid: boolean;
   showHelpers: boolean;
@@ -625,8 +624,6 @@ export interface EditorState {
     regions: {
       id: string;
       surface: string;
-      /** true = this region grades the game's own dev layer, not shipped content. */
-      dev: boolean;
       projector: string;
       dialect: string | null;
       anchors: string[];
@@ -661,11 +658,11 @@ export type TransformSpace = 'world' | 'local';
  * view. One runtime list owns both URL parsing and the public id type. */
 export const EDITOR_VIEW_WORKSPACE_DOCUMENT_IDS = [
   'workspace:scene',
+  'workspace:canvas-scene',
   'workspace:game',
   'workspace:3d-components',
   'workspace:2d-components',
   'workspace:ui-components',
-  'workspace:dev',
   'workspace:build-profiles',
   'account',
   'project-tools',