@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/dist/index.js.map

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

package/dist/kinds/building.d.ts

@@ -0,0 +1,44 @@
+import type { BuildContext, Vec3 } from '../core/index.js';
+import type { StripId } from '../material/index.js';
+export type Side = 'front' | 'back' | 'left' | 'right';
+export interface FacadeOptions {
+    readonly prefix: string;
+    /** Centre of the mass's base. */
+    readonly at: Vec3;
+    /** Footprint width (X) and depth (Y) of the mass this facade wraps. */
+    readonly footprint: readonly [number, number];
+    readonly floors: number;
+    readonly floorHeight: number;
+    /** Grammar per floor; the same line for every floor unless `ground` overrides floor 0. */
+    readonly grammar: string;
+    readonly ground?: string;
+    readonly sides: readonly Side[];
+    readonly glass: Vec3;
+    readonly frame?: Vec3;
+    /** Window height as a fraction of the floor. */
+    readonly windowRatio?: number;
+    /** Detailed openings (see `opening`): reveal in the wall colour, stone sill/lintel, sash bars. */
+    readonly kit?: {
+        readonly wall: Vec3;
+        readonly trim?: Vec3;
+        readonly depth?: number;
+        readonly panes?: readonly [number, number];
+        /** The wall's strip, so reveals continue its courses. Default 'plain'. */
+        readonly strip?: StripId;
+    };
+}
+export declare function facade(ctx: BuildContext, o: FacadeOptions): void;
+export interface SetbackTier {
+    readonly footprint: readonly [number, number];
+    readonly floors: number;
+}
+/** Stack of shrinking masses (Empire State, Chrysler-style towers). Returns the top z. */
+export declare function setbacks(ctx: BuildContext, o: {
+    prefix: string;
+    tiers: readonly SetbackTier[];
+    floorHeight: number;
+    color: Vec3;
+    grammar: string;
+    glass: Vec3;
+    detail: boolean;
+}): number;

package/dist/kinds/faces.d.ts

@@ -0,0 +1,27 @@
+import { type MeshBuilder, type Vec2, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+/** Keep the part of a convex polygon where the linear function `f` is ≤ 0. */
+export declare function clipPoly<P extends Vec2 | Vec3>(poly: readonly P[], f: (p: P) => number): P[];
+/** Drop consecutive duplicate points (clipping through a vertex emits it twice). */
+export declare function dedupe<P extends Vec2 | Vec3>(poly: readonly P[]): P[];
+/** Signed area of a 2D polygon (CCW positive). */
+export declare const area2: (poly: readonly Vec2[]) => number;
+/** Vertical extent of one band (one full V of the strip) in metres, from the house sheet. */
+export declare const stripScale: (strip: StripId) => number;
+export interface FaceOptions {
+    /** Convex and planar; either winding (it is turned to face `normal`). */
+    readonly points: readonly Vec3[];
+    readonly normal: Vec3;
+    /** Direction V grows along (up a slope, up a wall); projected into the face plane. */
+    readonly up: Vec3;
+    /** A point on the line where courses start (eave, wall foot). */
+    readonly vOrigin: Vec3;
+    readonly color: Vec3 | ((p: Vec3) => Vec3);
+    readonly strip: StripId;
+    /** false: one polygon, V squeezed over the whole face (far LODs). Default true. */
+    readonly banded?: boolean;
+}
+/** Emit a convex face into `b`, banded at the strip's true scale. Returns triangles added. */
+export declare function emitFace(b: MeshBuilder, o: FaceOptions): number;
+/** Newell's polygon normal (unnormalised): robust for any planar polygon. */
+export declare function newell(poly: readonly Vec3[]): Vec3;

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

@@ -0,0 +1,5 @@
+import type { SculptEdit } from '../primitives/index.js';
+import type { HeadParams } from './head-params.js';
+import { type BustFrame } from './head-torso.js';
+/** `cell`: the bust's sculpt cell; plates thicken to ≈ 2.5 cells so far LODs stay closed. */
+export declare function armour(p: HeadParams, f: BustFrame, cell?: number): SculptEdit[];

package/dist/kinds/head-beard.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';
+/** Eyebrows: two capsule segments (inner thick → outer thin) offset off the brow ridge. */
+export declare function browEdits(p: HeadParams, l: HeadLayout): SculptEdit[];
+export declare function beardEdits(p: HeadParams, l: HeadLayout): SculptEdit[];

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

@@ -0,0 +1,5 @@
+import { type SculptEdit } from '../primitives/index.js';
+import type { HeadLayout } from './head-layout.js';
+import type { HeadParams } from './head-params.js';
+/** `cell`: the bust's sculpt cell (head units), floors the plinth disc so far LODs keep it. */
+export declare function bustEdits(p: HeadParams, l: HeadLayout, cell?: number): SculptEdit[];

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,8 @@
+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[];
+/** `cell`: the sculpt cell (head units). Far LODs drop the teeth and floor the nose's radii at
+ *  about 0.6 cells so a long nose survives. */
+export declare function skullEdits(p: HeadParams, l: HeadLayout, cell?: number): SculptEdit[];

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

@@ -0,0 +1,4 @@
+import type { SculptEdit } from '../primitives/index.js';
+import type { HeadParams } from './head-params.js';
+import { type BustFrame } from './head-torso.js';
+export declare function vest(p: HeadParams, f: BustFrame): 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,31 @@
+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';
+/** Default plinth colour (dark slate). */
+export declare const PLINTH: Vec3;
+/** 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[];
+    /** The bust-cut region (≈ 0 on the cut faces), painted as bare plinth material. */
+    readonly bustCut?: Field;
+}
+/** `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-mouth.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 mouthEdits(p: HeadParams, l: HeadLayout, teeth?: boolean): SculptEdit[];

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

@@ -0,0 +1,116 @@
+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' | 'vest';
+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;
+    /** The bust's plinth (stone/wood socle); default a dark slate. */
+    readonly plinth?: Vec3;
+    /** Scarf / sash cloth (vest style); default `cloth`. */
+    readonly scarf?: 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;
+    };
+    /** Shoulder half-span, gear style, muscle mass (0 = bony and narrow … 1 = brute; default 0.5). */
+    readonly bust: {
+        readonly shoulders: number;
+        readonly style: BustStyle;
+        readonly mass?: number;
+    };
+    readonly hair: HairStyle;
+    readonly beard: BeardStyle;
+    /** Wart / bump count scattered on the skin (seeded). */
+    readonly warts: number;
+    /** Forehead creases (0 = smooth; a goblin's worried brow has 3). */
+    readonly wrinkles?: 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-tone.d.ts

