@volter/editor-blender 0.1.0

package/contributions/properties-data.inspector.tsx

@@ -0,0 +1,229 @@
+/**
+ * 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).
+ */
+import type { ToolContributionNode } from '@volter/editor-sdk/contributions';
+import { blenderPropertiesState, resolveBlenderSubject } from './blender-properties-model';
+import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
+import type { BlenderCuratedPanel } from './blender-properties-view';
+
+/** `properties_data_mesh.py`, panel by panel. Line numbers are that file's. */
+const CURATED: readonly BlenderCuratedPanel[] = [
+  {
+    // DATA_PT_vertex_groups, :198 — `template_list` over `ob.vertex_groups`,
+    // then the active group's name and lock (`MESH_UL_vgroups.draw_item`,
+    // :127). The door hands this tab the object's collection as its own path
+    // because a vertex group lives on the OBJECT, not on the mesh.
+    title: 'Vertex Groups',
+    from: 'Vertex Groups',
+    collection: true,
+    active: 'activeVertexGroup',
+    properties: ['name', 'index', 'lock_weight'],
+  },
+  {
+    // DATA_PT_shape_keys, :300 — `template_list` over `key.key_blocks`, with
+    // each key's value and slider range (:282-294). The door names the Key
+    // datablock; its `key_blocks` is the list.
+    title: 'Shape Keys',
+    from: 'Shape Keys',
+    properties: ['key_blocks', 'use_relative', 'eval_time', 'reference_key'],
+  },
+  {
+    // DATA_PT_uv_texture, :377 — `template_list` over `mesh.uv_layers`
+    // (`MESH_UL_uvmaps.draw_item`, :135: the name and `active_render`).
+    title: 'UV Maps',
+    properties: ['uv_layers'],
+  },
+  {
+    // DATA_PT_vertex_colors, :683 — `mesh.color_attributes`.
+    title: 'Color Attributes',
+    properties: ['color_attributes'],
+  },
+  {
+    // DATA_PT_mesh_attributes, :545 — `mesh.attributes`.
+    title: 'Attributes',
+    properties: ['attributes'],
+  },
+  {
+    // DATA_PT_texture_space, :173.
+    title: 'Texture Space',
+    closed: true,
+    properties: ['texture_mesh', 'use_auto_texspace', 'texspace_location', 'texspace_size'],
+  },
+  {
+    // DATA_PT_remesh, :403.
+    title: 'Remesh',
+    closed: true,
+    properties: [
+      'remesh_mode',
+      'remesh_voxel_size',
+      'remesh_voxel_adaptivity',
+      'use_remesh_fix_poles',
+      'use_remesh_preserve_volume',
+      'use_remesh_preserve_attributes',
+    ],
+  },
+  {
+    // 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.
+    title: 'Geometry Data',
+    closed: true,
+    properties: ['has_custom_normals', 'total_vert_sel', 'total_edge_sel', 'total_face_sel'],
+  },
+  {
+    // DATA_PT_mesh_animation, :461 — and DATA_PT_armature_animation, the same
+    // panel on an armature.
+    title: 'Animation',
+    closed: true,
+    properties: ['animation_data'],
+  },
+
+  // ---- `properties_data_armature.py`, for an ARMATURE's data. Same tab,
+  // same path, and each of these finds nothing on a mesh.
+  {
+    // DATA_PT_pose, :44 — Rest Position / Pose Position.
+    title: 'Pose',
+    properties: ['pose_position'],
+  },
+  {
+    // DATA_PT_bone_collections, :101 — `template_list` over
+    // `arm.collections_all`. The door also hands this tab the armature's BONES
+    // as a path of its own, which the next panel lists.
+    title: 'Bone Collections',
+    closed: true,
+    properties: ['collections_all', 'collections'],
+  },
+  {
+    // The armature's bones, which `buttons_context_path_data` puts on this
+    // tab's path list (`session.py::rna_context`) because Blender's Object
+    // Data tab is where an armature's skeleton is read. Blender itself draws
+    // them in the Outliner and the viewport rather than as a Properties list;
+    // this is the one panel here that is OURS, and it is named so.
+    title: 'Bones',
+    from: 'Bones',
+    collection: true,
+    active: 'activeBone',
+    properties: ['name', 'parent', 'use_connect', 'use_deform', 'head', 'tail', 'length'],
+  },
+  {
+    // DATA_PT_display, :55 (armature).
+    title: 'Viewport Display',
+    closed: true,
+    properties: [
+      'display_type',
+      'show_names',
+      'show_bone_custom_shapes',
+      'show_bone_colors',
+      'show_axes',
+      'axes_position',
+      'relation_line_position',
+    ],
+  },
+  {
+    // DATA_PT_iksolver_itasc, :192.
+    title: 'Inverse Kinematics',
+    closed: true,
+    properties: ['pose'],
+  },
+];
+
+const TAB = { id: 'data', curated: CURATED } as const;
+
+export const point = 'selection.inspector';
+export const title = 'Object Data';
+
+/**
+ * THE DATA TAB'S GLYPH IS PER OBJECT TYPE, and it is the one tab in the rail
+ * that is. `buttons_context_items` gives it `ICON_NONE`
+ * (`makesrna/intern/rna_space.cc:595`) because `buttons_context_compute`
+ * fills it in at read time: `sbuts->dataicon = RNA_struct_ui_icon(ptr->type)`
+ * over the data on the context path, with Light special-cased to
+ * `ICON_OUTLINER_DATA_LIGHT` (`space_buttons/buttons_context.cc:795-810`).
+ * So a mesh's tab is the MESH_DATA triangle, an armature's the ARMATURE_DATA
+ * figure, a camera's the camera body.
+ *
+ * Each key below is the RNA STRUCT's own `bl_rna.identifier` — which is what
+ * `rna_context` reports as `active.dataType` — and each value is the glyph
+ * traced from the icon that struct's `RNA_def_struct_ui_icon` call names.
+ */
+const DATA_GLYPHS: Readonly<Record<string, string>> = {
+  Mesh: 'properties-data-mesh', // rna_mesh.cc:2916      ICON_MESH_DATA
+  Armature: 'properties-data-armature', // rna_armature.cc:2191  ICON_ARMATURE_DATA
+  Curve: 'properties-data-curve', // rna_curve.cc:1685     ICON_CURVE_DATA
+  SurfaceCurve: 'properties-data-surface', // ICON_SURFACE_DATA
+  MetaBall: 'properties-data-meta', // rna_meta.cc:331       ICON_META_DATA
+  TextCurve: 'properties-data-font', // ICON_FONT_DATA
+  Lattice: 'properties-data-lattice', // rna_lattice.cc:337    ICON_LATTICE_DATA
+  Camera: 'properties-data-camera', // rna_camera.cc:741     ICON_CAMERA_DATA
+  Light: 'properties-data-light', // special-cased above   ICON_OUTLINER_DATA_LIGHT
+  Speaker: 'properties-data-speaker', // rna_speaker.cc:40     ICON_SPEAKER
+  PointCloud: 'properties-data-pointcloud', // rna_pointcloud.cc:174 ICON_POINTCLOUD_DATA
+  Volume: 'properties-data-volume', // rna_volume.cc:278     ICON_VOLUME_DATA
+};
+
+/**
+ * The host reads either a NAME or a function of the subject
+ * (`tool-loader.ts`'s `LoadedToolContributionBase.icon`). The type comes from
+ * the context the door last answered for this subject — the same read every
+ * tab's `match()` drives — so no extra engine call happens to paint a glyph,
+ * and before the first answer lands the tab draws the mesh mark, which is what
+ * Blender shows for the starter cube.
+ */
+export const icon = (node: ToolContributionNode | null, adapter: unknown): string => {
+  const subject = resolveBlenderSubject(node, adapter);
+  if (subject === null || subject.kind !== 'object') return 'properties-data';
+  const state = blenderPropertiesState();
+  if (state.object !== subject.name) return 'properties-data';
+  const type = state.context?.active?.dataType;
+  // An object with no data at all draws Blender's EMPTY_DATA — though the tab
+  // itself does not stand for one (`buttons_context_path_data` fails), so this
+  // arm is what a type this table has no row for falls back to rather than a
+  // state the rail normally shows.
+  if (type === null || type === undefined) return 'properties-data-empty';
+  return DATA_GLYPHS[type] ?? 'properties-data';
+};
+
+/** `ED_buttons_tabs_list` (`space_buttons.cc:218-252`) is the rail's order;
+ *  these are that order, spaced so a tab can be inserted between two. */
+export const order = 120;
+/** THE RAIL'S GROUPS, from `ED_buttons_tabs_list`'s own `add_spacer()` calls
+ *  (`space_buttons/space_buttons.cc:201-255`): the tool tab, then the scene
+ *  group (Render, Output, View Layer, Scene, World), then Collection, then the
+ *  object group (Object … Material), then Texture. The presentation draws a
+ *  separator wherever this changes. */
+export const railGroup = 'object';
+export const match = blenderPropertiesTabMatch(TAB);
+export default blenderPropertiesTabSection(TAB);

