@volter/editor-blender 0.1.0 → 0.1.2

package/contributions/blender-header-menus.tsx

@@ -452,13 +452,10 @@ export function BlenderObjectModeHeader({
           disabled={selected.length === 0}
           title={nothingSelected}
           onSelect={run('Duplicate Objects', async (outliner) => {
-            // One at a time, for the reason `duplicateSelection` awaits its own
-            // loop: each call runs a bpy script and the next must start from
-            // what the last produced.
-            for (const name of [...outliner.selectedObjectNames()]) {
-              const id = outliner.rowIdForObject(name);
-              if (id !== null) await outliner.structure.duplicate(id).ack;
-            }
+            const ids = outliner.selectedObjectNames()
+              .map(name => outliner.rowIdForObject(name))
+              .filter((id): id is string => id !== null);
+            return outliner.structure.duplicateMany?.(ids);
           })}
         >
           Duplicate Objects

package/contributions/blender-outliner-authoring.ts

@@ -75,7 +75,7 @@ import type {
   WriteAck,
 } from '@volter/editor-project/adapter';
 import type * as THREE from 'three';
-import { blenderExecute, blenderRnaSet } from '../host/blender-runtime-host';
+import { blenderExecute, blenderRnaSet, beginBlenderGesture, endBlenderGesture } from '../host/blender-runtime-host';
 import {
   blenderEngineSelection,
   blenderOutlinerState,
@@ -858,6 +858,7 @@ function py(name: string): string {
  */
 async function runBlenderOperator(
   body: string,
+  label = 'Blender Python',
 ): Promise<{ readonly made: readonly string[]; readonly error: string | null }> {
   const code = [
     'before = {o.name for o in bpy.data.objects}',
@@ -865,7 +866,7 @@ async function runBlenderOperator(
     'made = [o.name for o in bpy.data.objects if o.name not in before]',
     'print("\\n".join(made))',
   ].join('\n');
-  const answer = await blenderExecute(code);
+  const answer = await blenderExecute(code, true, label);
   // THE ENGINE'S REFUSAL, VERBATIM. `session.py::execute` answers with the
   // traceback in `error` rather than raising, and a paraphrase here is how a
   // refusal becomes a shrug.
@@ -919,7 +920,7 @@ async function writeBlenderSelection(
       ? '_vl.objects.active = None'
       : `_vl.objects.active = bpy.data.objects.get(${py(active)})`,
   ].join('\n');
-  const answer = await blenderExecute(body);
+  const answer = await blenderExecute(body, false);
   // THE ENGINE'S REFUSAL, VERBATIM — never a shrug. A selection that did not
   // land is the difference between the Properties rail showing this object and
   // showing the last one, so it is said out loud on the editor's console.
@@ -1004,6 +1005,9 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
   let lastEngineKey: string | null = null;
   /** The world matrix each live gesture started from — see `beginEdit`. */
   const gestureStart = new Map<THREE.Object3D, THREE.Matrix4>();
+  // Retain the subject until endEdit, even if a concurrent native edit removes
+  // it from the presented frame. The history group must still be closed.
+  const gestureObjects = new Map<string, THREE.Object3D>();
 
   const notify = (): void => {
     for (const listener of [...listeners]) listener();
@@ -1386,7 +1390,11 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
      *  one gesture in both id spaces (see the header). */
     beginEdit: (id) => {
       const object = objectFor(id);
-      if (object !== null) gestureStart.set(object, object.matrixWorld.clone());
+      if (object !== null && !gestureStart.has(object)) {
+        gestureStart.set(object, object.matrixWorld.clone());
+        gestureObjects.set(id, object);
+        beginBlenderGesture();
+      }
     },
     apply: (id, transform) => {
       const object = objectFor(id);
@@ -1404,29 +1412,35 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
       object.updateMatrixWorld(true);
     },
     endEdit: async (id): Promise<WriteAck | undefined> => {
-      const object = objectFor(id);
+      const object = gestureObjects.get(id) ?? objectFor(id);
+      gestureObjects.delete(id);
       const view = blenderPresentedView();
-      if (object === null || view === null) return undefined;
+      if (object === null) return undefined;
       const started = gestureStart.get(object);
       gestureStart.delete(object);
-      object.updateWorldMatrix(true, false);
-      if (started?.equals(object.matrixWorld) === true) return undefined;
-      const name = view.blenderObjectName(object);
-      if (name === null) return undefined;
-      // The engine's own address, quoted the way `_rna_resolve` parses it.
-      const path = `bpy.data.objects[${JSON.stringify(name)}]`;
       try {
-        await blenderRnaSet(path, 'matrix_world', blenderWorldMatrixRows(object, view.root));
-        return {
-          destination: `Blender — ${path}.matrix_world; the session saves the .blend`,
-          persisted: true,
-        };
-      } catch (error) {
-        // The engine's refusal, verbatim — never paraphrased and never acked.
-        return {
-          destination: error instanceof Error ? error.message : String(error),
-          persisted: false,
-        };
+        if (view === null) return undefined;
+        object.updateWorldMatrix(true, false);
+        if (started?.equals(object.matrixWorld) === true) return undefined;
+        const name = view.blenderObjectName(object);
+        if (name === null) return undefined;
+        // The engine's own address, quoted the way `_rna_resolve` parses it.
+        const path = `bpy.data.objects[${JSON.stringify(name)}]`;
+        try {
+          await blenderRnaSet(path, 'matrix_world', blenderWorldMatrixRows(object, view.root));
+          return {
+            destination: `Blender — ${path}.matrix_world; the session saves the .blend`,
+            persisted: true,
+          };
+        } catch (error) {
+          // The engine's refusal, verbatim — never paraphrased and never acked.
+          return {
+            destination: error instanceof Error ? error.message : String(error),
+            persisted: false,
+          };
+        }
+      } finally {
+        if (started) await endBlenderGesture();
       }
     },
   };
@@ -1484,11 +1498,9 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
    * writing the engine's selection first — a write the document would then
    * save.
    *
-   * THERE IS NO UNDO, and that is recorded rather than silently absent: the
-   * engine runs `--background` with no undo stack, and this editor's history
-   * has no door a contributed package can push an element through (WORK.md
-   * §THE BLENDER RELEASE, B5's OPEN (a)). Every verb here is as un-undoable as
-   * the gizmo drag beside it.
+   * The script door checkpoints Blender's native undo stack and records its
+   * callback in Code-OSS. These operators are undone by restoring Blender's
+   * state, never by constructing an inverse operator or replaying the script.
    */
   const structure: StructureProvider = {
     /**
@@ -1572,9 +1584,10 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
       const body = [
         `targets = ${targets}`,
         'with bpy.context.temp_override(selected_objects=targets, active_object=targets[0]):',
-        '    bpy.ops.object.delete(use_global=False)',
+        '    result = bpy.ops.object.delete(use_global=False)',
+        'if "FINISHED" not in result: raise RuntimeError("Blender cancelled deleting the selected objects")',
       ].join('\n');
-      const { error } = await runBlenderOperator(body);
+      const { error } = await runBlenderOperator(body, 'Delete Objects');
       if (error !== null) return refuse(error);
       // The deleted rows are gone; re-read with NO selection so nothing points
       // at a name `bpy.data.objects` no longer has.
@@ -1608,12 +1621,13 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
       const body = [
         `source = bpy.data.objects[${py(name)}]`,
         'with bpy.context.temp_override(selected_objects=[source], active_object=source):',
-        '    bpy.ops.object.duplicate(linked=False)',
+        '    result = bpy.ops.object.duplicate(linked=False)',
+        'if "FINISHED" not in result: raise RuntimeError("Blender cancelled duplicating the selected object")',
       ].join('\n');
       return {
         id,
         ack: (async (): Promise<WriteAck> => {
-          const { made, error } = await runBlenderOperator(body);
+          const { made, error } = await runBlenderOperator(body, 'Duplicate Object');
           if (error !== null) return refuse(error);
           await selectAfterOperator(made);
           return {
@@ -1623,6 +1637,24 @@ export const createBlenderOutlinerAuthoring: ToolObject3DDocumentAuthoringFactor
         })(),
       };
     },
+    duplicateMany: async (ids): Promise<WriteAck> => {
+      const names = [...new Set(ids.map(objectNameFor))];
+      if (names.length === 0 || names.some(name => name === null))
+        return refuse('Select objects to duplicate; collections and data rows cannot be duplicated here.');
+      const body = [
+        `sources = [bpy.data.objects[name] for name in ${JSON.stringify(names)}]`,
+        'with bpy.context.temp_override(selected_objects=sources, active_object=sources[0]):',
+        '    result = bpy.ops.object.duplicate(linked=False)',
+        'if "FINISHED" not in result: raise RuntimeError("Blender cancelled duplicating the selected objects")',
+      ].join('\n');
+      const { made, error } = await runBlenderOperator(body, 'Duplicate Objects');
+      if (error !== null) return refuse(error);
+      await selectAfterOperator(made);
+      return {
+        destination: 'Blender — duplicate selected objects as one native operation; the session saves the .blend',
+        persisted: true,
+      };
+    },
     /** REFUSED BY NAME. Parenting in Blender is `object.parent_set`, and it is
      *  a gesture of its own with a type to choose (Object, Object Keep
      *  Transform, Armature Deform, …) and a `matrix_parent_inverse` to settle.

package/contributions/blender-runtime-skin.ts

@@ -521,7 +521,8 @@ export class BlenderSkinDirector {
     this.#engineCalls++;
     // `rna_set` refuses `bpy.context.scene` — the scene must be addressed by
     // name through `bpy.data.scenes[...]`.
-    await blenderRnaSet(`bpy.data.scenes[${JSON.stringify(scene)}]`, 'frame_current', frame);
+    // Timeline navigation, like selection, must not erase an available redo.
+    await blenderRnaSet(`bpy.data.scenes[${JSON.stringify(scene)}]`, 'frame_current', frame, undefined, false);
     this.#clip = { ...clip, frameCurrent: frame };
     this.#publish();
     return frame;

package/contributions/blender.command.ts

@@ -52,7 +52,8 @@ const verb = (derivedRefresh: CommandDerivedRefresh, timeoutMs?: number): Comman
 
 export const commands: CommandContribution['commands'] = {
   'blender-start': verb('none', 120_000),
-  'blender-stop': verb('none'),
+  // Stop drains accepted modeling work and persists it before teardown.
+  'blender-stop': verb('none', 30 * 60_000),
   'blender-execute': verb('always', 30 * 60_000),
   'blender-scene-info': verb('none', 60_000),
   'blender-object-info': verb('none', 60_000),

package/host/blender-runtime-host.ts

@@ -338,9 +338,10 @@ export async function blenderRnaSet(
   property: string,
   value: unknown,
   index?: number,
+  history = true,
 ): Promise<BlenderRnaWrite | null> {
   if (!blenderSessionStarted()) return null;
-  const written = await blenderRuntime().rnaSet(path, property, value, index);
+  const written = await blenderRuntime().rnaSet(path, property, value, index, history);
   noteBlenderRnaChanged();
   return written;
 }
@@ -391,8 +392,8 @@ export async function blenderRnaSet(
  * two prefixes and records the same lesson from its own bug; this is the
  * second time, so the parse lives at the door now and both read it.
  */
-export async function blenderExecute(code: string): Promise<BlenderExecuteAnswer> {
-  const text = await blenderRuntime().execute(code);
+export async function blenderExecute(code: string, history = true, label = 'Blender Python'): Promise<BlenderExecuteAnswer> {
+  const text = await blenderRuntime().execute(code, history, label);
   noteBlenderRnaChanged();
   const failed = /^Error executing code:/.exec(text);
   return {
@@ -403,6 +404,16 @@ export async function blenderExecute(code: string): Promise<BlenderExecuteAnswer
   };
 }
 
+/** Coalesce a human gesture; Blender retains the states, Code-OSS the ordering. */
+export function beginBlenderGesture(): void {
+  void blenderRuntime().historyGesture('history-begin').catch(error =>
+    editorHost().console.error(`Could not begin Blender undo gesture: ${String(error)}`, 'blender-history'));
+}
+
+export async function endBlenderGesture(): Promise<void> {
+  await blenderRuntime().historyGesture('history-end');
+}
+
 /** One script's answer, with the MCP door's text split from what it means.
  *  `text` is what the wire and an MCP client get, verbatim; the other three are
  *  what a UI caller needs, and the `error` half is the one it must not drop. */
@@ -626,6 +637,12 @@ interface RuntimeView {
 }
 
 let runtime: BlenderRuntime | null = null;
+const historyResources = new Set<string>();
+
+function invalidateBlenderHistory(): void {
+  if (historyResources.size) editorHost().history.invalidate([...historyResources]);
+  historyResources.clear();
+}
 let captureLifetime: AbortController | null = null;
 /** Whether this module has asked the host to tell it when the session ends.
  *  Once per page, taken on the first runtime — before one there is nothing to
@@ -633,6 +650,7 @@ let captureLifetime: AbortController | null = null;
 let watchingSessionEnd = false;
 
 function terminateBlenderRuntime(): void {
+  invalidateBlenderHistory();
   captureLifetime?.abort();
   captureLifetime = null;
   runtime?.terminate();
@@ -652,6 +670,10 @@ function terminateBlenderRuntime(): void {
 function watchSessionEnd(): void {
   if (watchingSessionEnd) return;
   watchingSessionEnd = true;
+  editorHost().session.onBeforeClose(async () => {
+    await runtime?.stop();
+    terminateBlenderRuntime();
+  });
   editorHost().session.onEnded(terminateBlenderRuntime);
 }
 let lastCapture: CaptureRequest | null = null;
@@ -684,6 +706,29 @@ export function blenderRuntime(): BlenderRuntime {
   captureLifetime = lifetime;
   let photographing = false;
   runtime = new BlenderRuntime({
+    history: (entries) => {
+      const owner = runtime;
+      if (!owner) throw new Error('Blender history arrived before its runtime');
+      for (const entry of entries) {
+        if ('reset' in entry) {
+          invalidateBlenderHistory();
+          continue;
+        }
+        if (!entry.resource) throw new Error('A Blender edit has no document resource');
+        historyResources.add(entry.resource);
+        const restore = async (direction: 'undo' | 'redo'): Promise<boolean> => {
+          if (runtime !== owner) throw new Error('This Blender history belongs to a closed worker');
+          const moved = await owner.historyStep(entry.id, direction);
+          noteBlenderRnaChanged();
+          return moved;
+        };
+        editorHost().history.record({
+          id: entry.id, label: entry.label, resources: [entry.resource],
+          document: presentationDocumentId(),
+          undo: () => restore('undo'), redo: () => restore('redo'),
+        });
+      }
+    },
     present: async (frame, description, capture) => {
       const documentId = presentationDocumentId();
       const view = await runtimeView();
@@ -941,13 +986,13 @@ const string = (cmd: Record<string, unknown>, key: string): string => {
  * path is outside the project, because a record is better absent than wrong.
  */
 async function sessionDocumentPath(session: {
-  execute(code: string): Promise<string>;
+  execute(code: string, history?: boolean): Promise<string>;
 }): Promise<{ document?: string }> {
   const project = editorHost().projectLocalState.projectRootPath();
   if (project === null) return {};
   let answer: string;
   try {
-    answer = await session.execute('import bpy\nprint(bpy.data.filepath)\n');
+    answer = await session.execute('import bpy\nprint(bpy.data.filepath)\n', false);
   } catch {
     return {};
   }
@@ -1001,6 +1046,8 @@ export async function handleBlenderCommand(cmd: {
   try {
     const project = cmd.type === 'blender-start' ? string(cmd, 'project') : null;
     if (cmd.type === 'blender-stop' || (cmd.type === 'blender-start' && cmd['fresh'] === true)) {
+      // Do not invalidate history or discard the worker if persistence fails.
+      await runtime?.stop();
       terminateBlenderRuntime();
       if (cmd.type === 'blender-stop') return { ok: true, data: { stopped: true } };
     }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/editor-blender",
   "author": "Volter AI, Inc.",
   "license": "AGPL-3.0-only AND GPL-3.0-or-later",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "publishConfig": {
     "access": "public"
   },
@@ -61,8 +61,8 @@
     ]
   },
   "dependencies": {
-    "@volter/blender-engine": "0.1.0",
-    "@volter/editor-threejs": "0.5.57",
+    "@volter/blender-engine": "0.1.2",
+    "@volter/editor-threejs": "0.5.59",
     "zod": "^4.3.6"
   },
   "peerDependencies": {