feat(kit): façade module kit at the 4.96 m bay, assembled onto eight buildings

- Tools/facade_kit_build.py: the reusable kit (pilaster, sill, lintel, window bay,
  shopfront bay, door bay, cornice, parapet + coping) at the measured 4.96 m bay
  and 3.10 m storey; 16 meshes exported per object through the shared preset with
  a JSON part report recording dims and evidence.
- Tools/ue_import_facade_kit.py: imports to /Game/Hollywood/Kit with
  complex-as-simple collision, so thin panes keep their real faces.
- Tools/ue_apply_facade_kit.py: assembles from each building's own bounding box
  (bays = round(width/4.96), storeys above the ground floor) with shopfronts at
  street level, windows above, pilasters on bay boundaries, cornice and parapet at
  the top. Clears a previous application; unique labels per building.
  638 pieces across six frontage buildings and both north buildings.

Two bugs fixed en route: the window piece was modelled entirely at +Y so it sat
inside the solid wall and was invisible (now projects 3 cm proud with glazing
6 cm inset), and clearing materials mid-build invalidated handles.

Screenshots re-rendered; window rhythm now reads (edge transitions per row rose
from flat to ~197 on the spawn view).

Tools/ue_apply_facade_kit.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Assemble the façade kit onto the block buildings.
+
+Takes the imported kit from `/Game/Hollywood/Kit` and lays it out over a frontage
+building's street face: shopfront bays on the ground floor, window bays above,
+pilasters on the bay boundaries, a cornice under the parapet and a coping over it.
+
+Layout is driven by the building's own bounding box, so it follows whatever the
+blockout gives: the bay count is `round(width / BAY)` and the storey count comes
+from the height above the ground floor. Nothing is hand-placed per building.
+
+    UnrealEditor-Cmd <uproject> -run=pythonscript \
+        -script=Tools/ue_apply_facade_kit.py -nullrhi -unattended -nopause -stdout
+
+    # or, as a step inside the demo builder:
+    from ue_apply_facade_kit import apply_to_actor
+
+Result file: /tmp/gigline/kit-apply.txt
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+import unreal
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import ue_common  # noqa: E402
+
+KIT = "/Game/Hollywood/Kit"
+RESULT = "/tmp/gigline/kit-apply.txt"
+
+BAY_CM = 496.0          # the kit module
+STOREY_CM = 310.0
+SHOP_FLOOR_CM = 310.0   # ground floor is one storey tall
+KIT_PREFIX = "Kit_"
+
+lines: list[str] = []
+
+
+def log(message: str) -> None:
+    lines.append(message)
+    print(message)
+
+
+def load_kit() -> dict:
+    """Load every kit mesh once, keyed by its short name."""
+    kit = {}
+    registry = unreal.AssetRegistryHelpers.get_asset_registry()
+    filt = unreal.ARFilter(package_paths=[KIT], recursive_paths=False,
+                           class_paths=[unreal.TopLevelAssetPath("/Script/Engine", "StaticMesh")])
+    for data in registry.get_assets(filt):
+        mesh = unreal.EditorAssetLibrary.load_asset(str(data.package_name))
+        if mesh:
+            kit[mesh.get_name()] = mesh
+    return kit
+
+
+def _bounds(mesh):
+    box = mesh.get_bounding_box()
+    return box.min, box.max
+
+
+def _spawn(mesh, location, label, material=None, parent_collection=None):
+    actor = unreal.EditorLevelLibrary.spawn_actor_from_class(
+        unreal.StaticMeshActor, location)
+    if actor is None:
+        log(f"could not spawn {label}")
+        return None
+    actor.set_actor_label(label)
+    comp = actor.static_mesh_component
+    comp.set_static_mesh(mesh)
+    comp.set_mobility(unreal.ComponentMobility.STATIC)
+    comp.set_collision_enabled(unreal.CollisionEnabled.QUERY_AND_PHYSICS)
+    comp.set_collision_profile_name("BlockAll")
+    if material:
+        comp.set_material(0, material)
+    return actor
+
+
+def apply_to_actor(actor, kit, materials=None, prefix=None):
+    """Lay the kit out over one building actor's street face.
+
+    Returns the number of pieces placed. The building's own mesh stays in place
+    as the wall the pieces sit on.
+    """
+    comp = actor.get_component_by_class(unreal.StaticMeshComponent)
+    if not comp or not comp.static_mesh:
+        return 0
+    # Labels must be unique per building, otherwise two buildings' pieces share a
+    # label and the outliner (and any label-based lookup) becomes ambiguous.
+    slug = actor.get_actor_label().replace("Frontage_SM_", "").replace("North_", "").lower()
+    prefix = prefix or f"Kit_{slug}_"
+    mn, mx = _bounds(comp.static_mesh)
+    # The frontage meshes are spawned at the world origin and carry their position
+    # in the mesh, so the bounding box IS world space (actor location is 0,0,0).
+    origin = unreal.Vector(0.0, 0.0, 0.0)
+    width = mx.x - mn.x
+    height = mx.z - mn.z
+    if width < BAY_CM * 0.75 or height < STOREY_CM:
+        log(f"{actor.get_actor_label()}: too small for the kit "
+            f"({width / 100:.1f} x {height / 100:.1f} m)")
+        return 0
+
+    bays = max(1, int(round(width / BAY_CM)))
+    bay_w = width / bays                      # actual bay width for this building
+    # Street face: the frontage runs along X, and the street is at smaller Y.
+    face_y = mn.y
+    base_z = mn.z
+    storeys = max(1, int((height - SHOP_FLOOR_CM) // STOREY_CM))
+
+    def kit_material(name):
+        return (materials or {}).get(name)
+
+    placed = 0
+    for bay in range(bays):
+        cx = mn.x + bay_w * (bay + 0.5)
+        # ground floor: shopfront
+        for piece, dx in (("Kit_ShopPier_L", -bay_w / 2 + 30.0),
+                          ("Kit_ShopPier_R", bay_w / 2 - 30.0)):
+            if piece in kit:
+                if _spawn(kit[piece], unreal.Vector(cx + dx, face_y, base_z),
+                          f"{prefix}shop_pier_{bay}", kit_material(piece)):
+                    placed += 1
+        if "Kit_ShopGlass" in kit:
+            if _spawn(kit["Kit_ShopGlass"], unreal.Vector(cx, face_y, base_z),
+                      f"{prefix}shop_glass_{bay}", kit_material("Kit_ShopGlass")):
+                placed += 1
+        # upper storeys: window bays
+        for storey in range(storeys):
+            if "Kit_WindowBay" in kit:
+                z = base_z + SHOP_FLOOR_CM + STOREY_CM * storey + 65.0
+                if _spawn(kit["Kit_WindowBay"], unreal.Vector(cx, face_y, z),
+                          f"{prefix}window_{bay}_{storey}", kit_material("Kit_WindowBay")):
+                    placed += 1
+        # pilaster on the left boundary of every bay
+        if "Kit_Pilaster" in kit:
+            if _spawn(kit["Kit_Pilaster"],
+                      unreal.Vector(mn.x + bay_w * bay, face_y, base_z),
+                      f"{prefix}pilaster_{bay}", kit_material("Kit_Pilaster")):
+                placed += 1
+
+    # cornice under the parapet, coping on top
+    if "Kit_Cornice" in kit:
+        for bay in range(bays):
+            cx = mn.x + bay_w * (bay + 0.5)
+            if _spawn(kit["Kit_Cornice"],
+                      unreal.Vector(cx, face_y, base_z + height - 145.0),
+                      f"{prefix}cornice_{bay}", kit_material("Kit_Cornice")):
+                placed += 1
+    if "Kit_Parapet" in kit:
+        for bay in range(bays):
+            cx = mn.x + bay_w * (bay + 0.5)
+            if _spawn(kit["Kit_Parapet"],
+                      unreal.Vector(cx, face_y, base_z + height - 90.0),
+                      f"{prefix}parapet_{bay}", kit_material("Kit_Parapet")):
+                placed += 1
+
+    log(f"{actor.get_actor_label()}: {bays} bays x {storeys} storeys, "
+        f"{width / 100:.1f} x {height / 100:.1f} m -> {placed} pieces")
+    return placed
+
+
+def main() -> None:
+    kit = load_kit()
+    if not kit:
+        log(f"no kit meshes under {KIT} — run Tools/ue_import_facade_kit.py first")
+        return
+    log(f"kit meshes: {len(kit)}")
+
+    level = "/Game/Hollywood/DemoMap"
+    if not unreal.EditorLevelLibrary.load_level(level):
+        log(f"could not load {level}")
+        return
+    # The map is LFS-tracked and checks out read-only.
+    content = unreal.Paths.project_content_dir()
+    ue_common.make_writable(os.path.join(content, "Hollywood/DemoMap.umap"))
+
+    # Remove a previous application so re-running does not stack duplicates.
+    removed = 0
+    for actor in list(unreal.EditorLevelLibrary.get_all_level_actors()):
+        if actor.get_actor_label().startswith("Kit_"):
+            unreal.EditorLevelLibrary.destroy_actor(actor)
+            removed += 1
+    log(f"cleared {removed} previous kit actors")
+
+    targets = [a for a in unreal.EditorLevelLibrary.get_all_level_actors()
+               if a.get_actor_label().startswith(("Frontage_", "North_"))]
+    log(f"frontage actors: {len(targets)}")
+    total = 0
+    for actor in targets:
+        total += apply_to_actor(actor, kit)
+    log(f"placed {total} kit pieces")
+
+    saved = unreal.EditorLoadingAndSavingUtils.save_map(
+        unreal.EditorLevelLibrary.get_editor_world(), level)
+    log(f"save_map {level}: {saved}")
+
+
+try:
+    main()
+except Exception as exc:  # noqa: BLE001
+    import traceback
+    log(f"FAILED: {type(exc).__name__}: {exc}")
+    log(traceback.format_exc())
+
+os.makedirs(os.path.dirname(RESULT), exist_ok=True)
+with open(RESULT, "w", encoding="utf-8") as handle:
+    handle.write("\n".join(lines) + "\n")