@volter/editor-blender 0.1.150 → 0.1.151

package/contributions/blender.verbs.ts

@@ -0,0 +1,52 @@
+/** Session Blender verbs relay to volter.<verb> commands registered by the page half. Each manifest entry owns its timeout and derived-refresh policy. Mutating commands present a frame and refresh the document; handlers use only SDK host doors. */
+import type { VerbHandler } from '@volter/sdk/commands';
+import { handleBlenderCommand } from '../host/blender-runtime-host';
+
+/** The lane's one handler, for every verb. */
+const handle: VerbHandler = (cmd) => handleBlenderCommand(cmd as { type: string; [key: string]: unknown });
+
+export const blenderVerbs: Readonly<Record<string, VerbHandler>> = {
+  // Presentation-only comparison, no engine mutation or derived frame refresh.
+  'blender-draw-batching': handle,
+  'blender-start': handle,
+  // Stop drains accepted modeling work and persists it before teardown.
+  'blender-stop': handle,
+  'blender-execute': handle,
+  'blender-native-preview': handle,
+  'blender-scene-info': handle,
+  'blender-object-info': handle,
+  'blender-screenshot-view': handle,
+  'blender-read-file': handle,
+  'blender-write-file': handle,
+  // File listing uses the worker-read timeout while presentation and derived reads finish.
+  'blender-list-files': handle,
+  // RNA reads expose properties and context without presenting; RNA writes mutate, present and derive.
+  'blender-rna': handle,
+  'blender-rna-context': handle,
+  'blender-rna-set': handle,
+  // Outliner reads expose the View Layer tree; restriction writes mutate, present and derive.
+  'blender-outliner': handle,
+  // The node-tree door is read-only and requires no derivation.
+  'blender-node-tree': handle,
+  // The UV door reads one mesh layout; no UV writer is registered here.
+  'blender-uv-layout': handle,
+  // THE RIG AND CLIP DOORS (the Timeline). Both READS — the skin binding a
+  // `THREE.SkinnedMesh` is built from and the action as three.js tracks — so
+  // neither presents and neither owes a derivation. There is deliberately no
+  // writer beside them: keying, moving a key and setting a range are edits,
+  // and the ONE write the Timeline makes (`scene.frame_current`, once on
+  // pause and at scrub-end) goes through `blender-rna-set`, which already
+  // exists and already presents.
+  'blender-action-clip': handle,
+  // Node-view commands inspect and navigate view state. Editing gestures return the same named refusal as pointer handlers.
+  'blender-node-view': handle,
+  'blender-outliner-set': handle,
+  // A FILM, RENDERED (`cyclotron render-movie`, a film's Blender shots): started, answering at once, then followed
+  // until it ends. The frames are Blender's own renders; each chunk puts the scene's render settings and frame back, so
+  // none presents a change to the model.
+  'blender-render-movie': handle,
+  'blender-render-status': handle,
+  // A read of whether this tab HAS a session; it never starts one — and the
+  // one verb that answers before a project session exists.
+  'blender-status': handle,
+};

package/contributions/model.layout.ts

@@ -1,10 +1,4 @@
-/**
- * The MODEL workspace — Blender-shaped modeling: a dominant document, outliner
- * above properties (`@volter/sdk/looks`, a `workspace.layout`
- * contribution). Its arrangement carries Blender 5.2's own MODELING-workspace
- * proportions; `../src/layouts.tsx` states the measurement and the host's
- * fixed-pane clamp that bounds it.
- */
+/** Model workspace: a dominant document, outliner above Properties and a lower Timeline area. The workbench owns pane geometry. */
 
 import type { WorkspaceLayoutContribution } from '@volter/sdk/looks';
 import { BLENDER_REGIONS } from '../src/regions';
@@ -26,32 +20,6 @@ export const layout: WorkspaceLayoutContribution = {
     inspector: 'properties',
     drawer: 'hidden',
   },
