@volter/editor-sdk 0.5.57

package/src/views.ts

@@ -0,0 +1,164 @@
+/**
+ * A VIEW'S VERBS — the one product door into a panel that is not the centre
+ * document (ARCHITECTURE-CORE §Our tier over the Code-OSS frame, "a panel →
+ * view"; WORK.md §The core is Code-OSS U8, ruling (1), 2026-09-19).
+ *
+ * ## The problem this exists for, and the ruling that shaped it
+ *
+ * `editor.document.*` reaches only the ACTIVE CENTRE DOCUMENT, by its own
+ * contract. Every drawer utility — Console, Profiler, Network, I5's node
+ * editor — is therefore undrivable by the product, and each one that needed
+ * driving was shipping its OWN session verb to compensate (I5's
+ * `blender-node-view` is the worked case, and UV Editing, Animation and
+ * Texture Paint were each about to pay the same price).
+ *
+ * The ruling refused both a utility scope on the document door and a verb per
+ * view: **under the Code-OSS frame every one of our views is a VS Code view
+ * in a view container, and its state and verbs are reached through
+ * `vgai.<view>.<verb>` commands the bridge dispatches into the view** — the
+ * same one-name door as every other verb, so `vgai eval` reaches it through
+ * the frame's command service.
+ *
+ * ## Why the registry is HERE and not in the editor
+ *
+ * Both sides of it are outside `packages/editor/src`: a view's verbs are
+ * registered by the package that OWNS the view (`@vgai/blender`'s node
+ * editor), and they are read by the fork's bridge. The editor host mediates
+ * nothing, so a registry inside it would be a closure file with no reader of
+ * its own — the same reasoning `registerEditorHost` follows one module over.
+ *
+ * ## The two doors, one table
+ *
+ * Standalone `vgai edit` has no VS Code command service, so the SESSION's own
+ * verb is how a view is driven there. That is not a second implementation:
+ * the session verb calls {@link invokeViewVerb} on the same table the frame's
+ * commands call, exactly as `key-actions.ts`'s action table is one
+ * table behind two keyboards. A NEW view registers verbs here and adds no
+ * session verb at all.
+ */
+
+export interface ViewVerb {
+  /** The verb, bare: `state`, `view-all`, `zoom`. The frame publishes it as
+   *  `vgai.<view>.<verb>`; the session spells it its own way. */
+  readonly id: string;
+  /** What the palette calls it, when the verb is one a PERSON would run. A
+   *  verb with no title is reachable by command id and by the session, and is
+   *  not listed — a read (`state`) or a refusal probe is not a menu item. */
+  readonly title?: string;
+  /** Run it. `args` is the command's own argument object, unvalidated: a view
+   *  validates its own arguments and REFUSES BY NAME, because what an argument
+   *  means is the view's and no registry can know it. */
+  readonly run: (args?: Record<string, unknown>) => unknown;
+}
+
+export interface ViewVerbContribution {
+  /** The view's id, and the middle segment of every command it publishes —
+   *  `blender-node-view` → `vgai.blender-node-view.view-all`. It is the same
+   *  id the view registers under when it becomes a VS Code view. */
+  readonly view: string;
+  /** What the view is called, for the palette entry's category. */
+  readonly title: string;
+  readonly verbs: readonly ViewVerb[];
+}
+
+const REGISTRY_KEY = Symbol.for('vgai.editor.viewVerbs');
+interface RegistryState {
+  contributions: readonly ViewVerbContribution[];
+  listeners: Set<() => void>;
+  version: number;
+}
+const globals = globalThis as typeof globalThis & { [REGISTRY_KEY]?: RegistryState };
+// One registry across module copies, for the reason `host.ts` has one: the
+// fork's bridge and a package's contribution can be different instances of
+// this module, and a view registered into a second table is a view the frame
+// never sees.
+globals[REGISTRY_KEY] ??= { contributions: [], listeners: new Set(), version: 0 };
+const state: RegistryState = globals[REGISTRY_KEY];
+
+function emit(): void {
+  state.version++;
+  for (const listener of state.listeners) listener();
+}
+
+/**
+ * Register a view's verbs. Returns the removal, which only fires while this
+ * contribution is still the live one for its id.
+ *
+ * THE SAME VIEW REGISTERING AGAIN REPLACES ITSELF. A contribution module is
+ * evaluated more than once per session by design: the tool loader imports it
+ * as `/@fs/<path>?t=<version>` (packages/editor/src/tool-loader.ts) so a
+ * project's save re-evaluates it, and a BUNDLED package's contribution is
+ * reached by its bare specifier as well — while this registry is ONE table on
+ * `globalThis` across
+ * every module copy. Module-level `registerViewVerbs(...)` in a contribution
+ * therefore runs once per evaluation, and on 2026-09-19 the second evaluation
+ * threw and the editor did not boot. The re-evaluation is recognised by the
+ * view id AND title agreeing — the same source, loaded again — and the newer
+ * table wins, its predecessor's disposer becoming a no-op.
+ *
+ * A DIFFERENT view claiming the id still THROWS: the id keys the whole
+ * `vgai.<view>.<verb>` command namespace, and a second view under it would
+ * publish commands that shadow the first with no sign of it.
+ */
+export function registerViewVerbs(contribution: ViewVerbContribution): () => void {
+  const existing = state.contributions.find((entry) => entry.view === contribution.view);
+  if (existing && existing.title !== contribution.title) {
+    throw new Error(
+      `registerViewVerbs: the view "${contribution.view}" already publishes verbs as "${existing.title}"; "${contribution.title}" is a different view under the same id. A view id keys its whole \`vgai.<view>.<verb>\` command namespace, so a second view under it would shadow the first with no sign of it.`,
+    );
+  }
+  state.contributions = [
+    ...state.contributions.filter((entry) => entry !== existing),
+    contribution,
+  ];
+  emit();
+  return () => {
+    if (!state.contributions.includes(contribution)) return;
+    state.contributions = state.contributions.filter((entry) => entry !== contribution);
+    emit();
+  };
+}
+
+/** Every view publishing verbs right now. */
+export function viewVerbContributions(): readonly ViewVerbContribution[] {
+  return state.contributions;
+}
+
+export function viewVerbsVersion(): number {
+  return state.version;
+}
+
+export function subscribeViewVerbs(listener: () => void): () => void {
+  state.listeners.add(listener);
+  return () => state.listeners.delete(listener);
+}
+
+/**
+ * Run one view's verb. The refusal is a THROW naming the whole vocabulary,
+ * because both callers — the frame's command and the session's verb — report
+ * a thrown message and a silent `undefined` is how a typo becomes a mystery.
+ */
+export function invokeViewVerb(
+  view: string,
+  verb: string,
+  args?: Record<string, unknown>,
+): unknown {
+  const contribution = state.contributions.find((entry) => entry.view === view);
+  if (!contribution) {
+    const known = state.contributions.map((entry) => entry.view).join(', ') || 'none';
+    throw new Error(`No view "${view}" publishes verbs right now — the views that do: ${known}.`);
+  }
+  const entry = contribution.verbs.find((candidate) => candidate.id === verb);
+  if (!entry) {
+    throw new Error(
+      `The view "${view}" has no verb "${verb}" — it publishes: ${contribution.verbs.map((candidate) => candidate.id).join(', ')}.`,
+    );
+  }
+  return entry.run(args);
+}
+
+export function __resetViewVerbsForTest(): void {
+  state.contributions = [];
+  state.listeners.clear();
+  state.version = 0;
+}

