@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/dist/kinds/head-extras.d.ts

@@ -0,0 +1,15 @@
+import type { Rng } from '../core/index.js';
+import type { SculptEdit } from '../primitives/index.js';
+import type { HeadLayout } from './head-layout.js';
+import type { HeadParams } from './head-params.js';
+/** `minThick`: the blade's floor thickness (≈ a cell), so far LODs keep their ears attached. */
+export declare function earEdits(p: HeadParams, l: HeadLayout, minThick?: number): SculptEdit[];
+/** Lower tusks rising from the jaw past the upper lip, curving out and back (3 cone segments). */
+/** `minR`: radius floor (≈ half a cell) so far LODs keep the tusks. */
+export declare function tuskEdits(p: HeadParams, l: HeadLayout, minR?: number): SculptEdit[];
+/** War paint: thin deep ellipsoids painted through the skin, so each stripe is a clean band of
+ *  constant width wherever it crosses the surface — two claw marks per cheek, a crest stripe up
+ *  the forehead, three down the chin. */
+export declare function paintEdits(p: HeadParams, l: HeadLayout): SculptEdit[];
+/** Seeded warts and bumps on the cranium and cheeks. */
+export declare function wartEdits(p: HeadParams, l: HeadLayout, rng: Rng): SculptEdit[];

package/dist/kinds/head-face.d.ts

@@ -0,0 +1,6 @@
+import type { SculptEdit } from '../primitives/index.js';
+import type { HeadLayout } from './head-layout.js';
+import type { HeadParams } from './head-params.js';
+/** Brain case + face plate: the forms the eyes are seated against (head.ts probes them). */
+export declare function primaryEdits(l: HeadLayout): SculptEdit[];
+export declare function skullEdits(p: HeadParams, l: HeadLayout): SculptEdit[];

package/dist/kinds/head-geom.d.ts

@@ -0,0 +1,7 @@
+import type { Vec3 } from '../core/index.js';
+/** `rotate` (deg, X→Y→Z) taking local +X onto `d`, then rolling `roll` deg about it. */
+export declare function alongX(d: Vec3, roll?: number): Vec3;
+/** `rotate` taking local +Z (a cone's axis) onto `d`. */
+export declare function alongZ(d: Vec3): Vec3;
+export declare const unit: (d: Vec3) => Vec3;
+export declare const along: (a: Vec3, d: Vec3, t: number) => Vec3;

package/dist/kinds/head-hair.d.ts

@@ -0,0 +1,4 @@
+import type { SculptEdit } from '../primitives/index.js';
+import type { HeadLayout } from './head-layout.js';
+import type { HeadParams } from './head-params.js';
+export declare function hairEdits(p: HeadParams, l: HeadLayout): SculptEdit[];

package/dist/kinds/head-layout.d.ts

@@ -0,0 +1,29 @@
+import type { Vec3 } from '../core/index.js';
+import type { HeadParams } from './head-params.js';
+export interface HeadLayout {
+    /** Cranium ellipsoid centre and radii. */
+    readonly cranium: {
+        readonly at: Vec3;
+        readonly r: Vec3;
+    };
+    /** Forehead front at the eye line. */
+    readonly faceX: number;
+    /** Left eye centre (mirror for the right) and eyeball radius. */
+    readonly eye: Vec3;
+    readonly eyeR: number;
+    readonly browZ: number;
+    readonly noseZ: number;
+    readonly mouthZ: number;
+    /** Front of the lips. */
+    readonly mouthX: number;
+    readonly chin: Vec3;
+    /** Jaw hinge (x, z) — the jaw part's pivot. */
+    readonly hinge: readonly [number, number];
+    /** Left jaw angle (gonion). */
+    readonly angle: Vec3;
+    /** Top of the head, units. */
+    readonly crown: number;
+    /** Bottom of the bust (the asset's z = 0), units. */
+    readonly base: number;
+}
+export declare function headLayout(p: HeadParams): HeadLayout;

package/dist/kinds/head-mesh.d.ts