-  // THE TIMELINE IS THE BOTTOM AREA (owner, 2026-09-20: "doesn't blender have
-  // a timeline at the bottom?"). It does — and the workspace this Model
-  // document stands in is Blender's LAYOUT screen for us, not its Modeling
-  // one: Layout is the four-area screen with the Timeline, and Modeling is the
-  // same screen WITHOUT it (measured below).
-  //
-  // THE PROPORTION IS BLENDER'S OWN, measured through bpy on the installed
-  // Blender 5.2.1 at factory settings in a 1920-wide window
-  // (`bpy.data.workspaces['Layout'].screens[0].areas`):
-  //
-  //   PROPERTIES        x1579 y23  w339  h839
-  //   OUTLINER          x1579 y865 w339  h189
-  //   DOPESHEET_EDITOR  x2    y23  w1574 h74    ui_type TIMELINE  ← this area
-  //   VIEW_3D           x2    y100 w1574 h954
-  //
-  // and the same screen at a 1600×929 window gives the Timeline 63 of an
-  // 880-px centre column. Both are the same ratio to three places: 74/1029 =
-  // 0.0719 and 63/880 = 0.0716. The Modeling screen's own reading, for the
-  // contrast: VIEW_3D `x2 y23 w1574 h1031` and no DOPESHEET area at all.
-  //
-  // It is stated to four places because it is a measurement, not a preference;
-  // the dock uses it once, to size the group the first time this workspace
-  // stands up, and a capture of the settled grid wins afterwards.
-  //
-  // IN GAME MODE THE SAME AREA HOLDS THE GAME PANEL (`../src/play-mode.ts`):
-  // the document below draws the Timeline or the panel by the model's mode,
-  // so the area, its proportion and a person's resize all carry over.
+  // The Model workspace’s bottom editor area hosts the Timeline or Game panel. Initial Timeline ratio is Blender Layout’s 74/1029 ≈ 0.0719; a person’s later resize takes precedence.
   areas: [{ id: 'timeline', document: 'blender-timeline.document', place: 'below', ratio: 0.0719 }],
 };

package/contributions/models.finder.ts

@@ -1,33 +1,4 @@
-/**
- * The `modelsFromBlendFiles` FINDER (ARCHITECTURE-CORE §The project model,
- * "A model is Blender data, and a prefab is not a model"): every `.blend`
- * under the selection's `include` globs is a `model` document — a Blender
- * file the engine in the tab opens, edits and saves. The bpy scripts that
- * authored it are ordinary project files beside it (`src/models/<name>.py`);
- * this document does not run them, a person or an agent does, through the
- * session's Blender (`volter blender-mcp`).
- *
- * It replaced `modelsFromMeshModules`, which listed every module exporting
- * `build(): THREE.BufferGeometry` (owner ruling 2026-09-19, "do the delete":
- * the TypeScript mesh kit was the modeling engine while Blender could not run
- * in the tab; it now does, and a model is Blender data).
- *
- * Select it in `editor/volter.adapter.ts`:
- *
- *   documents: { find: [{ finder: 'modelsFromBlendFiles', include: ['src/models/**\/*.blend'] }] }
- *
- * THE SESSION'S OWN MODEL. A project that holds no `.blend` of its own still
- * needs ONE model — it is what `blender-start` presents into and what a first
- * bpy call models in, saved to the session's default `models/model.blend` — so
- * when the selection finds no file, the finder lists the standing
- * `blender:runtime` entry instead. Never beside a real model.
- *
- * This module is a plain object the HOST registers; it mounts no UI. It reads
- * the project only through `input.files` — the PATHS matching those globs.
- * Deliberately not `input.sources`: a `.blend` is binary, there is nothing in
- * it a text walk could honestly read, and the entry is the file itself. It says
- * so (`reads: 'files'`), and the host then lists the files without fetching them.
- */
+
 
 import { z } from 'zod';
 
@@ -43,10 +14,15 @@ export const finder = {
         .array(z.string().min(1))
         .min(1)
         .describe('Project-relative globs of the Blender files to list (`src/models/**/*.blend`)'),
+      defaultIn: z
+        .string()
+        .regex(/^[^/].*\/$/)
+        .optional()
+        .describe('A project folder (`levels/`): where exactly one listed Blender file is in it, that file is the default document'),
     })
     .strict(),
   run(
-    _selection: { finder: 'modelsFromBlendFiles'; include: readonly string[] },
+    selection: { finder: 'modelsFromBlendFiles'; include: readonly string[]; defaultIn?: string },
     input: { files?: readonly string[] },
   ) {
     const entries = [];
@@ -74,6 +50,10 @@ export const finder = {
         reach: { kind: 'root-mount' as const },
       });
     }
-    return { entries, notes };
+    // (the adapter's author names the folder whose lone file is the default: a std game's one level opens as its document)
+    const within = selection.defaultIn === undefined ? []
+      : (input.files ?? []).filter((path) => path.endsWith('.blend') && path.startsWith(selection.defaultIn!));
+    const only = within.length === 1 ? `model:${within[0]!}` : undefined;
+    return { entries, notes, ...(only === undefined ? {} : { default: only }) };
   },
 } as const;

