@volter/blender-engine 0.1.139 → 0.1.141

package/browser/session.py

@@ -207,6 +207,7 @@ def _load_post(_arg):
     # The DOOR resets its own revision table on LOAD_POST (it holds ID pointers
     # into the Main that just went away); this is the session's half.
     SESSION.forget()
+    SESSION.loaded()
     # Factory reset reloads add-ons. Preserve native Cycles and re-register
     # only the headless GPU presenters we own.
     ENGINES[:], UNAVAILABLE_ENGINES[:] = _register_engine()
@@ -1589,6 +1590,13 @@ class Session:
         # The OUTSIDE-THE-PROJECT file Blender was last found holding, once said
         # (`follow_open_file`): the refusal is told once per file, not per call.
         self._outside_file = None
+        # BLENDER HOLDS ANOTHER FILE'S MODEL (`loaded`): a load that was not the session's own
+        # open of its document -- `read_homefile`, `read_factory_settings`, `open_mainfile` of
+        # some other file. Until Blender holds the document again, or a project file the session
+        # follows, the model in memory is not the document's and is never saved over it.
+        self._foreign = False
+        self._foreign_said = False
+        self._binding = False
         # WHAT THE PRESENTER LAST REPORTED HOLDING, as an instrument: the
         # `(session, revision)` it held BEFORE the last frame, None when it
         # held nothing, and the string "unreported" for a presenter that does
@@ -1725,6 +1733,16 @@ class Session:
                     "metallic": float(material.metallic),
                 }
         graph = depsgraph if depsgraph is not None else bpy.context.evaluated_depsgraph_get()
+        # ONE NAME, TWO OBJECTS: Blender tells a linked object from a local one (or from another
+        # file's) by its library as well as its name; the presenter knows them by name alone and
+        # refuses the frame. Say which object and which files, so the clash can be renamed.
+        names = [row["name"] for row in frame["objects"]]
+        if len(set(names)) != len(names):
+            for name in sorted({n for n in names if names.count(n) > 1}):
+                files = [o.library.filepath if o.library is not None else "this file"
+                         for o in bpy.data.objects if o.name == name]
+                warn("%r is the name of objects from %s; the editor needs one object per name, "
+                     "so rename one (in its own file when it is linked)" % (name, ", ".join(files)))
         frame["instances"] = _depsgraph_placements(frame, graph)
         frame["world"] = draw_world(scene)
         frame["cameras"] = {
@@ -1982,7 +2000,7 @@ class Session:
         `18-riverside-bridge`, `19-tram-stop` and `20-rigged-courier` each got
         ZERO calls, refused inside `blender-start` -- `bind_document` opened
         the document the previous model wrote, whose textures live OUTSIDE the
-        project (`/Volumes/PeakSSD/volter-work/blender-scene-battery/...`) and
+        project (another folder of the machine that wrote it) and
         are in no fresh worker's filesystem.
 
         THE PRESENTER'S REFUSAL IS RIGHT AND STAYS. It answers "the record says
@@ -2127,6 +2145,8 @@ class Session:
         """
         self.document_relative = relative_path
         self.document = os.path.join(self.project, relative_path)
+        self._foreign = False
+        self._foreign_said = False
         if not os.path.exists(self.document):
             return {"document": relative_path, "opened": False}
         _asked({"checkpoint": "document-open"})
@@ -2134,9 +2154,15 @@ class Session:
         checkpointed_read = hasattr(_blender_web, "set_read_checkpoint")
         if checkpointed_read:
             _blender_web.set_read_checkpoint(lambda: _asked({"checkpoint": "file-read"}))
+        self._binding = True
         try:
             bpy.ops.wm.open_mainfile(filepath=self.document)
+        except BaseException:
+            # The document was not read, so what Blender holds is not its model.
+            self._foreign = True
+            raise
         finally:
+            self._binding = False
             if checkpointed_read:
                 _blender_web.set_read_checkpoint(None)
         _mark("open:after")
@@ -2156,6 +2182,18 @@ class Session:
                 "objects": len(bpy.data.objects),
                 "size": size}
 
+    def loaded(self):
+        """A FILE WAS LOADED (`_load_post`). The session's own open of its document is the one
+        load that leaves the document's model in memory; any other replaces it with another
+        file's (`read_homefile` is Blender's File > New), and the session used to save that over
+        the document: a script that ran `read_homefile` on its own, meaning to Save As a new
+        piece next, emptied the open level on disk. MEASURED 2026-10-08 in the editor's Blender:
+        a document with four objects was saved with none."""
+        if self._binding:
+            return
+        self._foreign = True
+        self._foreign_said = False
+
     def mark_changed(self):
         """A request that can change the model ran: the next present carries
         `saveDue`, and the tab saves after an idle second."""
@@ -2190,11 +2228,14 @@ class Session:
         holds a file outside the project: the editor has no document there, so
         the session keeps its own and keeps saving to it.
         """