package/contributions/properties-material.inspector.tsx

@@ -0,0 +1,121 @@
+/**
+ * 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).
+ */
+import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
+import type { BlenderCuratedPanel } from './blender-properties-view';
+
+/** `properties_material.py`, panel by panel. Line numbers are that file's. */
+const CURATED: readonly BlenderCuratedPanel[] = [
+  {
+    // EEVEE_MATERIAL_PT_context_material, :76 — the slot list. `link` is the
+    // slot's own Object/Data toggle, `material` the pointer it holds.
+    title: 'Material Slots',
+    from: 'Material Slots',
+    collection: true,
+    active: 'activeMaterial',
+    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.
+    title: 'Surface',
+    from: 'Material',
+    properties: ['use_nodes', 'node_tree', 'surface_render_method', 'use_backface_culling'],
+  },
+  {
+    // EEVEE_MATERIAL_PT_volume (:178) and _displacement (:201) / _thickness
+    // (:223), all three of them node-tree panels like Surface; what the
+    // material holds for them is its own.
+    title: 'Volume',
+    closed: true,
+    from: 'Material',
+    properties: ['volume_intersection_method', 'displacement_method', 'max_vertex_displacement'],
+  },
+  {
+    // EEVEE_MATERIAL_PT_settings (:297) and its two children (:322, :338).
+    title: 'Settings',
+    closed: true,
+    from: 'Material',
+    properties: [
+      'pass_index',
+      'use_backface_culling_shadow',
+      'use_backface_culling_lightprobe_volume',
+      'use_transparent_shadow',
+      'use_transparency_overlap',
+      'use_raytrace_refraction',
+      'thickness_mode',
+      'use_thickness_from_shadow',
+    ],
+  },
+  {
+    // MATERIAL_PT_lineart, :377 — reads `mat.lineart`, a sub-struct, so its
+    // pointer row stands and the values are one drill down.
+    title: 'Line Art',
+    closed: true,
+    from: 'Material',
+    properties: ['lineart'],
+  },
+  {
+    // MATERIAL_PT_viewport, :354 — the three values the solid viewport
+    // shades with, which is what our own three.js presenter reads.
+    title: 'Viewport Display',
+    from: 'Material',
+    properties: ['diffuse_color', 'metallic', 'roughness'],
+  },
+  {
+    // MATERIAL_PT_animation, :390-ish (after Line Art in the `classes` tuple).
+    title: 'Animation',
+    closed: true,
+    from: 'Material',
+    properties: ['animation_data'],
+  },
+];
+
+const TAB = { id: 'material', curated: CURATED } as const;
+
+export const point = 'selection.inspector';
+export const title = 'Material';
+/** `blender.icons.json` — Blender's own mark, TRACED from
+ *  `release/datafiles/icons_svg/` at the engine's pin (the icon this tab draws
+ *  is named in `buttons_context_items`, `makesrna/intern/rna_space.cc:579`),
+ *  and tinted by the group `UI_icons.hh` declares it in. */
+export const icon = 'properties-material';
+/** `ED_buttons_tabs_list` (`space_buttons.cc:218-252`) is the rail's order;
+ *  these are that order, spaced so a tab can be inserted between two. */
+export const order = 160;
+/** THE RAIL'S GROUPS, from `ED_buttons_tabs_list`'s own `add_spacer()` calls
+ *  (`space_buttons/space_buttons.cc:201-255`): the tool tab, then the scene
+ *  group (Render, Output, View Layer, Scene, World), then Collection, then the
+ *  object group (Object … Material), then Texture. The presentation draws a
+ *  separator wherever this changes. */
+export const railGroup = 'object';
+export const match = blenderPropertiesTabMatch(TAB);
+export default blenderPropertiesTabSection(TAB);