@@ -0,0 +1,27 @@
+import type { Mesh, Vec3 } from '../core/index.js';
+import { type Field, type SculptEdit } from '../primitives/index.js';
+import type { HeadLayout } from './head-layout.js';
+import type { HeadParams } from './head-params.js';
+/** The jaw region (head units): an ellipsoid around chin and lower lip, cut flat at the mouth
+ *  line. Its skin seam runs along the lips, down the marionette lines and under the chin — creases
+ *  a face already has — instead of across the cheek. */
+export declare function jawRegion(p: HeadParams, l: HeadLayout): {
+    field: Field;
+    centre: Vec3;
+    radii: Vec3;
+};
+export interface HeadEditSet {
+    readonly skull: readonly SculptEdit[];
+    readonly ears: readonly SculptEdit[];
+    readonly tusks: readonly SculptEdit[];
+    readonly bust: readonly SculptEdit[];
+}
+/** `head` and `jaw` meshes in head units at cell size `res` (units). Each is ONE sculpt (skull +
+ *  ears − region, skull ∩ region + tusks), so the sculpt's range skipping covers every edit. */
+export declare function headAndJaw(p: HeadParams, l: HeadLayout, set: HeadEditSet, res: number): {
+    head: Mesh;
+    jaw: Mesh;
+};
+export declare function bustMesh(p: HeadParams, set: HeadEditSet, res: number): Mesh;
+/** Eyeball of radius `r` centred on the origin, gazing +X. */
+export declare function eyeMesh(p: HeadParams, r: number, res: number): Mesh;

package/dist/kinds/head-params.d.ts

@@ -0,0 +1,108 @@
+import { type Vec3 } from '../core/index.js';
+export type EarShape = 'round' | 'pointed';
+export type HairStyle = 'none' | 'topknot' | 'mohawk' | 'swept' | 'tufts' | 'braids';
+export type BeardStyle = 'none' | 'short' | 'braided' | 'goatee';
+export type BustStyle = 'pauldrons' | 'hood' | 'tunic';
+export interface HeadColors {
+    readonly skin: Vec3;
+    /** Darker skin: lips edge, nostrils, inner ear, wrinkles. */
+    readonly shade: Vec3;
+    readonly lips: Vec3;
+    readonly sclera: Vec3;
+    readonly iris: Vec3;
+    readonly pupil: Vec3;
+    readonly teeth: Vec3;
+    readonly mouth: Vec3;
+    readonly hair: Vec3;
+    readonly cloth: Vec3;
+    readonly leather: Vec3;
+    readonly metal: Vec3;
+    /** Cloak / mantle over the shoulders; default `leather`. */
+    readonly cape?: Vec3;
+    /** Fur trim on the bust (mantle, hood lining); default `leather`. */
+    readonly fur?: Vec3;
+    /** War paint / tattoo stripes (orc), or none. */
+    readonly paint?: Vec3;
+}
+export interface HeadParams {
+    /** Chin to crown, metres (adult human ≈ 0.23). */
+    readonly height: number;
+    /** Full width / depth of the brain case; `height` = crown above the eye line. */
+    readonly cranium: {
+        readonly width: number;
+        readonly depth: number;
+        readonly height: number;
+    };
+    /** Ridge radius, how far it juts past the eyes, and the scowl (inner ends lowered). */
+    /** Ridge radius, overhang past the eyes, scowl (inner ends lowered), eyebrow hair radius
+     *  (omit or 0 = no eyebrows). */
+    readonly brow: {
+        readonly ridge: number;
+        readonly overhang: number;
+        readonly scowl: number;
+        readonly hair?: number;
+    };
+    readonly cheeks: {
+        readonly size: number;
+        readonly width: number;
+    };
+    /** Half-width at the jaw angle, chin size, lower-jaw jut past the upper lip, chin drop,
+     *  muzzle (how far mouth and jaw push forward of the brow: prognathism). */
+    readonly jaw: {
+        readonly muzzle: number;
+        readonly width: number;
+        readonly chin: number;
+        readonly underbite: number;
+        readonly drop: number;
+    };
+    /** Eye line → nose base, nostril half-width, tip radius, hook (droop), bridge projection. */
+    readonly nose: {
+        readonly length: number;
+        readonly width: number;
+        readonly tip: number;
+        readonly hook: number;
+        readonly bridge: number;
+    };
+    /** Length (root → tip), width, sweep back (deg), tilt up (deg). */
+    readonly ears: {
+        readonly shape: EarShape;
+        readonly length: number;
+        readonly width: number;
+        readonly sweep: number;
+        readonly lift: number;
+    };
+    /** Eyeball radius, centre-to-midline, eye line (fraction of height), lid angles (deg). */
+    readonly eyes: {
+        readonly radius: number;
+        readonly spacing: number;
+        readonly line: number;
+        readonly lid: number;
+        readonly lowerLid: number;
+    };
+    /** Half-width, lip thickness, grin (0 = closed line, 1 = wide toothy smile). */
+    readonly mouth: {
+        readonly width: number;
+        readonly lips: number;
+        readonly grin: number;
+    };
+    readonly tusks: {
+        readonly length: number;
+        readonly radius: number;
+        readonly spread: number;
+        readonly flare: number;
+    } | null;
+    readonly neck: {
+        readonly radius: number;
+    };
+    readonly bust: {
+        readonly shoulders: number;
+        readonly style: BustStyle;
+    };
+    readonly hair: HairStyle;
+    readonly beard: BeardStyle;
+    /** Wart / bump count scattered on the skin (seeded). */
+    readonly warts: number;
+    readonly colors: HeadColors;
+}
+/** Throws T3D_RECIPE_INVALID (with a fix) when `p` cannot make a head. */
+export declare function checkHead(p: HeadParams): HeadParams;

