@volter/editor-blender 0.1.129 → 0.1.131

package/contributions/blender-header-menus.tsx

@@ -37,6 +37,13 @@
  * `StructureProvider` for Add / Duplicate / Delete, and
  * `runBlenderObjectOperator` for Apply / Clear / Set Origin. Nothing here
  * reimplements a transform apply or an origin move.
+ *
+ * NO GAME CONTROLS (owner, 2026-10-06: "it's very confusing that the timeline at the bottom has
+ * a play button AND there's a play button at the top"). The header carries no Play of its own,
+ * nor View's Play row: in Game mode the one Play is the Game panel's (`blender-game-panel.tsx`),
+ * in Movie mode the one transport is the Timeline's. The Game / Movie switch that chooses
+ * between them is the bottom area's, at the leading edge of its header row (`PlayModeSwitch`),
+ * because switching modes swaps that area and nothing here.
  */
 
 import type { ToolNotice } from '@volter/editor-sdk/contributions';
@@ -60,7 +67,6 @@ import {
 } from './blender-outliner-authoring';
 import { blenderOutlinerVersion, subscribeBlenderOutliner } from './blender-outliner-model';
 import { areaSplit, setAreaSplit, subscribeAreaSplit } from '../src/area-split';
-import { documentPlayExtension, subscribeDocumentPlayExtensions } from '@volter/editor-sdk/kit/document-play-extension';
 
 type MenuId = 'view' | 'select' | 'add' | 'object';
 
@@ -274,9 +280,6 @@ export function BlenderObjectModeHeader({
     () => (documentId === undefined ? false : areaSplit(documentId)),
     () => false,
   );
-  const playExtension = useSyncExternalStore(subscribeDocumentPlayExtensions, () => documentPlayExtension('model'), () => null);
-  const PlayControl = playExtension?.Control;
-  const PlayMenu = playExtension?.Menu;
   const handle = blenderOutlinerHandle(documentId);
   // NOTHING RATHER THAN A DEAD BAR: with no Outliner published for this
   // document there is no subject for any of these rows, and a menu of rows
@@ -385,7 +388,6 @@ export function BlenderObjectModeHeader({
             Close Area
           </MenuItem>
         </MenuSubmenu>
-        {PlayMenu && <><MenuSeparator /><PlayMenu documentId={documentId} onClose={() => setOpen(null)} /></>}
       </MenuWord>
       {/* SELECT — `VIEW3D_MT_select_object`, `space_view3d.py:1713-1715`. The
           three rows are `object.select_all` with action SELECT / DESELECT /
@@ -516,7 +518,6 @@ export function BlenderObjectModeHeader({
           Delete
         </MenuItem>
       </MenuWord>
-      {PlayControl && <PlayControl documentId={documentId} onClose={() => setOpen(null)} />}
     </EditorToolbar>
   );
 }

package/contributions/blender-model-opening.tsx

@@ -1,12 +1,12 @@
 import type { ModelDocumentPreview } from '../src/model-document-preview';
 import { modelOpeningErrorMessage } from '../src/model-opening-error';
-import { Button, StateSurface, fontSizeVar, spaceVar, themeVars } from '@volter/editor-sdk/widgets';
+import { Button, StateSurface, fontMono, fontSizeVar, spaceVar, themeVars } from '@volter/editor-sdk/widgets';
 import type { AuthoringAdapter, EditorNode } from '@volter/editor-project/adapter';
 import { AssetEditorSubject } from '@volter/editor-sdk/kit/components/AssetEditorShell';
 import { useMemo } from 'react';
 
 /** A loading/error surface has no authoring stage and publishes no model. */
-export function BlenderModelOpening({ documentId, path, error, preview, retry, returnToPreview, preparingView = false }: {
+export function BlenderModelOpening({ documentId, path, error, preview, retry, returnToPreview, preparingView = false, note = null }: {
   readonly documentId: string;
   readonly path: string;
   readonly error: string | null;
@@ -14,6 +14,8 @@ export function BlenderModelOpening({ documentId, path, error, preview, retry, r
   readonly retry: () => void;
   readonly returnToPreview: () => void;
   readonly preparingView?: boolean;
+  /** What a slow open is waiting on — progress beside the spinner, not an error. */
+  readonly note?: string | null;
 }) {
   const title = error ? 'Could not open model' : preparingView ? 'Preparing model view' : 'Opening model';
   // This document has not published an authoring stage yet. Its panels still
@@ -44,6 +46,14 @@ export function BlenderModelOpening({ documentId, path, error, preview, retry, r
           description={<>
             <div style={{ color: themeVars.content.primary, marginBottom: spaceVar[3] }}>{path}</div>
             {error ? modelOpeningErrorMessage(error) : preparingView ? 'The file is open. Preparing its viewport.' : preview ? 'The previous model stays visible while this file opens.' : 'Preparing Blender and opening this file. The model will appear here when it is ready.'}
+            {/* THE CAUSE, VERBATIM, where the person is looking: the sentence above is a
+                category, and "details are available in the console" sent people to a console
+                they could not see (2026-10-06 audit). Selectable, so it can be copied. */}
+            {!error && note && <div data-testid="blender-model-opening-note" style={{ marginTop: spaceVar[3], color: themeVars.content.muted, userSelect: 'text' }}>{note}</div>}
+            {error && <div data-testid="blender-model-opening-detail"
+              style={{ marginTop: spaceVar[3], fontFamily: fontMono, fontSize: fontSizeVar.sm, color: themeVars.content.muted, whiteSpace: 'pre-wrap', userSelect: 'text', textAlign: 'left' }}>
+              {error}
+            </div>}
           </>}
           action={error ? <div style={{ display: 'flex', flexWrap: 'wrap', justifyContent: 'center', gap: spaceVar[3] }}>
             {preview && <Button onClick={returnToPreview}>Return to previous model</Button>}

package/contributions/blender-node-editor.document.tsx

@@ -110,7 +110,7 @@ export const title = 'Shader Editor';
 // THE VIEW'S PRODUCT DOOR (WORK.md §The core is Code-OSS U8, ruling 1). This
 // view's verbs are published ONCE, here, where the view itself is contributed:
 // under the Code-OSS frame each becomes a `volter.blender-node-view.<verb>`
-// command the bridge dispatches into the view, and standalone `volter-model-editor edit` —
+// command the bridge dispatches into the view, and standalone `cyclotron edit` —
 // which has no command service — reaches the SAME table through the session's
 // `blender-node-view` verb. One table, two doors, which is why the remaining
 // read-only editors (UV Editing, Animation, Texture Paint) add no session verb

package/contributions/blender-outliner-authoring.ts

@@ -1010,9 +1010,9 @@ async function writeBlenderSelection(
     '_vl = bpy.context.view_layer',
     'for _o in _vl.objects:',
     '    _o.select_set(_o.name in _sel)',
-    active === null
-      ? '_vl.objects.active = None'
-      : `_vl.objects.active = bpy.data.objects.get(${py(active)})`,
+    // object_select.cc::base_deselect_all_ex changes BASE_SELECTED without
+    // clearing the active base. Properties continues to inspect that object.
+    ...(active === null ? [] : [`_vl.objects.active = bpy.data.objects.get(${py(active)})`]),
   ].join('\n');
   const answer = await blenderExecute(body, false);
   // THE ENGINE'S REFUSAL, VERBATIM — never a shrug. A selection that did not
@@ -1242,9 +1242,8 @@ export function blenderOutlinerAuthoringFor(
    * `EditorShellStore.selectedEntityId` — the subject the Properties rail and
    * the gizmo take — is the LAST member of the selected set, and Blender's
    * active object is the same idea under its own name. An active object that
-   * is not selected still lands in the list: it is the subject the Properties
-   * editor is showing, and a rail pointing at a row nobody can see is the
-   * disagreement this whole unit exists to end.
+   * is not selected stays outside this list: Properties reads the active
+   * object from the frame independently, without adding an outline or gizmo.
    */
   const syncFromEngine = (): void => {
     if (disposed || pendingSelection !== null) return;
@@ -1255,7 +1254,7 @@ export function blenderOutlinerAuthoringFor(
     if (key === lastEngineKey) return;
     lastEngineKey = key;
     const names = engine.selected.filter((name) => name !== engine.active);
-    if (engine.active !== null) names.push(engine.active);
+    if (engine.active !== null && engine.selected.includes(engine.active)) names.push(engine.active);
     const next = names.map(rowIdForName).filter((id): id is string => id !== null);
     if (next.length === selected.length && next.every((id, at) => id === selected[at])) return;
     selected = next;

package/contributions/blender-properties-context.ts

@@ -0,0 +1,45 @@
+/** Blender's Properties context remains inspectable without a selection.
+ * Reuse the same RNA sections and Properties projection as selected objects. */
+import { registerNullSubjectProvider } from '@volter/editor-sdk/kit/inspection/null-subject';
+import { blenderOutlinerState } from './blender-outliner-model';
+import { blenderOutlinerKind } from './blender-outliner-authoring';
+import {
+  blenderPropertiesState,
+  blenderRnaViewFor,
+  resolveBlenderSubject,
+  writeBlenderRnaProperty,
+} from './blender-properties-model';
+
+registerNullSubjectProvider({
+  match: ({ adapter }) => resolveBlenderSubject(null, adapter) !== null,
+  describe: ({ adapter }) => {
+    const subject = resolveBlenderSubject(null, adapter);
+    if (subject === null) return null;
+    const row = subject.kind === 'object'
+      ? [...blenderOutlinerState().byId.values()].find(
+          (entry) => entry.struct === 'Object' && entry.object === subject.name,
+        )
+      : undefined;
+    const scenePath = blenderPropertiesState().context?.scene;
+    const scene = scenePath ? blenderRnaViewFor(scenePath) : undefined;
+    const title = subject.kind === 'object'
+      ? subject.name
+      : (scene?.kind === 'struct' ? scene.name : null) ?? 'Scene';
+    return {
+      id: `blender-properties:${JSON.stringify(subject)}`,
+      title,
+      identity: {
+        kindLabel: subject.kind === 'object' ? 'Object' : 'Scene',
+        kind: blenderOutlinerKind(row?.icon ?? 'SCENE_DATA'),
+        rename: {
+          readOnly: subject.kind !== 'object',
+          set: async (name: string) => {
+            if (subject.kind === 'object' && name.length > 0)
+              await writeBlenderRnaProperty(`bpy.data.objects[${JSON.stringify(subject.name)}]`, 'name', name);
+          },
+        },
+      },
+      sections: [],
+    };
+  },
+});

package/contributions/blender-properties-model.ts

@@ -7,7 +7,7 @@
  * pulling React into its closure, and the sections read it through one
  * `useSyncExternalStore` (`blender-properties-view.tsx`).
  *
- * THE SUBJECT IS OUR SELECTION, RESOLVED BY IDENTITY. The person clicks a node
+ * THE SUBJECT IS THE PRESENTED BLENDER CONTEXT. The person clicks a node
  * in our viewport; the adapter hands that node's `THREE.Object3D`; the
  * presented view answers which Blender object that three object IS
  * (`BlenderRuntimeView.blenderObjectName`, a lookup by object identity in the
@@ -16,6 +16,8 @@
  * exactly as `buttons_context.cc` builds one around
  * `BKE_view_layer_active_object_get`. Reading our selection never WRITES the
  * engine's active object: that is a mutation, and the document would save it.
+ * With no selected node, the presented frame's active object remains the
+ * Properties subject; no active object resolves the scene instead.
  *
  * WHEN IT RE-READS. Three times, and each is a signal rather than a poll:
  *  - a PRESENT (`BlenderRuntimeView.subscribeFrames`) — every mutation
@@ -53,13 +55,15 @@ interface PresentedView {
   readonly root: THREE.Object3D;
   subscribeFrames(listener: () => void): () => void;
   blenderObjectName(object: THREE.Object3D): string | null;
+  blenderSelection(): { readonly active: string | null };
 }
 
 const isPresentedView = (value: unknown): value is PresentedView =>
   typeof value === 'object' &&
   value !== null &&
   typeof (value as PresentedView).subscribeFrames === 'function' &&
-  typeof (value as PresentedView).blenderObjectName === 'function';
+  typeof (value as PresentedView).blenderObjectName === 'function' &&
+  typeof (value as PresentedView).blenderSelection === 'function';
 
 /** The active authoring adapter, as much of it as this module reads. The
  *  adapter is deliberately `unknown` at the contribution point (adapter-native
@@ -109,9 +113,17 @@ export function resolveBlenderSubject(
   node: { readonly id: string } | null,
   adapter: unknown,
 ): BlenderSubject | null {
-  if (node === null || !isObject3DAuthoring(adapter)) return null;
+  if (!isObject3DAuthoring(adapter)) return null;
   const view = presentedView();
   if (view === null) return null;
+  if (node === null) {
+    // buttons_context_path_object follows the active object, independently of
+    // BASE_SELECTED. The frame carries both; no active object still leaves
+    // the scene's Properties tabs. Scope this to the presented Model document.
+    if (adapter.documentRootObject !== view.root) return null;
+    const active = view.blenderSelection().active;
+    return active === null ? { kind: 'scene' } : { kind: 'object', name: active };
+  }
   if (node.id === adapter.documentId)
     return adapter.documentRootObject === view.root ? { kind: 'scene' } : null;
   // A COLLECTION ROW HAS NO OBJECT, so it has to be resolved before the object

package/contributions/blender-properties-view.tsx

@@ -54,7 +54,8 @@ import type {
   BlenderRnaView,
 } from '@volter/blender-engine/browser/rna';
 import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
-import { ColorPicker, hexToRgb, parseAlpha, toHex } from '@volter/editor-sdk/widgets';
+import { faLock, faLockOpen } from '@fortawesome/free-solid-svg-icons';
+import { ColorPicker, EditorIcon, hexToRgb, parseAlpha, toHex } from '@volter/editor-sdk/widgets';
 import {
   type BlenderSubject,
   blenderPropertiesState,
@@ -135,6 +136,7 @@ function Panel({
   closed = false,
   note,
   count,
+  headerControl,
   children,
 }: {
   readonly title: string;
@@ -147,6 +149,7 @@ function Panel({
   /** A list panel's length, beside its title — Blender's `template_list`
    *  shows the rows and the count is what a collapsed panel can still say. */
   readonly count?: number;
+  readonly headerControl?: React.ReactNode;
   readonly children: React.ReactNode;
 }) {
   const [open, setOpen] = useState(!closed);
@@ -162,6 +165,7 @@ function Panel({
         overflow: 'hidden',
       }}
     >
+      <div style={{ position: 'relative' }}>
       <button
         type="button"
         onClick={() => setOpen(!open)}
@@ -196,13 +200,16 @@ function Panel({
         >
           {open ? '▼' : '▶'}
         </span>
-        <span style={{ fontWeight: 400 }} title={note}>
+        <span style={{ fontWeight: 400, marginLeft: headerControl ? CHECKBOX + TRIANGLE_GAP : 0 }} title={note}>
           {title}
         </span>
         {count === undefined ? null : (
           <span style={{ opacity: READONLY_ALPHA, marginLeft: 'auto' }}>{count}</span>
         )}
       </button>
+      {headerControl ? <div style={{position: 'absolute', left: PANEL_LABEL_X, top: 0,
+        height: PANEL_HEADER, display: 'flex', alignItems: 'center'}}>{headerControl}</div> : null}
+      </div>
       {open ? <div style={{ padding: PANEL_PAD }}>{children}</div> : null}
     </div>
   );
@@ -576,7 +583,10 @@ function ColourWidget({ row, write }: WidgetProps) {
  *  scalar into a three-element array, which is a refusal rather than the lock
  *  the person asked for. Each toggle here writes its own index (the door's
  *  `index` argument, `session.py::rna_set`'s `getattr(target, id)[index]`). */
-function ArrayRows({ row, label, title, write }: WidgetProps & { label: string; title: string }) {
+function ArrayRows({ row, path, label, title, write, locks }: WidgetProps & {
+  label: string; title: string;
+  locks?: readonly { row: BlenderRnaRow; index?: number }[] | undefined;
+}) {
   const values = (row.value as readonly (number | boolean)[] | null) ?? [];
   return (
     <>
@@ -603,12 +613,31 @@ function ArrayRows({ row, label, title, write }: WidgetProps & { label: string;
               onWrite={(next, at) => write(next, at)}
             />
           )}
+          <LockToggle path={path} lock={locks?.[index]} />
         </Row>
       ))}
     </>
   );
 }
 
+function lockValue(lock: { row: BlenderRnaRow; index?: number }): boolean {
+  return lock.index === undefined ? lock.row.value === true
+    : Array.isArray(lock.row.value) && lock.row.value[lock.index] === true;
+}
+
+function LockToggle({path, lock}: {path: string;
+  lock: {row: BlenderRnaRow; index?: number} | undefined}) {
+  if (lock === undefined) return null;
+  const value = lockValue(lock);
+  return <button type="button" aria-label={fieldName(lock.row, lock.index)} aria-pressed={value}
+    disabled={lock.row.readonly}
+    onClick={() => void writeBlenderRnaProperty(path, lock.row.identifier, !value, lock.index)}
+    style={{height: UNIT, width: UNIT, flexShrink: 0, padding: 0, background: 'transparent',
+      border: 'none', color: INK, cursor: 'pointer'}}>
+    <EditorIcon icon={value ? faLock : faLockOpen} size="sm" />
+  </button>;
+}
+
 function componentLabel(label: string, index: number, subtype: string): string {
   const letter = arrayItemChar(subtype, index);
   if (letter === undefined) return index === 0 ? label : `${label} ${index}`;
@@ -642,14 +671,18 @@ function PropertyRow({
   row,
   path,
   onOpen,
+  label: overrideLabel,
+  locks,
 }: {
   readonly row: BlenderRnaRow;
   readonly path: string;
   readonly onOpen: (path: string) => void;
+  readonly label?: string | undefined;
+  readonly locks?: readonly { row: BlenderRnaRow; index?: number }[] | undefined;
 }) {
   const write = (next: unknown, index?: number) =>
     void writeBlenderRnaProperty(path, row.identifier, next, index);
-  const label = row.name || row.identifier;
+  const label = overrideLabel ?? (row.name || row.identifier);
   const title = `${row.identifier} — ${row.type}${row.subtype === 'NONE' ? '' : `/${row.subtype}`}${
     row.readonly ? ' (read-only)' : ''
   }${row.description ? `\n${row.description}` : ''}`;
@@ -680,7 +713,7 @@ function PropertyRow({
           <ColourWidget {...props} />
         </Row>
       );
-    return <ArrayRows {...props} label={label} title={title} />;
+    return <ArrayRows {...props} label={label} title={title} locks={locks} />;
   }
   return (
     <Row label={label} title={title} readonly={row.readonly} identifier={row.identifier}>
@@ -794,7 +827,18 @@ function CollectionRow({
  * what this is for; the alternative — a nested block per struct — would put
  * the rows in an order Blender does not use.
  */
-export type BlenderCuratedProperty = string | { readonly from: string; readonly property: string };
+export type BlenderCuratedProperty = string | {
+  readonly from?: string;
+  readonly property: string;
+  /** Blender's layout.prop(text=...) label. */
+  readonly label?: string;
+  /** A draw branch over a live RNA value, e.g. Object.rotation_mode. */
+  readonly when?: Omit<BlenderPanelCondition, 'from'>;
+  /** Whole-array lock toggles drawn beside the vector, not as extra rows. */
+  readonly lock?: string;
+  /** Quaternion/axis-angle W has a separate scalar lock. */
+  readonly firstLock?: string;
+};
 
 const identifierOf = (entry: BlenderCuratedProperty): string =>
   typeof entry === 'string' ? entry : entry.property;
@@ -821,6 +865,8 @@ export interface BlenderCuratedPanel {
   readonly properties: readonly BlenderCuratedProperty[];
   /** Blender's `bl_options = {'DEFAULT_CLOSED'}`. */
   readonly closed?: boolean;
+  /** A draw_header checkbox, such as Scene.use_gravity. */
+  readonly headerProperty?: string;
   /** A `bl_parent_id` child panel. */
   readonly sub?: readonly BlenderCuratedPanel[];
   /**
@@ -1061,18 +1107,37 @@ function CuratedPanel({
   // EACH ENTRY IS READ FROM THE DATABLOCK BLENDER READS IT FROM: the panel's
   // own, or the one a qualified entry names ({@link BlenderCuratedProperty}).
   // Order is Blender's list, whichever struct a row comes from.
-  const found: { identifier: string; row: BlenderRnaRow; path: string }[] = [];
+  const found: { identifier: string; row: BlenderRnaRow; path: string;
+    label?: string; locks?: readonly { row: BlenderRnaRow; index?: number }[] }[] = [];
   const missing: string[] = [];
   for (const item of panel.properties) {
     const identifier = identifierOf(item);
-    const where = typeof item === 'string' ? entry : paths.find((path) => path.label === item.from);
+    const where = typeof item === 'string' || item.from === undefined
+      ? entry : paths.find((path) => path.label === item.from);
     const source = where === undefined ? undefined : blenderRnaViewFor(where.path);
+    const rows = source?.kind === 'struct' ? source.groups.flatMap((group) => group.rows) : [];
+    if (typeof item !== 'string' && item.when) {
+      const value = rows.find((row) => row.identifier === item.when?.property)?.value;
+      if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') continue;
+      if (item.when.is && !item.when.is.includes(value)) continue;
+      if (item.when.isNot?.includes(value)) continue;
+    }
     const row =
       source?.kind === 'struct'
         ? source.groups.flatMap((group) => group.rows).find((it) => it.identifier === identifier)
         : undefined;
     if (row === undefined || where === undefined) missing.push(identifier);
-    else found.push({ identifier, row, path: where.path });
+    else {
+      const lock = typeof item === 'string' ? undefined : rows.find((row) => row.identifier === item.lock);
+      const firstLock = typeof item === 'string' ? undefined : rows.find((row) => row.identifier === item.firstLock);
+      found.push({ identifier, row, path: where.path,
+        ...(typeof item === 'string' || item.label === undefined ? {} : { label: item.label }),
+        ...(lock === undefined ? {} : { locks: [
+          ...(firstLock === undefined ? [] : [{ row: firstLock }]),
+          ...Array.from({length: lock.arrayLength}, (_, index) => ({row: lock, index})),
+        ] }),
+      });
+    }
   }
   if (view === undefined)
     return (
@@ -1087,6 +1152,14 @@ function CuratedPanel({
     <Panel
       title={panel.title}
       closed={panel.closed === true}
+      headerControl={(() => {
+        const row = view.kind === 'struct' ? view.groups.flatMap(group => group.rows)
+          .find(row => row.identifier === panel.headerProperty) : undefined;
+        return row ? <span onClick={event => event.stopPropagation()}><Checkbox
+          value={row.value === true} readonly={row.readonly} label={row.name}
+          onChange={value => void writeBlenderRnaProperty(entry.path, row.identifier, value)}
+        /></span> : null;
+      })()}
       note={
         missing.length === 0
           ? `${entry.path}`
@@ -1094,7 +1167,8 @@ function CuratedPanel({
       }
     >
       {found.map((item) => (
-        <PropertyRow key={item.identifier} row={item.row} path={item.path} onOpen={onOpen} />
+        <PropertyRow key={item.identifier} row={item.row} path={item.path} onOpen={onOpen}
+          label={item.label} locks={item.locks} />
       ))}
       {/* KEYED BY POSITION, NOT BY TITLE: Blender ships two panels with the
           same `bl_label` under different engines and expects the poll to pick