@vgai/editor 0.4.0-canary.20260715.0 → 0.4.0

package/server/packaged.ts

@@ -466,6 +466,26 @@ async function main(): Promise<void> {
         'react-dom/client',
         'react/jsx-runtime',
         'react/jsx-dev-runtime',
+        // A scaffold's project-authored client modules are loaded lazily by
+        // the prebuilt editor. They are outside the manifest-world entry
+        // crawl above, so a cold install otherwise discovers these aliases in
+        // waves (project tools during editor boot, GameComponent on first
+        // Play) and Vite hard-reloads the controlling tab each time. Keep the
+        // starter's runtime imports in the initial prebundle so the first SDK
+        // command is not disconnected by dependency optimization.
+        '@editor/widgets',
+        '@engine/data/data-asset',
+        '@engine/ecs/game-component',
+        '@engine/input/input-manager',
+        '@engine/input/rebind-controller',
+        '@engine/loader',
+        '@engine/react/use-data',
+        '@engine/runtime/mount-game',
+        '@engine/scene/component-registry',
+        '@engine/scene/parse',
+        '@engine/tools/define-tool',
+        '@engine/world2d',
+        'zod',
       ],
       entries: projectOptimizeDepsEntries,
       // C3 hardening: belt to the entries-scoping suspenders. Entries-scoping

package/src/asset-editor-context.tsx