package/dist/kinds/head-presets.d.ts

@@ -0,0 +1,19 @@
+import type { HeadParams } from './head-params.js';
+/** Classical proportions, slightly heroic: eye line at half height, thirds brow/nose/chin. */
+export declare const human: HeadParams;
+/** Massive underbitten jaw, tusks, heavy brow over small deep eyes, flat broad nose, thick neck. */
+export declare const orc: HeadParams;
+/** Small and sly: huge leaf ears, long hooked nose, wide toothy grin, big bright eyes. */
+export declare const goblin: HeadParams;
+/** Broad and bearded: wide skull, big bulbous nose, braided beard, deep-set eyes. */
+export declare const dwarf: HeadParams;
+/** Slender and ageless: long swept-back ears, high cheekbones, fine nose, almond eyes. */
+export declare const elf: HeadParams;
+export declare const HEADS: {
+    readonly human: HeadParams;
+    readonly orc: HeadParams;
+    readonly goblin: HeadParams;
+    readonly dwarf: HeadParams;
+    readonly elf: HeadParams;
+};
+export type HeadPreset = keyof typeof HEADS;

package/dist/kinds/head-rim.d.ts

@@ -0,0 +1,10 @@
+import type { Mesh } from '../core/index.js';
+import type { Field } from '../primitives/index.js';
+/** Part ≈ max(skull, side); `side` is the cut field signed so the part is where side < 0;
+ *  `part` is the part's full field (with ears/tusks), so their vertices are left alone. */
+export declare function sharpenRim(m: Mesh, skull: Field, side: Field, part: Field, res: number): Mesh;
+/**
+ * Where a field gradient smears across a hard crease (the jaw cut at coarse cells), a vertex
+ * normal can oppose its triangles; those vertices take their area-weighted face normal instead.
+ */
+export declare function creaseNormals(m: Mesh, minDot?: number): Mesh;

package/dist/kinds/head.d.ts

