@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/dist/kinds/mass.d.ts

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

package/dist/kinds/openings.d.ts

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

package/dist/kinds/planned.d.ts

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

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

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

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

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

package/dist/kinds/roof.d.ts

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

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

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

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

@@ -0,0 +1,9 @@
+import { type Mesh, type Rng } from '../core/index.js';
+import type { TreeParams } from './vegetation-params.js';
+import type { Stem } from './vegetation-skeleton.js';
+export interface Impostor {
+    readonly trunk: Mesh;
+    readonly leaves: Mesh;
+}
+export declare function blob(stems: readonly Stem[], p: TreeParams, rng: Rng): Impostor;
+export declare function frondCards(stems: readonly Stem[], p: TreeParams, level: number): Impostor;

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

@@ -0,0 +1,15 @@
+import { type Mesh, type Rng, type Vec3 } from '../core/index.js';
+import { type LeafParams } from './vegetation-params.js';
+import type { Stem } from './vegetation-skeleton.js';
+/** Crown occlusion: cards deep inside / low in the crown are darker. */
+export interface CrownShade {
+    readonly centre: Vec3;
+    readonly radius: number;
+    readonly zMin: number;
+    readonly zMax: number;
+}
+export declare function crownShade(stems: readonly Stem[], level: number): CrownShade;
+/** LOD0: `perStem` cards along the outer 70% of every terminal stem, rooted on a ring vertex. */
+export declare function leafCards(stems: readonly Stem[], level: number, ringSegments: number, leaf: LeafParams, shade: CrownShade, rng: Rng): Mesh;
+/** LOD1: one cluster card per (unemitted) twig, rooted where the twig would leave its parent. */
+export declare function clusterCards(stems: readonly Stem[], level: number, leaf: LeafParams, shade: CrownShade, rng: Rng): Mesh;

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

@@ -0,0 +1,21 @@
+import { type Mesh, type Rng, type Vec3 } from '../core/index.js';
+import type { TreeParams } from './vegetation-params.js';
+import type { Stem } from './vegetation-skeleton.js';
+export declare const radialSegments: (level: number, lod: number) => number;
+/** Every `step`-th path point (always keeping both ends): LOD1 halves path resolution. */
+export declare function coarsen(st: Stem, step: number): {
+    pts: Vec3[];
+    radii: number[];
+};
+/** All stems with level in [lo, hi], merged. */
+export declare function stemsMesh(stems: readonly Stem[], lo: number, hi: number, lod: number, color: Vec3): Mesh;
+/** Bark colour by height (bark → barkTop) with seeded marks; rewrites the mesh's colours. */
+export declare function barkTint(m: Mesh, p: TreeParams, top: number, rng: Rng): Mesh;
+/** The trunk, radius scaled by `radiusScale` (the fit's 1/sy keeps DBH exact after scaling). */
+export declare function trunkMesh(trunk: Stem, p: TreeParams, lod: number, radiusScale: number, rng: Rng): Mesh;
+/** Buttressed flare: `p.roots` lobes, wide at the ground, melting into the trunk by ~2·DBH. */
+export declare function rootsMesh(trunk: Stem, p: TreeParams, lod: number, radiusScale: number, rng: Rng): Mesh;
+/** Per-axis factors that bring the union of `meshes` to `target` = [X, Y, Z] spans. */
+export declare function fitFactors(meshes: readonly Mesh[], target: Vec3): Vec3;
+/** Non-uniform scale about the origin; normals by the inverse transpose, renormalised. */
+export declare function scaleMesh(m: Mesh, s: Vec3): Mesh;

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