package/contributions/properties-bone-constraints.inspector.tsx

@@ -1,19 +1,4 @@
-/**
- * BLENDER'S BONE CONSTRAINTS TAB, as a Properties section (WORK.md §Blender in
- * the tab is Blender, "Inspection parity", I2): the active POSE BONE's
- * constraint stack, with the generic view beneath under "All properties".
- *
- * It is the Object Constraints tab over a different datablock, and Blender
- * says so itself: `properties_constraint.py` registers
- * `BONE_PT_constraints` beside `OBJECT_PT_constraints` with the same
- * `template_constraints()` body, differing only in reading
- * `context.pose_bone.constraints`. So it shares the header list that module
- * exports rather than restating it — a second copy is a second thing to keep
- * in step.
- *
- * It stands when: `buttons_context_path_pose_bone` — a pose channel for the
- * active bone, and never in Edit mode.
- */
+/** Blender’s Bone Constraints Properties tab follows scripts/startup/bl_ui/properties_constraint.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
 import { CONSTRAINT_HEADER } from './properties-constraints.inspector';

package/contributions/properties-bone.inspector.tsx

@@ -1,26 +1,4 @@
-/**
- * BLENDER'S BONE TAB, as a Properties section (WORK.md §Blender in the tab is
- * Blender, "Inspection parity", I2). Blender's own panels over the RNA door,
- * with the generic view beneath under "All properties".
- *
- * THE SPECIFICATION IS `scripts/startup/bl_ui/properties_data_bone.py` at the
- * engine's pin: its `classes` tuple is the panel order, `bl_label` the title,
- * each `layout.prop(bone, "x")` an entry. Blender's UI layer is never run,
- * ported or recorded.
- *
- * TWO DATABLOCKS, AND THAT IS THE WHOLE STRUCTURE OF THIS TAB. Blender's panels
- * read `bone` (the armature's `Bone`, or the `EditBone` in Edit mode) for the
- * rest pose — head, tail, roll, envelope, collections, display — and `pchan`
- * (the `PoseBone`) for the POSE: its location/rotation/scale and its inverse
- * kinematics. `buttons_context_path_bone` and `_pose_bone` build both, and the
- * door hands this tab both as "Bone" and "Pose Bone", so each panel names the
- * one Blender's draw function reads. That is why Transform below is split in
- * two the way `BONE_PT_transform` (:39) is: its first half is `pchan`, its
- * second `bone`.
- *
- * It stands when: `buttons_context_path_bone` — an armature with an ACTIVE bone
- * (the edit bone in Edit mode).
- */
+/** Blender’s Bone Properties tab follows scripts/startup/bl_ui/properties_data_bone.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
 
@@ -44,14 +22,7 @@ const CURATED: readonly BlenderCuratedPanel[] = [
     ],
   },
   {
-    // BONE_PT_transform, :39, rest half (:104-110) — the bone's own geometry.
-    // NO MATRICES. The first cut named `matrix` and `matrix_local` beside them
-    // and the live read showed why Blender does not: a 3x3 and a 4x4 draw as
-    // twenty-five numbered rows, which buries the five values the panel is
-    // about. They are still in "All properties" beneath, where a matrix is
-    // something you go looking for. (`roll` is an EditBone property, so it
-    // draws in Edit mode and not in Object mode — the datablock's answer, not
-    // a condition of ours.)
+    // BONE_PT_transform rest geometry excludes matrices; those remain under All properties. roll exists only on EditBone and draws only when that datablock exposes it.
     title: 'Transform',
     from: 'Bone',
     properties: ['head', 'tail', 'roll', 'length', 'lock'],

package/contributions/properties-collection.inspector.tsx

@@ -1,37 +1,4 @@
-/**
- * BLENDER'S COLLECTION TAB, as a Properties section (WORK.md §Blender in the
- * tab is Blender, "Inspection parity", I2). Blender's own panels over the RNA
- * door, with the generic view beneath under "All properties".
- *
- * THE SPECIFICATION IS `scripts/startup/bl_ui/properties_collection.py` at the
- * engine's pin — `classes` (`:146-155`) is the panel order and `bl_label` the
- * title. Blender's UI layer is never run, ported or recorded.
- *
- * THE FIRST PANEL IS CALLED "VISIBILITY" AT THIS PIN, not "Restrictions":
- * `COLLECTION_PT_collection_flags.bl_label` is `"Visibility"` (`:32`). Its
- * child View Layer (`:47`) does not read the collection at all — it reads
- * `view_layer.active_layer_collection` (`:56`), a different datablock, which
- * the context door now names beside the collection as this tab's second path.
- *
- * TWO CHECKBOXES BLENDER DRAWS INVERTED. `hide_select` is labelled
- * "Selectable" with `invert_checkbox=True` (`:41`) and `exclude` is labelled
- * "Include" the same way (`:60`). What stands here is the RNA's own value
- * under the RNA's own name, because inverting a value in the presentation is
- * exactly the fabrication the anti-shim rule forbids — the same reading the
- * Object tab's Visibility panel already made.
- *
- * WHAT THE TRANSCRIPTION DELIBERATELY DROPS: `COLLECTION_PT_importer`
- * (`:65`), whose poll is a PREFERENCE (`prefs.experimental.use_collection_
- * importer`) and whose body is `template_collection_importer()` — an operator
- * template. Exporters (`:80`) is the same widget over `collection.exporters`,
- * and the collection itself is real RNA (`rna_collection.cc:954`), so its row
- * stands. `COLLECTION_PT_collection_custom_props` (`:143`) is IDProperties
- * rather than RNA.
- *
- * It stands when: `buttons_context_path_collection` — the view layer's ACTIVE
- * collection, and never the scene's master collection, which only the engine
- * knows.
- */
+/** Blender’s Collection Properties tab follows scripts/startup/bl_ui/properties_collection.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
 

package/contributions/properties-constraints.inspector.tsx

@@ -1,24 +1,4 @@
-/**
- * BLENDER'S OBJECT CONSTRAINTS TAB, as a Properties section (WORK.md §Blender
- * in the tab is Blender, "Inspection parity", I2): the STACK, each constraint
- * its own panel with its own settings, the generic view beneath under "All
- * properties".
- *
- * THE SPECIFICATION IS `scripts/startup/bl_ui/properties_constraint.py`, and
- * it has the same shape `properties_data_modifier.py` does: `draw` is
- * `layout.template_constraints()` and the per-type panels are built in C from
- * each constraint's RNA. So the stack is derived the same way — the shared
- * `Constraint` header properties named, then everything THIS constraint's own
- * struct declares (`andDeclared`, which reads `BlenderRnaRow.group`). A Copy
- * Location constraint gets `CopyLocationConstraint`'s target, subtarget, use_x
- * / use_y / use_z, invert flags and offset, in RNA's order.
- *
- * The ACTIVE constraint (`buttons_context_path_constraint`, reported as
- * `activeConstraint`) is marked.
- *
- * It stands when: `buttons_context_path_object` — Constraints shares Object's
- * path, so the engine grants it whenever it grants Object.
- */
+/** Blender’s Object Constraints Properties tab follows scripts/startup/bl_ui/properties_constraint.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
 

package/contributions/properties-data.inspector.tsx

@@ -1,36 +1,4 @@
-/**
- * BLENDER'S OBJECT DATA TAB, as a Properties section (WORK.md §Blender in the
- * tab is Blender, "Inspection parity", I2). Blender's own panels over the RNA
- * door, with the generic view of the whole datablock beneath under "All
- * properties".
- *
- * THE SPECIFICATION IS `scripts/startup/bl_ui/properties_data_mesh.py`, read
- * at the engine's pin: its `classes` tuple is the panel ORDER, each class's
- * `bl_label` the title, each `layout.prop(me, "x")` an entry in the order the
- * draw function lists it, `bl_options = {'DEFAULT_CLOSED'}` a `closed`, and a
- * `template_list` a `collection` panel. Blender's UI layer is never run,
- * ported or recorded.
- *
- * ONE TAB, MANY DATA TYPES, ONE LIST. `buttons_context_path_data` builds this
- * tab for whatever the object's data IS, so the same section draws a Mesh, an
- * Armature, a Camera or a Light — and the panels for all of them live in one
- * list here, because a panel draws only where its properties exist. A Camera's
- * data carries no `remesh_mode`, so the Remesh panel finds nothing and renders
- * nothing; an Armature's carries no `uv_layers` and every mesh panel stands
- * down for it. That is the same answer `MeshButtonsPanel.poll` /
- * `ArmatureButtonsPanel.poll` give, from the datablock rather than from a copy
- * of their conditions — which is why there is no per-type branch in this file
- * and no second module per data type.
- *
- * NO "NORMALS" PANEL: the brief expected one and 5.2 does not have it. The
- * mesh's `DATA_PT_normals` was folded away before this pin — `has_custom_normals`
- * survives as the Geometry Data panel's operator condition (`:456`), and the
- * shading-per-face data now lives on the Attributes list. Stated rather than
- * invented.
- *
- * It stands when: `buttons_context_path_data` — the object HAS data (an Empty
- * usually has none).
- */
+/** Blender’s Object Data Properties tab follows scripts/startup/bl_ui/properties_data_mesh.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 import type { ToolContributionNode } from '@volter/sdk/contributions';
 import { blenderPropertiesState, resolveBlenderSubject } from './blender-properties-model';
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
@@ -93,12 +61,7 @@ const CURATED: readonly BlenderCuratedPanel[] = [
     ],
   },
   {
-    // DATA_PT_customdata, :435, titled "Geometry Data". Its body is FIVE
-    // OPERATORS and one condition (`has_custom_normals`, :456) — no
-    // properties at all. Inspection parity is not editing parity
-    // (ARCHITECTURE-CORE §Blender north star), so what stands here is the
-    // condition the operators branch on, which is the only thing in the panel
-    // a reader can learn something from.
+    // Geometry Data exposes the condition and selection counts; its editing operators are not drawn here.
     title: 'Geometry Data',
     closed: true,
     properties: ['has_custom_normals', 'total_vert_sel', 'total_edge_sel', 'total_face_sel'],

package/contributions/properties-material.inspector.tsx

@@ -1,34 +1,4 @@
-/**
- * BLENDER'S MATERIAL TAB, as a Properties section (WORK.md §Blender in the tab
- * is Blender, "Inspection parity", I2). Blender's own panels over the RNA
- * door, with the generic view beneath under "All properties".
- *
- * THE SPECIFICATION IS `scripts/startup/bl_ui/properties_material.py` at the
- * engine's pin — its `classes` tuple is the panel order, `bl_label` the
- * title, each `layout.prop(mat, "x")` an entry. Blender's UI layer is never
- * run, ported or recorded.
- *
- * THE SLOTS LIST IS FIRST, and it is `MATERIAL_UL_matslots` over
- * `ob.material_slots` (`:76`, `EEVEE_MATERIAL_PT_context_material`, whose
- * `bl_label` is empty because in Blender it is the tab's header block rather
- * than a panel). The context door hands it to this tab as its own path, with
- * the ACTIVE slot named separately (`buttons_context_path_material`:
- * `BKE_object_material_get(ob, ob->actcol)`), so the list marks it.
- *
- * SURFACE IS A NODE TREE, AND THIS IS NOT THE NODE VIEW. Blender's Surface
- * panel (`:164`) calls `panel_node_draw`, which walks the material output
- * node's `Surface` input back to the shader that feeds it and draws THAT
- * node's inputs by name. Showing those values as a flat list needs the node
- * tree walked, which is I5's read-only node view (§Inspection parity, I5) —
- * and a half version of it here would be a second, worse implementation of
- * the same walk. What stands in this panel instead is what the MATERIAL
- * itself holds: `use_nodes` and the `node_tree` pointer, which drills into
- * the generic view, plus the settings Blender's own EEVEE panels read off the
- * material datablock directly.
- *
- * It stands when: `buttons_context_path_material` — the object's data holds a
- * `materials` collection (the tab stands even when the active slot is empty).
- */
+/** Blender’s Material Properties tab follows scripts/startup/bl_ui/properties_material.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
 
@@ -44,8 +14,7 @@ const CURATED: readonly BlenderCuratedPanel[] = [
     properties: ['name', 'material', 'link', 'slot_index'],
   },
   {
-    // EEVEE_MATERIAL_PT_surface, :164 — see the header for why this is the
-    // material's own two node properties rather than the shader's inputs.
+    // EEVEE_MATERIAL_PT_surface, :164. Read the material’s node properties; shader inputs belong to its node tree.
     title: 'Surface',
     from: 'Material',
     properties: ['use_nodes', 'node_tree', 'surface_render_method', 'use_backface_culling'],

package/contributions/properties-modifiers.inspector.tsx

@@ -1,32 +1,4 @@
-/**
- * BLENDER'S MODIFIERS TAB, as a Properties section (WORK.md §Blender in the
- * tab is Blender, "Inspection parity", I2): the STACK, each modifier its own
- * panel with its own settings, with the generic view beneath under "All
- * properties".
- *
- * THE SPECIFICATION IS `scripts/startup/bl_ui/properties_data_modifier.py` at
- * the engine's pin, and reading it is what decided the shape here. That file
- * is barely a panel list at all: `DATA_PT_modifiers.draw` is `Add Modifier`
- * plus `layout.template_modifiers()`, and the per-modifier panels are built in
- * C from each type's own RNA (`MOD_*.cc`'s `panel_draw`). There is no Python
- * table of sixty modifier types to transcribe — and transcribing one would be
- * a COPY of Blender's layout, which the ruling forbids, and would go stale the
- * first time a modifier gained a property.
- *
- * So the stack is derived instead: each member of `ob.modifiers` is a panel
- * headed by the four toggles every modifier has (`ModifierData`'s own
- * `show_viewport` / `show_render` / `show_in_editmode` / `show_on_cage`,
- * which is the header row `template_modifiers` draws), followed by every
- * property THIS MODIFIER'S OWN struct declares — `andDeclared`, which reads
- * `BlenderRnaRow.group`, RNA's own answer to "which struct declares this".
- * For a Subdivision modifier that is exactly `SubsurfModifier`'s levels,
- * render_levels, quality, uv_smooth and the rest, in RNA's order.
- *
- * The ACTIVE modifier (`buttons_context_path_modifier`, which the door reports
- * as `activeModifier`) is marked, the way Blender outlines the active panel.
- *
- * It stands when: the object's type is in `buttons_context.cc`'s modifier set.
- */
+/** Blender’s Modifiers Properties tab follows scripts/startup/bl_ui/properties_data_modifier.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
 
@@ -37,7 +9,7 @@ const CURATED: readonly BlenderCuratedPanel[] = [
     collection: true,
     active: 'activeModifier',
     // `ModifierData`'s own, in the order `template_modifiers` heads a panel
-    // with them; everything after these is the type's own (see the header).
+    // with them; everything after these is the type's own.
     properties: [
       'name',
       'type',

package/contributions/properties-object.inspector.tsx

@@ -1,34 +1,4 @@
-/**
- * BLENDER'S OBJECT TAB, as a Properties section (WORK.md §Blender in the tab
- * is Blender, "Inspection parity", I2). The body is Blender's own panels, in
- * Blender's own order, over the RNA door; the generic view of every property
- * the object has stays beneath them under "All properties".
- *
- * THE SPECIFICATION IS `scripts/startup/bl_ui/properties_object.py`, read at
- * the engine's pin. Its `classes` tuple at the foot of the file is the panel
- * ORDER, each class's `bl_label` the title, each `layout.prop(ob, "x")` an
- * entry below in the order the draw function lists it, and `bl_options =
- * {'DEFAULT_CLOSED'}` a `closed: true`. Blender's UI layer is never run,
- * ported or recorded — the Python is read as a statement of WHICH properties
- * this tab shows, and our widgets draw them from the door's rows.
- *
- * WHAT THE TRANSCRIPTION DELIBERATELY DROPS:
- *  - type-only `poll`/`if` branches. `show_all_edges` is mesh-only in Python; here
- *    it is simply not on a Camera's RNA, so it does not draw. Same outcome,
- *    from the datablock rather than from a copy of Blender's conditions.
- *    Rotation mode is a value on every object, so its draw branch is retained.
- *  - `OBJECT_PT_context_object` (`bl_label = ""`) — the breadcrumb row, which
- *    is the host's identity row here.
- *  - the four panels whose datablock is NOT the object: Motion Paths reads
- *    `ob.animation_visualization` and `ob.motion_path`, Light/Shadow Linking
- *    their collections. The context door names the object, so those are
- *    reached by drilling their POINTER row in the generic view beneath — a
- *    curated panel addresses one of the TAB's own datablocks, and inventing a
- *    second addressing scheme to reach a sub-struct is the kind of machinery
- *    the generic view exists to make unnecessary.
- *
- * It stands when: `buttons_context_path_object` — there is an active object.
- */
+/** Blender’s Object Properties tab follows scripts/startup/bl_ui/properties_object.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
@@ -196,19 +166,7 @@ export const order = 70;
  *  object group (Object … Material), then Texture. The presentation draws a
  *  separator wherever this changes. */
 export const railGroup = 'object';
