@volter/editor-core 0.5.57

package/src/workspace-status-registry.ts

@@ -0,0 +1,121 @@
+/**
+ * Workspace STATUS-CONTRIBUTION registry (W0 — the shell-contract slice of
+ * §9 W0). "Status is status, not a command" (§1.5): save/dirty/failure
+ * state, problem counts, connection/play state, build progress, and concise
+ * selection information belong in a narrow status bar — not mixed into the
+ * global command header and not spread across viewport overlays.
+ *
+ * Consumed since W4 by `components/StatusBar.tsx` (rendered under the
+ * bottom dock/drawer strip); the core contributions live in
+ * `components/status-contributions.tsx` (+ `build-documents.tsx`'s
+ * `build-progress`). Migration map.
+ *
+ * Idioms mirror `inspector-section-registry.ts`: module-scope state,
+ * `useSyncExternalStore`-shaped subscribe + monotonic version,
+ * `__resetForTest`, pure-logic headless tests (`Content` is never rendered
+ * here). Ids key persisted/status-bar slots, so duplicates throw (same rule
+ * as `workspace-utility-registry.ts`).
+ */
+
+import type { ComponentType } from 'react';
+
+/** The §7 status contribution contract: one compact status-bar item. */
+export interface WorkspaceStatusContribution {
+  /** Stable id — keys the status-bar slot (`data-testid`). */
+  readonly id: string;
+  /**
+   * WHAT A PERSON CALLS IT. Required, because the status bar this draws into
+   * is the workbench's and `IStatusbarEntry.name` is required there: it is the
+   * label in the bar's own right-click menu (`Hide <item>`) and the entry's
+   * aria label. Before it existed every contribution passed its raw id, so the
+   * menu read `tool:blender.status`, `console-counts`, `play-state` beside VS
+   * Code's own `Remote Host` and `Problems` (walk 4, 2026-09-20).
+   *
+   * Title Case, and a NOUN — it names the thing, not what it is doing right
+   * now: the CONTENT changes, this does not.
+   */
+  readonly name: string;
+  /** Which end of the bar (§4.1: session state left, selection info right).
+   *  Default `'left'`. */
+  readonly align?: 'left' | 'right';
+  /** Slot order within its side (ascending; ties keep registration order).
+   *  Default `0`. */
+  readonly order?: number;
+  /** React content host — compact, passive, non-command (§1.5). Never
+   *  rendered by the registry itself. */
+  readonly Content: ComponentType;
+}
+
+// --- Module-scope state (mirrors inspector-section-registry.ts) -----------
+
+interface StoredContribution {
+  readonly contribution: WorkspaceStatusContribution;
+  readonly seq: number;
+}
+
+let _contributions: StoredContribution[] = [];
+let _seq = 0;
+let _version = 0;
+const _listeners = new Set<() => void>();
+
+function notifyChanged(): void {
+  _version++;
+  for (const fn of _listeners) fn();
+}
+
+/** Subscribe to (un)registrations. Returns an unsubscribe function. */
+export function subscribeWorkspaceStatus(fn: () => void): () => void {
+  _listeners.add(fn);
+  return () => {
+    _listeners.delete(fn);
+  };
+}
+
+/** Monotonic change counter — the `getSnapshot` for `useSyncExternalStore`. */
+export function workspaceStatusRegistryVersion(): number {
+  return _version;
+}
+
+/**
+ * Register a status contribution. Returns an unregister function.
+ * Throws on a duplicate id (ids key status-bar slots — same uniqueness rule
+ * as `registerWorkspaceUtility`).
+ */
+export function registerWorkspaceStatus(contribution: WorkspaceStatusContribution): () => void {
+  if (_contributions.some((c) => c.contribution.id === contribution.id)) {
+    throw new Error(
+      `registerWorkspaceStatus: id "${contribution.id}" is already registered — ` +
+        'status ids key status-bar slots, so they must be unique; unregister the ' +
+        'previous contribution first.',
+    );
+  }
+  const stored: StoredContribution = { contribution, seq: _seq++ };
+  _contributions = [..._contributions, stored];
+  notifyChanged();
+  return () => {
+    if (!_contributions.includes(stored)) return;
+    _contributions = _contributions.filter((c) => c !== stored);
+    notifyChanged();
+  };
+}
+
+/** Registered contributions for one side of the bar, in (order,
+ *  registration-sequence) order; with no argument, both sides (left first). */
+export function workspaceStatusContributions(
+  align?: 'left' | 'right',
+): WorkspaceStatusContribution[] {
+  const side = (want: 'left' | 'right') =>
+    [..._contributions]
+      .filter((c) => (c.contribution.align ?? 'left') === want)
+      .sort((a, b) => (a.contribution.order ?? 0) - (b.contribution.order ?? 0) || a.seq - b.seq)
+      .map((c) => c.contribution);
+  if (align) return side(align);
+  return [...side('left'), ...side('right')];
+}
+
+/** Test-only reset (mirrors `__resetInspectorSectionRegistryForTest`). */
+export function __resetWorkspaceStatusRegistryForTest(): void {
+  _contributions = [];
+  _seq = 0;
+  notifyChanged();
+}