@@ -0,0 +1,90 @@
+import type { Vec2, Vec3 } from '../core/index.js';
+/** Crown envelope: how level-1 branch length varies up the trunk (Weber–Penn `Shape`). */
+export type CrownShape = 'conical' | 'spherical' | 'hemispherical' | 'cylindrical' | 'tapered' | 'flame';
+/** One recursion level. Level 0 is the trunk; levels 1–3 are branches, sub-branches, twigs. */
+export interface BranchLevel {
+    /** Children per parent (level 1: along the trunk). Ignored for level 0. */
+    readonly branches: number;
+    /** Level 0: fraction of tree height. Level ≥ 1: fraction of the parent's length. */
+    readonly length: number;
+    /** ± relative random length variation. */
+    readonly lengthVar?: number;
+    /** Degrees between child and parent axis at the attachment. */
+    readonly downAngle: number;
+    /** Added to downAngle from the first child (bottom) to the last (top) of the parent's zone. */
+    readonly downAngleV?: number;
+    /** Phyllotaxis step about the parent, degrees (golden angle 137.5° by default). */
+    readonly rotate?: number;
+    /** Total bend over the stem, degrees: + towards the sky, − towards the ground. Trunk: + bends
+     * back against `lean` (towards −X). */
+    readonly curve?: number;
+    /** If set, the second half bends by this instead (S-curves, weeping tips). */
+    readonly curveBack?: number;
+    /** Seeded wobble per path segment, ± degrees. */
+    readonly curveVar?: number;
+    /** Where children start along this stem's parent, as a fraction (level 1 uses `baseSize`). */
+    readonly start?: number;
+    /** Path segments at LOD0 (LOD1 halves them). */
+    readonly segments: number;
+}
+export type LeafShape = 'oval' | 'lobed' | 'tuft' | 'strand' | 'frond';
+/** Card outlines: u along the card (0 = stem end), v across (±0.5). */
+export declare const OUTLINES: Record<Exclude<LeafShape, 'frond'>, readonly Vec2[]>;
+export interface LeafParams {
+    readonly shape: LeafShape;
+    /** Card length at LOD0, metres. Cards stand for a cluster of leaves, not one leaf. */
+    readonly size: number;
+    /** Card width as a fraction of its length (fronds: leaflet length as a fraction of frond). */
+    readonly width: number;
+    /** Cards per terminal stem (fronds: leaflets per side). */
+    readonly perStem: number;
+    /** Where cards start along a terminal stem, 0–1 (default 0.3; tufts sit near the tip). */
+    readonly from?: number;
+    readonly color: Vec3;
+    /** ± relative colour variation per card. */
+    readonly colorVar: number;
+    /** 0–1: lay cards level, like the horizontal needle pads of a pine. */
+    readonly flat?: number;
+    /** 0 = cards splay outward, 1 = they hang straight down (willow strands). */
+    readonly hang?: number;
+}
+export interface TreeParams {
+    readonly shape: CrownShape;
+    /** Fraction of the trunk free of branches (clear bole). */
+    readonly baseSize: number;
+    /** [trunk, level 1, level 2?, level 3?]. */
+    readonly levels: readonly BranchLevel[];
+    /** Child radius = parent radius · (child length / parent length)^ratioPower. */
+    readonly ratioPower: number;
+    /** Trunk radius at the top as a fraction of its radius at breast height. */
+    readonly taper: number;
+    /** Trunk lean from vertical towards +X, degrees. The trunk stays in the XZ plane. */
+    readonly lean?: number;
+    readonly bark: Vec3;
+    /** Bark colour at the top of the trunk (Scots pine's orange upper bark); default `bark`. */
+    readonly barkTop?: Vec3;
+    /** Dark bark marks scattered per vertex (birch lenticels): colour + fraction of vertices. */
+    readonly barkMarks?: {
+        readonly color: Vec3;
+        readonly amount: number;
+    };
+    readonly leaves: LeafParams;
+    /** Buttress lobes in the root flare at the base (LOD0/1); 0 or absent = no `roots` part. */
+    readonly roots?: number;
+    /** Fruit hung under the crown (coconuts), merged into `branches`. LOD0 only. */
+    readonly fruit?: {
+        readonly count: number;
+        readonly radius: number;
+        readonly color: Vec3;
+    };
+    /** LOD2 stand-in: a lathe of the crown envelope, or a few coarse frond cards. */
+    readonly impostor: 'blob' | 'cards';
+    /** Typical mature size this preset was tuned on (used when the caller omits spread/dbh). */
+    readonly typical: {
+        readonly height: number;
+        readonly spread: number;
+        readonly dbh: number;
+    };
+}
+/** Weber–Penn ShapeRatio; `r` is 1 at the crown base and 0 at the trunk tip. */
+export declare function shapeRatio(shape: CrownShape, r: number): number;

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

