@jgengine/core 0.14.0 → 0.15.0

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. */

package/dist/world/cityGenerator.d.ts

@@ -1,41 +1,279 @@
 /**
- * The seed-driven procedural CITY GENERATOR — the composition seam over the two fabric engines:
- * {@link generateStreets} grows the street network, and {@link deriveBuildingLots} lines its
- * frontage with street-facing building lots. One call, one seed, one deterministic city: same rules
- * ⇒ identical streets and identical lots, with both engines' bounded-work caps intact. Local
- * (volume-centered) coords, same as the street generator; the caller translates into world space.
+ * The seed-driven procedural CITY GENERATOR — plot-first composition over the street and block
+ * engines. {@link generateStreets} grows the street network (with a seeded organic outline, so no
+ * two seeds share a silhouette), {@link extractBlocks} turns it into closed block polygons, and the
+ * plot pass subdivides every buildable block's street frontage into PLOTS of many sizes — narrow
+ * rowhouse slivers up to block-scale grand parcels. Everything that stands in the city stands on a
+ * plot, and every plot fronts a street by construction: there is no landmark special case (a
+ * landmark is just a grand plot) and no street-less interior fill. One call, one seed, one
+ * deterministic city. Local (volume-centered) coords; the caller translates into world space.
  *
- * Street dials default to a dense, gently-varied city net (high gridness/connectivity, light
- * winding); pass any subset of {@link StreetNetworkRules} to override, and lot options pass through
- * to the frontage engine untouched. Lanes are skipped as lot frontage by default — buildings line
- * boulevards, avenues, and streets — so alleys stay service alleys; opt lanes in via
- * `lots.laneFrontage`.
- *
- * @capability city-generator compose a deterministic city — street network plus street-facing building lots — from one seed
+ * @capability city-generator compose a deterministic city — street network, blocks, street-fronting plots of varied size — from one seed
  */
