@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/dist/material/paint/types.d.ts

@@ -0,0 +1,35 @@
+import type { CellId, StripId } from '../trim-sheet.js';
+export interface PaintedSheet {
+    readonly size: number;
+    /** RGBA8, sRGB. Near-greyscale: hue comes from vertex colour multiplied over it. */
+    readonly albedo: Uint8Array;
+    /** RGBA8, tangent-space (glTF / OpenGL, +Y toward decreasing V). */
+    readonly normal: Uint8Array;
+    /** R = occlusion, G = roughness, B = metalness. */
+    readonly orm: Uint8Array;
+}
+export type StripKind = 'bond' | 'planks' | 'plates' | 'noise' | 'flat' | 'slate' | 'concrete' | 'glass';
+export interface StripRecipe {
+    readonly kind: StripKind;
+    /**
+     * World metres the strip's V span represents (its U span is always `stripRect().metres`).
+     * Pick the typical face height the strip is stretched over; texels are anisotropic if needed.
+     */
+    readonly scaleMetres: number;
+    readonly roughness: number;
+    readonly metalness?: number;
+    /** Brick/plank courses, rivet pitch, etc. — read per kind (see each painter's header). */
+    readonly params?: Readonly<Record<string, number>>;
+}
+/** A cell stamped from PNG bytes (8-bit grey/RGB/RGBA, non-interlaced), e.g. a kubeez.com decal. */
+export interface CellImage {
+    readonly image: Uint8Array;
+}
+export interface SheetRecipe {
+    readonly seed: number;
+    readonly size?: 512 | 1024 | 2048;
+    /** Missing strips fall back to `DEFAULT_SHEET`'s recipe for that strip. */
+    readonly strips: Readonly<Partial<Record<StripId, StripRecipe>>>;
+    /** Cells painted from code, or stamped from a supplied image (e.g. a kubeez.com decal). */
+    readonly cells?: Readonly<Partial<Record<CellId, StripRecipe | CellImage>>>;
+}

package/dist/material/paint/validate.d.ts

@@ -0,0 +1,3 @@
+import type { SheetRecipe, StripRecipe } from './types.js';
+export declare function validateStrip(where: string, r: StripRecipe): void;
+export declare function validateSheet(recipe: SheetRecipe): void;

package/dist/material/palette.d.ts

@@ -0,0 +1,12 @@
+import type { Vec3 } from '../core/index.js';
+export type Palette = Readonly<Record<string, Vec3>>;
+/** sRGB hex → linear RGB, the space glTF vertex colours are in. */
+export declare function hex(value: string): Vec3;
+export declare function definePalette(entries: Readonly<Record<string, string>>): Palette;
+/** Era/region palettes ship as data; recipes extend them with object spread. */
+export declare const palettes: {
+    readonly victorianRail: Readonly<Record<string, Vec3>>;
+    readonly artDeco: Readonly<Record<string, Vec3>>;
+    readonly modernGlass: Readonly<Record<string, Vec3>>;
+    readonly harbour: Readonly<Record<string, Vec3>>;
+};

package/dist/material/shader-godot.d.ts

@@ -0,0 +1,2 @@
+import type { ShaderParams } from './shader.js';
+export declare function godotSource(p: ShaderParams): string;

package/dist/material/shader-three.d.ts

@@ -0,0 +1,2 @@
+import type { ShaderParams } from './shader.js';
+export declare function threeSource(p: ShaderParams): string;

package/dist/material/shader.d.ts

@@ -0,0 +1,46 @@
+import type { Surface } from '../core/index.js';
+import { type UvRect } from './trim-sheet.js';
+export interface ShaderHints {
+    /** Vertex sway for vegetation. Weight from the `_WIND` attribute or mesh-local height. */
+    readonly wind?: {
+        readonly strength: number;
+        readonly source?: 'attribute' | 'height';
+        /** Metres of height at which sway reaches full weight (height source). Default 4. */
+        readonly height?: number;
+        readonly hz?: number;
+    };
+    /** Emissive mask on window cells at night: `ratio` of windows lit. */
+    readonly windowGlow?: {
+        readonly color: string;
+        readonly ratio: number;
+        readonly intensity?: number;
+    };
+    /** Wear/grime mask strength 0..1 and how high ground grime climbs (metres). */
+    readonly wear?: {
+        readonly amount: number;
+        readonly grimeHeight?: number;
+    };
+    /** The surface the material is for: 'cutout' adds alpha test + double-sided. */
+    readonly surface?: Surface;
+}
+/** Resolved, validated numbers both emitters print. */
+export interface ShaderParams {
+    readonly windStrength: number;
+    readonly windAttribute: boolean;
+    readonly windHeight: number;
+    readonly windHz: number;
+    readonly glow: readonly [number, number, number];
+    readonly glowRatio: number;
+    readonly glowIntensity: number;
+    readonly wear: number;
+    readonly grimeHeight: number;
+    readonly cutout: boolean;
+    readonly blend: boolean;
+    readonly glowRects: readonly UvRect[];
+    readonly glassRect: UvRect;
+}
+export declare function resolveHints(h: ShaderHints): ShaderParams;
+/** A three.js (r18x, WebGPU/TSL) TypeScript module: `createTrimMaterial(maps)` + `upgradeTrimMaterials(root)`. */
+export declare function threeMaterialSource(hints?: ShaderHints): string;
+/** A Godot 4 spatial shader (.gdshader) with the same features and uniform names. */
+export declare function godotShaderSource(hints?: ShaderHints): string;

