@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/dist/primitives/index.js

@@ -0,0 +1,81 @@
+import {
+  box2,
+  lathe2,
+  cylinder2,
+  beam2,
+  cell2,
+  hydraulicErosion2,
+  heightfield2,
+  triangulate2,
+  lattice2,
+  ringXY2,
+  loft2,
+  gradientNoise22,
+  valueNoise22,
+  fbm2,
+  billow2,
+  ridged2,
+  warp2,
+  terrace2,
+  planar2,
+  prism2,
+  sd2,
+  sdf2,
+  sculptField2,
+  sculpt2,
+  arcLengths2,
+  transportFrames2,
+  sweep2,
+  terrainGrid2,
+  sampler2,
+  slopeMap2,
+  thermalErosion2,
+  terrainColor2,
+  measureText2,
+  text2,
+  tiled2,
+  valueNoise3
+} from "../chunk-wtqhq529.js";
+import"../chunk-kvcep7ft.js";
+import"../chunk-4ddzsqtc.js";
+export {
+  arcLengths2 as arcLengths,
+  beam2 as beam,
+  billow2 as billow,
+  box2 as box,
+  cell2 as cell,
+  cylinder2 as cylinder,
+  fbm2 as fbm,
+  gradientNoise22 as gradientNoise2,
+  heightfield2 as heightfield,
+  hydraulicErosion2 as hydraulicErosion,
+  lathe2 as lathe,
+  lattice2 as lattice,
+  loft2 as loft,
+  measureText2 as measureText,
+  planar2 as planar,
+  prism2 as prism,
+  ridged2 as ridged,
+  ringXY2 as ringXY,
+  sampler2 as sampler,
+  sculpt2 as sculpt,
+  sculptField2 as sculptField,
+  sd2 as sd,
+  sdf2 as sdf,
+  slopeMap2 as slopeMap,
+  sweep2 as sweep,
+  terrace2 as terrace,
+  terrainColor2 as terrainColor,
+  terrainGrid2 as terrainGrid,
+  text2 as text,
+  thermalErosion2 as thermalErosion,
+  tiled2 as tiled,
+  transportFrames2 as transportFrames,
+  triangulate2 as triangulate,
+  valueNoise3 as valueNoise,
+  valueNoise22 as valueNoise2,
+  warp2 as warp
+};
+
+//# debugId=5990930430129EC464756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/primitives/index.js.map

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

package/dist/primitives/lathe-facets.d.ts

@@ -0,0 +1,8 @@
+import type { Vec2, Vec3 } from '../core/index.js';
+/** The profile and segment count lathe was given. */
+interface Facetable {
+    readonly profile: readonly Vec2[];
+    readonly segments: number;
+}
+export declare function facets(o: Facetable, put: (p: Vec3, n: Vec3, uv: Vec2) => number, tri: (a: number, b: number, c: number) => void, sideUv: (s: number, i: number, r: number) => Vec2): void;
+export {};

package/dist/primitives/lathe.d.ts