@@ -0,0 +1,39 @@
+import { type BuildContext, type Rng, type Vec3 } from '../core/index.js';
+import { type HeadLayout } from './head-layout.js';
+import { type HeadEditSet } from './head-mesh.js';
+import { type HeadParams } from './head-params.js';
+import { type HeadPreset } from './head-presets.js';
+/** Overrides: top-level keys replace, nested objects merge one level (`{ jaw: { underbite: 0.1 } }`). */
+export type HeadOverrides = {
+    readonly [K in keyof HeadParams]?: Partial<HeadParams[K]>;
+};
+export interface HeadOptions {
+    readonly race?: HeadPreset | HeadParams;
+    readonly params?: HeadOverrides;
+    /** Part-name prefix: `orc` → `orc_head`, `orc_jaw`, `orc_eye_l` … Default none. */
+    readonly prefix?: string;
+    /** Where the bust base sits, metres. */
+    readonly at?: Vec3;
+    /** Baked jaw motion (degrees either side of rest, 0 = static pivot). Default 0. */
+    readonly jawSway?: number;
+}
+export interface HeadInfo {
+    readonly parts: {
+        bust: string;
+        head: string;
+        jaw: string;
+        eyeL: string;
+        eyeR: string;
+    };
+    /** Overall height of bust + head, metres. */
+    readonly height: number;
+    readonly params: HeadParams;
+}
+export declare function headParams(o?: Pick<HeadOptions, 'race' | 'params'>): HeadParams;
+/** Sculpt cell edge per LOD, in head units (× height = metres). */
+export declare const HEAD_RES: readonly [0.02, 0.045, 0.14];
+/** Every edit list of a head, in head units (pure: same params + rng state → same edits). */
+export declare function headEdits(p: HeadParams, rng: Rng, lod?: 0 | 1 | 2): HeadEditSet & {
+    layout: HeadLayout;
+};
+export declare function head(ctx: BuildContext, o?: HeadOptions): HeadInfo;

package/dist/kinds/hull-lines.d.ts

@@ -0,0 +1,65 @@
+import { type Vec3 } from '../core/index.js';
+export interface HullColors {
+    /** Above the boot-top. */
+    readonly topsides: Vec3;
+    /** Below the waterline (antifouling). */
+    readonly bottom: Vec3;
+    /** The boot-top band at the waterline. Default near-black. */
+    readonly boot?: Vec3;
+    readonly deck: Vec3;
+    /** Inside of the bulwarks and the cap rail. Default = topsides. */
+    readonly bulwark?: Vec3;
+}
+export interface HullOptions {
+    /** Length overall at the deck, metres. */
+    readonly length: number;
+    /** Maximum beam at the deck edge. */
+    readonly beam: number;
+    /** Keel below the waterline. */
+    readonly draft: number;
+    /** Deck edge above the waterline amidships (lowest point of the sheer). */
+    readonly freeboard: number;
+    /** Sheer rise of the deck edge at [bow, stern] above amidships. Default [0.035, 0.012]·L. */
+    readonly sheer?: readonly [number, number];
+    /** 'round' (cruiser / tug) or 'transom' (flat stern). Default 'round'. */
+    readonly stern?: 'round' | 'transom';
+    /** Transom half-width as a share of the half-beam. Default 0.75. */
+    readonly transomWidth?: number;
+    /** Bilge: section superellipse exponent, 1.5 (soft V) … 5 (barge). Default 3. */
+    readonly fullness?: number;
+    /** Plan entrance exponent at the bow: 1.4 sharp … 3 bluff. Default 2. */
+    readonly entrance?: number;
+    /** Deck-edge breadth over waterline breadth − 1. Default 0.06. */
+    readonly flare?: number;
+    /** Bottom deadrise, degrees. Default 5. */
+    readonly deadriseDeg?: number;
+    /** Bulwark height above the deck, metres; 0 = none. Default 0. */
+    readonly bulwark?: number;
+    /** Deck camber at the centreline, metres. Default beam / 50. */
+    readonly camber?: number;
+    /** Height of the boot-top band above the waterline. Default 0.3. */
+    readonly bootTop?: number;
+    readonly colors: HullColors;
+    /** A rubbing strake / fender along each side just below the sheer (LOD0/1). */
+    readonly fender?: {
+        readonly color: Vec3;
+        readonly radius?: number;
+    };
+    /** Waterline amidships. Default [0, 0, 0]. */
+    readonly at?: Vec3;
+}
+export interface HullLines {
+    readonly L: number;
+    /** Deck-edge half-breadth at x (outer hull). */
+    readonly halfBreadth: (x: number) => number;
+    /** Deck-edge height at x (sheer line), relative to the waterline. */
+    readonly deck: (x: number) => number;
+    /** Keel / stem / counter height at x. */
+    readonly keel: (x: number) => number;
+    /** Section point at x for θ ∈ [0, π/2] (0 = keel, π/2 = deck edge), starboard (y ≥ 0). */
+    readonly section: (x: number, theta: number) => [number, number];
+}
+export declare function validateHull(o: HullOptions): void;
+export declare function hullLines(o: HullOptions): HullLines;
+/** θ where the section crosses height z (bisection; the section rises monotonically). */
+export declare function thetaAt(lines: HullLines, x: number, z: number): number;