package/src/widgets/design-system.ts

@@ -0,0 +1,93 @@
+/**
+ * The editor design system — patterns, primitives and the theme members its
+ * own surfaces read, as ONE module. Theme definitions, CSS recipes,
+ * primitives and recurring patterns stay implementation details below it.
+ *
+ * It is not a published subpath: `./index.ts` re-exports it, and the face is
+ * `@volter/editor-sdk/widgets` (ARCHITECTURE-CORE §The target shape, rule 5 —
+ * one API, four faces). Everything in and below this file must stay
+ * react-only, or the Apache package starts reaching AGPL host source.
+ */
+
+export {
+  composeEditorAppearance,
+  EDITOR_MATERIAL_IDS,
+  EDITOR_MATERIALS,
+  type EditorMaterialChoice,
+  type EditorMaterialId,
+  type EditorPalette,
+  isEditorMaterialId,
+} from './editor-appearance';
+export * from './patterns/Dialog';
+export * from './patterns/Fields';
+export * from './patterns/List';
+export * from './patterns/StateSurface';
+export * from './patterns/Surfaces';
+export * from './patterns/Tabs';
+export * from './patterns/Toolbar';
+export * from './patterns/Tree';
+export * from './primitives/AnchoredMenu';
+export * from './primitives/Button';
+export * from './primitives/banner-tones';
+export * from './primitives/ColorInput';
+export * from './primitives/clamp-to-viewport';
+export * from './primitives/EditorIcon';
+export { editorIcons } from './primitives/editor-icons';
+export * from './primitives/FormControls';
+export * from './primitives/HoverPreview';
+export * from './primitives/JsonInput';
+export * from './primitives/Layout';
+export * from './primitives/Menu';
+export * from './primitives/NumberInput';
+export * from './primitives/Panel';
+export * from './primitives/SectionHeader';
+export * from './primitives/Text';
+export * from './primitives/ThemeRootPortal';
+export * from './primitives/Tooltip';
+export * from './primitives/Vec3Input';
+// Product surfaces consume runtime theme references through this boundary as
+// they migrate away from direct `theme.ts` imports. Keeping the references
+// here preserves custom-theme behavior without exposing design-system internals.
+export {
+  accent,
+  accentMuted,
+  applyEditorTheme,
+  bg,
+  border,
+  chromeSize,
+  controlSize,
+  danger,
+  dangerFaint,
+  dangerMuted,
+  EDITOR_THEME_CLASS,
+  type EditorTheme,
+  type EditorThemeId,
+  type EditorThemeVariable,
+  editorThemes,
+  editorThemeVariables,
+  fontMono,
+  fontSans,
+  fontSize,
+  fontSizeVar,
+  fontWeight,
+  graphiteDarkEditorTheme,
+  lineHeight,
+  lineHeightVar,
+  midnightHighContrastEditorTheme,
+  motion,
+  motionVar,
+  radius,
+  scrim,
+  selection,
+  shadow,
+  space,
+  spaceVar,
+  strokeWidth,
+  success,
+  successMuted,
+  text,
+  themeVars,
+  warn,
+  warnMuted,
+} from './theme';
+export { zIndex } from './z-index';