package/src/workspace-style.ts

@@ -0,0 +1,239 @@
+/**
+ * Workspace STYLE BUNDLES (Glass-UI spike, Unit 3, "New named style using
+ * existing axes" row).
+ *
+ * Named one-shot presets over PALETTE + MATERIAL + ICONS + REGIONS. The axes
+ * stay independently selectable; choosing a named style intentionally
+ * restores its canonical complete appearance. In particular, Classic must
+ * restore the original Graphite contract rather than inheriting a Glass
+ * palette.
+ *
+ * REGIONS is the anatomy axis (`workspace-regions.ts`): which chrome regions
+ * the documents show — the workspace tab strip, the document header, the tool
+ * shelf, and how the inspector lays its sections out. A bundle's regions are
+ * DEFAULTS beneath each workspace's own declaration, so Look stays minimal
+ * under every bundle. This is what lets the same host wear Blender's shape
+ * (tabs, header, shelf, a tabbed Properties column), Maya's (a header, no
+ * shelf, a stacked column) and Substance's (charcoal, no header or shelf)
+ * without a line of per-tool code: each is one row here plus one palette
+ * document under `palettes/`.
+ *
+ * Bundles are ONE-SHOT PRESETS, not a fifth stored axis: applying a bundle
+ * just calls the four existing axis setters, and this module keeps no store
+ * or persistence of its own. "Which bundle is active" is always DERIVED
+ * from their current values (`activeWorkspaceStyleId`) and can never
+ * disagree with them — e.g. after a user independently changes just the
+ * material, the derived id correctly falls back to `null` (a "custom" mix)
+ * rather than going stale.
+ */
+
+import type { StyleContribution } from '@volter/editor-sdk/looks';
+import type { EditorMaterialId, EditorPalette } from '@volter/editor-sdk/widgets';
+import {
+  DEFAULT_ICON_SET_ID,
+  registerContributedIconSet,
+  registerContributedMaterial,
+} from '@volter/editor-sdk/widgets';
+import { activeProduct, subscribeActiveProduct } from './active-product';
+import { registerContributedPalette } from './theme-library';
+import {
+  editorIconSetSnapshot,
+  editorMaterialSnapshot,
+  editorPaletteSnapshot,
+  setDefaultEditorAppearance,
+  setEditorIconSetPreference,
+  setEditorMaterialPreference,
+  setEditorPalettePreference,
+} from './theme-preference';
+import {
+  type ChromeRegions,
+  presetChromeRegions,
+  regionsKey,
+  setPresetRegions,
+} from './workspace-regions';
+
+export interface WorkspaceStyleBundle {
+  readonly id: string;
+  readonly title: string;
+  readonly paletteId: EditorPalette['id'];
+  readonly materialId: EditorMaterialId;
+  /** `icon-set-registry.ts`; `default` is the editor's own glyphs. */
+  readonly iconSetId: string;
+  /** Region defaults beneath each workspace's own (`workspace-regions.ts`).
+   *  Empty means "whatever the workspace says", which is what Classic and
+   *  Glass mean. */
+  readonly regions: ChromeRegions;
+}
+
+/** Frozen built-in list — the switch surface (command palette / View menu)
+ *  enumerates this directly. */
+const BUILT_IN_STYLES: readonly WorkspaceStyleBundle[] = Object.freeze([
+  {
+    id: 'classic',
+    title: 'Classic',
+    paletteId: 'graphite-dark',
+    materialId: 'classic',
+    iconSetId: DEFAULT_ICON_SET_ID,
+    regions: {},
+  },
+  {
+    id: 'glass',
+    title: 'Glass',
+    paletteId: 'graphite-neutral',
+    materialId: 'glass',
+    iconSetId: DEFAULT_ICON_SET_ID,
+    regions: {},
+  },
+  {
+    id: 'maya',
+    title: 'Maya',
+    paletteId: 'maya',
+    materialId: 'classic',
+    iconSetId: DEFAULT_ICON_SET_ID,
+    regions: { header: 'shown', shelf: 'hidden', inspector: 'column' },
+  },
+  {
+    id: 'substance',
+    title: 'Substance',
+    paletteId: 'substance',
+    materialId: 'classic',
+    iconSetId: DEFAULT_ICON_SET_ID,
+    regions: { header: 'hidden', shelf: 'hidden', inspector: 'column' },
+  },
+]);
+
+interface ContributedStyle {
+  readonly bundle: WorkspaceStyleBundle;
+  readonly unregisterPalette: (() => void) | null;
+  readonly unregisterMaterial: (() => void) | null;
+  readonly unregisterIconSet: (() => void) | null;
+}
+const contributedStyles = new Map<string, ContributedStyle>();
+let registryVersion = 0;
+const registryListeners = new Set<() => void>();
+
+/** Built-ins first, then contributions in registration order — the switch
+ *  surfaces (View menu, palette) enumerate this. */
+export function workspaceStyles(): readonly WorkspaceStyleBundle[] {
+  return [...BUILT_IN_STYLES, ...[...contributedStyles.values()].map((entry) => entry.bundle)];
+}
+
+export function workspaceStylesVersion(): number {
+  return registryVersion;
+}
+
+export function subscribeWorkspaceStyles(listener: () => void): () => void {
+  registryListeners.add(listener);
+  return () => registryListeners.delete(listener);
+}
+
+/**
+ * Register a package's style bundle (`workspace.style` contribution), with
+ * the palette document and the material it carries registered first — the
+ * bundle names their ids, and an id must exist before the bundle can be
+ * applied. Returns the unregister. A duplicate id throws.
+ */
+export function registerContributedStyle(contribution: StyleContribution): () => void {
+  if (
+    BUILT_IN_STYLES.some((entry) => entry.id === contribution.id) ||
+    contributedStyles.has(contribution.id)
+  )
+    throw new Error(`registerContributedStyle: style "${contribution.id}" is already registered.`);
+  const unregisterPalette =
+    contribution.palette === undefined ? null : registerContributedPalette(contribution.palette);
+  const unregisterMaterial =
+    contribution.material === undefined ? null : registerContributedMaterial(contribution.material);
+  const unregisterIconSet =
+    contribution.icons === undefined ? null : registerContributedIconSet(contribution.icons);
+  const entry: ContributedStyle = {
+    bundle: {
+      id: contribution.id,
+      title: contribution.title,
+      paletteId: contribution.paletteId,
+      materialId: contribution.materialId,
+      iconSetId: contribution.iconSetId ?? contribution.icons?.id ?? DEFAULT_ICON_SET_ID,
+      regions: contribution.regions ?? {},
+    },
+    unregisterPalette,
+    unregisterMaterial,
+    unregisterIconSet,
+  };
+  contributedStyles.set(contribution.id, entry);
+  registryVersion++;
+  for (const listener of registryListeners) listener();
+  // The product's look is usually one of these (the Blender look ships inside
+  // `@volter/editor-blender`), so the id it named only becomes resolvable here.
+  publishProductLook();
+  return () => {
+    if (contributedStyles.get(contribution.id) !== entry) return;
+    contributedStyles.delete(contribution.id);
+    entry.unregisterPalette?.();
+    entry.unregisterMaterial?.();
+    entry.unregisterIconSet?.();
+    registryVersion++;
+    for (const listener of registryListeners) listener();
+    publishProductLook();
+  };
+}
+
+/**
+ * THE PRODUCT'S LOOK, RESOLVED TO ITS AXES — the one thing this module does for
+ * a composition rather than for a gesture.
+ *
+ * A product names a style bundle id (`frame/product.ts`'s `look`); this is the
+ * module that knows what a bundle IS, so it resolves the id and pushes the
+ * palette/material/icons behind `theme-preference.ts`'s defaults. It runs on
+ * every registry change because a product's own look usually arrives as one of
+ * its packages' `workspace.style` contributions, which register a moment into
+ * the session — the Blender look is the worked case.
+ *
+ * It applies nothing and persists nothing: a bundle a person CHOOSES goes
+ * through {@link applyWorkspaceStyle}, which writes the preference. This is the
+ * floor under that.
+ */
+function publishProductLook(): void {
+  const declared = activeProduct()?.look;
+  if (declared === undefined) {
+    setDefaultEditorAppearance(null);
+    return;
+  }
+  const bundle = workspaceStyles().find((entry) => entry.id === declared);
+  if (!bundle) return;
+  setDefaultEditorAppearance({
+    palette: bundle.paletteId,
+    material: bundle.materialId,
+    icons: bundle.iconSetId,
+  });
+}
+
+subscribeActiveProduct(publishProductLook);
+publishProductLook();
+
+/** Apply all four axes for the named bundle. Unknown ids are a silent no-op —
+ *  callers (menu/command palette) only ever offer ids from {@link workspaceStyles}. */
+export function applyWorkspaceStyle(id: string): void {
+  const bundle = workspaceStyles().find((entry) => entry.id === id);
+  if (!bundle) return;
+  setEditorPalettePreference(bundle.paletteId);
+  setEditorMaterialPreference(bundle.materialId);
+  setEditorIconSetPreference(bundle.iconSetId);
+  setPresetRegions(bundle.regions);
+}
+
+/** The bundle id whose palette, material, icon set and regions all match the
+ *  current axis values, or `null` if the current combination isn't any
+ *  registered bundle (a "custom" mix — always derived, never a separate
+ *  stored state). */
+export function activeWorkspaceStyleId(): string | null {
+  const paletteId = editorPaletteSnapshot();
+  const materialId = editorMaterialSnapshot();
+  const regions = regionsKey(presetChromeRegions());
+  const bundle = workspaceStyles().find(
+    (entry) =>
+      entry.paletteId === paletteId &&
+      entry.materialId === materialId &&
+      entry.iconSetId === editorIconSetSnapshot() &&
+      regionsKey(entry.regions) === regions,
+  );
+  return bundle?.id ?? null;
+}