@@ -0,0 +1,10 @@
+import type { Vec3 } from '../core/index.js';
+import type { Field } from '../primitives/index.js';
+export interface ToneOptions {
+    /** Probe distance for the cavity test, head units (≈ the size of a fold). */
+    readonly reach: number;
+    /** 0 = flat colour, 1 = full painted tone. */
+    readonly strength?: number;
+}
+/** Wraps `colorAt` with cavity darkening and a warm-top / cool-under gradient. */
+export declare function toned(field: Field, colorAt: (q: Vec3) => Vec3, o: ToneOptions): (q: Vec3) => Vec3;

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

@@ -0,0 +1,35 @@
+import type { 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';
+/** Where the bust sits relative to the head: centre x, shoulder half-span, base, neck root… */
+export interface BustFrame {
+    readonly cx: number;
+    readonly s: number;
+    /** Reference z the torso is laid out from (the floor lifted by the build's hunch). */
+    readonly b: number;
+    /** The asset's floor: bottom of the plinth. */
+    readonly floor: number;
+    /** Neck root (top of the sternum), z. */
+    readonly nz: number;
+    readonly m: number;
+    /** Neck radius. */
+    readonly n: number;
+    /** Where the trapezius meets the neck, z (high behind the ear on a brute). */
+    readonly trapZ: number;
+    /** Top of the plinth = bottom of the chest cut, z. */
+    readonly cutZ: number;
+}
+export declare function frameOf(p: HeadParams, l: HeadLayout): BustFrame;
+/** Anatomy volumes (plain adds), every one grown by `g`. */
+export declare function torsoForms(f: BustFrame, g?: number): SculptEdit[];
+/** Signed distance to the bust-cut region (negative inside): ≈ 0 on the cut faces. */
+export declare function cutField(f: BustFrame): Field;
+/** Keeps a group to the bust silhouette: the U-cut under the chest, rising to cut the arms. */
+export declare function bustCut(f: BustFrame, g?: number): SculptEdit;
+/** The bare body: anatomy in `color`, sternal notch and groove, then the bust cut. */
+export declare function bodyEdits(p: HeadParams, f: BustFrame, color: Vec3): SculptEdit[];
+/** A turned plinth: wide disc with a bead moulding, then a narrower socle up to the chest cut.
+ *  Both start below the floor, so the bust's flat base cut alone makes the underside. */
+/** `minT`: floor for the disc's thickness (≈ a cell), so far LODs keep the bust on the ground. */
+export declare function plinthEdits(p: HeadParams, f: BustFrame, minT?: number): SculptEdit[];

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-8j4c28jt.js";
+import"../chunk-dxvypr7y.js";
+import"../chunk-d1fv6hrm.js";
+import"../chunk-y63c6zcv.js";
+import"../chunk-drna2rny.js";
+import"../chunk-hg7pf34j.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": []
+}