From 32756f0402764cf82512a2d2fe161094a1506113 Mon Sep 17 00:00:00 2001
From: SoftFever <softfeverever@gmail.com>
Date: Fri, 3 Jul 2026 16:30:28 +0800
Subject: [PATCH] add orca plugin example

---
 sandboxes/orca_plugin_example.py | 1322 ++++++++++++++++++++++++++++++
 1 file changed, 1322 insertions(+)
 create mode 100644 sandboxes/orca_plugin_example.py

diff --git a/sandboxes/orca_plugin_example.py b/sandboxes/orca_plugin_example.py
new file mode 100644
index 0000000000..238d8f8129
--- /dev/null
+++ b/sandboxes/orca_plugin_example.py
@@ -0,0 +1,1322 @@
+# /// script
+# requires-python = ">=3.12"
+# dependencies = ["numpy"]
+#
+# [tool.orcaslicer.plugin]
+# name = "Orca Host Inspector Panel"
+# description = "An interactive panel that browses the whole orca.host read-only API and demos every orca.host.ui facility."
+# author = "OrcaSlicer"
+# version = "2.0.0"
+# ///
+"""Orca Host Inspector — the worked sample for `orca.host` and `orca.host.ui`.
+
+Run it from the Plugins dialog. It opens a NON-MODAL window (OrcaSlicer stays
+usable) with a sidebar of sections, each exercising one part of the API:
+
+  Overview   plater state, scene statistics, current printer/process/filaments
+  Presets    every PresetCollection, preset flags, any preset's full config
+  Config     the complete merged full_config as a searchable table
+  Model      Model -> Object -> Volume/Instance tree with lazy mesh geometry
+  Assembly   objects grouped by module_name, per-instance assemble transforms
+  UI Toolkit live demos of message/show_dialog/create_window/ProgressDialog
+
+The page and the plugin talk JSON through the injected `window.orca` bridge:
+
+  page   --orca.postMessage({command:'fetch', section})-->      plugin.on_message()
+  page   --orca.postMessage({command:'mesh', object, volume})-->     "
+  page   --orca.postMessage({command:'ui', action, ...})-->          "
+  plugin --win.post({command:'section'|'mesh'|..., ok, data})--> page (orca.onMessage)
+
+Everything is fetched lazily: a section is built only when it is first shown,
+and heavy mesh geometry (zero-copy numpy arrays, world-space math, the little
+point-cloud previews) only when you ask for it. "Refresh" drops the cache and
+refetches the visible section.
+
+Style rules the page follows (see the plugin docs):
+  - no hardcoded colors — only the host-injected --orca-* theme variables, so
+    the panel matches light and dark mode automatically;
+  - self-contained HTML (inline CSS/JS, no external resources);
+  - on_message runs on the UI thread, so long work (the progress demos) is
+    offloaded to a thread and results are pushed back with win.post().
+
+numpy is declared as a dependency for the mesh arrays and 4x4 matrices; every
+numpy-dependent feature degrades gracefully if it is missing. The assembly
+transforms need bindings added in July 2026 — on older builds the panel shows
+what is missing instead of failing.
+"""
+
+import re
+import threading
+import time
+
+import orca
+
+try:
+    import numpy as np
+except Exception:
+    np = None
+
+
+# Soft caps so a heavy scene cannot produce an unusably large payload. When a
+# cap trims output the payload says so explicitly rather than truncating silently.
+MAX_OBJECTS = 50
+MAX_VOLUMES = 20
+MAX_INSTANCES = 20
+MAX_PRESET_NAMES = 500
+MAX_PREVIEW_POINTS = 4000
+
+
+# --------------------------------------------------------------------------- #
+# small converters — every builder returns plain JSON-able dicts/lists.
+# Cast numpy scalars with float()/int(): the bridge serializes unknown types
+# with str(), which would silently turn them into strings.
+# --------------------------------------------------------------------------- #
+def vec(v):
+    return [round(float(c), 4) for c in v]
+
+
+def bbox_dict(bb):
+    """host.BoundingBox -> dict (or None when the box is undefined)."""
+    if not bb.defined:
+        return None
+    return {"min": vec(bb.min), "max": vec(bb.max), "size": vec(bb.size),
+            "center": vec(bb.center), "radius": round(float(bb.radius), 4)}
+
+
+def enum_name(value):
+    return getattr(value, "name", str(value))
+
+
+def config_rows(keys, get_value):
+    """Sorted [{k, v}] for a config; None values become ''. Complete, not sampled."""
+    return [{"k": k, "v": "" if (v := get_value(k)) is None else str(v)}
+            for k in sorted(keys)]
+
+
+def preset_dict(preset):
+    """Every documented host.Preset attribute, in one dict."""
+    return {
+        "name": preset.name,
+        "alias": preset.alias,
+        "label": preset.label(),
+        "type": enum_name(preset.type),
+        "file": preset.file,
+        "bundle_id": preset.bundle_id,
+        "config_key_count": len(preset.config_keys()),
+        "is_default": preset.is_default,
+        "is_system": preset.is_system,
+        "is_user": preset.is_user(),
+        "is_external": preset.is_external,
+        "is_visible": preset.is_visible,
+        "is_dirty": preset.is_dirty,
+        "is_compatible": preset.is_compatible,
+        "is_project_embedded": preset.is_project_embedded,
+        "is_from_bundle": preset.is_from_bundle(),
+    }
+
+
+def split_config_list(value):
+    """Split a serialized per-extruder option ("#FF0000;#00FF00") into parts."""
+    if value is None:
+        return []
+    return [part.strip().strip('"') for part in str(value).split(";")]
+
+
+# --------------------------------------------------------------------------- #
+# section builders
+# --------------------------------------------------------------------------- #
+def build_overview():
+    plater = orca.host.plater()
+    model = orca.host.model()
+    bundle = orca.host.preset_bundle()
+    objects = model.objects()
+
+    cfg = bundle.full_config_value
+    colors = split_config_list(cfg("filament_colour"))
+    types = split_config_list(cfg("filament_type"))
+    filaments = []
+    for i, preset in enumerate(bundle.current_filament_presets()):
+        filaments.append({
+            "name": preset.name if preset else "<missing preset>",
+            "color": colors[i] if i < len(colors) else "",
+            "type": types[i] if i < len(types) else "",
+            "is_system": bool(preset.is_system) if preset else False,
+            "is_dirty": bool(preset.is_dirty) if preset else False,
+        })
+
+    printer = bundle.current_printer_preset()
+    process = bundle.current_process_preset()
+    return {
+        "plater": {
+            "project_dirty": plater.is_project_dirty(),
+            "presets_dirty": plater.is_presets_dirty(),
+            "in_snapshot": plater.inside_snapshot_capture(),
+        },
+        "stats": {
+            "objects": len(objects),
+            # derived from instances: ModelObject.printable is only the import-time flag
+            "printable_objects": sum(1 for o in objects if printable_instance_count(o)),
+            "volumes": sum(o.volume_count() for o in objects),
+            "instances": sum(o.instance_count() for o in objects),
+            "triangles": sum(o.facets_count() for o in objects),
+            "materials": model.material_count(),
+            "plate_index": model.current_plate_index(),
+            "max_z": round(float(model.max_z()), 3),
+            "config_keys": len(bundle.full_config_keys()),
+        },
+        "bbox": bbox_dict(model.bounding_box()),
+        "bbox_approx": bbox_dict(model.bounding_box_approx()),
+        "painted": {
+            "support": model.is_fdm_support_painted(),
+            "seam": model.is_seam_painted(),
+            "multimaterial": model.is_mm_painted(),
+            "fuzzy_skin": model.is_fuzzy_skin_painted(),
+        },
+        "design": {"designer": model.designer(), "design_id": model.design_id(),
+                   "model_id": model.id()},
+        "setup": {
+            "printer": {"name": printer.name, "is_system": printer.is_system,
+                        "is_dirty": printer.is_dirty},
+            "process": {"name": process.name, "is_system": process.is_system,
+                        "is_dirty": process.is_dirty},
+            "filaments": filaments,
+            "highlights": [{"k": key, "v": str(cfg(key))}
+                           for key in ("printer_model", "nozzle_diameter",
+                                       "printable_height", "layer_height",
+                                       "sparse_infill_density", "enable_prime_tower")
+                           if cfg(key) is not None],
+        },
+    }
+
+
+# label -> how to reach the PresetCollection on the bundle
+COLLECTIONS = [
+    ("prints", "Process"),
+    ("printers", "Printer"),
+    ("filaments", "Filament"),
+    ("sla_prints", "SLA print"),
+    ("sla_materials", "SLA material"),
+]
+
+
+def build_presets():
+    bundle = orca.host.preset_bundle()
+    collections = []
+    for attr, label in COLLECTIONS:
+        coll = getattr(bundle, attr)
+        names = coll.preset_names()
+        selected = coll.selected_preset()
+        collections.append({
+            "key": attr,
+            "label": label,
+            "size": coll.size(),
+            "selected_name": coll.selected_preset_name(),
+            # selected = as saved on disk; edited = selected + unsaved modifications
+            "selected": {"name": selected.name, "is_dirty": selected.is_dirty,
+                         "config_key_count": len(selected.config_keys())},
+            "edited": preset_dict(coll.edited_preset()),
+            "names": names[:MAX_PRESET_NAMES],
+            "truncated": max(0, len(names) - MAX_PRESET_NAMES),
+        })
+    return {
+        "collections": collections,
+        "filament_names": bundle.current_filament_preset_names(),
+    }
+
+
+def build_preset_config(collection_key, name):
+    bundle = orca.host.preset_bundle()
+    if collection_key not in {attr for attr, _ in COLLECTIONS}:
+        raise ValueError(f"unknown collection {collection_key!r}")
+    preset = getattr(bundle, collection_key).find_preset(name)
+    if preset is None:
+        raise ValueError(f"preset {name!r} not found")
+    return {"preset": preset_dict(preset),
+            "rows": config_rows(preset.config_keys(), preset.config_value)}
+
+
+def build_config():
+    bundle = orca.host.preset_bundle()
+    rows = config_rows(bundle.full_config_keys(), bundle.full_config_value)
+    return {"rows": rows, "count": len(rows)}
+
+
+def volume_dict(index, volume):
+    return {
+        "index": index,
+        "id": volume.id(),
+        "name": volume.name,
+        "type": enum_name(volume.type()),
+        "roles": {
+            "model_part": volume.is_model_part(),
+            "modifier": volume.is_modifier(),
+            "negative": volume.is_negative_volume(),
+            "support_enforcer": volume.is_support_enforcer(),
+            "support_blocker": volume.is_support_blocker(),
+        },
+        "extruder": volume.extruder_id(),      # 1-based; -1 = none/inherited
+        "offset": vec(volume.offset()),
+        "rotation": vec(volume.rotation()),    # radians
+        "scale": vec(volume.scaling_factor()),
+        "mirror": vec(volume.mirror()),
+        "facets": volume.facets_count(),
+        "volume_mm3": round(float(volume.volume()), 3),
+        "manifold": volume.is_manifold(),
+        "mesh_errors": volume.mesh_errors_count(),
+        "painted": {"support": volume.is_fdm_support_painted(),
+                    "seam": volume.is_seam_painted(),
+                    "multimaterial": volume.is_mm_painted(),
+                    "fuzzy_skin": volume.is_fuzzy_skin_painted()},
+        "bbox": bbox_dict(volume.bounding_box()),
+        "config": config_rows(volume.config_keys(), volume.config_value),
+    }
+
+
+def assemble_dict(instance):
+    """Assemble-view placement of one instance; needs bindings added 2026-07.
+    getattr-guarded so the panel still runs on an older OrcaSlicer build."""
+    if not hasattr(instance, "assemble_offset"):
+        return {"available": False}
+    return {
+        "available": True,
+        "initialized": instance.is_assemble_initialized(),
+        "offset": vec(instance.assemble_offset()),
+        "rotation": vec(instance.assemble_rotation()),   # radians
+        "offset_to_assembly": vec(instance.offset_to_assembly()),
+    }
+
+
+def instance_dict(index, instance):
+    return {
+        "index": index,
+        "id": instance.id(),
+        "printable_flag": instance.printable,
+        "is_printable": instance.is_printable(),  # also requires inside print volume
+        "offset": vec(instance.offset()),
+        "rotation": vec(instance.rotation()),      # radians
+        "scale": vec(instance.scaling_factor()),
+        "mirror": vec(instance.mirror()),
+        "left_handed": instance.is_left_handed(),
+        "bbox": bbox_dict(instance.bounding_box()),
+        "assemble": assemble_dict(instance),
+    }
+
+
+def printable_instance_count(obj):
+    """The GUI's printable toggle writes ModelInstance.printable only;
+    ModelObject.printable keeps its import-time value. So an object's effective
+    printable state must be derived from its instances."""
+    return sum(1 for i in range(obj.instance_count()) if obj.instance(i).printable)
+
+
+def object_dict(index, obj):
+    volumes = [volume_dict(i, obj.volume(i))
+               for i in range(min(obj.volume_count(), MAX_VOLUMES))]
+    instances = [instance_dict(i, obj.instance(i))
+                 for i in range(min(obj.instance_count(), MAX_INSTANCES))]
+    return {
+        "index": index,
+        "id": obj.id(),
+        "name": obj.name,
+        "module_name": obj.module_name,
+        "input_file": obj.input_file,
+        "printable": obj.printable,       # raw import-time flag, see above
+        "counts": {"volumes": obj.volume_count(), "instances": obj.instance_count(),
+                   "printable_instances": printable_instance_count(obj),
+                   "facets": obj.facets_count(), "parts": obj.parts_count(),
+                   "materials": obj.materials_count(),
+                   "mesh_errors": obj.mesh_errors_count()},
+        "flags": {"multiparts": obj.is_multiparts(), "cut": obj.is_cut(),
+                  "custom_layering": obj.has_custom_layering()},
+        "painted": {"support": obj.is_fdm_support_painted(),
+                    "seam": obj.is_seam_painted(),
+                    "multimaterial": obj.is_mm_painted(),
+                    "fuzzy_skin": obj.is_fuzzy_skin_painted()},
+        "z_range": [round(float(obj.min_z()), 3), round(float(obj.max_z()), 3)],
+        "bbox": bbox_dict(obj.bounding_box()),            # world, all instances
+        "raw_bbox": bbox_dict(obj.raw_mesh_bounding_box()),  # untransformed meshes
+        "config": config_rows(obj.config_keys(), obj.config_value),
+        "volumes": volumes,
+        "volumes_omitted": max(0, obj.volume_count() - len(volumes)),
+        "instances": instances,
+        "instances_omitted": max(0, obj.instance_count() - len(instances)),
+    }
+
+
+def build_model():
+    model = orca.host.model()
+    count = model.object_count()
+    shown = min(count, MAX_OBJECTS)
+    return {
+        # carried along so the extruder swatches never depend on a stale Overview
+        "filament_colors": split_config_list(
+            orca.host.preset_bundle().full_config_value("filament_colour")),
+        "id": model.id(),
+        "object_count": count,
+        "objects_omitted": count - shown,
+        "material_count": model.material_count(),
+        "plate_index": model.current_plate_index(),
+        "max_z": round(float(model.max_z()), 3),
+        "bbox": bbox_dict(model.bounding_box()),
+        "bbox_approx": bbox_dict(model.bounding_box_approx()),
+        "objects": [object_dict(i, model.object(i)) for i in range(shown)],
+    }
+
+
+def build_assembly():
+    """Group objects by module_name (the assembly path recorded in the 3mf) into
+    a tree, and report each instance's Assemble-view transform."""
+    model = orca.host.model()
+    root = {"name": "", "groups": {}, "objects": []}
+    count = min(model.object_count(), MAX_OBJECTS)
+    has_modules = False
+
+    for i in range(count):
+        obj = model.object(i)
+        module = (obj.module_name or "").strip()
+        has_modules = has_modules or bool(module)
+
+        node = root
+        for part in [p for p in re.split(r"[/\\]", module) if p]:
+            node = node["groups"].setdefault(part, {"name": part, "groups": {}, "objects": []})
+
+        instances = [{"index": j, "offset": vec(obj.instance(j).offset()),
+                      "printable": obj.instance(j).printable,
+                      "assemble": assemble_dict(obj.instance(j))}
+                     for j in range(min(obj.instance_count(), MAX_INSTANCES))]
+        bb = bbox_dict(obj.raw_mesh_bounding_box())
+        node["objects"].append({"index": i, "name": obj.name,
+                                "printable_instances": printable_instance_count(obj),
+                                "instance_count": obj.instance_count(),
+                                "size": bb["size"] if bb else None,
+                                "instances": instances,
+                                "instances_omitted": obj.instance_count() - len(instances)})
+
+    def freeze(node):  # dict-of-groups -> sorted list, for stable JSON
+        return {"name": node["name"],
+                "groups": [freeze(node["groups"][k]) for k in sorted(node["groups"])],
+                "objects": node["objects"]}
+
+    return {"tree": freeze(root),
+            "object_count": count,
+            "objects_omitted": model.object_count() - count,
+            "has_modules": has_modules}
+
+
+def build_mesh(object_index, volume_index):
+    """Heavy on purpose: full TriangleMesh access, numpy views, world-space math
+    and a sampled world-space point cloud for the previews."""
+    obj = orca.host.model().object(object_index)
+    volume = obj.volume(volume_index)
+    mesh = volume.mesh()
+
+    data = {
+        "vertex_count": mesh.vertex_count(),
+        "triangle_count": mesh.triangle_count(),
+        "empty": mesh.is_empty(),
+        "manifold": mesh.is_manifold(),
+        "volume_mm3": round(float(mesh.volume()), 3),
+        "bbox": bbox_dict(mesh.bounding_box()),
+        # numpy-free element access (always available, bounds-checked)
+        "vertex0": vec(mesh.vertex(0)) if not mesh.is_empty() else None,
+        "triangle0": list(mesh.triangle(0)) if not mesh.is_empty() else None,
+        "numpy": None,
+        "preview": None,
+    }
+    if np is None or mesh.is_empty():
+        return data
+
+    V = np.asarray(mesh.vertices())      # (N, 3) float32, read-only, zero-copy
+    T = np.asarray(mesh.triangles())     # (M, 3) int32,  read-only, zero-copy
+    N = np.asarray(mesh.face_normals())  # (M, 3) float32, computed copy
+    tri = V[T].astype(np.float64)        # (M, 3, 3) corner positions
+    area = 0.5 * np.linalg.norm(np.cross(tri[:, 1] - tri[:, 0],
+                                         tri[:, 2] - tri[:, 0]), axis=1).sum()
+    data["numpy"] = {
+        "vertices": f"shape={V.shape} dtype={V.dtype} writeable={V.flags.writeable} "
+                    f"zero_copy={V.base is not None}",
+        "triangles": f"shape={T.shape} dtype={T.dtype}",
+        "normals": f"shape={N.shape} dtype={N.dtype}",
+        "surface_area_mm2": round(float(area), 3),
+    }
+
+    # World-space math under the first instance, using the row-vector convention
+    # world = [V 1] @ (instance_matrix @ volume_matrix).T
+    if obj.instance_count():
+        instance = obj.instance(0)
+        homog = np.c_[V.astype(np.float64), np.ones(len(V))]
+        world = (homog @ (instance.matrix() @ volume.matrix()).T)[:, :3]
+        sample = world[::max(1, len(world) // MAX_PREVIEW_POINTS)]
+        data["numpy"]["world_bbox"] = {"min": vec(world.min(0)), "max": vec(world.max(0))}
+        data["preview"] = {"points": [vec(p) for p in sample],
+                           "sampled": len(sample), "total": len(world)}
+        # The same mesh placed by the Assemble view (new 2026-07 API, guarded).
+        if hasattr(instance, "assemble_matrix") and instance.is_assemble_initialized():
+            asm = (homog @ (instance.assemble_matrix() @ volume.matrix()).T)[:, :3]
+            data["numpy"]["assemble_bbox"] = {"min": vec(asm.min(0)), "max": vec(asm.max(0))}
+    return data
+
+
+SECTION_BUILDERS = {
+    "overview": build_overview,
+    "presets": build_presets,
+    "config": build_config,
+    "model": build_model,
+    "assembly": build_assembly,
+}
+
+
+# --------------------------------------------------------------------------- #
+# the page — sidebar app, themed exclusively via the injected --orca-* vars
+# --------------------------------------------------------------------------- #
+PAGE = r"""<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+  :root { --mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+  * { box-sizing: border-box; }
+  body { margin:0; height:100vh; display:flex; flex-direction:column; overflow:hidden; }
+
+  header { flex:none; display:flex; align-items:center; gap:10px;
+           padding:10px 16px; border-bottom:1px solid var(--orca-border); }
+  header h1 { font-size:15px; margin:0; }
+  #stamp { flex:1; color:var(--orca-muted); font-size:12px; }
+  button.secondary { background:transparent; color:var(--orca-fg);
+                     border-color:var(--orca-border); }
+  button.small { padding:2px 10px; font-size:12px; }
+
+  main { flex:1; display:flex; min-height:0; }
+  nav  { flex:none; width:150px; padding:8px 0; overflow-y:auto;
+         border-right:1px solid var(--orca-border); }
+  nav .item { padding:8px 14px; cursor:pointer; user-select:none;
+              color:var(--orca-muted); border-left:3px solid transparent; }
+  nav .item:hover  { color:var(--orca-fg); }
+  nav .item.active { color:var(--orca-fg); font-weight:600;
+                     border-left-color:var(--orca-accent); }
+  nav .glyph { display:inline-block; width:1.5em; }
+  #content { flex:1; overflow:auto; padding:14px 16px 28px; }
+
+  .tiles { display:grid; grid-template-columns:repeat(auto-fill,minmax(108px,1fr));
+           gap:10px; margin-bottom:12px; }
+  .tile  { border:1px solid var(--orca-border); border-radius:8px; padding:10px 12px; }
+  .tile .v { font-size:20px; font-weight:600; font-variant-numeric:tabular-nums; }
+  .tile .l { font-size:11px; color:var(--orca-muted); margin-top:2px; }
+
+  .cards { display:grid; grid-template-columns:repeat(auto-fit,minmax(260px,1fr)); gap:12px; }
+  .card  { border:1px solid var(--orca-border); border-radius:8px;
+           padding:12px 14px; min-width:0; }
+  .card h3 { margin:0 0 8px; font-size:11px; letter-spacing:.07em;
+             text-transform:uppercase; color:var(--orca-muted); }
+  .card.wide { grid-column:1 / -1; }
+
+  .kv { display:grid; grid-template-columns:minmax(110px,max-content) 1fr;
+        gap:3px 14px; font-size:12px; }
+  .kv .k { color:var(--orca-muted); }
+  .kv .v { font-family:var(--mono); word-break:break-word; }
+
+  .badge { display:inline-block; border:1px solid var(--orca-border);
+           color:var(--orca-muted); border-radius:999px; padding:1px 8px;
+           font-size:11px; margin:1px 3px 1px 0; white-space:nowrap; }
+  .badge.on { background:var(--orca-accent); border-color:var(--orca-accent);
+              color:var(--orca-accent-fg); }
+  .swatch { display:inline-block; width:12px; height:12px; border-radius:3px;
+            border:1px solid var(--orca-border); vertical-align:-2px; margin-right:5px; }
+
+  .toolbar { display:flex; gap:8px; align-items:center; margin-bottom:10px; }
+  .toolbar input { flex:1; max-width:340px; }
+  .count { color:var(--orca-muted); font-size:12px; }
+
+  table.cfg { width:100%; border-collapse:collapse; font-size:12px; }
+  table.cfg td:first-child { font-family:var(--mono); white-space:nowrap;
+                             vertical-align:top; }
+  table.cfg td.val { font-family:var(--mono); white-space:pre-wrap; word-break:break-word; }
+  td.val .more { color:var(--orca-accent); cursor:pointer; }
+
+  .node  { margin:1px 0; }
+  .nhead { display:flex; align-items:center; gap:7px; padding:4px 8px;
+           border-radius:6px; cursor:pointer; user-select:none; flex-wrap:wrap; }
+  .nhead:hover { background:var(--orca-border); }
+  .twist { width:1em; flex:none; color:var(--orca-muted); font-size:10px; }
+  .nname { font-weight:600; }
+  .nbody { display:none; margin-left:14px; padding:4px 0 4px 12px;
+           border-left:1px dotted var(--orca-border); }
+  .node.open > .nhead .twist { transform:rotate(90deg); }
+  .node.open > .nbody { display:block; }
+  .subhead { margin:8px 0 4px; font-size:11px; letter-spacing:.07em;
+             text-transform:uppercase; color:var(--orca-muted); }
+
+  .banner { border:1px solid var(--orca-border); border-left:3px solid var(--orca-accent);
+            border-radius:6px; padding:9px 12px; margin-bottom:12px; font-size:12px; }
+  .muted  { color:var(--orca-muted); }
+  .mono   { font-family:var(--mono); }
+
+  canvas.preview { width:100%; height:160px; border:1px solid var(--orca-border);
+                   border-radius:6px; }
+  .previews { display:grid; grid-template-columns:1fr 1fr; gap:10px; margin-top:8px; }
+  .previews .cap { font-size:11px; color:var(--orca-muted); text-align:center; margin-top:2px; }
+
+  .log { font-family:var(--mono); font-size:12px; border:1px solid var(--orca-border);
+         border-radius:6px; padding:8px 10px; max-height:190px; overflow:auto; }
+  .log div { padding:1px 0; }
+  fieldset { border:1px solid var(--orca-border); border-radius:6px; margin:0 0 10px; }
+  legend { color:var(--orca-muted); font-size:11px; padding:0 6px; }
+  .frow { display:flex; gap:8px; align-items:center; flex-wrap:wrap; margin:6px 0; }
+  label { font-size:12px; color:var(--orca-muted); }
+</style>
+</head>
+<body>
+  <header>
+    <h1>Host Inspector</h1>
+    <span id="stamp"></span>
+    <button class="small" onclick="refresh()">Refresh</button>
+    <button class="small secondary" onclick="orca.close()">Close</button>
+  </header>
+  <main>
+    <nav id="nav"></nav>
+    <div id="content"></div>
+  </main>
+
+<script>
+'use strict';
+/* ------------------------------------------------------------------ state */
+const SECTIONS = [
+  ['overview', '◎', 'Overview'],
+  ['presets',  '⚙', 'Presets'],
+  ['config',   '≡', 'Config'],
+  ['model',    '▦', 'Model'],
+  ['assembly', '⬡', 'Assembly'],
+  ['uikit',    '▣', 'UI Toolkit'],
+];
+const S = { current:'overview', cache:{}, busy:{}, colors:[], uiLog:[] };
+
+const $ = id => document.getElementById(id);
+const esc = s => String(s == null ? '' : s)
+  .replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+const num = (x, d=2) => Number(x).toFixed(d).replace(/\.?0+$/, '');
+const deg = r => num(r * 180 / Math.PI, 1) + '°';
+const vec3 = (v, d=2) => v ? '(' + v.map(c => num(c, d)).join(', ') + ')' : '—';
+const yn  = b => b ? 'yes' : 'no';
+const badge = (label, on) => '<span class="badge' + (on ? ' on' : '') + '">' + esc(label) + '</span>';
+const kv = rows => '<div class="kv">' + rows.map(([k, v]) =>
+  '<div class="k">' + esc(k) + '</div><div class="v">' + v + '</div>').join('') + '</div>';
+const bboxRows = (label, bb) => bb ? [
+  [label + ' min', esc(vec3(bb.min))], [label + ' max', esc(vec3(bb.max))],
+  [label + ' size', esc(vec3(bb.size))], [label + ' center', esc(vec3(bb.center))],
+] : [[label, '<span class="muted">undefined</span>']];
+
+/* ------------------------------------------------------- nav + fetching */
+function buildNav() {
+  $('nav').innerHTML = SECTIONS.map(([key, glyph, label]) =>
+    '<div class="item" id="nav-' + key + '" onclick="show(\'' + key + '\')">' +
+    '<span class="glyph">' + glyph + '</span>' + label + '</div>').join('');
+}
+function show(key) {
+  S.current = key;
+  SECTIONS.forEach(([k]) => $('nav-' + k).classList.toggle('active', k === key));
+  if (key === 'uikit') { render(); return; }         // local, nothing to fetch
+  if (S.cache[key]) render();
+  else if (S.busy[key]) $('content').innerHTML = '<p class="muted">Loading ' + esc(key) + '…</p>';
+  else fetchSection(key);
+}
+function fetchSection(key) {
+  S.busy[key] = true;
+  $('content').innerHTML = '<p class="muted">Loading ' + esc(key) + '…</p>';
+  orca.postMessage({ command:'fetch', section:key });
+}
+function refresh() {
+  S.cache = {};
+  S.busy = {};
+  show(S.current);
+}
+function stamp() {
+  $('stamp').textContent = 'updated ' + new Date().toLocaleTimeString();
+}
+
+/* ------------------------------------------------------------ renderers */
+function render() {
+  const key = S.current, d = S.cache[key];
+  if (key === 'uikit') { $('content').innerHTML = renderUikit(); paintUiLog(); return; }
+  if (!d) return;
+  if (!d.ok) {
+    $('content').innerHTML = '<div class="banner">⚠ ' + esc(key) +
+      ' failed: <span class="mono">' + esc(d.error) + '</span></div>' +
+      '<p class="muted">Is a project open? Click Refresh to retry.</p>';
+    return;
+  }
+  const r = { overview:renderOverview, presets:renderPresets, config:renderConfig,
+              model:renderModel, assembly:renderAssembly }[key];
+  $('content').innerHTML = r(d.data);
+  if (key === 'model') drawPendingPreviews();
+}
+
+function renderOverview(d) {
+  S.colors = d.setup.filaments.map(f => f.color);   // reused by the model tree
+  const t = d.stats;
+  const tiles = [
+    [t.objects, 'objects'], [t.volumes, 'volumes'], [t.instances, 'instances'],
+    [t.triangles.toLocaleString(), 'triangles'], [t.materials, 'materials'],
+    [t.plate_index, 'plate index'], [num(t.max_z) + ' mm', 'max Z'],
+    [t.config_keys, 'config keys'],
+  ].map(([v, l]) => '<div class="tile"><div class="v">' + v + '</div><div class="l">' + l + '</div></div>').join('');
+
+  const filaments = d.setup.filaments.map((f, i) =>
+    '<div style="margin:3px 0">' +
+    (f.color ? '<span class="swatch" style="background:' + esc(f.color) + '"></span>' : '') +
+    '<b>' + (i + 1) + '</b> ' + esc(f.name) +
+    (f.type ? ' <span class="muted">' + esc(f.type) + '</span>' : '') +
+    badge(f.is_system ? 'system' : 'user', f.is_system) +
+    (f.is_dirty ? badge('modified', true) : '') +
+    '</div>').join('') || '<span class="muted">none</span>';
+
+  return '<div class="tiles">' + tiles + '</div><div class="cards">' +
+    '<div class="card"><h3>Plater · orca.host.plater()</h3>' + kv([
+      ['project dirty', yn(d.plater.project_dirty)],
+      ['presets dirty', yn(d.plater.presets_dirty)],
+      ['in snapshot', yn(d.plater.in_snapshot)],
+      ['printable objects', t.printable_objects + ' / ' + t.objects],
+    ]) + '</div>' +
+    '<div class="card"><h3>Current setup</h3>' + kv([
+      ['printer', esc(d.setup.printer.name) + (d.setup.printer.is_dirty ? ' ' + badge('modified', true) : '')],
+      ['process', esc(d.setup.process.name) + (d.setup.process.is_dirty ? ' ' + badge('modified', true) : '')],
+    ]) + '<div class="subhead">Filaments</div>' + filaments + '</div>' +
+    '<div class="card"><h3>Scene bounds · model.bounding_box()</h3>' +
+      kv([...bboxRows('exact', d.bbox),
+          ['approx size', esc(vec3(d.bbox_approx && d.bbox_approx.size))],
+          ['radius', d.bbox ? num(d.bbox.radius) + ' mm' : '—']]) + '</div>' +
+    '<div class="card"><h3>Design &amp; painting</h3>' + kv([
+      ['designer', esc(d.design.designer) || '<span class="muted">—</span>'],
+      ['design id', esc(d.design.design_id) || '<span class="muted">—</span>'],
+      ['model id', esc(d.design.model_id)],
+      ['painted', badge('support', d.painted.support) + badge('seam', d.painted.seam) +
+                  badge('multimaterial', d.painted.multimaterial) + badge('fuzzy skin', d.painted.fuzzy_skin)],
+    ]) + '</div>' +
+    '<div class="card wide"><h3>Config highlights · full_config_value()</h3>' +
+      kv(d.setup.highlights.map(h => [h.k, esc(h.v)])) +
+      '<p class="muted" style="margin:8px 0 0">The complete merged configuration (' +
+      t.config_keys + ' keys) is on the Config tab.</p></div>' +
+    '</div>';
+}
+
+function presetBadges(p) {
+  return badge(p.is_system ? 'system' : 'user', p.is_system) +
+    (p.is_dirty ? badge('modified', true) : '') +
+    (p.is_default ? badge('default', false) : '') +
+    (p.is_external ? badge('external', false) : '') +
+    (p.is_project_embedded ? badge('project', false) : '') +
+    (p.is_from_bundle ? badge('bundle', false) : '') +
+    badge(p.is_compatible ? 'compatible' : 'incompatible', false) +
+    (p.is_visible ? '' : badge('hidden', false));
+}
+function renderPresets(d) {
+  return '<div class="banner">Each card is one <span class="mono">host.PresetCollection</span>. ' +
+    '“Edited” is the selected preset plus any unsaved changes. Pick any preset ' +
+    'and load its complete config via <span class="mono">find_preset().config_value()</span>.</div>' +
+    '<div class="cards">' + d.collections.map(c => {
+      const p = c.edited;
+      const options = c.names.map(n =>   // explicit value= so odd whitespace in names survives
+        '<option value="' + esc(n) + '"' + (n === c.selected_name ? ' selected' : '') + '>' +
+        esc(n) + '</option>').join('');
+      return '<div class="card"><h3>' + esc(c.label) + ' · ' + c.size + ' presets</h3>' +
+        '<div style="margin-bottom:6px"><b>' + esc(p.name) + '</b> ' + presetBadges(p) + '</div>' +
+        kv([['label()', esc(p.label)], ['alias', esc(p.alias) || '—'],
+            ['type', esc(p.type)], ['bundle', esc(p.bundle_id) || '—'],
+            ['edited_preset()', p.config_key_count + ' keys' +
+              (p.is_dirty ? ' · has unsaved changes' : ' · same as saved')],
+            ['selected_preset()', esc(c.selected.name) + ' · ' + c.selected.config_key_count + ' keys'],
+            ['file', '<span class="muted">' + esc(p.file) + '</span>']]) +
+        '<div class="frow" style="margin-top:8px">' +
+          '<select id="sel-' + c.key + '" style="flex:1;min-width:0">' + options + '</select>' +
+          '<button class="small" data-act="pcfg" data-coll="' + c.key + '">View config</button>' +
+        '</div>' +
+        (c.truncated ? '<p class="muted">list capped, ' + c.truncated + ' more not shown</p>' : '') +
+        '<div id="pcfg-' + c.key + '"></div></div>';
+    }).join('') + '</div>';
+}
+
+function configTable(rows, id) {
+  const body = rows.map(r => {
+    const long = r.v.length > 160;
+    const shown = long ? esc(r.v.slice(0, 160)) + '<span class="more" data-act="expand"> … show all</span>'
+                       : esc(r.v);
+    return '<tr data-k="' + esc(r.k.toLowerCase()) + '"><td>' + esc(r.k) + '</td>' +
+      '<td class="val" data-full="' + esc(r.v) + '">' + shown + '</td></tr>';
+  }).join('');
+  return '<table class="cfg" id="' + id + '"><tr><th>key</th><th>value</th></tr>' + body + '</table>';
+}
+function renderConfig(d) {
+  return '<div class="toolbar"><input id="cfg-search" placeholder="Filter ' + d.count +
+    ' keys…" oninput="filterConfig(this.value)">' +
+    '<span class="count" id="cfg-count">' + d.count + ' keys</span></div>' +
+    '<div class="banner">The merged result of printer + process + filament presets — ' +
+    'exactly what <span class="mono">preset_bundle().full_config_value(key)</span> returns for ' +
+    'every key in <span class="mono">full_config_keys()</span>.</div>' +
+    configTable(d.rows, 'cfg-table');
+}
+function filterConfig(q) {
+  q = q.trim().toLowerCase();
+  let visible = 0;
+  document.querySelectorAll('#cfg-table tr[data-k]').forEach(tr => {
+    const hit = !q || tr.dataset.k.includes(q) ||
+      tr.querySelector('.val').dataset.full.toLowerCase().includes(q);
+    tr.style.display = hit ? '' : 'none';
+    if (hit) visible++;
+  });
+  $('cfg-count').textContent = visible + ' keys';
+}
+
+function extruderChip(id) {
+  if (id == null || id < 1) return '<span class="badge">extruder —</span>';
+  const color = S.colors[id - 1];
+  return '<span class="badge">' + (color ? '<span class="swatch" style="background:' +
+    esc(color) + '"></span>' : '') + 'extruder ' + id + '</span>';
+}
+const VOL_GLYPH = { ModelPart:'◆', NegativeVolume:'◇', ParameterModifier:'▨',
+                    SupportEnforcer:'▲', SupportBlocker:'▽' };
+
+function node(head, body, open) {
+  return '<div class="node' + (open ? ' open' : '') + '">' +
+    '<div class="nhead" data-act="toggle"><span class="twist">▶</span>' + head + '</div>' +
+    '<div class="nbody">' + body + '</div></div>';
+}
+function paintedBadges(p) {
+  const parts = Object.entries(p).filter(([, v]) => v).map(([k]) => badge(k, true)).join('');
+  return parts || '<span class="muted">none</span>';
+}
+function configOverride(rows) {
+  if (!rows.length) return [['config overrides', '<span class="muted">none</span>']];
+  return [['config overrides', rows.map(r => '<span class="badge">' + esc(r.k) + ' = ' +
+    esc(r.v) + '</span>').join('')]];
+}
+function renderVolume(o, v) {
+  const glyph = VOL_GLYPH[v.type] || '◆';
+  const head = '<span>' + glyph + '</span><span class="nname">' + esc(v.name || '(volume ' + v.index + ')') +
+    '</span>' + badge(v.type, false) + extruderChip(v.extruder) +
+    '<span class="muted">' + v.facets.toLocaleString() + ' tris</span>' +
+    (v.manifold ? '' : badge('⚠ non-manifold', false)) +
+    (v.mesh_errors ? badge('⚠ ' + v.mesh_errors + ' repaired', false) : '');
+  const body = kv([
+    ['id', v.id], ['offset', esc(vec3(v.offset))],
+    ['rotation', esc(v.rotation.map(deg).join(', '))],
+    ['scale', esc(vec3(v.scale))], ['mirror', esc(vec3(v.mirror))],
+    ['mesh volume', num(v.volume_mm3) + ' mm³'],
+    ...bboxRows('local bbox', v.bbox),
+    ['painted', paintedBadges(v.painted)],
+    ...configOverride(v.config),
+  ]) +
+  '<div class="subhead">Mesh geometry · volume.mesh()</div>' +
+  '<div id="mesh-' + o + '-' + v.index + '">' +
+  '<button class="small secondary" data-act="mesh" data-o="' + o + '" data-v="' + v.index + '">' +
+  'Load mesh detail</button> <span class="muted">zero-copy numpy views + world-space preview</span></div>';
+  return node(head, body, false);
+}
+function renderInstance(o, i) {
+  const a = i.assemble;
+  const asmRows = !a.available
+    ? [['assemble', '<span class="muted">needs a newer OrcaSlicer build</span>']]
+    : [['assemble init', yn(a.initialized)],
+       ['assemble offset', esc(vec3(a.offset))],
+       ['assemble rotation', esc(a.rotation.map(deg).join(', '))],
+       ['offset to assembly', esc(vec3(a.offset_to_assembly))]];
+  const head = '<span>⌗</span><span class="nname">Instance ' + i.index + '</span>' +
+    badge(i.is_printable ? 'printable' : 'not printable', i.is_printable) +
+    '<span class="muted">at ' + esc(vec3(i.offset, 1)) + '</span>';
+  const body = kv([
+    ['id', i.id], ['printable flag', yn(i.printable_flag)],
+    ['rotation', esc(i.rotation.map(deg).join(', '))],
+    ['scale', esc(vec3(i.scale))], ['mirror', esc(vec3(i.mirror))],
+    ['left-handed', yn(i.left_handed)],
+    ...bboxRows('world bbox', i.bbox), ...asmRows,
+  ]);
+  return node(head, body, false);
+}
+// Effective printable state comes from the instances; the object flag is only
+// the import-time value (the GUI's toggle never writes it).
+function printableBadge(printable, total) {
+  return badge(printable === 0 ? 'not printable'
+    : printable < total ? printable + '/' + total + ' printable'
+    : 'printable', printable > 0);
+}
+function renderObject(o) {
+  const c = o.counts;
+  const head = '<span>▦</span><span class="nname">' + esc(o.name || '(object ' + o.index + ')') + '</span>' +
+    printableBadge(c.printable_instances, c.instances) +
+    (o.flags.cut ? badge('cut', false) : '') +
+    (o.flags.multiparts ? badge('multipart', false) : '') +
+    (o.flags.custom_layering ? badge('custom layers', false) : '') +
+    (c.mesh_errors ? badge('⚠ ' + c.mesh_errors + ' repaired', false) : '') +
+    '<span class="muted">' + c.volumes + ' vol · ' + c.instances + ' inst · ' +
+    c.facets.toLocaleString() + ' tris</span>';
+  const body = kv([
+    ['id', o.id],
+    ['module', esc(o.module_name) || '<span class="muted">—</span>'],
+    ['source file', '<span class="muted">' + (esc(o.input_file) || '—') + '</span>'],
+    ['printable flag', yn(o.printable) +
+      ' <span class="muted">import-time flag — the GUI toggle sets instances only</span>'],
+    ['parts / materials', c.parts + ' / ' + c.materials],
+    ['Z range', num(o.z_range[0]) + ' → ' + num(o.z_range[1]) + ' mm'],
+    ...bboxRows('world bbox', o.bbox),
+    ['raw size', esc(vec3(o.raw_bbox && o.raw_bbox.size))],
+    ['painted', paintedBadges(o.painted)],
+    ...configOverride(o.config),
+  ]) +
+  '<div class="subhead">Volumes (' + c.volumes + ')</div>' +
+  o.volumes.map(v => renderVolume(o.index, v)).join('') +
+  (o.volumes_omitted ? '<p class="muted">… ' + o.volumes_omitted + ' more not shown</p>' : '') +
+  '<div class="subhead">Instances (' + c.instances + ')</div>' +
+  o.instances.map(i => renderInstance(o.index, i)).join('') +
+  (o.instances_omitted ? '<p class="muted">… ' + o.instances_omitted + ' more not shown</p>' : '');
+  return node(head, body, o.index === 0);
+}
+function renderModel(d) {
+  S.colors = d.filament_colors || S.colors;
+  if (!d.object_count)
+    return '<div class="banner">The plate is empty — add or open a model, then Refresh.</div>';
+  return '<div class="cards" style="margin-bottom:12px"><div class="card wide"><h3>Model · orca.host.model()</h3>' +
+    kv([['model id', d.id], ['objects', d.object_count], ['materials', d.material_count],
+        ['plate index', d.plate_index], ['max Z', num(d.max_z) + ' mm'],
+        ...bboxRows('bbox', d.bbox)]) + '</div></div>' +
+    d.objects.map(renderObject).join('') +
+    (d.objects_omitted ? '<p class="muted">… ' + d.objects_omitted + ' more object(s) not shown</p>' : '');
+}
+
+function renderAssemblyGroup(g, depth) {
+  const objects = g.objects.map(o => {
+    const inst = o.instances.map(i => {
+      const a = i.assemble;
+      const detail = !a.available ? '<span class="muted">assemble API needs a newer build</span>'
+        : !a.initialized ? '<span class="muted">not initialized — no assemble placement recorded yet</span>'
+        : 'offset ' + esc(vec3(a.offset, 1)) + ' · rot ' + esc(a.rotation.map(deg).join(', ')) +
+          ' · to-assembly ' + esc(vec3(a.offset_to_assembly, 1));
+      return '<div class="kv" style="margin:2px 0"><div class="k">instance ' + i.index +
+        '</div><div class="v">' + detail + '</div></div>';
+    }).join('') + (o.instances_omitted
+      ? '<p class="muted">… ' + o.instances_omitted + ' more instance(s) not shown</p>' : '');
+    const head = '<span>▦</span><span class="nname">' + esc(o.name) + '</span>' +
+      (o.size ? '<span class="muted">' + esc(vec3(o.size, 1)) + ' mm</span>' : '') +
+      printableBadge(o.printable_instances, o.instance_count);
+    return node(head, inst || '<span class="muted">no instances</span>', false);
+  }).join('');
+  const groups = g.groups.map(child => renderAssemblyGroup(child, depth + 1)).join('');
+  if (!g.name) return groups + objects;   // root: contents only
+  const head = '<span>⬡</span><span class="nname">' + esc(g.name) + '</span>' +
+    '<span class="muted">' + (g.objects.length + g.groups.length) + ' item(s)</span>';
+  return node(head, groups + objects, depth < 2);
+}
+function renderAssembly(d) {
+  let banner;
+  if (!d.object_count)
+    banner = 'The plate is empty — add or open a model, then Refresh.';
+  else if (!d.has_modules)
+    banner = 'No object carries a <span class="mono">module_name</span> — the hierarchy below is flat. ' +
+      'Import a 3mf saved from an assembly (e.g. a STEP import) to see real modules.';
+  else
+    banner = 'Objects grouped by their <span class="mono">module_name</span>, the assembly path ' +
+      'recorded in the project. Instances show their Assemble-view transforms.';
+  return '<div class="banner">' + banner + '</div>' +
+    renderAssemblyGroup(d.tree, 0) +
+    (d.objects_omitted ? '<p class="muted">… ' + d.objects_omitted + ' more object(s) not shown</p>' : '');
+}
+
+/* --------------------------------------------------------- mesh previews */
+const pendingPreviews = [];
+const PREVIEWS = {};   // canvas id -> {pts, ax, ay}; repainted when a collapsed node reopens
+function renderMeshDetail(container, d) {
+  let html = kv([
+    ['vertices', d.vertex_count.toLocaleString()],
+    ['triangles', d.triangle_count.toLocaleString()],
+    ['manifold', yn(d.manifold)], ['mesh volume', num(d.volume_mm3) + ' mm³'],
+    ['vertex(0)', esc(vec3(d.vertex0, 3))], ['triangle(0)', esc(String(d.triangle0))],
+    ...bboxRows('local bbox', d.bbox),
+  ]);
+  if (d.numpy) {
+    html += '<div class="subhead">numpy arrays</div>' + kv([
+      ['vertices()', esc(d.numpy.vertices)], ['triangles()', esc(d.numpy.triangles)],
+      ['face_normals()', esc(d.numpy.normals)],
+      ['surface area', num(d.numpy.surface_area_mm2) + ' mm²'],
+      ...(d.numpy.world_bbox ? [
+        ['world bbox min', esc(vec3(d.numpy.world_bbox.min))],
+        ['world bbox max', esc(vec3(d.numpy.world_bbox.max))]] : []),
+      ...(d.numpy.assemble_bbox ? [
+        ['assemble bbox', esc(vec3(d.numpy.assemble_bbox.min)) + ' → ' +
+                          esc(vec3(d.numpy.assemble_bbox.max)) + ' via assemble_matrix()']] : []),
+    ]);
+  } else {
+    html += '<p class="muted">numpy not available — arrays, world-space math and previews are skipped.</p>';
+  }
+  if (d.preview) {
+    const id = container.id;
+    html += '<div class="previews"><div><canvas class="preview" id="' + id + '-top"></canvas>' +
+      '<div class="cap">top (X/Y)</div></div><div><canvas class="preview" id="' + id + '-front"></canvas>' +
+      '<div class="cap">front (X/Z)</div></div></div>' +
+      '<p class="muted">' + d.preview.sampled.toLocaleString() + ' of ' +
+      d.preview.total.toLocaleString() + ' world-space vertices, via zero-copy arrays and ' +
+      'instance.matrix() @ volume.matrix()</p>';
+    pendingPreviews.push([id, d.preview.points]);
+  }
+  container.innerHTML = html;
+  drawPendingPreviews();
+}
+function drawPendingPreviews() {
+  while (pendingPreviews.length) {
+    const [id, pts] = pendingPreviews.pop();
+    drawPoints($(id + '-top'), pts, 0, 1);
+    drawPoints($(id + '-front'), pts, 0, 2);
+  }
+}
+function drawPoints(canvas, pts, ax, ay) {
+  if (!canvas || !pts.length) return;
+  PREVIEWS[canvas.id] = { pts, ax, ay };
+  const scaleDpr = window.devicePixelRatio || 1;
+  const w = canvas.clientWidth * scaleDpr, h = canvas.clientHeight * scaleDpr;
+  if (!w || !h) return;      // inside a collapsed node; repainted on toggle
+  canvas.dataset.painted = '1';
+  canvas.width = w; canvas.height = h;
+  const ctx = canvas.getContext('2d');
+  let minX = 1/0, maxX = -1/0, minY = 1/0, maxY = -1/0;
+  for (const p of pts) {
+    minX = Math.min(minX, p[ax]); maxX = Math.max(maxX, p[ax]);
+    minY = Math.min(minY, p[ay]); maxY = Math.max(maxY, p[ay]);
+  }
+  const pad = 10 * scaleDpr;
+  const scale = Math.min((w - 2 * pad) / Math.max(maxX - minX, 1e-6),
+                         (h - 2 * pad) / Math.max(maxY - minY, 1e-6));
+  const ox = (w - (maxX - minX) * scale) / 2, oy = (h - (maxY - minY) * scale) / 2;
+  const style = getComputedStyle(document.body);
+  ctx.strokeStyle = style.getPropertyValue('--orca-accent');
+  ctx.strokeRect(ox, oy, (maxX - minX) * scale, (maxY - minY) * scale);
+  ctx.fillStyle = style.color;
+  ctx.globalAlpha = 0.55;
+  const r = Math.max(1, 1.2 * scaleDpr);
+  for (const p of pts)
+    ctx.fillRect(ox + (p[ax] - minX) * scale - r / 2,
+                 h - oy - (p[ay] - minY) * scale - r / 2, r, r);
+}
+
+/* ------------------------------------------------------------ UI toolkit */
+function renderUikit() {
+  return '<div class="banner">Live calls into <span class="mono">orca.host.ui</span>. Results appear in the ' +
+    'event log; the plugin runs the progress demos on a worker thread and pushes results back with ' +
+    '<span class="mono">win.post()</span>.</div>' +
+    '<div class="cards">' +
+    '<div class="card"><h3>Native message box · ui.message()</h3>' +
+      '<div class="frow"><label>buttons</label><select id="ui-btns"><option>ok</option>' +
+      '<option>ok_cancel</option><option selected>yes_no</option><option>yes_no_cancel</option></select>' +
+      '<label>icon</label><select id="ui-icon"><option>info</option><option>warning</option>' +
+      '<option>error</option><option selected>question</option></select></div>' +
+      '<div class="frow"><input id="ui-text" style="flex:1" value="Shall we inspect some hosts?">' +
+      '<button class="small" data-act="ui" data-ui="message">Show</button></div></div>' +
+    '<div class="card"><h3>Modal HTML dialog · ui.show_dialog()</h3>' +
+      '<p class="muted">Blocks until closed; returns the <span class="mono">orca.submit()</span> payload.</p>' +
+      '<button class="small" data-act="ui" data-ui="modal">Open modal dialog</button></div>' +
+    '<div class="card"><h3>Progress dialog · ui.ProgressDialog</h3>' +
+      '<p class="muted">Determinate update() loop (cancellable) and start_pulse()/stop_pulse().</p>' +
+      '<div class="frow"><button class="small" data-act="ui" data-ui="progress">40-step demo</button>' +
+      '<button class="small secondary" data-act="ui" data-ui="pulse">Pulse demo</button></div></div>' +
+    '<div class="card"><h3>Second window · ui.create_window()</h3>' +
+      '<p class="muted">A plugin can own several windows; the child echoes pings through the plugin.</p>' +
+      '<div class="frow"><button class="small" data-act="ui" data-ui="child_open">Open child</button>' +
+      '<button class="small secondary" data-act="ui" data-ui="child_close">Close child</button>' +
+      '<button class="small secondary" data-act="ui" data-ui="child_state">is_open()?</button></div></div>' +
+    '<div class="card wide"><h3>Event log</h3><div class="log" id="ui-log"></div></div>' +
+    '</div>';
+}
+function addLog(text) {
+  S.uiLog.push(new Date().toLocaleTimeString() + '  ' + text);
+  if (S.uiLog.length > 80) S.uiLog.shift();
+  paintUiLog();
+}
+function paintUiLog() {
+  const el = $('ui-log');
+  if (!el) return;
+  el.innerHTML = S.uiLog.map(esc).map(l => '<div>' + l + '</div>').join('') ||
+    '<span class="muted">no events yet</span>';
+  el.scrollTop = el.scrollHeight;
+}
+function uiAction(action) {
+  const msg = { command:'ui', action };
+  if (action === 'message') {
+    msg.text = $('ui-text').value;
+    msg.buttons = $('ui-btns').value;
+    msg.icon = $('ui-icon').value;
+  }
+  addLog('→ ' + action);
+  orca.postMessage(msg);
+}
+
+/* -------------------------------------------------------- event delegation */
+$('content').addEventListener('click', e => {
+  const t = e.target.closest('[data-act]');
+  if (!t) return;
+  const act = t.dataset.act;
+  if (act === 'toggle') {
+    const node = t.parentElement;
+    node.classList.toggle('open');
+    // Repaint any preview whose canvas was hidden (zero-size) when its data arrived.
+    node.querySelectorAll('canvas.preview').forEach(c => {
+      const p = PREVIEWS[c.id];
+      if (p && !c.dataset.painted) drawPoints(c, p.pts, p.ax, p.ay);
+    });
+  } else if (act === 'mesh') {
+    t.disabled = true;
+    t.textContent = 'Loading…';
+    orca.postMessage({ command:'mesh', object:+t.dataset.o, volume:+t.dataset.v });
+  } else if (act === 'pcfg') {
+    const coll = t.dataset.coll;
+    orca.postMessage({ command:'preset_config', collection:coll,
+                       name:$('sel-' + coll).value });
+  } else if (act === 'expand') {
+    const td = t.closest('td');
+    td.textContent = td.dataset.full;
+  } else if (act === 'ui') {
+    uiAction(t.dataset.ui);
+  }
+});
+
+/* ------------------------------------------------------------- messages */
+orca.onMessage(msg => {
+  if (!msg || !msg.command) return;
+  if (msg.command === 'section') {
+    S.cache[msg.section] = msg;
+    S.busy[msg.section] = false;
+    stamp();
+    if (msg.section === S.current) render();
+  } else if (msg.command === 'mesh') {
+    const container = $('mesh-' + msg.object + '-' + msg.volume);
+    if (!container) return;
+    if (msg.ok) renderMeshDetail(container, msg.data);
+    else container.innerHTML = '<span class="muted">⚠ ' + esc(msg.error) + '</span>';
+  } else if (msg.command === 'preset_config') {
+    const container = $('pcfg-' + msg.collection);
+    if (!container) return;
+    container.innerHTML = msg.ok
+      ? '<div class="subhead">' + esc(msg.name) + ' · ' + msg.data.rows.length +
+        ' keys</div>' + configTable(msg.data.rows, 'pcfg-table-' + msg.collection)
+      : '<span class="muted">⚠ ' + esc(msg.error) + '</span>';
+  } else if (msg.command === 'ui_result') {
+    addLog(msg.ok ? '← ' + msg.action + ': ' + msg.result
+                  : '← ' + msg.action + ' failed: ' + msg.error);
+  }
+});
+
+buildNav();
+show('overview');
+</script>
+</body>
+</html>
+"""
+
+
+# The modal page demoed from the UI Toolkit tab: orca.submit(payload) resolves the
+# blocking show_dialog() call with that payload; orca.close() resolves it with None.
+MODAL_PAGE = r"""<!DOCTYPE html>
+<html><head><meta charset="utf-8"></head>
+<body style="padding:18px">
+  <h3 style="margin-top:0">Modal dialog</h3>
+  <p>show_dialog() blocks the plugin until this closes, then returns the submitted payload.</p>
+  <p><input id="note" style="width:100%" value="hello from the modal"></p>
+  <p style="text-align:right">
+    <button style="background:transparent;color:var(--orca-fg);border-color:var(--orca-border)"
+            onclick="orca.postMessage({live: document.getElementById('note').value})">Post while open</button>
+    <button style="background:transparent;color:var(--orca-fg);border-color:var(--orca-border)"
+            onclick="orca.close()">Cancel</button>
+    <button onclick="orca.submit({note: document.getElementById('note').value})">Submit</button>
+  </p>
+</body></html>
+"""
+
+CHILD_PAGE = r"""<!DOCTYPE html>
+<html><head><meta charset="utf-8"></head>
+<body style="padding:18px">
+  <h3 style="margin-top:0">Child window</h3>
+  <p>Same create_window() API — one plugin, several windows.</p>
+  <p><button onclick="orca.postMessage({command:'ping'})">Ping the plugin</button></p>
+  <div id="log" style="color:var(--orca-muted)"></div>
+  <script>
+    var n = 0;
+    orca.onMessage(function (msg) {
+      if (msg && msg.command === 'pong')
+        document.getElementById('log').textContent = 'pong #' + (++n) + ' via child.post()';
+    });
+  </script>
+</body></html>
+"""
+
+
+# --------------------------------------------------------------------------- #
+# the plugin
+# --------------------------------------------------------------------------- #
+class HostInspectorPanel(orca.script.ScriptPluginCapabilityBase):
+    win = None
+    child = None
+
+    def get_name(self):
+        return "Host Inspector"
+
+    def execute(self):
+        # Capability objects are instantiated once per plugin load, so a second
+        # Run lands on the same instance — close any previous windows first, or
+        # the old panel would keep posting into the new one.
+        if self.win is not None and self.win.is_open():
+            self.win.close()
+        if self.child is not None:
+            self.child.close()
+            self.child = None
+        # Non-modal: returns immediately. The window is host-owned and lives on
+        # after execute() returns; on_message keeps firing when the page posts.
+        self.win = orca.host.ui.create_window(
+            title="Host Inspector",
+            html=PAGE,
+            width=940,
+            height=680,
+            on_message=self.on_message,
+            on_close=self.on_close,
+        )
+        return orca.ExecutionResult.success("Host Inspector opened.")
+
+    # Called on the UI thread when the page posts a message. Every branch posts
+    # a reply carrying ok/error so the page never waits on a silent failure.
+    def on_message(self, msg):
+        msg = msg or {}
+        command = msg.get("command")
+        if command == "fetch":
+            self.send_section(msg.get("section", ""))
+        elif command == "mesh":
+            self.send_mesh(int(msg.get("object", -1)), int(msg.get("volume", -1)))
+        elif command == "preset_config":
+            self.send_preset_config(msg.get("collection", ""), msg.get("name", ""))
+        elif command == "ui":
+            self.run_ui_action(msg)
+
+    def on_close(self):
+        if self.child is not None:
+            self.child.close()
+            self.child = None
+        print("Host Inspector closed")
+
+    def send_section(self, section):
+        builder = SECTION_BUILDERS.get(section)
+        reply = {"command": "section", "section": section}
+        if builder is None:
+            self.win.post({**reply, "ok": False, "error": f"unknown section {section!r}"})
+            return
+        try:
+            self.win.post({**reply, "ok": True, "data": builder()})
+        except Exception as exc:
+            self.win.post({**reply, "ok": False, "error": str(exc)})
+
+    def send_mesh(self, object_index, volume_index):
+        reply = {"command": "mesh", "object": object_index, "volume": volume_index}
+        try:
+            self.win.post({**reply, "ok": True,
+                           "data": build_mesh(object_index, volume_index)})
+        except Exception as exc:
+            self.win.post({**reply, "ok": False, "error": str(exc)})
+
+    def send_preset_config(self, collection, name):
+        reply = {"command": "preset_config", "collection": collection, "name": name}
+        try:
+            self.win.post({**reply, "ok": True,
+                           "data": build_preset_config(collection, name)})
+        except Exception as exc:
+            self.win.post({**reply, "ok": False, "error": str(exc)})
+
+    # ---------------------------------------------------------------- ui demos
+    def run_ui_action(self, msg):
+        action = msg.get("action", "")
+        reply = {"command": "ui_result", "action": action}
+
+        def report(result):
+            self.win.post({**reply, "ok": True, "result": result})
+
+        try:
+            if action == "message":
+                clicked = orca.host.ui.message(
+                    msg.get("text") or "Hello from Host Inspector",
+                    title="Host Inspector",
+                    buttons=msg.get("buttons", "ok"),
+                    icon=msg.get("icon", "info"))
+                report(f"user clicked {clicked!r}")
+            elif action == "modal":
+                # We are on the UI thread, so this nests a modal event loop and
+                # blocks right here until the dialog closes. on_message still
+                # fires while the dialog is open (the log updates live).
+                result = orca.host.ui.show_dialog(
+                    html=MODAL_PAGE, title="Host Inspector — modal", width=420, height=280,
+                    on_message=lambda m: self.win.post(
+                        {**reply, "ok": True, "result": f"modal posted {m!r} while open"}))
+                report(f"show_dialog returned {result!r}")
+            elif action == "progress":
+                threading.Thread(target=self.progress_demo, daemon=True).start()
+                report("started on a worker thread…")
+            elif action == "pulse":
+                threading.Thread(target=self.pulse_demo, daemon=True).start()
+                report("started on a worker thread…")
+            elif action == "child_open":
+                if self.child is not None and self.child.is_open():
+                    report("child already open")
+                else:
+                    self.child = orca.host.ui.create_window(
+                        title="Host Inspector — child", html=CHILD_PAGE,
+                        width=380, height=240, on_message=self.on_child_message,
+                        on_close=lambda: self.win.post(
+                            {**reply, "ok": True, "result": "child window closed"}))
+                    report("child opened")
+            elif action == "child_close":
+                if self.child is not None:
+                    self.child.close()
+                else:
+                    report("no child window")
+            elif action == "child_state":
+                is_open = self.child is not None and self.child.is_open()
+                report(f"child.is_open() = {is_open}")
+            else:
+                self.win.post({**reply, "ok": False, "error": f"unknown action {action!r}"})
+        except Exception as exc:
+            self.win.post({**reply, "ok": False, "error": str(exc)})
+
+    def on_child_message(self, msg):
+        if (msg or {}).get("command") == "ping":
+            self.child.post({"command": "pong"})
+            self.win.post({"command": "ui_result", "action": "child",
+                           "ok": True, "result": "child pinged; replied with pong"})
+
+    # Both demos run on a worker thread: ProgressDialog calls marshal to the UI
+    # thread internally, and win.post() is thread-safe, so the app stays live.
+    def progress_demo(self):
+        style = (orca.host.ui.PD_APP_MODAL | orca.host.ui.PD_AUTO_HIDE |
+                 orca.host.ui.PD_CAN_ABORT | orca.host.ui.PD_ELAPSED_TIME |
+                 orca.host.ui.PD_ESTIMATED_TIME | orca.host.ui.PD_REMAINING_TIME)
+        outcome = "completed 40 steps"
+        with orca.host.ui.create_progress_dialog(
+                "Host Inspector", "Crunching very important numbers…",
+                maximum=40, style=style) as progress:
+            for step in range(1, 41):
+                time.sleep(0.05)
+                if not progress.update(step, f"Step {step}/40"):
+                    outcome = f"cancelled at step {step}"
+                    break
+        self.win.post({"command": "ui_result", "action": "progress",
+                       "ok": True, "result": outcome})
+
+    def pulse_demo(self):
+        # ui.ProgressDialog(...) is the constructor form of create_progress_dialog().
+        with orca.host.ui.ProgressDialog(
+                "Host Inspector", "Waiting for something indeterminate…",
+                style=orca.host.ui.PD_APP_MODAL | orca.host.ui.PD_AUTO_HIDE) as progress:
+            for _ in range(10):                     # manual single-shot pulses...
+                time.sleep(0.1)
+                if not progress.pulse("Manual pulse()…"):
+                    break
+            progress.start_pulse(80, "Host-timed start_pulse()…")   # ...then host-timed
+            time.sleep(1.5)
+            progress.stop_pulse()
+            was_open = progress.is_open()
+        self.win.post({"command": "ui_result", "action": "pulse", "ok": True,
+                       "result": f"pulsed manually + via timer (is_open while shown: {was_open})"})
+
+
+@orca.plugin
+class HostInspectorPlugin(orca.base):
+    def register_capabilities(self):
+        orca.register_capability(HostInspectorPanel)