@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/dist/passes/grime.d.ts

@@ -0,0 +1,15 @@
+import type { Mesh, Vec3 } from '../core/index.js';
+export interface GrimeZone {
+    readonly at: Vec3;
+    readonly radius: number;
+    /** 0..1 darkening at the centre. */
+    readonly strength: number;
+}
+export interface GrimeOptions {
+    /** Height (m) below which mud/dust builds up toward the ground. */
+    readonly ground?: number;
+    /** Darkening at z = 0. */
+    readonly groundStrength?: number;
+    readonly zones?: readonly GrimeZone[];
+}
+export declare function grime(mesh: Mesh, o: GrimeOptions): Mesh;

package/dist/passes/index.d.ts

@@ -0,0 +1,6 @@
+export { type AoOptions, bakeAo, bakeAoAsset } from './bake-ao.js';
+export { type GrimeOptions, type GrimeZone, grime } from './grime.js';
+export { type Livery, type LiveryRule, livery } from './livery.js';
+export { type OptimizeOptions, type OptimizeReport, optimize } from './optimize.js';
+export { RayGrid } from './ray-grid.js';
+export { type WeightedNormalsOptions, weightedNormals } from './weighted-normals.js';

package/dist/passes/index.js

@@ -0,0 +1,22 @@
+import {
+  RayGrid2,
+  bakeAo2,
+  bakeAoAsset2,
+  grime2,
+  livery2,
+  optimize2,
+  weightedNormals2
+} from "../chunk-drna2rny.js";
+import"../chunk-hg7pf34j.js";
+export {
+  RayGrid2 as RayGrid,
+  bakeAo2 as bakeAo,
+  bakeAoAsset2 as bakeAoAsset,
+  grime2 as grime,
+  livery2 as livery,
+  optimize2 as optimize,
+  weightedNormals2 as weightedNormals
+};
+
+//# debugId=FB4A86370A140D3564756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/passes/index.js.map

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

package/dist/passes/livery.d.ts

@@ -0,0 +1,19 @@
+import type { Mesh, Vec2, Vec3 } from '../core/index.js';
+export interface LiveryRule {
+    readonly color: Vec3;
+    /** Height band [z0, z1] (metres). */
+    readonly z?: readonly [number, number];
+    /** Along-length band [x0, x1] (metres, +X forward). */
+    readonly x?: readonly [number, number];
+    /** Polygon in the side elevation (x, z): the region a stripe or panel covers. */
+    readonly poly?: readonly Vec2[];
+    /** Only faces whose normal points this way (n·axis > 0.5; roof: n.z > 0.55). */
+    readonly facing?: 'roof' | 'under' | 'front' | 'back' | 'side';
+    /** Multiply into the existing colour instead of replacing it (weathering, shading). */
+    readonly multiply?: boolean;
+}
+export interface Livery {
+    readonly base?: Vec3;
+    readonly rules: readonly LiveryRule[];
+}
+export declare function livery(mesh: Mesh, l: Livery): Mesh;

package/dist/passes/optimize-cache.d.ts

@@ -0,0 +1,15 @@
+/** Reorder triangles for an LRU cache of 32 (Forsyth). Returns a new index buffer. */
+export declare function forsyth(indices: Uint32Array, vertexCount: number): Uint32Array;
+/** Renumber vertices in order of first use; unreferenced vertices are dropped. */
+export declare function fetchOrder(indices: Uint32Array, vertexCount: number): {
+    indices: Uint32Array;
+    order: Uint32Array;
+};
+export interface CacheStats {
+    /** Average cache misses per triangle (0.5 ideal on a regular grid, 3 worst). */
+    readonly acmr: number;
+    /** Misses per unique vertex (1.0 ideal). */
+    readonly atvr: number;
+}
+/** Simulate a FIFO post-transform cache (16 entries, the meshoptimizer/NVIDIA convention). */
+export declare function cacheStats(indices: Uint32Array, vertexCount: number, size?: number): CacheStats;

package/dist/passes/optimize-weld.d.ts