-        if self.document is None or not bpy.data.filepath:
+        if self.document is None:
             return None
+        if not bpy.data.filepath:
+            return self._not_saving("a new, untitled file")
         current = os.path.normpath(os.path.abspath(bpy.data.filepath))
         if current == os.path.normpath(self.document):
             self._outside_file = None
+            self._foreign = False
             return None
         root = os.path.normpath(self.project)
         relative = current[len(root) + 1:] if current.startswith(root + "/") else None
@@ -2205,15 +2246,30 @@ class Session:
             self.document = current
             self.document_relative = relative
             self._outside_file = None
+            self._foreign = False
             # The file Blender wrote sits only in the engine's filesystem until the
             # session's own save carries it to the project.
             self.save_due = True
             return {"moved": True, "from": previous, "document": relative}
+        if self._foreign:
+            return self._not_saving(current)
         if current == self._outside_file:
             return None
         self._outside_file = current
         return {"moved": False, "from": self.document_relative, "outside": current}
 
+    def _not_saving(self, holds):
+        """The answer, once per load, that the document is no longer being saved."""
+        if not self._foreign or self._foreign_said:
+            return None
+        self._foreign_said = True
+        return {"moved": False, "from": self.document_relative, "notSaving": True,
+                "note": "Blender now holds %s, not %s's model, so %s is no longer saved: "
+                        "save_as_mainfile(filepath=<project>/src/models/<name>.blend) makes this a "
+                        "document of its own, and opening %s again in the editor returns to it"
+                        % (holds, self.document_relative, self.document_relative,
+                           self.document_relative)}
+
     def save_document(self):
         """Write the document -- Blender's own format, by Blender's own operator.
 
@@ -2236,11 +2292,11 @@ class Session:
         `relative_remap` is described as remapping RELATIVE paths so they stay
         valid from a new location; on this build it also rewrites ABSOLUTE
         ones. MEASURED 2026-09-18 in the tab, four cells, one image loaded from
-        `/Volumes/PeakSSD/volter-work/wsh-outside/textures/wsh_abs.png`:
+        an absolute path outside the project, `/outside/wsh-outside/textures/wsh_abs.png`:
 
           relative_remap  use_relative_paths  img.filepath after the save
-          False           True                /Volumes/.../wsh_abs.png
-          False           False               /Volumes/.../wsh_abs.png
+          False           True                /outside/.../wsh_abs.png
+          False           False               /outside/.../wsh_abs.png
           True            False               //../../../wsh-outside/.../wsh_abs.png
           True            True                //../../../wsh-outside/.../wsh_abs.png
 
@@ -2287,10 +2343,29 @@ class Session:
         `BLENDER`). Blender reads either back, so nothing was broken; what was
         wrong is that the BYTES of a file the project commits depended on a
         per-machine preference. A document states its own format.
+
+        THE FORMAT IT STATES IS COMPRESSED (Zstandard, Blender's own). Measured
+        2026-10-08 on a character with a 43-clip library (1.3 million keys): the
+        uncompressed write was 101.9 MB, compressed 12.8 MB, and the save itself
+        took the same time (0.07-0.17 s against 0.10-0.14 s). A game scene with
+        that character was 120 MB uncompressed, past GitHub's 100 MB file limit,
+        and 17 MB compressed. Blender reads both.
+
+        THE SAVE'S CHUNKED TRANSPORT READS THE BYTES (`document-chunks.mts`): it
+        sends the server only the chunks it lacks, and that reuse was measured
+        on uncompressed files. Measured again with compression, same character,
+        one small edit per save after the first: uncompressed sent 4.19 MB (one
+        chunk) in about 1.4 s end to end; compressed sent 2.31 MB in about
+        0.26 s. Zstandard compresses in independent blocks, so an edit still
+        changes part of the file, not all of it.
         """
         self.save_due = False
         if self.document is None:
             return {"saved": False, "reason": "no-document"}