package/dist/kinds/hull-skin.d.ts

@@ -0,0 +1,6 @@
+import type { MeshBuilder, Vec3 } from '../core/index.js';
+export type Grid = Vec3[][];
+/** Smooth normals over a station × column grid (outward = tj × ti for the starboard side). */
+export declare function normalsOf(g: Grid): Grid;
+/** Emit columns [j0, j1] of a starboard grid and its port mirror. */
+export declare function emitBand(b: MeshBuilder, g: Grid, nrm: Grid, j0: number, j1: number, color: Vec3, mirror: boolean): void;

package/dist/kinds/hull.d.ts

@@ -0,0 +1,14 @@
+import { type BuildContext, type Lod, type Mesh } from '../core/index.js';
+import { type HullLines, type HullOptions } from './hull-lines.js';
+export type { HullColors, HullLines, HullOptions } from './hull-lines.js';
+export interface HullMesh {
+    /** Shell (+ bulwarks + transom). */
+    readonly shell: Mesh;
+    readonly deck: Mesh;
+    readonly lines: HullLines;
+}
+export declare function hullMesh(o: HullOptions, lod?: Lod): HullMesh;
+/** Add `name` (shell) and `name_deck` parts; returns the lines for placing deckhouses and fittings. */
+export declare function hull(ctx: BuildContext, o: HullOptions & {
+    readonly name?: string;
+}): HullLines;

package/dist/kinds/index.d.ts

@@ -0,0 +1,16 @@
+export { type FacadeOptions, facade, type SetbackTier, type Side, setbacks } from './building.js';
+export { HEAD_RES, type HeadInfo, type HeadOptions, type HeadOverrides, head, headEdits, headParams, } from './head.js';
+export { type BeardStyle, type BustStyle, checkHead, type EarShape, type HairStyle, type HeadColors, type HeadParams, } from './head-params.js';
+export { HEADS, type HeadPreset } from './head-presets.js';
+export { type HullColors, type HullLines, type HullMesh, type HullOptions, hull, hullMesh, } from './hull.js';
+export { hullLines } from './hull-lines.js';
+export { type MassOptions, mass } from './mass.js';
+export { type OpeningOptions, type OpeningSide, opening } from './openings.js';
+export { creature } from './planned.js';
+export { type RoofInfo, type RoofMeshOptions, roof, roofInfo, roofMesh } from './roof.js';
+export type { RoofChimney } from './roof-chimney.js';
+export { type RoofOptions, type RoofSide, type RoofType, ridgeHeight, roofHeightAt, } from './roof-shape.js';
+export { type TreeFamilyParams, type TreeInfo, type TreeOptions, tree, treeParams, treeReal, trees, } from './vegetation.js';
+export type { BranchLevel, CrownShape, LeafParams, LeafShape, TreeParams, } from './vegetation-params.js';
+export { birch, oak, palm, pine, SPECIES, type SpeciesName, willow } from './vegetation-presets.js';
+export { axle, propeller, trackRun, whyteAxles } from './vehicle.js';

package/dist/kinds/index.js