@@ -0,0 +1,15 @@
+import type { Mesh } from '../core/index.js';
+export interface WeldTolerance {
+    /** Position grid, metres. */
+    readonly position: number;
+    readonly normal: number;
+    readonly uv: number;
+    readonly color: number;
+}
+export declare const DEFAULT_WELD: WeldTolerance;
+export interface Welded {
+    readonly mesh: Mesh;
+    readonly degenerate: number;
+    readonly duplicate: number;
+}
+export declare function weld(m: Mesh, t?: WeldTolerance): Welded;

package/dist/passes/optimize.d.ts

@@ -0,0 +1,28 @@
+import type { Mesh } from '../core/index.js';
+export interface OptimizeOptions {
+    /** Merge vertices closer than this (metres) with matching normal/uv/colour. Default 1e-5. */
+    readonly weldEpsilon?: number;
+    /** Reorder for the vertex cache (Forsyth). Default true. */
+    readonly vertexCache?: boolean;
+}
+export interface OptimizeReport {
+    readonly verticesBefore: number;
+    readonly verticesAfter: number;
+    readonly trianglesBefore: number;
+    readonly trianglesAfter: number;
+    /** Zero-area / collapsed triangles dropped. */
+    readonly degenerate: number;
+    /** Exact duplicate triangles (same winding) dropped. */
+    readonly duplicate: number;
+    /** Average cache miss ratio per triangle before (FIFO 16). */
+    readonly acmrBefore: number;
+    /** Average cache miss ratio per triangle after reordering (lower is better, ~0.6–0.8 is good). */
+    readonly acmr: number;
+    /** Cache misses per vertex before / after (1.0 is ideal). */
+    readonly atvrBefore: number;
+    readonly atvr: number;
+}
+export declare function optimize(mesh: Mesh, o?: OptimizeOptions): {
+    mesh: Mesh;
+    report: OptimizeReport;
+};

package/dist/passes/ray-grid.d.ts

@@ -0,0 +1,23 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+export declare class RayGrid {
+    private readonly tri;
+    /** Per triangle: v0, e1 = v1 − v0, e2 = v2 − v0 (Möller–Trumbore inputs, computed once). */
+    private readonly edges;
+    /** Per triangle: unnormalised plane normal e1 × e2 and its offset n·v0. */
+    private readonly planes;
+    private readonly start;
+    private readonly list;
+    private readonly min;
+    private readonly res;
+    private readonly cell;
+    private readonly stamp;
+    private ray;
+    constructor(mesh: Mesh);
+    private coord;
+    /** Any hit of the ray o + t·d (d unit) for 0 < t ≤ tMax. Scalar arguments: no allocation. */
+    hit(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number): boolean;
+    /** Möller–Trumbore on cached v0, e1, e2 (the same arithmetic as deriving them per ray). */
+    private test;
+    /** True if the ray o + t·d (d unit) hits any triangle for 0 < t ≤ tMax. */
+    occluded(o: Vec3, d: Vec3, tMax: number): boolean;
+}

package/dist/passes/weighted-normals.d.ts

@@ -0,0 +1,8 @@
+import type { Mesh } from '../core/index.js';
+export interface WeightedNormalsOptions {
+    /** Faces meeting at more than this many degrees keep a hard edge. Default 40. */
+    readonly hardAngle?: number;
+    /** Positions closer than this (metres) count as one point. Default 1e-5. */
+    readonly epsilon?: number;
+}
+export declare function weightedNormals(m: Mesh, o?: WeightedNormalsOptions): Mesh;

package/dist/primitives/beam.d.ts

@@ -0,0 +1,17 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import type { StripId } from '../material/index.js';
+export interface BeamOptions {
+    readonly from: Vec3;
+    readonly to: Vec3;
+    /** Side of a square section, or diameter of a round one. */
+    readonly width: number;
+    readonly height?: number;
+    readonly segments?: number;
+    readonly color: Vec3;
+    readonly strip?: StripId;
+    /** Which way the section's local Y faces (roll). Default: world Z, or X for vertical beams. */
+    readonly up?: Vec3;
+    /** End caps; turn off for lattice members whose ends are buried in joints (−⅓ triangles). */
+    readonly caps?: boolean;
+}
+export declare function beam(o: BeamOptions): Mesh;

