@jgengine/core 0.13.0 → 0.15.0-next.0

package/dist/world/cityBlocks.d.ts

@@ -94,6 +94,51 @@ export declare function extractBlocks(streets: readonly FabricStreet[], hx: numb
         width: number;
     }[];
 };
+/** Minimal node/edge shapes {@link extractGraphBlocks} needs (matches `StreetNetwork.nodes`/`edges`). */
+export interface GraphBlockNode {
+    x: number;
+    z: number;
+}
+/** One street-graph edge {@link extractGraphBlocks} traces block faces through. */
+export interface GraphBlockEdge {
+    /** Endpoint node indices. `points[0]` sits exactly on node `a`, the last on node `b`. */
+    a: number;
+    b: number;
+    points: readonly (readonly [number, number])[];
+    width: number;
+    level: FabricStreet["level"];
+    /** Owning street index, carried through to pruned dead-end corridors so callers can line them. */
+    street?: number;
+}
+/** One block from {@link extractGraphBlocks}: the face polygon and its inset land ring. */
+export interface GraphBlockRings {
+    /** Face polygon on road CENTERLINES (as traced, interior faces CCW). */
+    face: Vec2[];
+    /** Land ring: face inset by each bordering edge's half width + curb margin + sidewalk band. */
+    land: Vec2[];
+}
+/**
+ * Extract closed blocks from an EXACT street graph — the `nodes`/`edges` a street network already
+ * carries — instead of re-deriving topology from welded polylines. Half-edges are ordered by true
+ * departure angle at each node, dangling chains are pruned first (returned as `deadEnds` for
+ * corridor carving), interior faces are traced through the rotation system, and each face is inset
+ * to its land ring by the bordering edges' half-widths (+ curb + sidewalk). Robust against wandered
+ * and arc-filleted centerlines, which defeat proximity welding. Pure bounded geometry.
+ *
+ * @capability city-district extract block polygons directly from a street network's exact graph
+ */
+export declare function extractGraphBlocks(nodes: readonly GraphBlockNode[], edges: readonly GraphBlockEdge[], params: {
+    sidewalkBase: number;
+    curbMargin: number;
+}): {
+    blocks: GraphBlockRings[];
+    deadEnds: {
+        pts: Vec2[];
+        width: number;
+        level: FabricStreet["level"];
+        street?: number;
+    }[];
+};
 /** Arc-length station lookup along a closed ring. */
 export declare class RingWalker {
     readonly ring: readonly Vec2[];

package/dist/world/cityBlocks.js

@@ -11,8 +11,20 @@
  * @capability city-district road-derived block polygons, parcel subdivision, buildable footprints
  */
 import { clipHalfPlane, dedupeRing, distanceToRing, ensureCcw, extractSimpleLoop, insetRing, pointInPolygon, polygonArea, polygonMeanWidth, polygonSignedArea, } from "./cityGeometry.js";
+import { isProductionEnvironment } from "../devtools/saveEndpoint.js";
 const MAX_BLOCKS = 420;
 const WELD_RADIUS = 1.4;
+// Proximity welding (WELD_RADIUS) assumes near-collinear / aligned centerlines. Wandered and
+// arc-filleted streets weld into a degenerate face set: a real case went 38 streets → 2 faces
+// with no signal. These constants gate a dev-mode collapse warning. A connected road grid has
+// bounded faces on the order of its street count (Euler: bounded faces = edges − nodes + 1), so
+// faces far below the street count means welding ate the topology, not that the district is sparse.
+// COLLAPSE_MIN_STREETS avoids false positives on genuinely tiny inputs (a handful of crossings
+// legitimately yields few faces); COLLAPSE_RATIO_DIVISOR flags only a gross collapse — with 8
+// streets it fires under 2 faces, with 38 streets under 9 (the 38 → 2 case triggers, a healthy
+// grid where faces ≥ street count never does).
+const COLLAPSE_MIN_STREETS = 8;
+const COLLAPSE_RATIO_DIVISOR = 4;
 const RIM_SNAP = 6;
 /** Sidewalk band width by street hierarchy (base = the district's street-level width). */
 export function sidewalkWidthFor(level, base) {
@@ -346,6 +358,7 @@ function extractFaces(nodes, halves) {
 export function extractBlocks(streets, hx, hz, params) {
     const { nodes, halves, deadEnds } = buildGraph(streets, hx, hz);
     const faces = extractFaces(nodes, halves);
+    warnOnImplausibleCollapse(streets.length, faces.length);
     faces.sort((a, b) => polygonArea(b.polygon) - polygonArea(a.polygon));
     const blocks = [];
     for (const face of faces) {
@@ -391,6 +404,26 @@ export function extractBlocks(streets, hx, hz, params) {
     }
     return { blocks, deadEnds };
 }
+/**
+ * Dev-mode guard: warn when {@link extractBlocks} extracts implausibly few faces for the street
+ * count — the silent-collapse failure mode where proximity welding folds wandered / arc-filleted
+ * centerlines into a degenerate face set (see issue #1502: 38 streets → 2 faces). No-ops in a
+ * production build. Points at {@link extractGraphBlocks}, which traces faces from the exact street
+ * graph and is robust against the centerlines that defeat welding.
+ */
+function warnOnImplausibleCollapse(streetCount, faceCount) {
+    if (isProductionEnvironment() || typeof console === "undefined")
+        return;
+    if (streetCount < COLLAPSE_MIN_STREETS)
+        return;
+    if (faceCount >= streetCount / COLLAPSE_RATIO_DIVISOR)
+        return;
+    console.warn(`[jgengine:extractBlocks] ${streetCount} streets extracted only ${faceCount} block face(s) — ` +
+        "implausibly few, likely a silent proximity-welding collapse on wandered / arc-filleted " +
+        "centerlines (the WELD_RADIUS heuristic assumes near-aligned streets). The fabric will look " +
+        "empty rather than error. Trace blocks from the exact street graph with extractGraphBlocks() " +
+        "instead, which is robust against centerlines that defeat welding.");
+}
 /** Reverse per-edge street labels when a ring got rewound to CCW. */
 function remapReversedEdgeStreets(streetsPerEdge) {
     const n = streetsPerEdge.length;
@@ -400,6 +433,132 @@ function remapReversedEdgeStreets(streetsPerEdge) {
         out[i] = streetsPerEdge[(2 * n - 2 - i) % n];
     return out;
 }
+/**
+ * Extract closed blocks from an EXACT street graph — the `nodes`/`edges` a street network already
+ * carries — instead of re-deriving topology from welded polylines. Half-edges are ordered by true
+ * departure angle at each node, dangling chains are pruned first (returned as `deadEnds` for
+ * corridor carving), interior faces are traced through the rotation system, and each face is inset
+ * to its land ring by the bordering edges' half-widths (+ curb + sidewalk). Robust against wandered
+ * and arc-filleted centerlines, which defeat proximity welding. Pure bounded geometry.
+ *
+ * @capability city-district extract block polygons directly from a street network's exact graph
+ */
+export function extractGraphBlocks(nodes, edges, params) {
+    // --- prune dangling chains: an edge touching a degree-1 node can't border a closed face ---
+    const degree = new Array(nodes.length).fill(0);
+    const alive = edges.map((e) => e.a !== e.b && e.points.length >= 2);
+    edges.forEach((e, i) => {
+        if (!alive[i])
+            return;
+        degree[e.a] += 1;
+        degree[e.b] += 1;
+    });
+    const deadEnds = [];
+    let pruned = true;
+    while (pruned) {
+        pruned = false;
+        for (let i = 0; i < edges.length; i += 1) {
+            if (!alive[i])
+                continue;
+            const e = edges[i];
+            if (degree[e.a] === 1 || degree[e.b] === 1) {
+                alive[i] = false;
+                deadEnds.push({ pts: e.points.map((p) => [p[0], p[1]]), width: e.width, level: e.level, street: e.street });
+                degree[e.a] -= 1;
+                degree[e.b] -= 1;
+                pruned = true;
+            }
+        }
+    }
+    const halves = [];
+    const out = nodes.map(() => []);
+    const departAngle = (pts) => {
+        // First non-degenerate segment sets the true departure direction.
+        for (let i = 1; i < pts.length; i += 1) {
+            const dx = pts[i][0] - pts[0][0];
+            const dz = pts[i][1] - pts[0][1];
+            if (dx * dx + dz * dz > 1e-12)
+                return Math.atan2(dz, dx);
+        }
+        return 0;
+    };
+    const angles = [];
+    edges.forEach((e, ei) => {
+        if (!alive[ei])
+            return;
+        const fwd = e.points.map((p) => [p[0], p[1]]);
+        const rev = [...fwd].reverse();
+        const h0 = halves.length;
+        halves.push({ to: e.b, pts: fwd, twin: h0 + 1, edge: ei, visited: false });
+        halves.push({ to: e.a, pts: rev, twin: h0, edge: ei, visited: false });
+        angles.push(departAngle(fwd), departAngle(rev));
+        out[e.a].push(h0);
+        out[e.b].push(h0 + 1);
+    });
+    for (const list of out)
+        list.sort((a, b) => angles[a] - angles[b]);
+    // --- trace interior faces: at each destination, rotate clockwise from the twin ---
+    const blocks = [];
+    for (let start = 0; start < halves.length && blocks.length < MAX_BLOCKS; start += 1) {
+        if (halves[start].visited)
+            continue;
+        const polygon = [];
+        const segEdge = [];
+        let current = start;
+        let guard = 0;
+        let closed = false;
+        while (guard < halves.length + 4) {
+            guard += 1;
+            const half = halves[current];
+            if (half.visited)
+                break;
+            half.visited = true;
+            for (let i = 0; i + 1 < half.pts.length; i += 1) {
+                polygon.push(half.pts[i]);
+                segEdge.push(half.edge);
+            }
+            const list = out[half.to];
+            const idx = list.indexOf(half.twin);
+            if (idx < 0)
+                break;
+            current = list[(idx - 1 + list.length) % list.length];
+            if (current === start) {
+                closed = true;
+                break;
+            }
+        }
+        if (!closed || polygon.length < 3)
+            continue;
+        if (polygonSignedArea(polygon) <= 1)
+            continue; // outer face (CW) or degenerate sliver
+        // Dedupe near-coincident vertices while keeping each surviving segment's source edge.
+        const ring = [];
+        const ringEdge = [];
+        for (let i = 0; i < polygon.length; i += 1) {
+            const p = polygon[i];
+            const prev = ring[ring.length - 1];
+            if (prev !== undefined && Math.hypot(prev[0] - p[0], prev[1] - p[1]) < 0.02)
+                continue;
+            ring.push(p);
+            ringEdge.push(segEdge[i]);
+        }
+        while (ring.length > 1 && Math.hypot(ring[0][0] - ring[ring.length - 1][0], ring[0][1] - ring[ring.length - 1][1]) < 0.02) {
+            ring.pop();
+            ringEdge.pop();
+        }
+        if (ring.length < 3)
+            continue;
+        const dist = ring.map((_, i) => {
+            const e = edges[ringEdge[i]];
+            const walk = e.level === "lane" ? 0 : sidewalkWidthFor(e.level, params.sidewalkBase);
+            return e.width / 2 + params.curbMargin + walk;
+        });
+        const land = insetRing(ring, dist);
+        blocks.push({ face: ring, land });
+    }
+    blocks.sort((a, b) => polygonArea(b.land) - polygonArea(a.land));
+    return { blocks, deadEnds };
+}
 /** Arc-length station lookup along a closed ring. */
 export class RingWalker {
     ring;

package/dist/world/cityContent.d.ts

@@ -14,6 +14,15 @@ import type { WeightedParamEntry } from "../scene/sceneKinds.js";
 export type CityLotClass = "tower" | "slab" | "shop" | "rowhouse" | "house" | "mansion" | "farmhouse" | "barn" | "silo";
 /** All classes, for schema hints and validation. */
 export declare const CITY_LOT_CLASSES: readonly CityLotClass[];
+/**
+ * Filler classes used ONLY by the block-interior fill pass (`resolveCityLotContent` at a high
+ * `blockFill`). They are deliberately kept OUT of {@link CITY_LOT_CLASSES} so a zone mix can never
+ * weight them onto street frontage — they exist to pack the backs of Manhattan-style blocks with
+ * parking structures and warehouses/depots, mixed in with ordinary zone classes.
+ */
+export type CityFillerClass = "garage" | "depot";
+/** All filler classes, for validation and interior-pass allow-lists. */
+export declare const CITY_FILLER_CLASSES: readonly CityFillerClass[];
 /** Zone band a lot falls in: dense core, middle ring, or the district edge. */
 export type CityZoneBand = "core" | "mid" | "edge";
 /** How the radial zone metric maps to bands. */
@@ -37,6 +46,11 @@ export interface CityLotPiece {
     /** Banded walls receive the window-strip treatment in the renderer. */
     banded: boolean;
 }
+/**
+ * Natural frontage-width range (meters) of a class's massing — what the plot-size class bias reads
+ * so towers land on wide plots and rowhouses on narrow ones. @internal
+ */
+export declare function classWidthRange(cls: string): readonly [number, number] | undefined;
 /** Placement numbers a resolved lot carries out of the class profile. @internal */
 export interface ClassPlacement {
     width: number;
@@ -52,7 +66,16 @@ export interface ClassPlacement {
  * aligned building wall; spacing likewise, so neighbors form rhythmic rows instead of scatter.
  * @internal
  */
-export declare function rollClassPlacement(cls: CityLotClass, rng: () => number, lotScale: number, floorsMin: number, floorsMax: number, setbackBase: number, spacingBase: number): ClassPlacement;
+export declare function rollClassPlacement(cls: CityLotClass | CityFillerClass, rng: () => number, lotScale: number, floorsMin: number, floorsMax: number, setbackBase: number, spacingBase: number, widthStretch?: number): ClassPlacement;
+/**
+ * Weight multiplier favouring classes whose natural frontage fits a plot of width `plotW`: a class
+ * far wider than the plot (a tower profile on a 6 m slice) is heavily downweighted, a class that
+ * would rattle around a much wider plot is mildly downweighted, and anything whose width range
+ * genuinely fits keeps weight 1. Pure data over {@link CLASS_PROFILES} — this is what turns a
+ * mixed-plot frontage into terraces on the slices and detached houses on the wide parcels.
+ * @internal
+ */
+export declare function classPlotFit(cls: CityLotClass, plotW: number): number;
 /**
  * Normalized zone metric for a point in district-local space: 0 at the center line, 1 at the rim,
  * shaped to the district's rectangle (Chebyshev) so bands follow the volume's footprint.
@@ -68,7 +91,28 @@ export declare function pickClass(mix: readonly WeightedParamEntry[], roll: numb
  * floors, and stream always yield the identical silhouette. Sizes are in meters, lot-local.
  * @internal
  */
-export declare function buildLotPieces(cls: CityLotClass, width: number, depth: number, floors: number, floorHeight: number, rng: () => number): CityLotPiece[];
+export declare function buildLotPieces(cls: CityLotClass | CityFillerClass, width: number, depth: number, floors: number, floorHeight: number, rng: () => number): CityLotPiece[];
+/**
+ * A block-scale landmark class. Unlike {@link CityLotClass} these are never weighted into a zone
+ * mix — the landmark pass in `resolveCityLotContent` picks clusters of adjacent lots and stamps one
+ * of these over them. Each expresses with the same four piece shapes (box/gable/cylinder/dome) at a
+ * much larger footprint (~40–90 m).
+ */
+export type CityLandmarkClass = "hall" | "arena" | "market" | "campus";
+/** All landmark classes, for schema hints, validation, and default allow-lists. */
+export declare const CITY_LANDMARK_CLASSES: readonly CityLandmarkClass[];
+/** Minimum depth-into-block factor for a landmark class (the pass grows shallow clusters to this). @internal */
+export declare function landmarkMinDepthFactor(cls: CityLandmarkClass): number;
+/** Roll a landmark's floor count from its profile range. @internal */
+export declare function landmarkFloors(cls: CityLandmarkClass, rng: () => number): number;
+/**
+ * Compose the massing pieces for one landmark parcel, filling the given `width`×`depth` footprint
+ * (lot-local, x along frontage, z into the block). Deterministic per `rng`. Every piece is kept
+ * inside the `[-width/2, width/2] × [-depth/2, depth/2]` box so the reported footprint matches the
+ * merged cluster's AABB. Sizes are in meters.
+ * @internal
+ */
+export declare function buildLandmarkPieces(cls: CityLandmarkClass, width: number, depth: number, floors: number, floorHeight: number, rng: () => number): CityLotPiece[];
 /** Tree species a district's tree mix can weight — the renderer keeps one canopy mesh per species. */
 export type CityTreeSpecies = "broadleaf" | "conifer" | "palm" | "cypress";
 /** All species, for schema hints and validation. */

package/dist/world/cityContent.js

@@ -10,6 +10,8 @@ export const CITY_LOT_CLASSES = [
     "barn",
     "silo",
 ];
+/** All filler classes, for validation and interior-pass allow-lists. */
+export const CITY_FILLER_CLASSES = ["garage", "depot"];
 const CLASS_PROFILES = {
     tower: { width: [16, 24], depth: [14, 20], setbackFactor: 0.3, spacingFactor: 1, floors: [12, 34], backRow: true },
     slab: { width: [14, 20], depth: [11, 15], setbackFactor: 0.5, spacingFactor: 1, floors: [4, 9], backRow: true },
@@ -20,7 +22,17 @@ const CLASS_PROFILES = {
     farmhouse: { width: [11, 14], depth: [9, 12], setbackFactor: 2.8, spacingFactor: 4, floors: [2, 2], backRow: false },
     barn: { width: [12, 16], depth: [9, 13], setbackFactor: 3.6, spacingFactor: 5, floors: [1, 1], backRow: false },
     silo: { width: [5, 6], depth: [5, 6], setbackFactor: 4, spacingFactor: 3, floors: [1, 1], backRow: false },
+    // Interior-fill fillers: broad, plain footprints that pack the backs of dense blocks.
+    garage: { width: [18, 26], depth: [16, 22], setbackFactor: 0.3, spacingFactor: 0.4, floors: [2, 6], backRow: true },
+    depot: { width: [20, 30], depth: [18, 26], setbackFactor: 0.4, spacingFactor: 0.5, floors: [1, 2], backRow: true },
 };
+/**
+ * Natural frontage-width range (meters) of a class's massing — what the plot-size class bias reads
+ * so towers land on wide plots and rowhouses on narrow ones. @internal
+ */
+export function classWidthRange(cls) {
+    return CLASS_PROFILES[cls]?.width;
+}
 function range(rng, [lo, hi]) {
     return lo + rng() * (hi - lo);
 }
@@ -30,11 +42,13 @@ function range(rng, [lo, hi]) {
  * aligned building wall; spacing likewise, so neighbors form rhythmic rows instead of scatter.
  * @internal
  */
-export function rollClassPlacement(cls, rng, lotScale, floorsMin, floorsMax, setbackBase, spacingBase) {
+export function rollClassPlacement(cls, rng, lotScale, floorsMin, floorsMax, setbackBase, spacingBase, widthStretch = 1) {
     const profile = CLASS_PROFILES[cls];
     const floors = Math.round(range(rng, profile.floors));
     return {
-        width: range(rng, profile.width) * lotScale,
+        // `widthStretch` (≥1, from the block-fill dial) is a post-multiply on the rolled width — it
+        // never changes the rng draw order, so the default (1) stays byte-identical.
+        width: range(rng, profile.width) * lotScale * widthStretch,
         depth: range(rng, profile.depth) * lotScale,
         setback: setbackBase * profile.setbackFactor * (0.9 + rng() * 0.2),
         gap: Math.max(0.2, spacingBase * profile.spacingFactor * (0.7 + rng() * 0.6)),
@@ -42,6 +56,26 @@ export function rollClassPlacement(cls, rng, lotScale, floorsMin, floorsMax, set
         backRow: profile.backRow,
     };
 }
+/**
+ * Weight multiplier favouring classes whose natural frontage fits a plot of width `plotW`: a class
+ * far wider than the plot (a tower profile on a 6 m slice) is heavily downweighted, a class that
+ * would rattle around a much wider plot is mildly downweighted, and anything whose width range
+ * genuinely fits keeps weight 1. Pure data over {@link CLASS_PROFILES} — this is what turns a
+ * mixed-plot frontage into terraces on the slices and detached houses on the wide parcels.
+ * @internal
+ */
+export function classPlotFit(cls, plotW) {
+    const [lo, hi] = CLASS_PROFILES[cls].width;
+    if (plotW < lo * 0.6)
+        return 0; // physically cannot fit — a tower never squeezes onto a slice
+    if (plotW < lo) {
+        const r = plotW / lo;
+        return Math.max(0.1, r * r);
+    }
+    if (plotW > hi * 1.7)
+        return Math.max(0.35, (hi * 1.7) / plotW);
+    return 1;
+}
 /**
  * Normalized zone metric for a point in district-local space: 0 at the center line, 1 at the rim,
  * shaped to the district's rectangle (Chebyshev) so bands follow the volume's footprint.
@@ -236,6 +270,130 @@ export function buildLotPieces(cls, width, depth, floors, floorHeight, rng) {
             }
             return pieces;
         }
+        case "garage": {
+            // Parking structure: a plain banded box (the window bands read as deck slots) with a flat cap.
+            pieces.push(box([0, 0, 0], [width, H, depth], "wall", { grounded: true, banded: true }));
+            pieces.push(box([0, H, 0], [width * 1.02, 0.4, depth * 1.02], "trim"));
+            if (rng() < 0.6) {
+                // Stair/lift core poking above the roof deck.
+                const cx = (rng() - 0.5) * width * 0.5;
+                const cz = (rng() - 0.5) * depth * 0.4;
+                pieces.push(box([cx, H + 0.4, cz], [width * 0.16, 1.6 + rng() * 1.2, depth * 0.16], "accent"));
+            }
+            return pieces;
+        }
+        case "depot": {
+            // Warehouse/depot: a low broad box under a shallow gable, with an optional loading canopy.
+            const bw = width * 0.98;
+            const bd = depth * 0.96;
+            pieces.push(box([0, 0, 0], [bw, H, bd], "wall", { grounded: true }));
+            const roofH = Math.min(2.4 + rng() * 1.6, bd * 0.28);
+            pieces.push(gable([0, H, 0], [bw, roofH, bd]));
+            if (rng() < 0.5) {
+                pieces.push(box([0, Math.min(H - 0.4, 2.6), bd / 2 - 0.4], [bw * 0.55, 0.4, 0.8], "accent"));
+            }
+            return pieces;
+        }
+    }
+}
+/** All landmark classes, for schema hints, validation, and default allow-lists. */
+export const CITY_LANDMARK_CLASSES = ["hall", "arena", "market", "campus"];
+const LANDMARK_PROFILES = {
+    hall: { floors: [2, 3], minDepthFactor: 0.55 },
+    arena: { floors: [3, 5], minDepthFactor: 0.85 },
+    market: { floors: [1, 2], minDepthFactor: 0.6 },
+    campus: { floors: [3, 6], minDepthFactor: 0.7 },
+};
+/** Minimum depth-into-block factor for a landmark class (the pass grows shallow clusters to this). @internal */
+export function landmarkMinDepthFactor(cls) {
+    return LANDMARK_PROFILES[cls].minDepthFactor;
+}
+/** Roll a landmark's floor count from its profile range. @internal */
+export function landmarkFloors(cls, rng) {
+    return Math.round(range(rng, LANDMARK_PROFILES[cls].floors));
+}
+/**
+ * Compose the massing pieces for one landmark parcel, filling the given `width`×`depth` footprint
+ * (lot-local, x along frontage, z into the block). Deterministic per `rng`. Every piece is kept
+ * inside the `[-width/2, width/2] × [-depth/2, depth/2]` box so the reported footprint matches the
+ * merged cluster's AABB. Sizes are in meters.
+ * @internal
+ */
+export function buildLandmarkPieces(cls, width, depth, floors, floorHeight, rng) {
+    const H = Math.max(1, floors) * floorHeight;
+    const pieces = [];
+    switch (cls) {
+        case "hall": {
+            // Civic block: broad walled base, an entablature, a fronting colonnade, and a central dome.
+            const bw = width * 0.96;
+            const bd = depth * 0.96;
+            pieces.push(box([0, 0, 0], [bw, H, bd], "wall", { grounded: true }));
+            pieces.push(box([0, H, 0], [bw, 0.6, bd], "trim"));
+            const cols = Math.max(4, Math.round(bw / 6));
+            const colH = H * 0.92;
+            const zFront = bd / 2 - 0.6;
+            for (let i = 0; i < cols; i += 1) {
+                const t = cols === 1 ? 0.5 : i / (cols - 1);
+                const x = (t - 0.5) * (bw - 1.4);
+                pieces.push(box([x, 0, zFront], [0.7, colH, 0.7], "trim", { grounded: true }));
+            }
+            // Portico roof over the colonnade.
+            pieces.push(box([0, colH, zFront], [bw - 1.0, 0.5, 1.6], "roof"));
+            const dd = Math.min(bw, bd) * (0.4 + rng() * 0.06);
+            pieces.push({ shape: "dome", offset: [0, H, 0], size: [dd, dd * 0.55, dd], rotationY: 0, role: "roof", grounded: false, banded: false });
+            return pieces;
+        }
+        case "arena": {
+            // Bowl: an elliptical outer wall, a rim ring, and a sunken inner field ring.
+            const ow = width * 0.94;
+            const od = depth * 0.94;
+            pieces.push({ shape: "cylinder", offset: [0, 0, 0], size: [ow, H, od], rotationY: 0, role: "wall", grounded: true, banded: true });
+            pieces.push({ shape: "cylinder", offset: [0, H, 0], size: [ow * 0.99, 0.9, od * 0.99], rotationY: 0, role: "trim", grounded: false, banded: false });
+            pieces.push({ shape: "cylinder", offset: [0, 0, 0], size: [ow * 0.66, H * 0.5, od * 0.66], rotationY: 0, role: "accent", grounded: true, banded: false });
+            if (rng() < 0.6) {
+                // A short mast/scoreboard on the rim.
+                pieces.push(box([0, H, 0], [1.4, 3 + rng() * 3, 1.4], "trim"));
+            }
+            return pieces;
+        }
+        case "market": {
+            // Broad low gabled hall with an open stall face on the street side.
+            const bw = width * 0.97;
+            const bd = depth * 0.95;
+            pieces.push(box([0, 0, 0], [bw, H, bd], "wall", { grounded: true }));
+            const roofH = Math.min(4 + rng() * 2, bd * 0.4);
+            pieces.push(gable([0, H, 0], [bw, roofH, bd]));
+            // Clerestory monitor along the ridge.
+            pieces.push(box([0, H, 0], [bw * 0.5, roofH * 0.5, bd * 0.25], "accent"));
+            // Awning/stall lip on the front face.
+            pieces.push(box([0, Math.min(H - 0.5, 3), bd / 2 - 0.4], [bw * 0.94, 0.4, 1.0], "accent"));
+            return pieces;
+        }
+        case "campus": {
+            // Courtyard: four connected slab wings around an open center, varied heights.
+            const bw = width * 0.96;
+            const bd = depth * 0.96;
+            const wingT = Math.min(bw, bd) * 0.22;
+            const innerD = Math.max(1, bd - 2 * wingT);
+            const frontH = H * (0.9 + rng() * 0.2);
+            const backH = H * (0.85 + rng() * 0.2);
+            const leftH = H * (0.9 + rng() * 0.25);
+            const rightH = H * (1.0 + rng() * 0.2);
+            pieces.push(box([0, 0, (bd - wingT) / 2], [bw, frontH, wingT], "wall", { grounded: true, banded: true }));
+            pieces.push(box([0, 0, -(bd - wingT) / 2], [bw, backH, wingT], "wall", { grounded: true, banded: true }));
+            pieces.push(box([(bw - wingT) / 2, 0, 0], [wingT, rightH, innerD], "wall", { grounded: true, banded: true }));
+            pieces.push(box([-(bw - wingT) / 2, 0, 0], [wingT, leftH, innerD], "wall", { grounded: true, banded: true }));
+            // Parapet caps.
+            for (const [wx, wz, ww, wd, wh] of [
+                [0, (bd - wingT) / 2, bw, wingT, frontH],
+                [0, -(bd - wingT) / 2, bw, wingT, backH],
+                [(bw - wingT) / 2, 0, wingT, innerD, rightH],
+                [-(bw - wingT) / 2, 0, wingT, innerD, leftH],
+            ]) {
+                pieces.push(box([wx, wh, wz], [ww, 0.4, wd], "trim"));
+            }
+            return pieces;
+        }
     }
 }
 /** All species, for schema hints and validation. */