@@ -0,0 +1,78 @@
+import {
+  mass2,
+  opening2,
+  facade2,
+  setbacks2,
+  checkHead2,
+  HEADS2,
+  headParams2,
+  HEAD_RES2,
+  headEdits2,
+  head2,
+  hullLines2,
+  hullMesh2,
+  hull2,
+  creature2,
+  roofHeightAt2,
+  ridgeHeight2,
+  roofMesh2,
+  roof2,
+  roofInfo2,
+  oak2,
+  pine2,
+  palm2,
+  birch2,
+  willow2,
+  SPECIES2,
+  treeParams2,
+  tree2,
+  treeReal2,
+  trees2,
+  axle2,
+  whyteAxles2,
+  trackRun2,
+  propeller2
+} from "../chunk-1ypfs7ga.js";
+import"../chunk-ravbb06q.js";
+import"../chunk-wtqhq529.js";
+import"../chunk-kvcep7ft.js";
+import"../chunk-xnt2sdhf.js";
+import"../chunk-4ddzsqtc.js";
+export {
+  HEADS2 as HEADS,
+  HEAD_RES2 as HEAD_RES,
+  SPECIES2 as SPECIES,
+  axle2 as axle,
+  birch2 as birch,
+  checkHead2 as checkHead,
+  creature2 as creature,
+  facade2 as facade,
+  head2 as head,
+  headEdits2 as headEdits,
+  headParams2 as headParams,
+  hull2 as hull,
+  hullLines2 as hullLines,
+  hullMesh2 as hullMesh,
+  mass2 as mass,
+  oak2 as oak,
+  opening2 as opening,
+  palm2 as palm,
+  pine2 as pine,
+  propeller2 as propeller,
+  ridgeHeight2 as ridgeHeight,
+  roof2 as roof,
+  roofHeightAt2 as roofHeightAt,
+  roofInfo2 as roofInfo,
+  roofMesh2 as roofMesh,
+  setbacks2 as setbacks,
+  trackRun2 as trackRun,
+  tree2 as tree,
+  treeParams2 as treeParams,
+  treeReal2 as treeReal,
+  trees2 as trees,
+  whyteAxles2 as whyteAxles,
+  willow2 as willow
+};
+
+//# debugId=2A8DC31E36ABDA1E64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/kinds/index.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "2A8DC31E36ABDA1E64756E2164756E21",
+  "names": []
+}

package/dist/kinds/mass.d.ts

@@ -0,0 +1,15 @@
+import { type Lod, type Mesh, type Vec3 } from '../core/index.js';
+import type { StripId } from '../material/index.js';
+export interface MassOptions {
+    /** Width (X), depth (Y), height (Z). */
+    readonly size: Vec3;
+    /** Centre of the base. */
+    readonly at?: Vec3;
+    readonly color: Vec3;
+    readonly strip?: StripId;
+    /** Courses start at this world z (default 0, the ground) so stacked masses line up. */
+    readonly courseOrigin?: number;
+    /** Skip faces nobody sees (bottom on the ground, top under a roof, a party wall). */
+    readonly omit?: readonly ('top' | 'bottom' | 'front' | 'back' | 'left' | 'right')[];
+}
+export declare function mass(o: MassOptions, lod?: Lod): Mesh;

package/dist/kinds/openings.d.ts

@@ -0,0 +1,30 @@
+import { type Lod, type Mesh, type Vec3 } from '../core/index.js';
+import type { StripId } from '../material/index.js';
+export type OpeningSide = 'front' | 'back' | 'left' | 'right';
+export interface OpeningOptions {
+    readonly kind: 'window' | 'door';
+    /** Clear opening, metres (UK sash ≈ 0.9 × 1.6; door ≈ 0.9 × 2.1). */
+    readonly width: number;
+    readonly height: number;
+    /** Bottom centre of the opening ON the wall face. */
+    readonly at: Vec3;
+    /** Which way the wall faces (front = +X, left = +Y). */
+    readonly facing: OpeningSide;
+    readonly glass: Vec3;
+    /** Sash frame / door leaf colour. */
+    readonly frame: Vec3;
+    /** Reveal (surround) colour: the wall's, so the opening reads recessed. */
+    readonly wall: Vec3;
+    readonly wallStrip?: StripId;
+    /** Sill + lintel colour (dressed stone). */
+    readonly trim?: Vec3;
+    /** Reveal depth, metres. Default 0.12 (half a brick). */
+    readonly depth?: number;
+    /** Reveal band width either side. Default 0.1. */
+    readonly surround?: number;
+    /** Glazing panes [across, up]: 2-over-2 sash = [2, 2]. Default window [2, 2]. */
+    readonly panes?: readonly [number, number];
+    readonly sill?: boolean;
+    readonly lintel?: boolean;
+}
+export declare function opening(o: OpeningOptions, lod?: Lod): Mesh;