package/contributions/properties-modifiers.inspector.tsx

@@ -0,0 +1,74 @@
+/**
+ * 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.
+ */
+import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
+import type { BlenderCuratedPanel } from './blender-properties-view';
+
+const CURATED: readonly BlenderCuratedPanel[] = [
+  {
+    title: 'Modifiers',
+    from: 'Modifiers',
+    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).
+    properties: [
+      'name',
+      'type',
+      'show_viewport',
+      'show_render',
+      'show_in_editmode',
+      'show_on_cage',
+      'use_pin_to_last',
+      'is_active',
+    ],
+    andDeclared: true,
+  },
+];
+
+const TAB = { id: 'modifier', curated: CURATED } as const;
+
+export const point = 'selection.inspector';
+export const title = 'Modifiers';
+/** `blender.icons.json` — Blender's own mark, TRACED from
+ *  `release/datafiles/icons_svg/` at the engine's pin (the icon this tab draws
+ *  is named in `buttons_context_items`, `makesrna/intern/rna_space.cc:579`),
+ *  and tinted by the group `UI_icons.hh` declares it in. */
+export const icon = 'properties-modifiers';
+/** `ED_buttons_tabs_list` (`space_buttons.cc:218-252`) is the rail's order;
+ *  these are that order, spaced so a tab can be inserted between two. */
+export const order = 80;
+/** THE RAIL'S GROUPS, from `ED_buttons_tabs_list`'s own `add_spacer()` calls
+ *  (`space_buttons/space_buttons.cc:201-255`): the tool tab, then the scene
+ *  group (Render, Output, View Layer, Scene, World), then Collection, then the
+ *  object group (Object … Material), then Texture. The presentation draws a
+ *  separator wherever this changes. */
+export const railGroup = 'object';
+export const match = blenderPropertiesTabMatch(TAB);
+export default blenderPropertiesTabSection(TAB);