package/dist/primitives/bevel-box.d.ts

@@ -0,0 +1,13 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+type FaceName = 'top' | 'bottom' | 'front' | 'back' | 'left' | 'right';
+export interface BevelBoxInput {
+    readonly half: Vec3;
+    readonly centre: Vec3;
+    readonly bevel: number;
+    readonly color: Vec3;
+    readonly strip: StripId;
+    readonly omit: readonly FaceName[];
+}
+export declare function bevelBox(o: BevelBoxInput): Mesh;
+export {};

package/dist/primitives/box.d.ts

@@ -0,0 +1,16 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+export interface BoxOptions {
+    /** Width (X), depth (Y), height (Z) in metres. */
+    readonly size: Vec3;
+    readonly color: Vec3;
+    readonly strip?: StripId;
+    /** Centre of the base face. */
+    readonly at?: Vec3;
+    /** Skip faces nobody sees (e.g. the bottom on the ground). */
+    readonly omit?: readonly ('top' | 'bottom' | 'front' | 'back' | 'left' | 'right')[];
+    /** Chamfer width in metres on every edge (12 + 8 extra faces, 44 triangles). LOD it:
+     *  `bevel: ctx.pick([0.02, 0.01, 0])`. Must stay under half the smallest size. Default 0. */
+    readonly bevel?: number;
+}
+export declare function box(o: BoxOptions): Mesh;

package/dist/primitives/cell.d.ts

@@ -0,0 +1,20 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type CellId, type StripId } from '../material/index.js';
+export interface CellOptions {
+    /** Bottom-left corner as seen from the front. */
+    readonly origin: Vec3;
+    /** Width edge (cell U), metres. */
+    readonly u: Vec3;
+    /** Height edge (cell V, up), metres. */
+    readonly v: Vec3;
+    readonly color: Vec3;
+    readonly cell: CellId;
+    /** Recess depth in metres (> 0 behind the plane, < 0 proud of it). Default 0. */
+    readonly inset?: number;
+    /** Strip the reveal faces tile at true scale. Default 'plain'. */
+    readonly reveal?: StripId;
+    readonly revealColor?: Vec3;
+    /** Both sides (leaf cards, hanging signs). Not with an inset. */
+    readonly doubleSided?: boolean;
+}
+export declare function cell(o: CellOptions): Mesh;

package/dist/primitives/check.d.ts

@@ -0,0 +1,12 @@
+import { type Vec3 } from '../core/index.js';
+export declare function invalid(cause: string, fix: string): never;
+/** Two edge vectors spanning a real parallelogram; returns |u|, |v| and the unit normal u×v. */
+export declare function spanOf(what: string, origin: Vec3, u: Vec3, v: Vec3): {
+    lu: number;
+    lv: number;
+    n: Vec3;
+};
+/** An integer count in [min, max]. */
+export declare function count(what: string, n: number, min: number, max: number): number;
+/** A finite number > 0. */
+export declare function positive(what: string, n: number, example: string): number;

package/dist/primitives/closed.d.ts

@@ -0,0 +1,11 @@
+import type { Mesh } from '../core/index.js';
+/** Undirected edges walked a different number of times a→b than b→a (0 = closed, oriented). */
+export declare function openEdges(m: Mesh): number;
+/** Directed edges used more than once: 0 = 2-manifold (given openEdges = 0). */
+export declare function nonManifoldEdges(m: Mesh): number;
+/**
+ * Triangles whose winding (b − a) × (c − a) clearly disagrees with their mean vertex normal
+ * (cosine < −0.1; inside-out scores ≈ −1). Slivers whose face normal lies in the surface
+ * (cosine ≈ 0, e.g. surface nets at sub-cell features) are orientation-ambiguous, not counted.
+ */
+export declare function windingFlips(m: Mesh): number;

package/dist/primitives/erosion.d.ts