@@ -0,0 +1,20 @@
+import type { TreeParams } from './vegetation-params.js';
+/** Quercus robur (English oak): 20–25 m, crown about as wide; girth 4–12 m. Spreading, crooked limbs. */
+export declare const oak: TreeParams;
+/** Pinus sylvestris (Scots pine): 25–35 m, DBH up to 1 m; long clean bole, orange upper bark,
+ * flat-topped crown in the top third, dark blue-green needle tufts on upturned tips. */
+export declare const pine: TreeParams;
+/** Cocos nucifera (coconut palm): up to 30 m; single ringed stem 30–40 cm; 4–6 m pinnate fronds. */
+export declare const palm: TreeParams;
+/** Betula pendula (silver birch): 15–25 m, narrow crown, white bark with black marks, weeping twigs. */
+export declare const birch: TreeParams;
+/** Salix babylonica (weeping willow): 10–15 m, wider than tall; long hanging leafy strands. */
+export declare const willow: TreeParams;
+export declare const SPECIES: {
+    readonly oak: TreeParams;
+    readonly pine: TreeParams;
+    readonly palm: TreeParams;
+    readonly birch: TreeParams;
+    readonly willow: TreeParams;
+};
+export type SpeciesName = keyof typeof SPECIES;

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

@@ -0,0 +1,20 @@
+import type { Rng, Vec3 } from '../core/index.js';
+import { type TreeParams } from './vegetation-params.js';
+export interface Stem {
+    readonly level: number;
+    readonly pts: readonly Vec3[];
+    readonly radii: readonly number[];
+    readonly length: number;
+    /** Index of the parent stem, −1 for the trunk. */
+    readonly parent: number;
+    /** Attachment point on the parent's bark (cluster cards root here at LOD1). */
+    readonly surface: Vec3;
+    /** Nominal length before shape/variation: drives the child count. */
+    readonly maxLength: number;
+}
+/** Rodrigues rotation of v about unit axis k by angle a (radians). */
+export declare function rotate(v: Vec3, k: Vec3, a: number): Vec3;
+export declare function grow(p: TreeParams, size: {
+    height: number;
+    dbh: number;
+}, rng: Rng): Stem[];

package/dist/kinds/vegetation.d.ts

@@ -0,0 +1,42 @@
+import { type BuildContext, type RealDimensions } from '../core/index.js';
+import type { TreeParams } from './vegetation-params.js';
+export interface TreeOptions {
+    /** A preset name (`oak`, `pine`, `palm`, `birch`, `willow`) or a full parameter set. */
+    readonly species?: string | TreeParams;
+    /** Overrides on top of the species. */
+    readonly params?: Partial<TreeParams>;
+    /** Total height, metres (ground to crown top). */
+    readonly height: number;
+    /** Crown spread (X and Y), metres. Default: the species' typical ratio to height. */
+    readonly spread?: number;
+    /** Trunk diameter at breast height (1.3 m), metres. Default: the species' typical ratio. */
+    readonly dbh?: number;
+    readonly seed?: number;
+    /** Part-name prefix: `oak_3` → `oak_3_trunk`, `oak_3_crown`, … */
+    readonly prefix?: string;
+}
+export interface TreeInfo {
+    readonly parts: {
+        trunk: string;
+        crown: string;
+        branches: string;
+        leaves: string;
+        roots: string;
+    };
+    readonly height: number;
+    readonly spread: number;
+    readonly dbh: number;
+}
+export declare function treeParams(o: Pick<TreeOptions, 'species' | 'params'>): TreeParams;
+export declare function tree(ctx: BuildContext, o: TreeOptions): TreeInfo;
+/** `real` for a tree recipe: overall envelope plus DBH (trunk across Y) and total height. */
+export declare function treeReal(o: {
+    height: number;
+    spread: number;
+    dbh: number;
+    prefix?: string;
+    source?: string;
+}): RealDimensions;
+export type TreeFamilyParams = Omit<TreeOptions, 'prefix'>;
+/** One family, many species: `trees.variant({ name: 'oak', params: { species: 'oak', height: 22 } })`. */
+export declare const trees: import("../index.ts").Family<TreeFamilyParams>;