package/src/workspace-utility-commands.ts

@@ -0,0 +1,74 @@
+/** Semantic commands and failure auto-open policy for workspace utilities. */
+
+import { getMountFailureReports, subscribeToMountFailures } from './authoring/mount-failure-report';
+import { editorConsole } from './editor-console';
+import type { HistoryService } from './history/history-service';
+import { showWorkspaceUtility, toggleWorkspaceUtility } from './workspace-host-commands';
+import { activeChromeRegions } from './workspace-regions';
+
+export const CONSOLE_UTILITY_ID = 'console';
+
+/**
+ * Only actionable failures open a utility automatically.
+ *
+ * A world that did not mount is the most actionable failure the editor has —
+ * the project is showing something that is not the game — and revealing the
+ * Console (where every mount route already wrote its full line) is what keeps
+ * it LOUD without a second error surface. This replaced a top-of-shell red
+ * banner: the reveal, not the banner, is the answer to "the Console is not
+ * the default bottom tab". Fires on the empty→failing EDGE only, so a second
+ * failing world in the same attempt does not yank the region back.
+ *
+ * Source persistence failures arrive through the project history that guarded
+ * and rolled back the write. Watch its failure EDGE directly: this keeps the
+ * Console reveal format-neutral and avoids a second adapter-specific event.
+ *
+ * A workspace whose regions HIDE the drawer (Blender's modeling workspace has
+ * no strip below the viewport) is never yanked open by this policy: the
+ * status bar's error count stays the loud surface there, and a person's own
+ * gesture (a failure item, View → Console) still reveals it.
+ */
+export function installUtilityAutoOpen(history: HistoryService): () => void {
+  let hadMountFailure = getMountFailureReports().length > 0;
+  const stopMountFailures = subscribeToMountFailures(() => {
+    const failing = getMountFailureReports().length > 0;
+    if (failing && !hadMountFailure && activeChromeRegions().drawer !== 'hidden')
+      showWorkspaceUtility(CONSOLE_UTILITY_ID);
+    hadMountFailure = failing;
+  });
+
+  let hadSourceFailure = history.getSnapshot().lastError !== null;
+  const stopHistory = history.subscribe(() => {
+    const error = history.getSnapshot().lastError;
+    const failing = error !== null;
+    if (failing && !hadSourceFailure) {
+      // The one place every rolled-back write is named for the DOOR: the
+      // screen narrates it (a toast, the document's own message), and
+      // `vgai console` must say the same — measured silent before this line.
+      editorConsole.error(`Source write rolled back: ${error.message} (${error.code})`, 'history');
+      if (activeChromeRegions().drawer !== 'hidden') showWorkspaceUtility(CONSOLE_UTILITY_ID);
+    }
+    hadSourceFailure = failing;
+  });
+
+  return () => {
+    stopMountFailures();
+    stopHistory();
+  };
+}
+
+/** Toggle the Console utility — the semantic command every menu/hotkey/
+ *  control-API caller invokes directly. It used to be reached through a
+ *  `window` CustomEvent (`editor:toggle-console`) installed by
+ *  `installUtilityEvents`; that indirection was a shell-era relay with no
+ *  remaining second implementation, so it was deleted. */
+export function toggleConsoleUtility(): void {
+  toggleWorkspaceUtility(CONSOLE_UTILITY_ID);
+}
+
+/** REVEAL the Console — what a failure item clicks through to. Distinct from
+ *  {@link toggleConsoleUtility} on purpose: a user acting on a reported error
+ *  must never have that click HIDE the panel holding the error's trace. */
+export function showConsoleUtility(): void {
+  showWorkspaceUtility(CONSOLE_UTILITY_ID);
+}