-/** THE TAB THE RAIL OPENS ON. Blender's Properties editor stores its context
- *  per screen in the startup file, and at factory settings the Layout
- *  workspace's is OBJECT:
- *
- *    bpy.data.screens['Layout'].areas[PROPERTIES].spaces[0].context -> 'OBJECT'
- *
- *  (measured against Blender 5.2.0 LTS at `--factory-startup`, walk 5 parity
- *  row 3; the other screens read OBJECT, MODIFIER, WORLD, DATA, TOOL, OUTPUT
- *  and RENDER, so a per-workspace default is the next fidelity step and this
- *  one declaration is the Layout/Model answer). Without it the rail opened on
- *  Render — the first tab in `ED_buttons_tabs_list`'s order — and a person
- *  selecting the cube got Sampling and Light Paths where Blender shows
- *  Transform. */
+/** The Model Properties rail opens on Object, matching the factory Layout workspace’s context. */
 export const railDefault = true;
 export const match = blenderPropertiesTabMatch(TAB);
 export default blenderPropertiesTabSection(TAB);

package/contributions/properties-output.inspector.tsx

@@ -1,30 +1,4 @@
-/**
- * BLENDER'S OUTPUT TAB, as a Properties section (WORK.md §Blender in the tab
- * is Blender, "Inspection parity", I2). Blender's own panels over the RNA
- * door, with the generic view beneath under "All properties".
- *
- * THE SPECIFICATION IS `scripts/startup/bl_ui/properties_output.py` at the
- * engine's pin — `classes` (`:728-748`) is the panel order, `bl_label` the
- * title, each `layout.prop(rd, "x")` an entry in the order the draw function
- * lists it. Blender's UI layer is never run, ported or recorded.
- *
- * THE TAB'S DATABLOCK IS `scene.render`, and three panels reach past it: Frame
- * Range is the SCENE's own `frame_start`/`frame_end`/`frame_step` (`:151`),
- * Output's Color Management is `rd.image_settings` (`:371`), and Encoding is
- * `rd.ffmpeg` (`:499`). The context door names each beside the render
- * settings as one of this tab's paths and the rows say which they come from
- * ({@link BlenderCuratedProperty}).
- *
- * WHAT THE TRANSCRIPTION DELIBERATELY DROPS:
- *  - the preset menus (`RENDER_PT_format_presets` `:15`,
- *    `RENDER_MT_framerate_presets` `:28`, `RENDER_PT_ffmpeg_presets` `:22`)
- *    and `template_image_settings`/`template_image_views` — operator and
- *    template widgets. Inspection parity, not editing parity.
- *  - `RENDER_PT_output_pixel_density` (`:396`), whose body is a preset menu
- *    plus two properties behind it; the two are named here.
- *
- * It stands when: `buttons_context_path_scene` — the same path as Render.
- */
+/** Blender’s Output Properties tab follows scripts/startup/bl_ui/properties_output.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
 

package/contributions/properties-particles.inspector.tsx

@@ -1,48 +1,4 @@
-/**
- * BLENDER'S PARTICLES TAB, as a Properties section (WORK.md §Blender in the
- * tab is Blender, "Inspection parity", I2). Blender's own panels over the RNA
- * door, with the generic view beneath under "All properties".
- *
- * THE SPECIFICATION IS `scripts/startup/bl_ui/properties_particle.py` at the
- * engine's pin — `classes` (`:2248-2302`) is the panel order, `bl_label` the
- * title, each `layout.prop(part, "x")` an entry. Blender's UI layer is never
- * run, ported or recorded.
- *
- * NEARLY EVERY PANEL DRAWS `psys.settings`, NOT THE SYSTEM. `part` in these
- * draw functions is `particle_get_settings(context)` (`:40-46`), which is the
- * active system's ParticleSettings — a datablock of its own. The system
- * itself carries only a handful (`seed`, `parent`, `child_seed`, the
- * vertex-group names, `use_hair_dynamics`). The context door names both, plus
- * the hair-dynamics cloth settings, as this tab's paths, and each row says
- * which it comes from.
- *
- * THE TYPE POLLS ARE READ, and this tab is why `when` exists. Blender gates
- * these panels on values rather than on structure: `settings.type == 'HAIR'`
- * (Hair Dynamics `:362`, Hair Shape `:2205`), `settings.physics_type` in
- * NEWTON/FLUID or == BOIDS (`:1161`, `:1195`, `:1222`, `:934`),
- * `settings.render_type` (`:1449`, `:1507`, `:1536`), `settings.child_type`
- * (`:1743`, `:1778`), `settings.is_fluid` (`:272`). Every one of those
- * properties is on the same struct under every mode, so RNA cannot answer the
- * poll and the condition is read from the ENGINE's live value instead — a copy
- * of Blender's test, never of its branching.
- *
- * WHAT THE TRANSCRIPTION DELIBERATELY DROPS:
- *  - `PARTICLE_PT_context_particles` (`:156`, `bl_label = ""`) — the systems
- *    list plus the settings ID template. The list itself is the first panel
- *    here, as a collection with the active system marked; the `template_ID`
- *    row is an editing widget.
- *  - the Boids panels (`:931`-`:1045`) and the fluid-spring panels
- *    (`:835`-`:928`): both read sub-structs of the settings (`part.boids`,
- *    `part.fluid`), which stand as POINTER rows in the Physics panel and
- *    drill. Naming a fourth and fifth datablock on this tab to reach a mode
- *    almost nothing uses is the machinery the generic view exists to avoid.
- *  - `PARTICLE_PT_boidbrain` (`:1254`) — a rules list with per-rule operators.
- *  - `template_curve_mapping` (the clump and roughness curves) — a curve
- *    widget this view does not draw.
- *  - `PARTICLE_PT_custom_props` (`:2243`), IDProperties rather than RNA.
- *
- * It stands when: `buttons_context_path_particle` — `ob->type == OB_MESH`.
- */
+/** Blender’s Particles Properties tab follows scripts/startup/bl_ui/properties_particle.py at the engine pin. Curated panels read the RNA context’s datablocks; the generic view remains under All properties. Match tab availability and engine-specific panels against the live context. */
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
 