package/dist/kinds/vehicle.d.ts

@@ -0,0 +1,42 @@
+import { type BuildContext, type Vec3 } from '../core/index.js';
+/** A pair of wheels on one spinning axle. */
+export declare function axle(ctx: BuildContext, o: {
+    name: string;
+    at: Vec3;
+    radius: number;
+    gauge: number;
+    width: number;
+    color: Vec3;
+    rps: number;
+}): void;
+/** Lays out wheel groups from a Whyte arrangement along X; returns axle x-positions per role. */
+export declare function whyteAxles(arrangement: string, o: {
+    leading: number;
+    driving: number;
+    trailing: number;
+    spacing: number;
+}): {
+    role: string;
+    x: number;
+    radius: number;
+}[];
+/** One side of a tracked running gear: road wheels (spinning) + a flat track loop. */
+export declare function trackRun(ctx: BuildContext, o: {
+    side: 'l' | 'r';
+    y: number;
+    length: number;
+    wheels: number;
+    radius: number;
+    width: number;
+    color: Vec3;
+    track: Vec3;
+}): void;
+/** A propeller hub + blades that spin about X (nose direction). */
+export declare function propeller(ctx: BuildContext, o: {
+    name: string;
+    at: Vec3;
+    radius: number;
+    blades: number;
+    color: Vec3;
+    parent?: string;
+}): void;

package/dist/material/cc0.d.ts

@@ -0,0 +1,4 @@
+import type { MaterialDef } from './material-def.js';
+/** Poly Haven "Wood Planks Grey" by Rob Tuytel (CC0), 1.5 m square, 1k PNG maps. */
+export declare const CC0_WOOD_PLANKS_GREY: MaterialDef;
+export declare const CC0_MATERIALS: readonly MaterialDef[];

package/dist/material/define.d.ts

@@ -0,0 +1,34 @@
+import { type MaterialDef } from './material-def.js';
+import type { StripRecipe } from './paint/types.js';
+import { type TextureSource } from './texture-source.js';
+import { type CustomStripId, type StripId } from './trim-sheet.js';
+/**
+ * Register a project material and return its strip id for `strip:` options.
+ * @example
+ * const teak = defineMaterial({ id: 'teak_deck', kind: 'planks', roughness: 0.6,
+ *   albedo: '#8a5a32', albedo2: '#5a3a1e', params: { width: 0.12, rings: 0.5 } });
+ * box({ size: [4, 2, 0.05], strip: teak, color: NATURAL });
+ */
+export declare function defineMaterial(def: MaterialDef): CustomStripId;
+/**
+ * Forget every defined material (tests; long-lived workers that reload recipes). Built-ins stay.
+ * Meshes compiled before the reset keep UVs into rows that may be reassigned.
+ */
+export declare function resetMaterials(): void;
+export interface MaterialInfo {
+    readonly id: StripId;
+    /** classic = greyscale strip tinted by vertex colour; library/defined carry their own colour. */
+    readonly origin: 'classic' | 'library' | 'defined';
+    readonly recipe: StripRecipe;
+    readonly description: string;
+    readonly sources: readonly string[];
+}
+/** What a strip is: its recipe, origin, description and sources. Unknown ids throw. */
+export declare function materialOf(id: StripId): MaterialInfo;
+/** Every texture set a defined material references (what `bun run textures` fetches). */
+export declare function textureSources(): readonly TextureSource[];
+/**
+ * Credit lines for the image strips a mesh samples: any V coordinate inside such a strip's row
+ * counts. Empty when no image strip is used (the GLB stays byte-identical).
+ */
+export declare function stripCredits(vs: ArrayLike<number>): string[];