package/dist/kinds/planned.d.ts

@@ -0,0 +1,6 @@
+import { type BuildContext } from '../core/index.js';
+/** Stylised creature from a skeleton + SDF flesh (Spore-like). Realistic ones go via /neural. M4. */
+export declare function creature(_ctx: BuildContext, _o: {
+    skeleton: 'biped' | 'quadruped' | 'bird';
+    height: number;
+}): void;

package/dist/kinds/roof-chimney.d.ts

@@ -0,0 +1,16 @@
+import { type Lod, type Mesh, type Vec3 } from '../core/index.js';
+import type { StripId } from '../material/index.js';
+export interface RoofChimney {
+    /** Centre offset from the roof's `at`, world X/Y metres. */
+    readonly at: readonly [number, number];
+    /** Stack width (X) and depth (Y). Default [0.9, 0.6]. */
+    readonly size?: readonly [number, number];
+    /** Height above the highest roof point it touches. Default 0.9. */
+    readonly height?: number;
+    readonly color: Vec3;
+    readonly strip?: StripId;
+    /** Clay pots on top (LOD0). Default: one per 0.4 m of width. */
+    readonly pots?: number;
+    readonly potColor?: Vec3;
+}
+export declare function chimney(c: RoofChimney, heightAt: (x: number, y: number) => number, at: Vec3, lod: Lod): Mesh;

package/dist/kinds/roof-shape.d.ts

@@ -0,0 +1,64 @@
+import { type Vec2, type Vec3 } from '../core/index.js';
+import type { StripId } from '../material/index.js';
+export type RoofType = 'gable' | 'hip' | 'pyramid' | 'mansard' | 'gambrel' | 'shed';
+export type RoofSide = 'front' | 'back' | 'left' | 'right';
+export interface RoofOptions {
+    readonly type: RoofType;
+    /** Wall-line width (X) and depth (Y) of the mass the roof sits on, metres. */
+    readonly footprint: readonly [number, number];
+    /** Main slope, degrees (the lower, steep slope of a mansard or gambrel). */
+    readonly pitchDeg: number;
+    /** Centre of the footprint at wall-plate height (top of the walls). */
+    readonly at: Vec3;
+    readonly color: Vec3;
+    /** Roofing strip, laid in true-scale courses down the slope. Default 'slate'. */
+    readonly strip?: StripId;
+    /** Eave overhang past the walls, metres. Default 0.35. */
+    readonly overhang?: number;
+    /** Gable-end (rake) overhang; default = overhang. Hipped roofs ignore it. */
+    readonly rake?: number;
+    /** Slab thickness perpendicular to the slope (rafter + battens + slate). Default 0.18. */
+    readonly thickness?: number;
+    /** Ridge direction; default along the longer side. */
+    readonly ridge?: 'x' | 'y';
+    /** Shed only: the side the single slope falls toward. Default 'front' (+X). */
+    readonly low?: RoofSide;
+    /** Mansard / gambrel upper slope, degrees. Default 20 (mansard), 30 (gambrel). */
+    readonly upperPitchDeg?: number;
+    /** Mansard / gambrel: share of the half-span the lower slope covers in plan. Default 0.3 / 0.45. */
+    readonly knee?: number;
+}
+export interface Plane {
+    /** z = c + ga·a + gb·b (local, relative to the wall plate). */
+    readonly c: number;
+    readonly ga: number;
+    readonly gb: number;
+}
+export interface RoofShape {
+    readonly L: number;
+    readonly D: number;
+    /** Underside planes and the matching top planes (offset by the perpendicular thickness). */
+    readonly under: readonly Plane[];
+    readonly top: readonly Plane[];
+    /** Plan outline at the eaves (CCW, local a/b). */
+    readonly outline: readonly Vec2[];
+    /** Local unit axes in world XY: a → ex, b → ey (ex × ey = +Z). */
+    readonly ex: Vec2;
+    readonly ey: Vec2;
+    readonly thickness: number;
+}
+export declare function validateRoof(o: RoofOptions): void;
+export declare function roofShape(o: RoofOptions): RoofShape;
+export declare const zAt: (p: Plane, q: Vec2) => number;
+/** Envelope height (min of planes) at a local plan point. */
+export declare const envelope: (planes: readonly Plane[], q: Vec2) => number;
+/** The plan cell of each plane on the envelope (empty cells dropped), with its plane. */
+export declare function facets(planes: readonly Plane[], outline: readonly Vec2[]): [Plane, Vec2[]][];
+/** Local plan → world XY offset (add `at`). */
+export declare const toWorld: (s: RoofShape, q: Vec2, z: number, at: Vec3) => Vec3;
+/** World XY → local plan. */
+export declare const toLocal: (s: RoofShape, x: number, y: number, at: Vec3) => Vec2;
+/** World z of the roof's top surface at world (x, y) — chimneys, dormers, aerials sit on this. */
+export declare function roofHeightAt(o: RoofOptions, x: number, y: number): number;
+/** World z of the highest point of the roof surface (ridge or apex), slab included. */
+export declare function ridgeHeight(o: RoofOptions): number;