package/contributions/properties-object.inspector.tsx

@@ -0,0 +1,215 @@
+/**
+ * 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:
+ *  - the `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.
+ *  - `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.
+ */
+
+import { blenderPropertiesTabMatch, blenderPropertiesTabSection } from './blender-properties-tab';
+import type { BlenderCuratedPanel } from './blender-properties-view';
+
+/** `properties_object.py`, panel by panel. Line numbers are that file's. */
+const CURATED: readonly BlenderCuratedPanel[] = [
+  {
+    // OBJECT_PT_transform, :36. Blender draws the rotation channel that
+    // `rotation_mode` selects; all three are listed, and the two the object is
+    // not in are still real RNA, so all three draw. That is MORE than Blender
+    // shows and it is the honest reading: the door reports what the object
+    // holds, and a quaternion object's euler is not a fiction.
+    title: 'Transform',
+    properties: [
+      'location',
+      'lock_location',
+      'rotation_quaternion',
+      'rotation_axis_angle',
+      'rotation_euler',
+      'lock_rotation_w',
+      'lock_rotation',
+      'rotation_mode',
+      'scale',
+      'lock_scale',
+    ],
+  },
+  {
+    // OBJECT_PT_delta_transform, :86.
+    title: 'Delta Transform',
+    closed: true,
+    properties: [
+      'delta_location',
+      'delta_rotation_quaternion',
+      'delta_rotation_euler',
+      'delta_scale',
+    ],
+  },
+  {
+    // OBJECT_PT_relations, :132.
+    title: 'Relations',
+    closed: true,
+    properties: [
+      'parent',
+      'parent_type',
+      'parent_bone',
+      'parent_bone_head_tail_factor',
+      'parent_vertices',
+      'use_parent_final_indices',
+      'use_camera_lock_parent',
+      'track_axis',
+      'up_axis',
+      'pass_index',
+    ],
+  },
+  {
+    // OBJECT_PT_collections, :185 — a UIList of the collections this object is
+    // in. `users_collection` is the RNA behind it.
+    title: 'Collections',
+    closed: true,
+    properties: ['users_collection'],
+  },
+  {
+    // OBJECT_PT_instancing, :284, with OBJECT_PT_instancing_size (:317) as its
+    // `bl_parent_id` child.
+    title: 'Instancing',
+    closed: true,
+    properties: [
+      'instance_type',
+      'use_instance_vertices_rotation',
+      'instance_collection',
+      'show_instancer_for_viewport',
+      'show_instancer_for_render',
+    ],
+    sub: [
+      {
+        title: 'Scale by Face Size',
+        closed: true,
+        properties: ['use_instance_faces_scale', 'instance_faces_scale'],
+      },
+    ],
+  },
+  {
+    // OBJECT_PT_display, :218.
+    title: 'Viewport Display',
+    closed: true,
+    properties: [
+      'show_name',
+      'show_axis',
+      'show_wire',
+      'show_all_edges',
+      'show_texture_space',
+      'show_in_front',
+      'display_type',
+      'color',
+      'show_bounds',
+      'display_bounds_type',
+      'display',
+    ],
+  },
+  {
+    // OBJECT_PT_shadow_terminator, :602.
+    title: 'Shadow Terminator',
+    closed: true,
+    properties: [
+      'shadow_terminator_normal_offset',
+      'shadow_terminator_geometry_offset',
+      'shadow_terminator_shading_offset',
+    ],
+  },
+  {
+    // OBJECT_PT_visibility, :412. Blender draws four of these INVERTED
+    // (`invert_checkbox=True`, so "Selectable" is `not hide_select`); the
+    // checkbox here is the RNA's own value and its label is the RNA's own
+    // name, because inverting a value in the presentation is exactly the
+    // fabrication the anti-shim rule forbids.
+    title: 'Visibility',
+    closed: true,
+    properties: [
+      'hide_select',
+      'hide_surface_pick',
+      'hide_viewport',
+      'hide_render',
+      'visible_camera',
+      'visible_shadow',
+      'visible_raycast',
+      'visible_diffuse',
+      'visible_glossy',
+      'visible_transmission',
+      'visible_volume_scatter',
+      'hide_probe_volume',
+      'hide_probe_sphere',
+      'hide_probe_plane',
+      'use_grease_pencil_lights',
+      'is_holdout',
+    ],
+  },
+  {
+    // OBJECT_PT_lineart, :340 — the panel reads `ob.lineart`, a sub-struct, so
+    // what stands here is its POINTER row; the values are one drill down.
+    title: 'Line Art',
+    closed: true,
+    properties: ['lineart'],
+  },
+  {
+    // OBJECT_PT_animation (:631) and OBJECT_PT_custom_props (:635).
+    title: 'Animation',
+    closed: true,
+    properties: ['animation_data'],
+  },
+];
+
+const TAB = { id: 'object', standing: 'object', curated: CURATED } as const;
+
+export const point = 'selection.inspector';
+export const title = 'Object';
+/** `blender.icons.json` — Blender's own mark, TRACED from
+ *  `release/datafiles/icons_svg/` at the engine's pin (the icon this tab draws
+ *  is named in `buttons_context_items`, `makesrna/intern/rna_space.cc:579`),
+ *  and tinted by the group `UI_icons.hh` declares it in. */
+export const icon = 'properties-object';
+/** `ED_buttons_tabs_list` (`space_buttons.cc:218-252`) is the rail's order;
+ *  these are that order, spaced so a tab can be inserted between two. */
+export const order = 70;
+/** THE RAIL'S GROUPS, from `ED_buttons_tabs_list`'s own `add_spacer()` calls
+ *  (`space_buttons/space_buttons.cc:201-255`): the tool tab, then the scene
+ *  group (Render, Output, View Layer, Scene, World), then Collection, then the
+ *  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. */
+export const railDefault = true;
+export const match = blenderPropertiesTabMatch(TAB);
+export default blenderPropertiesTabSection(TAB);