package/src/widgets/editor-appearance.ts

@@ -0,0 +1,149 @@
+import { CLASSIC_MATERIAL, GLASS_MATERIAL } from './editor-material';
+import type { EditorTheme } from './theme';
+
+/**
+ * Editor appearance is deliberately composed from independent axes:
+ *
+ *   palette (a theme-library document) × material
+ *
+ * Palette documents own chroma and typography. Materials own surface physics,
+ * boundaries, neutral interaction overlays, shape, elevation, and treatment.
+ * Components only receive the resolved EditorTheme token set and therefore
+ * remain blind to both axes.
+ */
+export const EDITOR_MATERIAL_IDS = ['classic', 'glass'] as const;
+/** One of the editor's own materials, or one a package's style bundle
+ *  carries ({@link registerContributedMaterial}). */
+export type EditorMaterialId = string;
+
+export interface EditorMaterialChoice {
+  readonly id: EditorMaterialId;
+  readonly title: string;
+  readonly description: string;
+}
+
+/**
+ * An OPAQUE material a package's style bundle carries (`@volter/editor-sdk/looks`
+ * `MaterialContribution`): Classic's physics under its own shape and
+ * elevation. Glass is the editor's own and is not contributable.
+ */
+export interface ContributedMaterialDefinition extends EditorMaterialChoice {
+  readonly shape: EditorTheme['shape'];
+  readonly elevation: EditorTheme['elevation'];
+  readonly density?: EditorTheme['density'];
+}
+
+/** The only fields a color-theme document may contribute to composition. */
+export type EditorPalette = Pick<EditorTheme, 'id' | 'color' | 'typography'>;
+
+export const EDITOR_MATERIALS: readonly EditorMaterialChoice[] = Object.freeze([
+  {
+    id: 'classic',
+    title: 'Classic',
+    description: 'Opaque editor surfaces with conventional bars and panels.',
+  },
+  {
+    id: 'glass',
+    title: 'Glass',
+    description: 'Adaptive clear material with refraction, frost, and floating chrome.',
+  },
+]);
+
+const contributedMaterials = new Map<string, ContributedMaterialDefinition>();
+let cachedMaterials: readonly EditorMaterialChoice[] | null = null;
+const materialListeners = new Set<() => void>();
+
+/** Every material the switch surfaces offer — the editor's own, then the
+ *  contributed in registration order. Stable between registrations. */
+export function editorMaterials(): readonly EditorMaterialChoice[] {
+  cachedMaterials ??= [
+    ...EDITOR_MATERIALS,
+    ...[...contributedMaterials.values()].map(({ id, title, description }) => ({
+      id,
+      title,
+      description,
+    })),
+  ];
+  return cachedMaterials;
+}
+
+export function subscribeEditorMaterials(listener: () => void): () => void {
+  materialListeners.add(listener);
+  return () => materialListeners.delete(listener);
+}
+
+/** Register the material a style bundle carries. Returns the unregister. A
+ *  duplicate id throws — ids key the persisted appearance setting. */
+export function registerContributedMaterial(definition: ContributedMaterialDefinition): () => void {
+  if (isEditorMaterialId(definition.id))
+    throw new Error(
+      `registerContributedMaterial: material "${definition.id}" is already registered.`,
+    );
+  contributedMaterials.set(definition.id, definition);
+  cachedMaterials = null;
+  for (const listener of materialListeners) listener();
+  return () => {
+    if (contributedMaterials.get(definition.id) !== definition) return;
+    contributedMaterials.delete(definition.id);
+    cachedMaterials = null;
+    for (const listener of materialListeners) listener();
+  };
+}
+
+export function isEditorMaterialId(value: unknown): value is EditorMaterialId {
+  return (
+    typeof value === 'string' &&
+    (EDITOR_MATERIAL_IDS.includes(value as (typeof EDITOR_MATERIAL_IDS)[number]) ||
+      contributedMaterials.has(value))
+  );
+}
+
+/** Compose one palette source with the selected material. */
+export function composeEditorAppearance(
+  palette: EditorPalette,
+  materialId: EditorMaterialId,
+  reducedTransparency = false,
+): EditorTheme {
+  if (materialId !== 'glass') {
+    // Classic, or a contributed opaque material: Classic's physics under the
+    // material's own shape and elevation.
+    const material = contributedMaterials.get(materialId);
+    return {
+      id: material ? `${palette.id}--${material.id}` : palette.id,
+      color: palette.color,
+      typography: palette.typography,
+      shape: material?.shape ?? CLASSIC_MATERIAL.shape,
+      elevation: material?.elevation ?? CLASSIC_MATERIAL.elevation,
+      ...(material?.density ? { density: material.density } : {}),
+      appearance: { material: 'classic', transparency: 'standard' },
+    };
+  }
+
+  const resolvedId = `${palette.id}--${reducedTransparency ? 'glass-reduced' : 'glass'}`;
+
+  return {
+    id: resolvedId,
+    color: {
+      // Material owns the physical surface; palette owns every semantic hue.
+      surface: reducedTransparency
+        ? GLASS_MATERIAL.reducedTransparency.surface
+        : GLASS_MATERIAL.color.surface,
+      boundary: GLASS_MATERIAL.color.boundary,
+      content: palette.color.content,
+      accent: palette.color.accent,
+      semantic: palette.color.semantic,
+      neutralOverlay: GLASS_MATERIAL.color.neutralOverlay,
+      scrim: reducedTransparency
+        ? GLASS_MATERIAL.reducedTransparency.scrim
+        : GLASS_MATERIAL.color.scrim,
+    },
+    typography: palette.typography,
+    shape: GLASS_MATERIAL.shape,
+    elevation: GLASS_MATERIAL.elevation,
+    appearance: {
+      material: 'glass',
+      transparency: reducedTransparency ? 'reduced' : 'standard',
+    },
+    ...(reducedTransparency ? {} : { treatment: GLASS_MATERIAL.treatment }),
+  };
+}