package/dist/kinds/roof.d.ts

@@ -0,0 +1,31 @@
+import { type BuildContext, type Lod, type Mesh, type Vec3 } from '../core/index.js';
+import type { StripId } from '../material/index.js';
+import { type RoofChimney } from './roof-chimney.js';
+import { type RoofOptions } from './roof-shape.js';
+export interface RoofMeshOptions extends RoofOptions {
+    /** Fascia, bargeboards, soffit and ridge caps. Default: the roof colour, darkened. */
+    readonly trim?: Vec3;
+    /** Gable / shed end infill walls. Default pale render. */
+    readonly wall?: {
+        readonly color: Vec3;
+        readonly strip?: StripId;
+    };
+    /** Ridge and hip caps (LOD0/1). Default true. */
+    readonly caps?: boolean;
+    readonly chimneys?: readonly RoofChimney[];
+}
+export interface RoofInfo {
+    /** World z of the ridge / apex top. */
+    readonly ridge: number;
+    /** World z of the lowest eave edge (underside). */
+    readonly eave: number;
+    /** World z of the top surface at world (x, y). */
+    readonly heightAt: (x: number, y: number) => number;
+}
+/** The roof as one mesh at a detail level. Pure: compose with place/merge or pass to ctx.part. */
+export declare function roofMesh(o: RoofMeshOptions, lod?: Lod): Mesh;
+/** Add the roof as part `name` (default 'roof') at the context's LOD; returns its heights. */
+export declare function roof(ctx: BuildContext, o: RoofMeshOptions & {
+    readonly name?: string;
+}): RoofInfo;
+export declare function roofInfo(o: RoofOptions): RoofInfo;

package/dist/kinds/vegetation-fronds.d.ts

@@ -0,0 +1,15 @@
+import { type Mesh, type Rng, type Vec3 } from '../core/index.js';
+import type { CrownShade } from './vegetation-leaves.js';
+import type { LeafParams } from './vegetation-params.js';
+import type { Stem } from './vegetation-skeleton.js';
+/**
+ * Leaflets along every frond (stem at `level`). `perSide` leaflets each side; `from` overrides
+ * each frond's first rachis point (LOD2 roots them all on the trunk's top cap centre).
+ */
+export declare function frondLeaflets(stems: readonly Stem[], level: number, leaf: LeafParams, perSide: number, shade: CrownShade, rng: Rng): Mesh;
+/** Coconuts: `count` spheres hugging the trunk just below the frond bases. */
+export declare function fruit(trunk: Stem, at: number, o: {
+    count: number;
+    radius: number;
+    color: Vec3;
+}, rng: Rng): Mesh;