package/dist/material/generator.d.ts

@@ -0,0 +1,4 @@
+import type { PaintedSheet, SheetRecipe } from './paint/types.js';
+export { DEFAULT_SHEET } from './paint/default-sheet.js';
+export type { CellImage, MaterialPainter, MaterialSurface, PaintedSheet, PaintKit, SheetRecipe, StripKind, StripRecipe, } from './paint/types.js';
+export declare function paintTrimSheet(recipe?: SheetRecipe): PaintedSheet;

package/dist/material/index.d.ts

@@ -0,0 +1,9 @@
+export { CC0_MATERIALS, CC0_WOOD_PLANKS_GREY } from './cc0.js';
+export { defineMaterial, type MaterialInfo, materialOf, resetMaterials, stripCredits, textureSources, } from './define.js';
+export { type CellImage, DEFAULT_SHEET, type MaterialPainter, type MaterialSurface, type PaintedSheet, type PaintKit, paintTrimSheet, type SheetRecipe, type StripKind, type StripRecipe, } from './generator.js';
+export { MATERIAL_LIBRARY } from './library.js';
+export type { MaterialDef } from './material-def.js';
+export { definePalette, hex, NATURAL, type Palette, palettes } from './palette.js';
+export { godotShaderSource, type ShaderHints, threeMaterialSource } from './shader.js';
+export { creditOf, provideTextures, type TextureCache, type TextureFile, type TextureSource, } from './texture-source.js';
+export { type BuiltinStripId, CELLS, type CellId, CLASSIC_STRIPS, type ClassicStripId, CUSTOM_STRIP_SLOTS, type CustomStripId, cellRect, DECAL_CELLS, type DecalCellId, FOLIAGE_CELLS, type FoliageCellId, isFoliage, MATERIAL_STRIPS, type MaterialStripId, STRIP_ROWS, STRIPS, type StripId, stripRect, stripRow, TRIM_SHEET_SIZE, type UvRect, } from './trim-sheet.js';

package/dist/material/index.js