-import { type BuildingLotOptions, type PlacedBuildingLot } from "./buildingLots.js";
-import { type StreetNetwork, type StreetNetworkContext, type StreetNetworkRules } from "./streetGenerator.js";
-/** Options for {@link generateCity}: a seed, street-dial overrides, and lot pass-through options. */
+import type { PlacedBuildingLot } from "./buildingLots.js";
+import { type CityFillerClass, type CityLandmarkClass, type CityLotClass, type CityLotPiece, type CityZoneBand, type CityZoneProfile } from "./cityContent.js";
+import { type Vec2 } from "./cityGeometry.js";
+import type { WeightedParamEntry } from "../scene/sceneKinds.js";
+import { type StreetLevel, type StreetNetwork, type StreetNetworkContext, type StreetNetworkRules } from "./streetGenerator.js";
+/** Options for {@link generateCity}: a seed, street-dial overrides, and plot pass-through options. */
 export interface CityGeneratorOptions {
-    /** Drives both the street network and downstream lot/floor variation. */
+    /** Drives the street network and all downstream plot/class/massing variation. */
     seed: string;
-    /** Street-dial overrides; anything omitted takes the city defaults above. */
+    /** Street-dial overrides; anything omitted takes the city defaults above (including `outline`). */
     streets?: Partial<Omit<StreetNetworkRules, "seed">>;
-    /** Frontage-lot options, minus `roads` (the generated streets are the roads). */
-    lots?: Omit<BuildingLotOptions, "roads" | "seed"> & {
-        /** Also line `lane`-level streets (alleys) with lots. Default false. */
+    /** Plot-pass options (sizes scale off `footprint`, gaps off `spacing`, fronts off `setback`). */
+    lots?: {
+        /** Base plot-size hint: tier frontage/depth ranges scale by `w/12` and `d/10`. Default 12×10. */
+        footprint?: {
+            w: number;
+            d: number;
+        };
+        /** Base gap between neighbouring plots along a frontage, world units. Default 2. */
+        spacing?: number;
+        /** Mix between uniform medium plots (0) and the full zone/street tier distribution (1). Default 1. */
+        variety?: number;
+        /** Sidewalk strip between the curb and the building front, world units. Default 3. */
+        setback?: number;
+        /** Manhattan streetwall dial (0..1): frontage coverage and plot depth grow with it. Default {@link DEFAULT_BLOCK_FILL}. */
+        blockFill?: number;
+        /** Also line `lane`-level streets (alleys) with plots. Default false. */
         laneFrontage?: boolean;
+        /** Hard cap on emitted plots so a big network stays bounded. Default 600. */
+        maxLots?: number;
     };
     /** Ground sampler + bridge/tunnel toggles forwarded to the street generator. */
     context?: StreetNetworkContext;
+    /**
+     * Also resolve each plot into zone/class/floors/massing. Pass `true` for city defaults, or an
+     * overrides object to tune bands/mixes/floors. Omit (default) to keep the cheap geometry-only
+     * path — `lotContent` stays absent. See {@link resolveCityLotContent}.
+     */
+    content?: boolean | CityContentOverrides;
+}
+/** Size tier a plot was cut at. `grand` is the block-scale tier that used to be a landmark pass. */
+export type CityPlotTier = "small" | "medium" | "large" | "grand";
+/** All plot tiers, for schema hints and validation. */
+export declare const CITY_PLOT_TIERS: readonly CityPlotTier[];
+/** The street frontage a plot faces: which street, and the frontage chord along it. */
+export interface CityPlotFrontage {
+    /** Index into `network.streets`. */
+    street: number;
+    /** Frontage chord endpoints on the plot boundary. */
+    a: Vec2;
+    b: Vec2;
+}
+/** One polygonal plot cut from a block's street frontage. Every plot fronts a street. */
+export interface CityPlot {
+    /** Plot polygon (CCW) in local XZ. */
+    polygon: Vec2[];
+    /** Building-rect center inside the plot (matches the paired {@link PlacedBuildingLot}). */
+    center: Vec2;
+    /** Yaw turning the building front toward its street. */
+    rotationY: number;
+    /** Building-rect frontage width / depth fitted inside the plot polygon. */
+    width: number;
+    depth: number;
+    frontage: CityPlotFrontage;
+    /** Hierarchy level of the fronted street. */
+    streetLevel: StreetLevel;
+    /** Index of the block the plot was cut from; `-1` for plots lining a cul-de-sac/branch corridor. */
+    block: number;
+    tier: CityPlotTier;
+    /** True when the plot wraps a block corner (two frontages meet inside it). */
+    corner: boolean;
 }
-/** A generated city: the street network and the building lots lining its frontage. */
+/** A generated city: streets, plots (with rect building lots as a compat view), and park blocks. */
 export interface GeneratedCity {
     network: StreetNetwork;
+    /** Rect building-lot view of `plots` (same order, same indices) — the renderer-compat seam. */
     lots: PlacedBuildingLot[];
+    /** The polygonal plots the city is made of. `plots[i]` pairs with `lots[i]`. */
+    plots: CityPlot[];
+    /** Land polygons of whole blocks reserved as parks/open space (no plots cut). */
+    parks: Vec2[][];
+    /**
+     * Present only when {@link CityGeneratorOptions.content} was requested: every plot enriched with
+     * its zone band, building class, floors, and lot-local massing pieces. Same order as `lots`.
+     */
+    lotContent?: readonly ResolvedCityLot[];
 }
 /**
- * Grow a street network inside the `hx`/`hz` half-extents and line its frontage with building lots.
- * Deterministic: identical options ⇒ identical city.
+ * Grow a street network inside the `hx`/`hz` half-extents, extract its blocks, and subdivide their
+ * frontage into plots. Deterministic: identical options ⇒ identical city.
  */
 export declare function generateCity(options: CityGeneratorOptions, hx: number, hz: number): GeneratedCity;
+/** Default `blockFill`: gently gapped frontage — plots with breathing room, parks reserved. */
+export declare const DEFAULT_BLOCK_FILL = 0.45;
+/** Default grand-plot share dial — a handful of block-scale parcels per default city. */
+export declare const DEFAULT_LANDMARK_SHARE = 0.04;
+/** Hard cap on grand plots emitted regardless of dial/city size. */
+export declare const LANDMARK_HARD_CAP = 12;
+/** Options for {@link deriveCityPlots}. */
+export interface CityPlotOptions {
+    seed: string;
+    /** Half-extents the city was grown in — zone tiers normalize to these. */
+    halfExtents: readonly [number, number];
+    /** Cut plots along `lane`-level frontage too. Default false. */
+    laneFrontage?: boolean;
+    /** Sidewalk strip between curb and building front, meters. Default 3. */
+    setback?: number;
+    /** Base gap between neighbouring plots, meters. Default 2. */
+    spacing?: number;
+    /** Mix between uniform medium plots (0) and the full zone/street tier distribution (1). Default 1. */
+    variety?: number;
+    /** Streetwall dial (0..1): frontage coverage, plot depth, and park share ride on it. Default {@link DEFAULT_BLOCK_FILL}. */
+    blockFill?: number;
+    /** Grand-plot share dial (0..1): probability weight of the block-scale tier. Default {@link DEFAULT_LANDMARK_SHARE}; `0` disables grand plots. */
+    landmarks?: number;
+    /** Tier size multiplier `[wScale, dScale]`. Default `[1, 1]`. */
+    plotScale?: readonly [number, number];
+    /** Hard cap on emitted plots. Default 600. */
+    maxPlots?: number;
+    /** Zone profile the tier weights read. Defaults match {@link resolveCityLotContent}. */
+    profile?: CityZoneProfile;
+    coreExtent?: number;
+    midExtent?: number;
+}
+/** Output of {@link deriveCityPlots}: the plots plus whole-block park polygons. */
+export interface CityPlotResult {
+    plots: CityPlot[];
+    parks: Vec2[][];
+}
+/**
+ * Subdivide every buildable block's street frontage into size-tiered polygonal plots. Blocks come
+ * from the street network's planar faces ({@link extractBlocks}), so every plot fronts a real
+ * street; block interiors stay open (courtyards) and a seeded fraction of whole blocks becomes
+ * parks. Grand plots — the old "landmarks" — are just the biggest tier of the same pass.
+ * Deterministic per seed, bounded by `maxPlots` and per-block caps.
+ *
+ * @capability city-generator subdivide street blocks into size-tiered street-fronting plots
+ */
+export declare function deriveCityPlots(network: StreetNetwork, options: CityPlotOptions): CityPlotResult;
+/** Weighted building-class mix per zone band; the radial profile decides which band a lot falls in. */
+export interface CityZoneMixes {
+    core: readonly WeightedParamEntry[];
+    mid: readonly WeightedParamEntry[];
+    edge: readonly WeightedParamEntry[];
+}
+/** Default zoned-metropolis mixes: towers/slabs downtown, slabs+rowhouses mid, houses at the edge. */
+export declare const DEFAULT_CITY_ZONE_MIXES: CityZoneMixes;
+/**
+ * Per-street-level class weight multipliers applied to the band mix before the class pick, so towers
+ * and slabs bias toward wide boulevard/avenue frontage while houses bias toward lanes and quiet
+ * streets. A missing class ⇒ multiplier 1. Pure data modulating the weighted mixes.
+ */
+export type CityLevelClassBias = Record<StreetLevel, Partial<Record<CityLotClass, number>>>;
+/** Default street-level bias — boulevards favor big massing, lanes favor small/rural massing. */
+export declare const DEFAULT_CITY_LEVEL_BIAS: CityLevelClassBias;
+/** Tunable overrides for {@link resolveCityLotContent} (seed/halfExtents/laneFrontage are supplied). */
+export interface CityContentOverrides {
+    /** Radial band profile: `core-out` (default), `inverted`, or spatially `uniform`. */
+    profile?: CityZoneProfile;
+    /** Fraction of the half-extent the core band covers. Default 0.35. */
+    coreExtent?: number;
+    /** Fraction of the half-extent where the mid band ends and the edge begins. Default 0.7. */
+    midExtent?: number;
+    /** Weighted class mix per band; any omitted band takes {@link DEFAULT_CITY_ZONE_MIXES}. */
+    mixes?: Partial<CityZoneMixes>;
+    /** Global massing-size multiplier forwarded to the class placement roll. Default 1. */
+    lotScale?: number;
+    /** Minimum building floors (district clamp over class ranges). Default 1. */
+    floorsMin?: number;
+    /** Maximum building floors. Default 30. */
+    floorsMax?: number;
+    /** Height of one floor in meters. Default 3. */
+    floorHeight?: number;
+    /** Base road setback in meters (class factors scale it). Default 2.5. */
+    setback?: number;
+    /** Base side spacing in meters between neighbours. Default 1.4. */
+    spacing?: number;
+    /**
+     * Bias the band mix by the plot's frontage street level before the class pick. `true` (default)
+     * uses {@link DEFAULT_CITY_LEVEL_BIAS}; pass a table to customise; `false` disables the bias.
+     */
+    streetLevelBias?: boolean | CityLevelClassBias;
+    /**
+     * Grand-plot share dial (0..1): the probability weight of the block-scale plot tier at geometry
+     * time — a landmark is nothing but a grand plot. Default {@link DEFAULT_LANDMARK_SHARE}; `0`
+     * yields a city with no grand plots. Count is hard-capped at {@link LANDMARK_HARD_CAP}.
+     */
+    landmarks?: number;
+    /**
+     * Restrict grand plots to these classes (a subset of {@link CITY_LANDMARK_CLASSES}). Omit to
+     * allow every class the zone table would pick.
+     */
+    landmarkClasses?: readonly CityLandmarkClass[];
+    /**
+     * Streetwall dial (0..1). Default {@link DEFAULT_BLOCK_FILL}. As it rises frontage coverage
+     * approaches a contiguous wall, plots deepen toward the block spine, and fewer whole blocks are
+     * reserved as parks; falling it loosens the frontage and greens the city. Block interiors are
+     * never filled with street-less buildings — every plot fronts a street.
+     */
+    blockFill?: number;
+}
+/** Full options for {@link resolveCityLotContent}: the city geometry frame plus content overrides. */
+export interface CityContentOptions extends CityContentOverrides {
+    /** Seed for the deterministic class/floor/massing rolls. Reuse the city seed for a coherent city. */
+    seed: string;
+    /** Half-extents the city was grown in — the radial zone metric normalizes to these. */
+    halfExtents: readonly [number, number];
+    /** Whether lanes were lined with plots (mirror the geometry option). Default false. */
+    laneFrontage?: boolean;
+}
+/** Axis-aligned massing extents (lot-local): full width along x and depth along z. */
+export interface MassingFootprint {
+    /** Full width of the massing bounding box along local x (frontage). */
+    w: number;
+    /** Full depth of the massing bounding box along local z (into the block). */
+    d: number;
+    /** Bounding-box corners in lot-local space, so a renderer can ground/cull the parcel. */
+    bounds: {
+        minX: number;
+        maxX: number;
+        minZ: number;
+        maxZ: number;
+    };
+}
+/** One plot enriched with its zone/class/floors/massing — the renderer instances `pieces` at `center`. */
+export interface ResolvedCityLot {
+    /** The paired rect building lot (`city.lots[i]`). */
+    lot: PlacedBuildingLot;
+    /** Zone band the plot center fell in under the profile. */
+    zone: CityZoneBand;
+    /**
+     * Building class. Ordinary plots roll a {@link CityLotClass} from the band mix; grand plots roll
+     * a {@link CityLandmarkClass}. ({@link CityFillerClass} remains in the union for renderer compat.)
+     */
+    class: CityLotClass | CityLandmarkClass | CityFillerClass;
+    /**
+     * Set only on grand plots; equals {@link ResolvedCityLot.class} there and is `undefined` for
+     * every ordinary building. Renderers branch on this.
+     */
+    landmark?: CityLandmarkClass;
+    /** Hierarchy level of the frontage street (`street` when it can't be recovered). */
+    streetLevel: StreetLevel;
+    /** Building floor count after the district clamp. */
+    floors: number;
+    /** Deterministic massing pieces in lot-local space (x along frontage, z into block, y up from grade). */
+    pieces: readonly CityLotPiece[];
+    /** Lot center in world XZ (mirrors `lot.center`) — the anchor the renderer offsets pieces from. */
+    center: Vec2;
+    /** Building yaw so its front faces the road (mirrors `lot.rotationY`). */
+    rotationY: number;
+    /** Actual massing extents in lot-local space (from `pieces`), for grounding and culling. */
+    footprint: MassingFootprint;
+}
+/**
+ * Enrich a generated city's plots into classed, massed buildings: each plot gets its zone band
+ * (radial position under a {@link CityZoneProfile}), a building class rolled from the band's
+ * weighted mix — biased by street level AND plot size, with grand plots rolling a landmark class —
+ * floors, and the deterministic massing pieces the class composes, sized to the plot's building
+ * rect. Deterministic per `seed` via {@link seededStreams}, bounded (one pass over `city.lots`),
+ * and pure. Same seed + city ⇒ identical resolved lots.
+ *
+ * A city without `plots` (a hand-built `{network, lots}` pair) still resolves: every lot is treated
+ * as an ordinary plot of its footprint size.
+ *
+ * @capability city-generator resolve city plots into zoned, classed, massed buildings
+ */
+export declare function resolveCityLotContent(city: Pick<GeneratedCity, "network" | "lots"> & Partial<Pick<GeneratedCity, "plots" | "parks">>, options: CityContentOptions): ResolvedCityLot[];