@@ -193,7 +149,7 @@ const CURATED: readonly BlenderCuratedPanel[] = [
   },
   {
     // PARTICLE_PT_physics, :730. `boids` and `fluid` are the two mode
-    // sub-structs whose own panels are one drill away (see the header).
+    // sub-structs whose own panels are one drill away.
     title: 'Physics',
     closed: true,
     from: 'Settings',

package/contributions/properties-physics.inspector.tsx

@@ -1,42 +1,4 @@
-/**
- * BLENDER'S PHYSICS TAB, as a Properties section (WORK.md §Blender in the tab
- * is Blender, "Inspection parity", I2). Blender's own panels over the RNA
- * door, with the generic view beneath under "All properties".
- *
- * THE SPECIFICATION IS SEVEN FILES, not one: `properties_physics_common.py`
- * carries the tab's own header block, and `properties_physics_rigidbody.py`,
- * `_rigidbody_constraint.py`, `_cloth.py`, `_softbody.py`, `_field.py`
- * (Force Fields AND Collision), `_fluid.py` and `_dynamicpaint.py` each carry
- * one simulation. Each panel below cites its file and line. Blender's UI
- * layer is never run, ported or recorded.
- *
- * THE "ENABLE BUTTONS" ROW IS NOT DRAWN, AND WHAT IT SAYS STILL IS.
- * `PHYSICS_PT_add` (`properties_physics_common.py:55`) is a grid of
- * `object.modifier_add` / `rigidbody.object_add` OPERATORS — editing, not
- * inspection (ARCHITECTURE-CORE §Blender north star), and this view draws
- * properties. What that row COMMUNICATES is which simulations the object has,
- * and that is exactly which panels stand here: the context door resolves a
- * path per simulation the way `physics_add`/`physics_add_special` test for
- * one — the data for `obj.rigid_body`, `obj.rigid_body_constraint`,
- * `obj.soft_body`, `obj.collision` and `obj.field`, and a MODIFIER of the
- * right type for cloth, fluid and dynamic paint (Blender's `context.cloth` is
- * the ClothModifier, and the panels read its `settings` structs). An absent
- * simulation is an absent path and its panels do not draw.
- *
- * FLUID AND DYNAMIC PAINT STOP AT THEIR TYPE. Both are a modifier whose whole
- * panel set is per-`fluid_type` / per-`ui_type` — domain, flow and effector
- * are three different property surfaces, and dynamic paint's canvas splits
- * again per surface. What stands here is the modifier's type row and the
- * pointer to the settings struct the type selects, which drills into the
- * generic view; transcribing three or four alternative panel sets each is the
- * machinery the generic view exists to make unnecessary. Stated, not
- * silently partial.
- *
- * It stands when: `buttons_context_path_object` — Physics shares Object's
- * path, so the engine grants it whenever it grants Object. It is
- * context-gated rather than standing because the Properties editor follows
- * the ACTIVE OBJECT, not the row that was clicked.
- */
+
 import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
 import type { BlenderCuratedPanel } from './blender-properties-view';
 
@@ -578,8 +540,7 @@ const CURATED: readonly BlenderCuratedPanel[] = [
     ],
   },
   {
-    // properties_physics_fluid.py — see the header for why this stops at the
-    // type and the settings pointer.
+    // properties_physics_fluid.py: show the type and settings pointers; each pointer drills into its properties.
     title: 'Fluid',
     from: 'Fluid',
     properties: ['fluid_type', 'domain_settings', 'flow_settings', 'effector_settings'],