@@ -0,0 +1,70 @@
+import {
+  CC0_WOOD_PLANKS_GREY2,
+  CC0_MATERIALS2,
+  MATERIAL_LIBRARY2,
+  hex2,
+  NATURAL2,
+  definePalette2,
+  palettes2,
+  provideTextures2,
+  creditOf2,
+  DEFAULT_SHEET2,
+  STRIP_ROWS2,
+  CUSTOM_STRIP_SLOTS2,
+  TRIM_SHEET_SIZE2,
+  stripRow2,
+  stripRect2,
+  cellRect2,
+  STRIPS2,
+  CLASSIC_STRIPS2,
+  MATERIAL_STRIPS2,
+  CELLS2,
+  DECAL_CELLS2,
+  FOLIAGE_CELLS2,
+  isFoliage2,
+  defineMaterial2,
+  resetMaterials2,
+  materialOf2,
+  textureSources2,
+  stripCredits2,
+  paintTrimSheet2,
+  threeMaterialSource2,
+  godotShaderSource2
+} from "../chunk-y63c6zcv.js";
+import"../chunk-hg7pf34j.js";
+export {
+  CC0_MATERIALS2 as CC0_MATERIALS,
+  CC0_WOOD_PLANKS_GREY2 as CC0_WOOD_PLANKS_GREY,
+  CELLS2 as CELLS,
+  CLASSIC_STRIPS2 as CLASSIC_STRIPS,
+  CUSTOM_STRIP_SLOTS2 as CUSTOM_STRIP_SLOTS,
+  DECAL_CELLS2 as DECAL_CELLS,
+  DEFAULT_SHEET2 as DEFAULT_SHEET,
+  FOLIAGE_CELLS2 as FOLIAGE_CELLS,
+  MATERIAL_LIBRARY2 as MATERIAL_LIBRARY,
+  MATERIAL_STRIPS2 as MATERIAL_STRIPS,
+  NATURAL2 as NATURAL,
+  STRIPS2 as STRIPS,
+  STRIP_ROWS2 as STRIP_ROWS,
+  TRIM_SHEET_SIZE2 as TRIM_SHEET_SIZE,
+  cellRect2 as cellRect,
+  creditOf2 as creditOf,
+  defineMaterial2 as defineMaterial,
+  definePalette2 as definePalette,
+  godotShaderSource2 as godotShaderSource,
+  hex2 as hex,
+  isFoliage2 as isFoliage,
+  materialOf2 as materialOf,
+  paintTrimSheet2 as paintTrimSheet,
+  palettes2 as palettes,
+  provideTextures2 as provideTextures,
+  resetMaterials2 as resetMaterials,
+  stripCredits2 as stripCredits,
+  stripRect2 as stripRect,
+  stripRow2 as stripRow,
+  textureSources2 as textureSources,
+  threeMaterialSource2 as threeMaterialSource
+};
+
+//# debugId=DC34FA57446536B164756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/material/index.js.map

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

package/dist/material/library.d.ts

@@ -0,0 +1,7 @@
+import type { MaterialDef } from './material-def.js';
+import type { MaterialStripId } from './trim-sheet.js';
+type Library = Readonly<Record<MaterialStripId, MaterialDef & {
+    readonly id: MaterialStripId;
+}>>;
+export declare const MATERIAL_LIBRARY: Library;
+export {};

package/dist/material/material-def.d.ts

@@ -0,0 +1,30 @@
+import { type Vec3 } from '../core/index.js';
+import type { MaterialPainter, StripKind, StripRecipe } from './paint/types.js';
+import { type TextureSource } from './texture-source.js';
+export interface MaterialDef {
+    /** snake_case, unique; becomes the strip id recipes pass as `strip`. */
+    readonly id: string;
+    /** Base painter the strip starts from. Default 'noise' (a quiet surface). */
+    readonly kind?: StripKind;
+    /** World metres the strip's V span represents (typical face height). Default 1. */
+    readonly scaleMetres?: number;
+    /** Perceptual roughness 0..1 (glTF): 0 mirror, 1 chalk. */
+    readonly roughness: number;
+    /** 0 dielectric, 1 metal. Default 0. Avoid in-between values except for dirt/oxide blends. */
+    readonly metalness?: number;
+    /** Intrinsic base colour: sRGB '#rrggbb' or linear RGB. Default white (vertex colour = hue). */
+    readonly albedo?: string | Vec3;
+    /** Second colour the painter blends to (latewood, rust, verdigris, bare wood under paint). */
+    readonly albedo2?: string | Vec3;
+    /** Painter knobs for `kind` (see each painter's header in src/material/paint/). */
+    readonly params?: Readonly<Record<string, number>>;
+    /** Your own layer, painted after `kind`: write height/tone/rough/metal/mix per texel. */
+    readonly paint?: MaterialPainter;
+    /** Paint from a CC0 texture set (opt-in, needs `bun run textures`) instead of `kind`. */
+    readonly texture?: TextureSource;
+    readonly description?: string;
+    /** Where the numbers come from (URLs). */
+    readonly sources?: readonly string[];
+}
+/** Validate a definition and turn it into the strip recipe the sheet painter runs. */
+export declare function toStripRecipe(d: MaterialDef): StripRecipe;

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

@@ -0,0 +1,3 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintBond(c: Canvas, r: StripRecipe, seed: number): void;