@@ -0,0 +1,22 @@
+import type { Rng } from '../core/index.js';
+import type { TerrainGrid } from './terrain-grid.js';
+export interface ErosionOptions {
+    /** Droplets simulated. ~1 per grid point is mild, 2–3 is strongly carved. Default 70 000. */
+    readonly droplets?: number;
+    /** Steps a droplet lives. Default 30. */
+    readonly lifetime?: number;
+    /** 0 = droplets follow the gradient exactly, 1 = they never turn. Default 0.05. */
+    readonly inertia?: number;
+    /** Sediment a droplet can carry per unit of speed × water × drop. Default 4. */
+    readonly capacity?: number;
+    readonly minCapacity?: number;
+    /** Share of spare capacity eroded per step. Default 0.3. */
+    readonly erode?: number;
+    /** Share of surplus sediment deposited per step. Default 0.3. */
+    readonly deposit?: number;
+    readonly evaporate?: number;
+    readonly gravity?: number;
+    /** Erosion brush radius in grid cells (wider = smoother gullies). Default 3. */
+    readonly radius?: number;
+}
+export declare function hydraulicErosion(g: TerrainGrid, rng: Rng, o?: ErosionOptions): TerrainGrid;

package/dist/primitives/font-5x7.d.ts

@@ -0,0 +1,3 @@
+export declare const GLYPHS: Readonly<Record<string, readonly number[]>>;
+/** Every character `text` can set (lower case is accepted and set as upper case). */
+export declare const SUPPORTED_CHARS: string;

package/dist/primitives/heightfield.d.ts

@@ -0,0 +1,16 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+import { type StripId } from '../material/index.js';
+export interface HeightfieldOptions {
+    /** [minX, minY, maxX, maxY] in metres. */
+    readonly rect: readonly [number, number, number, number];
+    readonly cells: readonly [number, number];
+    readonly height: (x: number, y: number) => number;
+    /** Vertex colour per point (e.g. darker in ruts, greener on slopes). */
+    readonly color: Vec3 | ((x: number, y: number, z: number) => Vec3);
+    readonly strip?: StripId;
+    /** Close the sides down to this z (e.g. 0): flat-shaded walls, outward normals. */
+    readonly skirt?: number;
+    /** Wall colour; default: the terrain colour at the top edge. */
+    readonly skirtColor?: Vec3;
+}
+export declare function heightfield(o: HeightfieldOptions): Mesh;

package/dist/primitives/index.d.ts

@@ -0,0 +1,23 @@
+export { type BeamOptions, beam } from './beam.js';
+export { type BoxOptions, box } from './box.js';
+export { type CellOptions, cell } from './cell.js';
+export { type ErosionOptions, hydraulicErosion } from './erosion.js';
+export { type HeightfieldOptions, heightfield } from './heightfield.js';
+export { cylinder, type LatheOptions, lathe } from './lathe.js';
+export { type LatticeOptions, lattice, type TrussPattern } from './lattice.js';
+export { type LoftColor, type LoftOptions, loft, ringXY } from './loft.js';
+export type { SectionKind } from './member.js';
+export { billow, type FractalOptions, fbm, gradientNoise2, type Noise2, ridged, terrace, valueNoise2, warp, } from './noise.js';
+export { type PlanarOptions, planar } from './planar.js';
+export { type PrismOptions, prism } from './prism.js';
+export { type SculptEdit, type SculptField, type SculptOptions, type SculptShape, sculpt, sculptField, } from './sculpt.js';
+export { type SdfColor, type SdfOptions, sdf } from './sdf.js';
+export { type Field, sd } from './sdf-ops.js';
+export { type SweepOptions, sweep } from './sweep.js';
+export { type TerrainColorOptions, type TerrainPalette, terrainColor } from './terrain-color.js';
+export { sampler, slopeMap, type TerrainGrid, type TerrainGridOptions, type ThermalOptions, terrainGrid, thermalErosion, } from './terrain-grid.js';
+export { type MeasureOptions, measureText, type TextFont, type TextOptions, text, } from './text.js';
+export { type TiledOptions, tiled } from './tiled.js';
+export { arcLengths, type SweepFrame, transportFrames } from './transport.js';
+export { triangulate } from './triangulate.js';
+export { valueNoise } from './value-noise.js';

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-d1fv6hrm.js";
+import"../chunk-y63c6zcv.js";
+import"../chunk-hg7pf34j.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;