package/src/widgets/editor-material.ts

@@ -0,0 +1,83 @@
+import type { EditorTheme } from './theme';
+
+type MaterialColor = Pick<
+  EditorTheme['color'],
+  'surface' | 'boundary' | 'neutralOverlay' | 'scrim'
+>;
+
+export interface EditorMaterialDefinition {
+  readonly id: 'glass';
+  readonly color: MaterialColor;
+  readonly shape: EditorTheme['shape'];
+  readonly elevation: EditorTheme['elevation'];
+  readonly treatment: NonNullable<EditorTheme['treatment']>;
+  readonly reducedTransparency: {
+    readonly surface: EditorTheme['color']['surface'];
+    readonly scrim: string;
+  };
+}
+
+export const CLASSIC_MATERIAL = Object.freeze({
+  id: 'classic' as const,
+  shape: { small: '3px', medium: '6px', large: '8px', full: '9999px' },
+  elevation: {
+    small: '0 2px 8px rgba(0,0,0,0.6)',
+    medium: '0 4px 12px rgba(0,0,0,0.5)',
+    large: '0 8px 32px rgba(0,0,0,0.6)',
+  },
+});
+
+/** Canonical Glass material. It cannot contain accent or semantic colors. */
+export const GLASS_MATERIAL: EditorMaterialDefinition = Object.freeze({
+  id: 'glass',
+  color: {
+    surface: {
+      shell: '#12161f',
+      panel: 'rgba(255,255,255,0.06)',
+      chrome: 'rgba(255,255,255,0.10)',
+      raised: 'rgba(255,255,255,0.16)',
+      inset: 'rgba(10,14,22,0.38)',
+      overlay: 'rgba(255,255,255,0.08)',
+    },
+    boundary: {
+      default: 'rgba(255,255,255,0.22)',
+      strong: 'rgba(255,255,255,0.38)',
+    },
+    neutralOverlay: {
+      hover: 'color-mix(in srgb, currentColor 10%, transparent)',
+      active: 'color-mix(in srgb, currentColor 16%, transparent)',
+    },
+    scrim: 'rgba(8,12,20,0.35)',
+  },
+  shape: { small: '4px', medium: '8px', large: '14px', full: '9999px' },
+  elevation: {
+    small: '0 4px 14px -6px rgba(0,0,0,0.45)',
+    medium: '0 8px 24px -10px rgba(0,0,0,0.5)',
+    large: '0 20px 46px -16px rgba(0,0,0,0.55), 0 4px 14px -6px rgba(0,0,0,0.35)',
+  },
+  treatment: {
+    backdropBlurPx: 1,
+    backdropSaturation: 1.15,
+    edgeSpecular: 0.7,
+    specularAngleDeg: 120,
+    refractionBezelPx: 56,
+    refractionThickness: 1.25,
+    textShadowOpacity: 0.72,
+    contentFrostBlurPx: 24,
+    ambientLiftOpacity: 0.07,
+    adaptiveContent: true,
+    brightTextShadowOpacity: 0,
+    brightFrostBg: 'rgba(255,255,255,0.3)',
+  },
+  reducedTransparency: {
+    surface: {
+      shell: '#12161f',
+      panel: '#33373e',
+      chrome: '#3d4047',
+      raised: '#4b4e55',
+      inset: '#23272f',
+      overlay: '#383b43',
+    },
+    scrim: 'rgba(8,12,20,0.5)',
+  },
+});