@@ -0,0 +1,26 @@
+import { type Mesh, type Vec2, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+export interface LatheOptions {
+    readonly profile: readonly Vec2[];
+    readonly segments: number;
+    readonly color: Vec3;
+    readonly strip?: StripId;
+    /** Rotate the lathe axis from Z onto X or Y (wheels spin about Y). */
+    readonly axis?: 'x' | 'y' | 'z';
+    readonly at?: Vec3;
+    /** Close the ends with fans (solid cylinders/wheels). */
+    readonly caps?: boolean;
+    /** Profile turns sharper than this (degrees) get split normals: a hard rim, not a smear
+     *  whose averaged normal opposes one band. Default 50. */
+    readonly creaseDeg?: number;
+    /** 'metres': true-scale strip mapping. Default 'stretch'. */
+    readonly uv?: 'stretch' | 'metres';
+    /** Flat facets: one normal per segment (an n-sided prism of revolution). */
+    readonly faceted?: boolean;
+}
+export declare function lathe(o: LatheOptions): Mesh;
+/** Convenience: a capped cylinder, the most common lathe. */
+export declare const cylinder: (o: Omit<LatheOptions, 'profile' | 'caps'> & {
+    radius: number;
+    length: number;
+}) => Mesh;

package/dist/primitives/lattice.d.ts

@@ -0,0 +1,30 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+import { type SectionKind } from './member.js';
+export type TrussPattern = 'warren' | 'pratt' | 'howe' | 'x';
+export interface LatticeOptions {
+    readonly from: Vec3;
+    readonly to: Vec3;
+    /** Chord-to-chord height in metres (at `from`; `depthEnd` tapers it toward `to`). */
+    readonly depth: number;
+    readonly depthEnd?: number;
+    /** Box truss: chord spacing across, metres (and `widthEnd`). Omit for a planar truss. */
+    readonly width?: number;
+    readonly widthEnd?: number;
+    /** Which way depth rises. Default world Z (world X for a vertical truss). */
+    readonly up?: Vec3;
+    readonly centred?: boolean;
+    readonly pattern?: TrussPattern;
+    /** Panels along the length. Default ≈ length / depth. */
+    readonly bays?: number;
+    /** Chord member width, metres. */
+    readonly chord: number;
+    /** Web member width. Default 0.6 · chord. */
+    readonly web?: number;
+    readonly section?: SectionKind;
+    readonly color: Vec3;
+    readonly strip?: StripId;
+}
+export declare function lattice(o: LatticeOptions): Mesh;
+/** Web members of one face as [t0, onTop0, t1, onTop1], in a fixed order (determinism). */
+export declare function webMembers(pattern: TrussPattern, k: number): [number, boolean, number, boolean][];

package/dist/primitives/loft.d.ts

@@ -0,0 +1,15 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+export type LoftColor = Vec3 | ((ring: readonly Vec3[], i: number, p: Vec3) => Vec3);
+export interface LoftOptions {
+    readonly rings: readonly (readonly Vec3[])[];
+    /** One colour, or one per vertex from (ring, ring index, point). */
+    readonly color: LoftColor;
+    readonly strip?: StripId;
+    readonly capStart?: boolean;
+    readonly capEnd?: boolean;
+    readonly uv?: 'length' | 'row' | 'swap';
+}
+/** An elliptical ring in the plane z = centre.z, CCW seen from +Z; `wobble(angle)` scales radius. */
+export declare function ringXY(centre: Vec3, rx: number, ry: number, segments: number, wobble?: (angle: number) => number, phase?: number): Vec3[];
+export declare function loft(o: LoftOptions): Mesh;

package/dist/primitives/mc-table.d.ts

@@ -0,0 +1,2 @@
+/** TRI[c] = flat edge-index list for cube case c (length a multiple of 3). */
+export declare const TRI: readonly (readonly number[])[];

package/dist/primitives/member.d.ts

@@ -0,0 +1,19 @@
+import type { MeshBuilder, Vec2, Vec3 } from '../core/index.js';
+import type { UvRect } from '../material/index.js';
+export type SectionKind = 'square' | 'angle';
+export interface Section {
+    /** Profile in the member's (x, y) plane, CCW seen from the far end. */
+    readonly ring: readonly Vec2[];
+    readonly caps: readonly (readonly [number, number, number])[];
+    /** Cumulative perimeter run at each ring vertex, as a fraction 0..1 (V across the strip). */
+    readonly run: readonly number[];
+    /** Side triangles per member (caps add 2 · caps.length). */
+    readonly sideTris: number;
+}
+/** A section of outside width `w`; angle legs are 15% of the width thick. */
+export declare function section(kind: SectionKind, w: number): Section;
+/**
+ * Extrude `s` from a to b. `y` is the section's local up (must not be parallel to b − a): put it
+ * on the face normal so members lie flush in their truss plane. Caps close both ends.
+ */
+export declare function emitMember(mb: MeshBuilder, s: Section, a: Vec3, b: Vec3, y: Vec3, caps: boolean, color: Vec3, rect: UvRect): void;

package/dist/primitives/noise.d.ts

@@ -0,0 +1,34 @@
+import type { Rng } from '../core/index.js';
+export type Noise2 = (x: number, y: number) => number;
+export interface FractalOptions {
+    /** Metres per base feature (the first octave's wavelength). Default 1. */
+    readonly scale?: number;
+    readonly octaves?: number;
+    /** Frequency multiplier per octave. Default 2. */
+    readonly lacunarity?: number;
+    /** Amplitude multiplier per octave (persistence). Default 0.5. */
+    readonly gain?: number;
+}
+/** Perlin gradient noise, feature size 1 m, ≈ [−1, 1]. */
+export declare function gradientNoise2(rng: Rng): Noise2;
+/** Value noise (smoothed random lattice), feature size 1 m, [−1, 1]. Blobbier than gradient. */
+export declare function valueNoise2(rng: Rng): Noise2;
+/** Fractal Brownian motion: the default rolling-hills / rough-surface noise, ≈ [−1, 1]. */
+export declare const fbm: (n: Noise2, o?: FractalOptions) => Noise2;
+/** Billow: |noise| octaves, rounded domes and sharp creases (hills, clouds), [−1, 1]. */
+export declare const billow: (n: Noise2, o?: FractalOptions) => Noise2;
+/**
+ * Ridged multifractal (Musgrave): inverted |noise| squared, each octave weighted by the last, so
+ * detail piles up on the ridgelines and valleys stay smooth. [0, 1].
+ */
+export declare function ridged(n: Noise2, o?: FractalOptions & {
+    readonly offset?: number;
+}): Noise2;
+/** Domain warp: sample `n` at a point pushed by two other noises × `amount` metres (Quílez). */
+export declare const warp: (n: Noise2, wx: Noise2, wy: Noise2, amount: number) => Noise2;
+/**
+ * Terraces: snap a height to steps of `step` metres. `sharpness` is the share of each step that is
+ * a flat tread (0 = no terracing, 1 = flat treads and vertical risers); the rest is a smooth riser.
+ * Strata, rice paddies, open-pit benches.
+ */
+export declare function terrace(h: number, step: number, sharpness?: number): number;

package/dist/primitives/planar.d.ts

@@ -0,0 +1,10 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+export interface PlanarOptions {
+    /** Counter-clockwise as seen from the side the face points to. */
+    readonly points: readonly Vec3[];
+    readonly color: Vec3;
+    readonly strip?: StripId;
+    readonly doubleSided?: boolean;
+}
+export declare function planar(o: PlanarOptions): Mesh;

package/dist/primitives/prism.d.ts

@@ -0,0 +1,13 @@
+import { type Mesh, type Vec2, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+export interface PrismOptions {
+    readonly profile: readonly Vec2[];
+    readonly depth: number;
+    readonly plane?: 'xz' | 'xy' | 'yz';
+    /** Extrusion is centred on the plane unless `from` is given (0 = starts at the plane). */
+    readonly centred?: boolean;
+    readonly color: Vec3;
+    readonly strip?: StripId;
+    readonly caps?: boolean;
+}
+export declare function prism(o: PrismOptions): Mesh;

package/dist/primitives/sculpt-edit.d.ts

@@ -0,0 +1,56 @@
+import type { Vec3 } from '../core/index.js';
+import { type Field } from './sdf-ops.js';
+export type SculptShape = 'sphere' | 'ellipsoid' | 'capsule' | 'roundBox' | 'cone' | 'torus';
+/** An edit: one shape, or a group of edits folded on their own first (local trims). */
+export type SculptEdit = SculptShapeEdit | SculptGroup;
+/**
+ * Edits folded on their own (from nothing), then applied to the sculpt as ONE edit with this
+ * op/blend/colour: subtract or intersect inside the group trims only the group's shapes (a
+ * half-sphere eyelid, a hair cap stopped at the hairline) and leaves earlier edits alone.
+ */
+export interface SculptGroup {
+    readonly group: readonly SculptEdit[];
+    readonly op?: 'add' | 'subtract' | 'intersect';
+    readonly blend?: number;
+    /** Default colour of the group's own edits (and its colour when it carves). */
+    readonly color?: Vec3;
+    /** Default mirror for the group's edits. */
+    readonly mirror?: boolean;
+}
+export interface SculptShapeEdit {
+    readonly shape: SculptShape;
+    /** Centre (sphere, ellipsoid, roundBox, torus), base centre (cone) or start (capsule). */
+    readonly at: Vec3;
+    /**
+     * sphere: radius · ellipsoid: [rx, ry, rz] · roundBox: full [x, y, z] · cone: [base radius,
+     * top radius, height] along local +Z · torus: [ring radius, tube radius] in local XY ·
+     * capsule: radius (segment `at` → `to`).
+     */
+    readonly size: number | readonly [number, number] | Vec3;
+    /** Capsule end point. */
+    readonly to?: Vec3;
+    /** Degrees about X, then Y, then Z (world axes), around `at`. */
+    readonly rotate?: Vec3;
+    /** roundBox edge radius, metres. */
+    readonly round?: number;
+    readonly op?: 'add' | 'subtract' | 'intersect' | 'paint';
+    /** Smooth-blend radius in metres (0 = hard edge). For paint: the colour falloff width. */
+    readonly blend?: number;
+    readonly color?: Vec3;
+    /** Override the sculpt's `mirror` for this edit (e.g. one scar). */
+    readonly mirror?: boolean;
+}
+export declare function sculptShape(e: SculptShapeEdit, i: number, mirrorAll: boolean): Field;
+/**
+ * A sphere the shape lies in, and how its field compares with the distance to it: every shape's
+ * value v satisfies v ≥ scale · (|p − centre| − radius) outside the sphere (scale 1 = exact SDFs;
+ * the ellipsoid approximation only guarantees (r_min / r_max)², and nothing inside its sphere).
+ */
+export declare function shapeSphere(e: SculptShapeEdit): {
+    c: Vec3;
+    r: number;
+    scale: number;
+    inside: boolean;
+};
+/** Conservative world bounds of an add edit (bounding sphere), grown by its blend radius. */
+export declare function editBounds(e: SculptEdit, mirrorAll: boolean): [Vec3, Vec3];

package/dist/primitives/sculpt-tree.d.ts

@@ -0,0 +1,23 @@
+import type { Vec3 } from '../core/index.js';
+import { type SculptEdit } from './sculpt-edit.js';
+import type { Field } from './sdf-ops.js';
+export interface Node {
+    readonly op: number;
+    readonly k: number;
+    /** The edit's own colour (shapes), or null. */
+    readonly color: Vec3 | null;
+    readonly shape: Field | null;
+    readonly kids: readonly Node[] | null;
+    /** Default colour for this group's edits; its scratch colour buffer. */
+    readonly base: Vec3;
+    readonly rgb: Float64Array;
+    readonly c: Vec3;
+    readonly r: number;
+    readonly scale: number;
+    readonly inside: boolean;
+    readonly mirror: boolean;
+    readonly under: number;
+}
+export declare function compile(edits: readonly SculptEdit[], base: Vec3, mirror: boolean, path?: string): Node[];
+/** Fold `nodes` at p; writes the blended colour into `rgb` (seeded with `base`) when given. */
+export declare function fold(nodes: readonly Node[], p: Vec3, rgb: Float64Array | null, base: Vec3, sparse?: boolean): number;

package/dist/primitives/sculpt.d.ts

@@ -0,0 +1,27 @@
+import type { Mesh, Vec3 } from '../core/index.js';
+import type { StripId } from '../material/index.js';
+import { type SculptEdit } from './sculpt-edit.js';
+import type { Field } from './sdf-ops.js';
+export type { SculptEdit, SculptGroup, SculptShape, SculptShapeEdit } from './sculpt-edit.js';
+export interface SculptField {
+    readonly field: Field;
+    /** Blended edit colour at a point (call at surface points). */
+    readonly colorAt: (p: Vec3) => Vec3;
+    /** Edits' bounds grown by their blend radii. */
+    readonly bounds: readonly [Vec3, Vec3];
+}
+export interface SculptOptions {
+    readonly edits: readonly SculptEdit[];
+    /** Cell edge in metres (the LOD knob). */
+    readonly resolution: number;
+    /** Colour of edits that give none. */
+    readonly color: Vec3;
+    readonly mirror?: 'y';
+    readonly mesher?: 'nets' | 'cubes';
+    readonly strip?: StripId;
+}
+export declare function sculptField(edits: readonly SculptEdit[], o: {
+    readonly color: Vec3;
+    readonly mirror?: 'y';
+}): SculptField;
+export declare function sculpt(o: SculptOptions): Mesh;

package/dist/primitives/sdf-grid.d.ts

@@ -0,0 +1,17 @@
+import type { Vec3 } from '../core/index.js';
+import type { Field } from './sdf-ops.js';
+export interface Grid {
+    /** Points per axis. */
+    readonly nx: number;
+    readonly ny: number;
+    readonly nz: number;
+    /** Position of point (0, 0, 0) and the cell edge, metres. */
+    readonly origin: Vec3;
+    readonly h: number;
+    readonly values: Float32Array;
+    /** The clipped field the grid sampled (normals take its gradient). */
+    readonly field: Field;
+}
+/** Grid points above this are refused (≈ 80 MB of samples). */
+export declare const MAX_POINTS: number;
+export declare function sampleGrid(raw: Field, bounds: readonly [Vec3, Vec3], h: number, lipschitz: number, symmetricY?: boolean): Grid;

package/dist/primitives/sdf-ops.d.ts

@@ -0,0 +1,37 @@
+import type { Vec3 } from '../core/index.js';
+export type Field = (p: Vec3) => number;
+/** Shape distances in the shape's own frame (centre/base at the origin). */
+export declare const shapes: {
+    sphere: (x: number, y: number, z: number, r: number) => number;
+    ellipsoid(x: number, y: number, z: number, rx: number, ry: number, rz: number): number;
+    /** Box of half extents (hx, hy, hz) with edges rounded by `r`. */
+    roundBox(x: number, y: number, z: number, hx: number, hy: number, hz: number, r: number): number;
+    /** Segment (0,0,0) → (0,0,len) with radius r. */
+    capsule(x: number, y: number, z: number, len: number, r: number): number;
+    /** Capped cone standing on z = 0: base radius r1, top radius r2, height h. */
+    cone(x: number, y: number, z: number, r1: number, r2: number, h: number): number;
+    /** Ring in the XY plane: major radius R, tube radius r. */
+    torus(x: number, y: number, z: number, R: number, r: number): number;
+};
+/** Polynomial smooth-min weight: 1 → all `a`, 0 → all `b`; k = 0 is a hard min. */
+export declare const smoothWeight: (a: number, b: number, k: number) => number;
+/** Field constructors and combinators, world space. */
+export declare const sd: {
+    sphere: (at: Vec3, r: number) => Field;
+    ellipsoid: (at: Vec3, radii: Vec3) => Field;
+    /** Axis-aligned box of full `size` centred on `at`, edges rounded by `round`. */
+    box: (at: Vec3, size: Vec3, round?: number) => Field;
+    capsule(a: Vec3, b: Vec3, r: number): Field;
+    cone: (at: Vec3, r1: number, r2: number, h: number) => Field;
+    torus: (at: Vec3, R: number, r: number) => Field;
+    union: (...fs: readonly Field[]) => Field;
+    intersect: (a: Field, b: Field) => Field;
+    /** a minus b. */
+    subtract: (a: Field, b: Field) => Field;
+    /** Union with a fillet of radius ~k metres between the two. */
+    smoothUnion: (k: number, a: Field, b: Field) => Field;
+    /** a minus b with a rounded crease of ~k metres. */
+    smoothSubtract: (k: number, a: Field, b: Field) => Field;
+    /** Push the surface out/in by `amount` metres × noise (∈ [−1, 1]). */
+    displace: (f: Field, noise: Field, amount: number) => Field;
+};

package/dist/primitives/sdf.d.ts

@@ -0,0 +1,21 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+/** One colour, or one per vertex from its position and unit normal (moss on top, dark in cracks). */
+export type SdfColor = Vec3 | ((p: Vec3, n: Vec3) => Vec3);
+export interface SdfOptions {
+    /** Signed distance in metres: negative inside. Must not keep the `p` it is given. */
+    readonly field: (p: Vec3) => number;
+    /** [min, max] corners; the surface is clipped to this box, so it is always closed. */
+    readonly bounds: readonly [Vec3, Vec3];
+    /** Cell edge in metres (the LOD knob). */
+    readonly resolution: number;
+    readonly color: SdfColor;
+    readonly strip?: StripId;
+    readonly mesher?: 'nets' | 'cubes';
+    /** Upper bound on |∇field| (1 for exact distances). Raise it for strongly displaced fields so
+     *  the sparse pass never skips a block that holds surface. Default 1.25. */
+    readonly lipschitz?: number;
+    /** 'y': the field is mirror-symmetric across y = 0 — snap the grid so the mesh is too. */
+    readonly symmetry?: 'y';
+}
+export declare function sdf(o: SdfOptions): Mesh;

package/dist/primitives/strip-uv.d.ts

@@ -0,0 +1,11 @@
+import { type StripId, type UvRect } from '../material/index.js';
+/** Half a texel at the house sheet size: keeps bilinear samples inside the region. */
+export declare const HALF_TEXEL: number;
+/** World metres one strip band covers along V on the house sheet (`scaleMetres`). */
+export declare const stripVMetres: (id: StripId) => number;
+/** U for a run of `metres` along the strip. */
+export declare const stripU: (rect: UvRect, metres: number) => number;
+/** V for a fraction 0..1 of one band. */
+export declare const stripV: (rect: UvRect, frac: number) => number;
+/** V for any metre value, mirrored every band: continuous, never leaves the strip (organic). */
+export declare function mirroredV(rect: UvRect, metres: number, vMetres: number): number;

package/dist/primitives/surface-nets.d.ts

@@ -0,0 +1,7 @@
+import type { Grid } from './sdf-grid.js';
+export interface RawSurface {
+    readonly pos: number[];
+    readonly tris: number[];
+}
+export declare function surfaceNets(g: Grid): RawSurface;
+export declare function marchingCubes(g: Grid): RawSurface;

package/dist/primitives/sweep.d.ts

@@ -0,0 +1,19 @@
+import { type Mesh, type Vec2, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+export interface SweepOptions {
+    /** Closed section in the frame's (normal, binormal) plane, either winding; or a circle. */
+    readonly section: readonly Vec2[] | {
+        readonly radius: number;
+        readonly segments: number;
+    };
+    readonly path: readonly Vec3[];
+    /** Section scale per path point (taper). Default 1 everywhere. */
+    readonly scale?: readonly number[];
+    /** Total section rotation from first to last point, degrees, spread by arc length. */
+    readonly twist?: number;
+    readonly color: Vec3;
+    readonly strip?: StripId;
+    /** Close the ends with fans about the path point: both, or just one. */
+    readonly caps?: boolean | 'start' | 'end';
+}
+export declare function sweep(o: SweepOptions): Mesh;

package/dist/primitives/terrain-color.d.ts

@@ -0,0 +1,30 @@
+import type { Vec3 } from '../core/index.js';
+import type { Noise2 } from './noise.js';
+import { type TerrainGrid } from './terrain-grid.js';
+export interface TerrainPalette {
+    readonly forest: Vec3;
+    readonly grass: Vec3;
+    /** Alpine debris/tundra above the meadows and on deposits. */
+    readonly scree: Vec3;
+    readonly rock: Vec3;
+    readonly snow: Vec3;
+    /** Damp ground in gullies and river beds. */
+    readonly wet: Vec3;
+}
+export interface TerrainColorOptions {
+    readonly palette: TerrainPalette;
+    /** Altitude of z = 0 in metres above sea level (z is relative to it). Default 0. */
+    readonly datum?: number;
+    /** Altitude where forest gives way to meadow, m. */
+    readonly treeline: number;
+    /** Altitude above which snow lies on gentle slopes, m. */
+    readonly snowline: number;
+    /** Slope (rise/run) where bare rock takes over: default 0.8 (≈ 39°). */
+    readonly rockSlope?: number;
+    /** Steepest slope that holds snow: default 1.0 (45°). */
+    readonly snowSlope?: number;
+    /** Noise in [−1, 1] (metres in) jittering every boundary; `jitter` = its altitude reach, m. */
+    readonly noise?: Noise2;
+    readonly jitter?: number;
+}
+export declare function terrainColor(g: TerrainGrid, o: TerrainColorOptions): (x: number, y: number, z: number) => Vec3;

package/dist/primitives/terrain-grid.d.ts

@@ -0,0 +1,36 @@
+export interface TerrainGrid {
+    /** Points along X and Y (cells + 1). Row-major: index = j · nx + i. */
+    readonly nx: number;
+    readonly ny: number;
+    /** [minX, minY, maxX, maxY] in metres. */
+    readonly rect: readonly [number, number, number, number];
+    readonly z: Float64Array;
+    /** Water passage per point, 0..1 (rivers, gullies). Set by hydraulicErosion. */
+    readonly flow?: Float64Array;
+    /** Sediment laid down per point, 0..1 (scree fans, valley fill). Set by hydraulicErosion. */
+    readonly deposit?: Float64Array;
+}
+export interface TerrainGridOptions {
+    readonly rect: readonly [number, number, number, number];
+    /** Cells per side (points = cells + 1); 256 ≈ 8 m on a 2 km tile. */
+    readonly cells: number;
+    readonly height: (x: number, y: number) => number;
+}
+export declare function terrainGrid(o: TerrainGridOptions): TerrainGrid;
+/** Bilinear reader of any per-point map of the grid, clamped at the edges, in metres. */
+export declare function sampler(g: TerrainGrid, map?: Float64Array): (x: number, y: number) => number;
+/** Slope (rise / run, tan of the angle) at every point, by central differences. */
+export declare function slopeMap(g: TerrainGrid): Float64Array;
+export interface ThermalOptions {
+    /** Stable slope as rise/run: 0.7 ≈ 35° (scree's angle of repose). Default 0.7. */
+    readonly talus?: number;
+    readonly iterations?: number;
+    /** Share of the excess moved per iteration, 0..0.5. Default 0.4. */
+    readonly rate?: number;
+}
+/**
+ * Thermal erosion: wherever a neighbour sits lower than the talus slope allows, part of the
+ * excess slides down to it. Every iteration reads the old heights and writes a new array, so the
+ * result is independent of visiting order.
+ */
+export declare function thermalErosion(g: TerrainGrid, o?: ThermalOptions): TerrainGrid;

package/dist/primitives/text-layout.d.ts

@@ -0,0 +1,22 @@
+export type TextFont = '5x7' | 'block';
+export interface MeasureOptions {
+    /** Cap height in metres (the 7 glyph rows). */
+    readonly height: number;
+    readonly font?: TextFont;
+    /** Gap between glyphs in pixels (1 px = height / 7). Default 1. */
+    readonly tracking?: number;
+}
+/** A filled rectangle: columns [c0, c1) from the line start, rows [r0, r1) from the cap line. */
+export interface PixelRect {
+    readonly c0: number;
+    readonly c1: number;
+    readonly r0: number;
+    readonly r1: number;
+}
+/** Width of `str` in metres when set at cap `height`. Throws on characters without a glyph. */
+export declare function measureText(str: string, o: MeasureOptions): number;
+/** The line as merged pixel rectangles, plus its width in pixels. */
+export declare function layout(str: string, font: TextFont, tracking: number): {
+    rects: PixelRect[];
+    width: number;
+};

package/dist/primitives/text.d.ts

@@ -0,0 +1,27 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+import { type TextFont } from './text-layout.js';
+export { type MeasureOptions, measureText, type TextFont } from './text-layout.js';
+export interface TextOptions {
+    readonly origin: Vec3;
+    /** Reading direction. Default +Y (a sign read from +X). */
+    readonly along?: Vec3;
+    /** Letter up. Default +Z. */
+    readonly up?: Vec3;
+    /** Cap height in metres. */
+    readonly height: number;
+    readonly color: Vec3;
+    readonly font?: TextFont;
+    /** Raised thickness in metres; 0 = flush decal lifted 2 mm. Default 0. */
+    readonly depth?: number;
+    /** Gap between glyphs in pixels (height / 7). Default 1. */
+    readonly tracking?: number;
+    readonly align?: 'left' | 'centre' | 'right';
+    /** Shrink the cap height so the line fits this width, metres. */
+    readonly maxWidth?: number;
+    /** Offset (m, along the facing normal) of the surface under a letter piece. `u` = metres along
+     *  `along` from `origin` (negative left of a centre/right anchor), `v` = metres up from it. */
+    readonly surface?: (u: number, v: number) => number;
+    readonly strip?: StripId;
+}
+export declare function text(str: string, o: TextOptions): Mesh;

package/dist/primitives/tiled.d.ts

@@ -0,0 +1,22 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+export interface TiledOptions {
+    /** One corner of the face. */
+    readonly origin: Vec3;
+    /** Edge along the strip (texture U), metres. */
+    readonly u: Vec3;
+    /** The other edge, texture "up" (V), metres. */
+    readonly v: Vec3;
+    readonly color: Vec3;
+    readonly strip?: StripId;
+    /** Columns along `u` (vertex density for grime/bending); the LOD knob. Default 1. */
+    readonly segments?: number;
+    /** Metres the pattern is shifted along U / V (continue a course round a corner). */
+    readonly uOffset?: number;
+    readonly vOffset?: number;
+    /** World metres one strip band spans along V. Default: the house sheet's `scaleMetres`.
+     *  Raise it to stretch the strip (fewer bands, fewer triangles on a far LOD). */
+    readonly vMetres?: number;
+    readonly doubleSided?: boolean;
+}
+export declare function tiled(o: TiledOptions): Mesh;

package/dist/primitives/transport.d.ts

@@ -0,0 +1,17 @@
+import { type Vec3 } from '../core/index.js';
+export interface SweepFrame {
+    /** Unit tangent. */
+    readonly t: Vec3;
+    /** Unit normal: section X. */
+    readonly n: Vec3;
+    /** Unit binormal t × n: section Y. */
+    readonly b: Vec3;
+}
+/** Throws unless the path has ≥ 2 points and no zero-length segment. Returns cumulative lengths. */
+export declare function arcLengths(path: readonly Vec3[]): number[];
+/**
+ * One frame per path point. The first normal comes from world X when the path starts near
+ * vertical, else world Z, so a path in the XZ plane keeps b = ±Y all the way (trunk widths
+ * measured across Y stay exact).
+ */
+export declare function transportFrames(path: readonly Vec3[]): SweepFrame[];