+        if self._foreign:
+            # Not the document's model (`loaded`): writing it would replace the file with another.
+            return {"saved": False, "reason": "not-the-document", "document": self.document_relative,
+                    "holds": bpy.data.filepath or "a new, untitled file"}
         # `bpy.data.is_dirty` IS NOT A PREDICATE HERE, and this is the measurement
         # rather than a preference. Before native undo initialization it stayed
         # False even after a script built fourteen objects; with explicit undo
@@ -2317,7 +2392,7 @@ class Session:
             except OSError:
                 pass
         bpy.ops.wm.save_as_mainfile(
-            filepath=self.document, compress=False, relative_remap=False, copy=True)
+            filepath=self.document, compress=True, relative_remap=False, copy=True)
         return {"saved": True, "path": self.document,
                 "document": self.document_relative,
                 "size": os.path.getsize(self.document),

package/browser/three/blender-runtime-view.ts

@@ -749,7 +749,7 @@ export class BlenderRuntimeView {
    * visibility belongs to the viewport's Helpers menu rather than to this
    * presenter, and the door for that is the host's own — a document hands
    * each group to its stage's `setHelper(kind, object)`
-   * (`@volter/editor-sdk/host`, `EditorHostStage`), which marks it
+   * (`@volter/sdk/host`, `EditorHostStage`), which marks it
    * `editorHelper`, keeps it out of the hierarchy and the raycast, and turns
    * it on and off with the kind's checkbox. `blender-runtime.document.tsx`
    * is where they are handed over.
@@ -1804,7 +1804,11 @@ export class BlenderRuntimeView {
     if (this.frame?.session === next.session && next.revision < this.frame.revision)
       throw new Error('The runtime frame is older than the displayed model');
     const ids = new Set(next.objects.map((obj) => obj.id));
-    if (ids.size !== next.objects.length) throw new Error('Runtime object IDs must be unique');
+    if (ids.size !== next.objects.length) {
+      const seen = new Set<string>();
+      const twice = [...new Set(next.objects.map((obj) => obj.id).filter((id) => seen.has(id) || !seen.add(id)))];
+      throw new Error(`Runtime object IDs must be unique; more than one object is named ${twice.map((id) => JSON.stringify(id)).join(', ')}`);
+    }
     const byId = new Map(next.objects.map((obj) => [obj.id, obj]));
     for (const obj of next.objects) {
       if (obj.mesh !== null && !next.meshes[obj.mesh])

package/browser/worker.ts

@@ -197,7 +197,7 @@ async function saveDocument(): Promise<void> {
     ms[phase] = Math.round(now - mark);
     mark = now;
   };
-  let answer: { saved?: boolean; path?: string; size?: number };
+  let answer: { saved?: boolean; path?: string; size?: number; reason?: string; holds?: string };
   try {
     answer = (await engine.request({ op: 'save-document' })) as typeof answer;
     lap('save');
@@ -206,6 +206,15 @@ async function saveDocument(): Promise<void> {
     // is a named condition in the editor's console, not a debug line.
     throw new Error(`The Blender document ${relative} could not be saved: ${describeThrown(error)}`);
   }
+  // BLENDER HOLDS ANOTHER FILE'S MODEL (`session.py::loaded`), so the session wrote nothing over
+  // the document. Said each time an edit goes unsaved, where the person looks: the document on
+  // disk is the last one saved, and what they see now is not being kept.
+  if (answer?.saved === false && answer.reason === 'not-the-document') {
+    setDocumentDirty(false);
+    log('warn', `@@VOLTER-WARN ${relative} is not being saved: Blender holds ${answer.holds ?? 'another file'}, ` +
+      `not its model. Save As a .blend under src/models to keep this as a document of its own, or open ${relative} again to return to it.`);
+    return;
+  }
   if (!answer?.saved || typeof answer.path !== 'string')
     throw new Error(`Blender did not save the document ${relative}`);
   let bytes: Uint8Array;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/blender-engine",
   "author": "Volter AI, Inc.",
   "license": "GPL-3.0-or-later",
-  "version": "0.1.139",
+  "version": "0.1.141",
   "publishConfig": {
     "access": "public"
   },