package/dist/material/trim-sheet.d.ts

@@ -0,0 +1,22 @@
+export type StripId = 'plain' | 'brick' | 'stone' | 'slate' | 'iron' | 'wood' | 'glass' | 'concrete';
+export type DecalCellId = 'window_sash' | 'door_panel' | 'clock' | 'smokebox' | 'sign' | 'porthole';
+/** Cutout leaf cards: the anchor (twig base) is the cell's bottom-centre, growth toward +V. */
+export type FoliageCellId = 'foliage_broadleaf' | 'foliage_maple' | 'foliage_maple_autumn' | 'foliage_birch' | 'foliage_acacia' | 'foliage_palm' | 'foliage_spruce' | 'foliage_spruce_snow' | 'foliage_willow' | 'foliage_reeds' | 'foliage_needles';
+export type CellId = DecalCellId | FoliageCellId;
+export interface UvRect {
+    readonly u0: number;
+    readonly v0: number;
+    readonly u1: number;
+    readonly v1: number;
+    /** Metres of world surface one full rect covers, so texel density is equal across assets. */
+    readonly metres: number;
+}
+export declare const TRIM_SHEET_SIZE = 1024;
+export declare function stripRect(id: StripId): UvRect;
+/** Cells sit in the lower half (V ≥ 0.5), 8 per row: decals on row 0, foliage from row 1. */
+export declare function cellRect(id: CellId): UvRect;
+export declare const STRIPS: readonly StripId[];
+export declare const CELLS: readonly CellId[];
+export declare const DECAL_CELLS: readonly DecalCellId[];
+export declare const FOLIAGE_CELLS: readonly FoliageCellId[];
+export declare const isFoliage: (id: CellId) => id is FoliageCellId;

package/dist/neural/generator.d.ts

@@ -0,0 +1,25 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+export interface GenerateRequest {
+    readonly prompt?: string;
+    /** PNG/JPEG bytes of a reference or concept image. */
+    readonly image?: Uint8Array;
+    readonly seed: number;
+    /** Fit the result into this box (metres), Z up, base on the ground. */
+    readonly fit: Vec3;
+    readonly targetTriangles: number;
+}
+export interface MeshGenerator {
+    /** e.g. 'trellis-2', 'hunyuan3d-2.1', 'sf3d'. Part of the cache key. */
+    readonly model: string;
+    generate(request: GenerateRequest): Promise<Mesh>;
+}
+/** Talks to a local server (e.g. a ComfyUI / gradio wrapper) at `endpoint`. Planned: M5. */
+export declare function localGenerator(_o: {
+    model: string;
+    endpoint: string;
+}): MeshGenerator;
+/** Import an existing GLB (a CC0 base mesh, a sculpt, a generator's output) as a part. Planned: M5. */
+export declare function importGlb(_bytes: Uint8Array, _o: {
+    fit: Vec3;
+    recolor?: Vec3;
+}): Mesh;

package/dist/neural/images.d.ts

@@ -0,0 +1,17 @@
+export interface ImageRequest {
+    readonly prompt: string;
+    readonly seed: number;
+    readonly width: number;
+    readonly height: number;
+    /** e.g. 'decal', 'tileable', 'reference', 'concept'. */
+    readonly purpose: 'decal' | 'tileable' | 'reference' | 'concept';
+}
+export interface ImageSource {
+    readonly name: string;
+    generate(request: ImageRequest): Promise<Uint8Array>;
+}
+/** kubeez.com image generation. Reads the key from the caller, never from ambient env. */
+export declare function kubeezImages(_o: {
+    apiKey: string;
+    model?: string;
+}): ImageSource;

package/dist/neural/index.d.ts

@@ -0,0 +1,2 @@
+export { type GenerateRequest, importGlb, localGenerator, type MeshGenerator, } from './generator.js';
+export { type ImageRequest, type ImageSource, kubeezImages } from './images.js';

package/dist/neural/index.js

@@ -0,0 +1,14 @@
+import {
+  localGenerator2,
+  importGlb2,
+  kubeezImages2
+} from "../chunk-a8fxakcj.js";
+import"../chunk-4ddzsqtc.js";
+export {
+  importGlb2 as importGlb,
+  kubeezImages2 as kubeezImages,
+  localGenerator2 as localGenerator
+};
+
+//# debugId=12BB55DFBFF53CDF64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/neural/index.js.map

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

package/dist/passes/bake-ao.d.ts

@@ -0,0 +1,17 @@
+import { type CompiledAsset, type Mesh } from '../core/index.js';
+export interface AoOptions {
+    /** Rays per vertex. Default 24. */
+    readonly samples?: number;
+    /** Occluders farther than this (metres) don't count. Default 1. */
+    readonly radius?: number;
+    /** 0 = no change, 1 = fully occluded vertices go black. Default 0.6. */
+    readonly strength?: number;
+    /** Treat z = 0 as a ground plane (contact shadow under the asset). Default true. */
+    readonly ground?: boolean;
+}
+export declare function bakeAo(mesh: Mesh, o?: AoOptions, occluder?: Mesh): Mesh;
+/**
+ * Bake AO across a whole compiled asset: every part is occluded by every other (a wheel darkens
+ * the hull behind it). Colours only change, so parts keep their local meshes and pivots.
+ */
+export declare function bakeAoAsset(asset: CompiledAsset, o?: AoOptions): CompiledAsset;

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-xnt2sdhf.js";
+import"../chunk-4ddzsqtc.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';