@@ -0,0 +1,130 @@
+/**
+ * Context contributed by the active typed Asset Editor to the existing editor
+ * shell. Asset documents own content; the workspace owns placement. Keeping
+ * this as a tiny external store lets Dockview's persistent Hierarchy,
+ * Inspector, bottom drawer, and status bar render the active document's
+ * context without an Asset Editor recreating those panes inside the center.
+ */
+
+import type { ReactNode } from 'react';
+import { useSyncExternalStore } from 'react';
+import { themeVars } from './design-system';
+import { createHmrRegistrationGroup } from './hmr-registration-group';
+import { registerWorkspaceStatus } from './workspace-status-registry';
+import { registerWorkspaceUtility } from './workspace-utility-registry';
+
+export const ASSET_EDITOR_CONTROLS_UTILITY_ID = 'asset-editor-controls';
+
+export interface AssetEditorContextValue {
+  readonly documentId: string;
+  readonly title: string;
+  readonly type: string;
+  readonly structure?: ReactNode;
+  readonly details?: ReactNode;
+  readonly status?: string;
+  readonly controls?: ReactNode;
+}
+
+interface ActiveAssetEditorContext extends AssetEditorContextValue {
+  readonly token: symbol;
+}
+
+let active: ActiveAssetEditorContext | null = null;
+let version = 0;
+const listeners = new Set<() => void>();
+
+function notifyChanged(): void {
+  version++;
+  for (const listener of listeners) listener();
+}
+
+export function subscribeAssetEditorContext(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function assetEditorContextVersion(): number {
+  return version;
+}
+
+export function getActiveAssetEditorContext(): AssetEditorContextValue | null {
+  return active;
+}
+
+/** Activate one document contribution. The returned disposer only clears the
+ * exact activation it created, so an older tab unmount cannot erase a newer
+ * active tab's context. */
+export function activateAssetEditorContext(value: AssetEditorContextValue): () => void {
+  const token = Symbol(value.documentId);
+  active = { ...value, token };
+  notifyChanged();
+  return () => {
+    if (active?.token !== token) return;
+    active = null;
+    notifyChanged();
+  };
+}
+
+export function AssetEditorControlsUtility() {
+  useSyncExternalStore(subscribeAssetEditorContext, assetEditorContextVersion);
+  const context = getActiveAssetEditorContext();
+  if (!context?.controls) return null;
+  return (
+    <div
+      data-testid="asset-editor-controls"
+      style={{
+        minHeight: 0,
+        padding: 8,
+        color: themeVars.content.primary,
+        pointerEvents: 'auto',
+      }}
+    >
+      {context.controls}
+    </div>
+  );
+}
+
+export function AssetEditorStatus() {
+  useSyncExternalStore(subscribeAssetEditorContext, assetEditorContextVersion);
+  const context = getActiveAssetEditorContext();
+  return context?.status ? (
+    <span data-testid="status-asset-editor" style={{ color: themeVars.content.muted }}>
+      {context.status}
+    </span>
+  ) : null;
+}
+
+const registrationGroup = createHmrRegistrationGroup(
+  import.meta.hot,
+  'asset-editor-shell-contributions',
+);
+
+export function ensureAssetEditorShellContributionsRegistered(): void {
+  registrationGroup.ensure((track) => {
+    track(
+      registerWorkspaceUtility({
+        id: ASSET_EDITOR_CONTROLS_UTILITY_ID,
+        title: 'Asset Controls',
+        Content: AssetEditorControlsUtility,
+        available: () => getActiveAssetEditorContext()?.controls != null,
+        visibleByDefault: false,
+        closeable: true,
+      }),
+    );
+    track(
+      registerWorkspaceStatus({
+        id: 'asset-editor-status',
+        align: 'left',
+        order: 40,
+        Content: AssetEditorStatus,
+      }),
+    );
+  });
+}
+
+ensureAssetEditorShellContributionsRegistered();
+
+export function __resetAssetEditorContextForTest(): void {
+  active = null;
+  notifyChanged();
+}

package/src/asset-preview.ts

@@ -785,6 +785,10 @@ function parseGltfData(
       data,
       new URL('.', sourceUrl).href,
       (gltf) => {
+        // GLTFLoader keeps clips on the GLTF result rather than its scene.
+        // Asset Editor's model contract is Object3D-shaped, so preserve those
+        // clips instead of silently degrading animated assets into static ones.
+        gltf.scene.animations = [...gltf.animations];
         if (!finish(() => resolve(gltf.scene))) {
           disposeOwnedModel(gltf.scene);
         }

package/src/asset-selection.ts

@@ -13,19 +13,19 @@
  * (mirrors `inspector-section-registry.ts`): version counter + subscribe +
  * `__resetForTest`. It deliberately does NOT touch the EditorStore's entity
  * selection — clicking an asset must never deselect/reselect scene entities
- * (§6.1 "selection never unexpectedly..."); instead the Inspector section
- * simply appears for the selected asset, and the selection is auto-cleared
+ * (§6.1 "selection never unexpectedly..."); instead the Inspector gives the
+ * asset domain precedence while retaining that entity selection, and the asset is auto-cleared
  * when the ENTITY selection changes (the user moved on — see
  * `installAssetSelectionAutoClear`).
  */
 
 import type { AssetCapabilities } from './asset-workflow/asset-capabilities';
-import type { AssetKind } from './editor-store';
+import type { AssetKind, OnlineAssetInfo } from './editor-store';
 
 /** The §5.1 compact-selection payload — enough for the Inspector section to
  *  render preview + metadata without re-deriving browser state. */
 export interface SelectedAsset {
-  /** Serving path (`/textures/crate.png`) — doubles as the open-document key. */
+  /** Project serving path, or a stable `online:<source>:<id>` document key. */
   readonly path: string;
   /** Source-owned file name as authored (§8 — `crate.png`). */
   readonly name: string;
@@ -39,6 +39,11 @@ export interface SelectedAsset {
   readonly dependencies?: readonly string[];
   readonly references?: readonly { ownerPath: string; jsonPath: string }[];
   readonly healthCodes?: readonly string[];
+  /** Selection came from the external acquisition Library rather than the
+   * project's owned file tree. `online` carries the provider identity and is
+   * intentionally absent from project assets. */
+  readonly origin?: 'project' | 'library';
+  readonly online?: OnlineAssetInfo;
 }
 
 let _selected: SelectedAsset | null = null;

package/src/asset-workflow/thumbnail-system.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { getStorageBackend } from '../storage';
+import { getStorageBackend, type StorageBackend } from '../storage';
 import type { AssetCatalog } from './asset-types';
 
 export const THUMBNAIL_PROFILE = {
@@ -39,15 +39,24 @@ export const thumbnailManifestSchema = z.object({
 export type ThumbnailManifest = z.infer<typeof thumbnailManifestSchema>;
 
 let manifestPromise: Promise<ThumbnailManifest | null> | null = null;
+
+/** Optional project thumbnail metadata must never block live fallback previews.
+ * HTTP-backed projects can return the Vite HTML shell for an absent file, so
+ * existence and parsing are both guarded at this storage boundary. */
+export async function readProjectThumbnailManifest(
+  backend: Pick<StorageBackend, 'read'>,
+): Promise<ThumbnailManifest | null> {
+  try {
+    return thumbnailManifestSchema.parse(JSON.parse(await backend.read('.vgai/thumbnails.json')));
+  } catch {
+    return null;
+  }
+}
+
 export function loadProjectThumbnailManifest(): Promise<ThumbnailManifest | null> {
   if (!manifestPromise) {
     const backend = getStorageBackend() as ReturnType<typeof getStorageBackend> | undefined;
-    manifestPromise = backend
-      ? backend.read('.vgai/thumbnails.json').then(
-          (content) => thumbnailManifestSchema.parse(JSON.parse(content)),
-          () => null,
-        )
-      : Promise.resolve(null);
+    manifestPromise = backend ? readProjectThumbnailManifest(backend) : Promise.resolve(null);
   }
   return manifestPromise;
 }