package/src/widgets/icon-set-registry.ts

@@ -0,0 +1,105 @@
+/**
+ * THE ICON SET AXIS — the fourth appearance axis beside palette, material and
+ * composition. Every glyph the editor draws renders through `EditorIcon`
+ * (`primitives/EditorIcon.tsx`, the one consumer of Font Awesome),
+ * so a style bundle can carry a whole icon set as DATA keyed by the Font
+ * Awesome icon name each site names (`plus`, `xmark`, `trash`, …): a glyph
+ * present in the active set paints instead of the editor's own; a glyph
+ * absent falls through, so a set may be partial while it is drawn.
+ *
+ * This module is REGISTRY AND ACTIVE STATE ONLY — no settings, because the
+ * icon primitive sits in every core closure and must stay a leaf. The stored
+ * preference (`appearance.icons`) is read and written by `theme-preference.ts`,
+ * which applies it here, exactly as it owns the palette and material choices.
+ * Registered by `workspace-style.ts` with the bundle that carries it.
+ */
+import type { IconCategoryTone, IconSetContribution } from '../looks';
+
+export type { IconCategoryTone };
+
+export interface EditorIconGlyph {
+  /** Defaults to a 16-unit square. */
+  readonly viewBox?: string;
+  /** One `path` `d`, painted with `currentColor`. */
+  readonly path: string;
+  /** THE COLOUR CHANNEL — the glyph's own category (`IconCategoryTone`),
+   *  painted `var(--vgai-category-<tone>, currentColor)`. With `tonedPath`
+   *  it tints only that second path; alone it tints the whole glyph. An
+   *  explicit `tone` prop at the site wins over both. */
+  readonly tone?: IconCategoryTone;
+  /** A second `path` `d` drawn OVER `path` and carrying `tone`: the operated
+   *  element of an operator mark, where the cube itself stays neutral. */
+  readonly tonedPath?: string;
+}
+export type EditorIconSet = IconSetContribution;
+export interface EditorIconSetChoice {
+  readonly id: string;
+  readonly title: string;
+}
+
+export const DEFAULT_ICON_SET_ID = 'default';
+const DEFAULT_CHOICE: EditorIconSetChoice = { id: DEFAULT_ICON_SET_ID, title: 'Editor' };
+
+const contributedSets = new Map<string, EditorIconSet>();
+let cachedChoices: readonly EditorIconSetChoice[] | null = null;
+let activeId: string = DEFAULT_ICON_SET_ID;
+const listeners = new Set<() => void>();
+
+function emit(): void {
+  for (const listener of listeners) listener();
+}
+
+/** Every set the switch surfaces offer — the editor's own, then the contributed. */
+export function editorIconSets(): readonly EditorIconSetChoice[] {
+  cachedChoices ??= [
+    DEFAULT_CHOICE,
+    ...[...contributedSets.values()].map(({ id, title }) => ({ id, title })),
+  ];
+  return cachedChoices;
+}
+
+export function isEditorIconSetId(value: unknown): value is string {
+  return typeof value === 'string' && (value === DEFAULT_ICON_SET_ID || contributedSets.has(value));
+}
+
+/** Register the set a style bundle carries. Returns the unregister. A
+ *  duplicate id throws — ids key the persisted appearance setting. */
+export function registerContributedIconSet(set: EditorIconSet): () => void {
+  if (isEditorIconSetId(set.id))
+    throw new Error(`registerContributedIconSet: icon set "${set.id}" is already registered.`);
+  contributedSets.set(set.id, set);
+  cachedChoices = null;
+  emit();
+  return () => {
+    if (contributedSets.get(set.id) !== set) return;
+    contributedSets.delete(set.id);
+    cachedChoices = null;
+    emit();
+  };
+}
+
+/** The set painting now. */
+export function activeIconSetSnapshot(): string {
+  return activeId;
+}
+
+/** Applied by `theme-preference.ts` from the stored choice; an unregistered
+ *  id paints the editor's own until its package registers. */
+export function setActiveIconSet(id: string): void {
+  const next = isEditorIconSetId(id) ? id : DEFAULT_ICON_SET_ID;
+  if (next === activeId) return;
+  activeId = next;
+  emit();
+}
+
+/** Fires when the registry or the active set changes. */
+export function subscribeIconSets(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+/** The active set's glyph for a Font Awesome icon name, or `null` to paint the editor's own. */
+export function activeIconGlyph(iconName: string): EditorIconGlyph | null {
+  if (activeId === DEFAULT_ICON_SET_ID) return null;
+  return contributedSets.get(activeId)?.glyphs[iconName] ?? null;
+}

package/src/widgets/index.ts

@@ -0,0 +1,71 @@
+/**
+ * `@volter/editor-sdk/widgets` — THE WIDGET KIT, the API's fourth face beside
+ * `protocol`, the host doors + `layouts`, and `session`
+ * (ARCHITECTURE-CORE §The target shape, rule 5: "One API, four faces,
+ * Apache"). These are the editor's OWN widgets — the exact components its
+ * inspector renders — so a panel built from them looks native and re-skins
+ * with the editor. Apache-2.0 like the rest of the SDK: a package or a
+ * project may draw a panel without taking the host's AGPL.
+ *
+ * Import it from a package contribution or a project's own
+ * `src/contributions/my-tool.document.tsx`:
+ *
+ * ```tsx
+ * import { Inline, NumberInput, SectionHeader, themeVars } from '@volter/editor-sdk/widgets';
+ * ```
+ *
+ * What's here:
+ * - **Tokens**: typed semantic `themeVars`; legacy `THEME`/font aliases remain
+ *   compatibility exports for existing inspector widgets only.
+ * - **Structure**: layout, typography, surfaces, dialogs, toolbars, tabs,
+ *   trees, fields, feedback, and menus.
+ * - **Inputs**: `NumberInput` (scrub-or-type), `Vec3Input`, `ColorInput`,
+ *   `DraftTextInput`, `ScrubbableInput`, `ColorPicker`/`ColorSwatch`,
+ *   `GradientEditor`, `FontPicker`, `AlignmentGrid`, `BorderEditor`,
+ *   `ShadowEditor`, `FilterEditor`, `CurveEditor`, `AssetSlotPicker`,
+ *   `ToggleButton`.
+ * - **Appearance**: the theme table, the editor materials, the icon-set
+ *   registry, the glyph table and the stacking scale — the values the
+ *   components above paint with. `design-system.ts` re-exports the members
+ *   its own surfaces use; this face is the UNION, which is why each of those
+ *   modules also has its own line below. Where a name arrives by two stars
+ *   both resolve to the SAME declaration, so nothing is ambiguous.
+ *
+ * Contract notes:
+ * - The rich widgets share one change contract, `ChangeHandlers<T>`
+ *   (`value` + `onChange` per interaction tick + optional `onChangeEnd`
+ *   commit — see its doc comment).
+ * - Layout and state chrome are API so built-in and project-authored tools
+ *   cannot drift into parallel UI kits. Domain charts remain project-owned.
+ * - ONE SUBPATH: there is no `./design-system` and no `./theme` door, and the
+ *   deep paths the host used to take (`./editor-material`,
+ *   `./icon-set-registry`, `./interactive-edit-scope`, `./z-index`,
+ *   `components/primitives/editor-icons`) all arrive through this module.
+ *   The kit's dependency closure is deliberately shallow — react, react-dom,
+ *   Font Awesome, and the SDK's own `looks` types — so a scaffolded
+ *   project's `tsc` never drags the editor's internals along, and the
+ *   Apache face never reaches AGPL host source (`interactive-edit-scope.ts`
+ *   exists precisely to keep `NumberInput`/`ColorInput` off `EditorContext`).
+ *   Don't add re-exports here that import the editor store, adapters, or
+ *   server code.
+ * - The CLASSES these components paint with (`vgai-btn`, `vgai-input`,
+ *   `vgai-menu`, …) are declared by the host's own `theme.css`, which stays
+ *   in `packages/editor/src` because it is the editor's chrome sheet — the
+ *   TOKENS those rules read are installed at runtime from `theme.ts` here
+ *   (`editorThemeVariables`).
+ *
+ * The export lines are ONE alphabetical block because Biome's
+ * `organizeImports` sorts them; each line's subject is named above rather
+ * than beside it, so a re-sort cannot separate a comment from its target.
+ */
+
+export * from './design-system';
+export * from './editor-appearance';
+export * from './editor-material';
+export * from './icon-set-registry';
+export * from './inspector-widgets';
+export * from './interactive-edit-scope';
+export * from './primitives/DraftTextInput';
+export * from './primitives/editor-icons';
+export * from './theme';
+export * from './z-index';