@developerz.ai/ts23d 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,39 @@
+import type { Vec3 } from '../../core/index.js';
+export interface Canvas {
+    readonly w: number;
+    readonly h: number;
+    /** World metres the canvas spans along U (x) and V (y). Row y grows with world up (+V). */
+    readonly metresU: number;
+    readonly metresV: number;
+    /** Strips wrap along U (tile seamlessly); cells clamp. */
+    readonly wrapU: boolean;
+    readonly height: Float32Array;
+    readonly tone: Float32Array;
+    readonly rough: Float32Array;
+    readonly metal: Float32Array;
+    /** Extra occlusion multiplied into the cavity AO (foliage darkens toward the twig). */
+    readonly occl: Float32Array;
+    /** 0 = `colours[0]`, 1 = `colours[1]` (latewood, rust, bare wood under chipped paint…). */
+    readonly mix: Float32Array;
+    /** Linear albedo pair for material strips; null = greyscale (vertex colour carries hue). */
+    colours: readonly [Vec3, Vec3] | null;
+    /** sRGB RGBA override (stamped images, coloured foliage); null when painted greyscale. */
+    rgba: Uint8Array | null;
+    /** Tangent-space normal override (image strips); null = derived from `height`. */
+    normalRgba: Uint8Array | null;
+}
+export declare function createCanvas(w: number, h: number, metresU: number, metresV: number, wrapU: boolean): Canvas;
+/** Metres per pixel along x and y. */
+export declare const pxU: (c: Canvas) => number;
+export declare const pxV: (c: Canvas) => number;
+/** Noise period (lattice cells across the canvas width) for a feature size in metres. */
+export declare function periodFor(c: Canvas, featureMetres: number): number;
+/**
+ * fBm sampled at metres (xm, ym) with feature size `sizeU` along U and `sizeV` along V,
+ * snapped so it tiles along U. Returns [-1, 1].
+ */
+export declare function noiseAt(c: Canvas, xm: number, ym: number, sizeU: number, sizeV: number, seed: number, octaves?: number): number;
+/** Read a parameter with a default, rejecting nothing (validation happens in the generator). */
+export declare const param: (params: Readonly<Record<string, number>> | undefined, key: string, fallback: number) => number;
+export declare const clamp01: (v: number) => number;
+export declare const smooth: (e0: number, e1: number, v: number) => number;

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

@@ -0,0 +1,4 @@
+import { type CellId } from '../trim-sheet.js';
+import type { Canvas } from './canvas.js';
+import type { CellImage, StripRecipe } from './types.js';
+export declare function paintCell(c: Canvas, id: CellId, entry: StripRecipe | CellImage, seed: number): void;

package/dist/material/paint/cells-round.d.ts

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

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

@@ -0,0 +1,7 @@
+import { type Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+/** Pane tone: dark enough that `luma < 0.3` marks glass for window glow. */
+export declare const PANE_TONE = 0.12;
+export declare function paintWindowSash(c: Canvas, r: StripRecipe, seed: number): void;
+export declare function paintDoorPanel(c: Canvas, r: StripRecipe, seed: number): void;
+export declare function paintSign(c: Canvas, r: StripRecipe, _seed: number): void;

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

@@ -0,0 +1,5 @@
+import type { Canvas } from './canvas.js';
+import type { PaintedSheet } from './types.js';
+/** An empty sheet: white albedo (vertex colour reads true), flat normal, AO 1, rough 0.8. */
+export declare function blankSheet(size: number): PaintedSheet;
+export declare function composeRegion(sheet: PaintedSheet, c: Canvas, x0: number, y0: number, pad: number): void;

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

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

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

@@ -0,0 +1,31 @@
+import type { Canvas } from './canvas.js';
+export interface CourseSpec {
+    /** Course height, metres (along V). */
+    readonly course: number;
+    /** Mean tile length, metres (along U). */
+    readonly length: number;
+    /** 0 = regular; 0.5 = sizes vary ±25 %. */
+    readonly irregular: number;
+    /** Fraction of a tile each odd course shifts; random offsets when irregular. */
+    readonly stagger: number;
+    readonly seed: number;
+}
+export declare class Courses {
+    /** Tile index within the current course, per column. */
+    readonly id: Int32Array;
+    /** Distance to the nearest vertical joint, metres, per column. */
+    readonly dx: Float32Array;
+    /** Distance from the tile's left joint, metres, per column. */
+    readonly ux: Float32Array;
+    /** The current course: index and its bottom / top in metres. */
+    index: number;
+    y0: number;
+    y1: number;
+    private readonly bounds;
+    private readonly c;
+    private readonly spec;
+    constructor(c: Canvas, spec: CourseSpec);
+    /** Point the tables at the course containing metres `ym`; returns the course index. */
+    at(ym: number): number;
+    private fill;
+}

package/dist/material/paint/decode-png.d.ts

@@ -0,0 +1,6 @@
+export interface Rgba {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+}
+export declare function decodePng(bytes: Uint8Array): Rgba;

package/dist/material/paint/default-sheet.d.ts

@@ -0,0 +1,4 @@
+import type { StripId } from '../trim-sheet.js';
+import type { SheetRecipe, StripRecipe } from './types.js';
+export declare const HOUSE_STRIPS: Partial<Record<StripId, StripRecipe>>;
+export declare const DEFAULT_SHEET: SheetRecipe;

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

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

package/dist/material/paint/foliage-broad.d.ts

@@ -0,0 +1,5 @@
+import type { Canvas } from './canvas.js';
+export declare function paintBroadleaf(c: Canvas, seed: number): void;
+export declare function paintMaple(c: Canvas, seed: number): void;
+export declare function paintMapleAutumn(c: Canvas, seed: number): void;
+export declare function paintBirch(c: Canvas, seed: number): void;

package/dist/material/paint/foliage-common.d.ts

@@ -0,0 +1,35 @@
+import type { Rng } from '../../core/index.js';
+import type { Foliage, Rgb } from './foliage-raster.js';
+/** A quadratic Bézier from p0 via p1 to p2, metres in the cell (anchor usually 0.5, 0.02). */
+export interface Curve {
+    readonly x: readonly number[];
+    readonly y: readonly number[];
+    /** Tangent angle per sample (0 = +V, + toward +U), the convention `Foliage.leaf` takes. */
+    readonly a: readonly number[];
+}
+export declare function curve(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, n?: number): Curve;
+/** Sample index nearest parameter t ∈ [0, 1]. */
+export declare const at: (c: Curve, t: number) => number;
+/** Draw a curve as a tapered stem. */
+export declare function drawStem(f: Foliage, c: Curve, w0: number, w1: number, col: Rgb): void;
+/** Jitter a colour per leaf: brightness ±amt and a small hue drift between R and G. */
+export declare function vary(rng: Rng, col: Rgb, amt: number): Rgb;
+export declare const dim: (col: Rgb, k: number) => Rgb;
+/** Leaf palettes, linear RGB (multiply by a near-white vertex colour on the card). */
+export declare const LEAF: {
+    readonly beech: Rgb;
+    readonly maple: Rgb;
+    readonly birch: Rgb;
+    readonly acacia: Rgb;
+    readonly palm: Rgb;
+    readonly dry: Rgb;
+    readonly spruce: Rgb;
+    readonly pine: Rgb;
+    readonly willow: Rgb;
+    readonly reed: Rgb;
+    readonly snow: Rgb;
+    readonly bark: Rgb;
+    readonly twig: Rgb;
+};
+/** Autumn maple: each leaf picks one of these, then gets jittered. */
+export declare const AUTUMN: readonly Rgb[];

package/dist/material/paint/foliage-compound.d.ts

@@ -0,0 +1,4 @@
+import type { Canvas } from './canvas.js';
+export declare function paintAcacia(c: Canvas, seed: number): void;
+export declare function paintPalm(c: Canvas, seed: number): void;
+export declare function paintWillow(c: Canvas, seed: number): void;

package/dist/material/paint/foliage-conifer.d.ts

@@ -0,0 +1,5 @@
+import type { Canvas } from './canvas.js';
+export declare const paintSpruce: (c: Canvas, seed: number) => void;
+export declare const paintSpruceSnow: (c: Canvas, seed: number) => void;
+export declare function paintNeedles(c: Canvas, seed: number): void;
+export declare function paintReeds(c: Canvas, seed: number): void;

package/dist/material/paint/foliage-raster.d.ts

@@ -0,0 +1,26 @@
+import { type Canvas } from './canvas.js';
+export type Rgb = readonly [number, number, number];
+/** Width profile of a leaf along its length t ∈ [0, 1]; 1 = full half-width. */
+export type LeafShape = 'ovate' | 'lance' | 'needle' | 'blade' | 'palmate';
+export declare class Foliage {
+    private readonly r;
+    private readonly g;
+    private readonly b;
+    private readonly a;
+    private readonly c;
+    private readonly px;
+    constructor(c: Canvas);
+    /** Composite `cov` of colour (cr, cg, cb) × shade over texel i. */
+    private put;
+    /** Pixel bounds of a metre-space box, clipped to the canvas. */
+    private span;
+    /** A tapered stem / twig / rachis from (ax, ay) width w0 to (bx, by) width w1, metres. */
+    stem(ax: number, ay: number, bx: number, by: number, w0: number, w1: number, col: Rgb): void;
+    /**
+     * A leaf from its base (bx, by) along `angle` (radians, 0 = +V, positive = toward +U), `len`
+     * long and `wid` wide at its widest. `serrate` adds teeth; `lift` raises it over earlier layers.
+     */
+    leaf(shape: LeafShape, bx: number, by: number, angle: number, len: number, wid: number, col: Rgb, serrate?: number, lift?: number): void;
+    /** Write the layers to the canvas: sRGB RGBA with bled colour, occlusion toward the twig. */
+    finish(axisX?: number, reach?: number): void;
+}

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

@@ -0,0 +1,3 @@
+import type { FoliageCellId } from '../trim-sheet.js';
+import type { Canvas } from './canvas.js';
+export declare const FOLIAGE_PAINTERS: Readonly<Record<FoliageCellId, (c: Canvas, seed: number) => void>>;

package/dist/material/paint/image-strip.d.ts

@@ -0,0 +1,4 @@
+import type { TextureSource } from '../texture-source.js';
+import type { Canvas } from './canvas.js';
+import type { StripRecipe } from './types.js';
+export declare function paintImageStrip(c: Canvas, r: StripRecipe, t: TextureSource, where: string): void;

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

@@ -0,0 +1,5 @@
+import { type Canvas } from './canvas.js';
+import type { PaintKit } from './types.js';
+export declare function paintKit(c: Canvas, seed: number): PaintKit;
+/** Throw T3D_MATERIAL_INVALID if any layer holds a non-finite value. */
+export declare function checkFinite(c: Canvas, where: string): void;

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

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

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

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

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

@@ -0,0 +1,9 @@
+/** Integer hash of a lattice point to [0, 1). */
+export declare function hash2(ix: number, iy: number, seed: number): number;
+/** Value noise in [0, 1] on a unit lattice, periodic in x with an integer `period` (cells). */
+export declare function valueNoise(x: number, y: number, period: number, seed: number): number;
+/**
+ * Fractal Brownian motion in [-1, 1]: `octaves` layers of value noise, each at double frequency
+ * and `gain` amplitude. Doubling keeps the period an integer, so the sum stays tileable.
+ */
+export declare function fbm(x: number, y: number, period: number, seed: number, octaves?: number, gain?: number): number;

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

@@ -0,0 +1,8 @@
+import type { Canvas } from './canvas.js';
+/** Neighbour column indices, precomputed so the hot loop does no modulo. */
+export declare function neighbours(n: number, wrap: boolean): {
+    lo: Int32Array;
+    hi: Int32Array;
+};
+/** RGBA8 tangent-space normals for the canvas; `strength` scales the slope. */
+export declare function sobelNormals(c: Canvas, strength?: number): Uint8Array;

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

@@ -0,0 +1,8 @@
+import type { Canvas } from './canvas.js';
+/** Per-texel ambient occlusion in [1 - AO_STRENGTH, 1]. */
+export declare function cavityOcclusion(c: Canvas): Float32Array;
+export declare const SRGB: Uint8Array<ArrayBuffer>;
+/** RGBA8 ORM: R = occlusion, G = roughness, B = metalness, A = 255. */
+export declare function packOrm(c: Canvas, ao: Float32Array): Uint8Array;
+/** RGBA8 sRGB albedo: the stamped image if any, else (colour pair by mix or grey) × tone × cavity. */
+export declare function packAlbedo(c: Canvas, ao: Float32Array): Uint8Array;

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

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

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

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

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

@@ -0,0 +1,8 @@
+/** Distance from (px, py) to the segment (ax, ay)–(bx, by). */
+export declare function segment(px: number, py: number, ax: number, ay: number, bx: number, by: number): number;
+/** Signed distance to an axis-aligned rectangle (negative inside). */
+export declare function rect(px: number, py: number, x0: number, y0: number, x1: number, y1: number): number;
+/** Dome profile in [0, 1] for a round boss of radius `r` at distance `d`. */
+export declare const dome: (d: number, r: number) => number;
+/** Distance to the nearest of `n` points evenly spaced on a circle of radius `ring`. */
+export declare function boltRing(px: number, py: number, ring: number, n: number, phase?: number): number;

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

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

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

@@ -0,0 +1,3 @@
+import type { Canvas } from './canvas.js';
+export declare const STAMP_ROUGHNESS = 0.6;
+export declare function stampImage(c: Canvas, png: Uint8Array): void;

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

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

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

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

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

@@ -0,0 +1,65 @@
+import type { Vec3 } from '../../core/index.js';
+import type { TextureSource } from '../texture-source.js';
+import type { CellId, StripId } from '../trim-sheet.js';
+import type { Canvas } from './canvas.js';
+export interface PaintedSheet {
+    readonly size: number;
+    /** RGBA8, sRGB. Classic strips are greyscale (vertex colour carries hue); materials carry colour. */
+    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' | 'metal' | 'weave' | 'leather';
+/**
+ * The surface a painter writes, one float per texel per layer, in real metres. Row y grows with
+ * world up (+V); strips wrap along x. Layers: `height` (metres, + is out), `tone` (linear
+ * brightness multiplier), `rough` and `metal` (0–1), `mix` (0 = albedo, 1 = albedo2), `occl`.
+ */
+export type MaterialSurface = Canvas;
+/** Helpers handed to a custom painter: seeded, tileable noise and smoothstep, all in metres. */
+export interface PaintKit {
+    readonly seed: number;
+    /** Tileable fBm in [−1, 1] with feature size `sizeU` × `sizeV` metres; `salt` varies it. */
+    noise(xm: number, ym: number, sizeU: number, sizeV: number, salt?: number, octaves?: number): number;
+    /** Integer hash in [0, 1). */
+    hash(a: number, b: number, salt?: number): number;
+    smooth(e0: number, e1: number, v: number): number;
+    /** Visit every texel: index into the layers and its centre in metres. */
+    each(fn: (i: number, xm: number, ym: number) => void): void;
+}
+/** A project painter: runs after the base `kind`, layering its own pattern over it. */
+export type MaterialPainter = (s: MaterialSurface, kit: PaintKit) => void;
+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>>;
+    /** Intrinsic linear albedo; omitted = white (greyscale strip, vertex colour carries hue). */
+    readonly albedo?: Vec3;
+    /** Second linear albedo the painter blends to through `mix` (latewood, rust, bare wood…). */
+    readonly albedo2?: Vec3;
+    /** Extra layer painted after `kind` (see `defineMaterial`). */
+    readonly paint?: MaterialPainter;
+    /** Paint from a cached CC0 texture set instead of `kind` (see texture-source.ts). */
+    readonly texture?: TextureSource;
+}
+/** 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,14 @@
+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;
+/** Vertex colour for material strips that carry their own colour (oak, brass, rubber…). */
+export declare const NATURAL: 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/slots.d.ts

@@ -0,0 +1,5 @@
+/** Slot index among the custom strips, or −1. */
+export declare const customIndex: (id: string) => number;
+export declare const customIds: () => readonly string[];
+export declare function pushCustom(id: string): number;
+export declare function clearCustom(): void;

package/dist/material/texture-source.d.ts

@@ -0,0 +1,34 @@
+export interface TextureFile {
+    /** Download URL (https) or, for `source: 'file'`, a path relative to the working directory. */
+    readonly url: string;
+    /** Lower-case hex sha256 of the file's bytes: the cache key and the integrity check. */
+    readonly sha256: string;
+}
+export interface TextureSource {
+    readonly source: 'polyhaven' | 'ambientcg' | 'file';
+    /** The set's id at the source, e.g. 'wood_planks_grey'. */
+    readonly id: string;
+    /** Only public-domain sets are accepted, so a generated asset never inherits a licence duty. */
+    readonly license: 'CC0-1.0';
+    /** Human page crediting the set (goes into the GLB's XMP credits). */
+    readonly page: string;
+    readonly author?: string;
+    /** Real-world size the image covers, metres (U × V). Poly Haven lists it as `dimensions`. */
+    readonly metres: readonly [number, number];
+    readonly maps: {
+        /** sRGB base colour. */
+        readonly albedo: TextureFile;
+        /** Tangent-space normal, OpenGL convention (+Y up in the image; Poly Haven `nor_gl`). */
+        readonly normal?: TextureFile;
+        /** Packed AO / roughness / metalness (Poly Haven `arm`, glTF ORM order). */
+        readonly arm?: TextureFile;
+    };
+}
+/** PNG bytes by sha256. */
+export type TextureCache = ReadonlyMap<string, Uint8Array>;
+/** Hand verified texture bytes to the painter (e.g. from `loadTextureCache()` in scripts). */
+export declare function provideTextures(cache: TextureCache): void;
+export declare function textureBytes(file: TextureFile, where: string): Uint8Array;
+export declare function validateTexture(id: string, t: TextureSource): void;
+/** One credit line for the GLB's XMP and the docs. */
+export declare const creditOf: (t: TextureSource) => string;

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

@@ -0,0 +1,38 @@
+/** The original eight strips: greyscale, tinted by vertex colour. */
+export type ClassicStripId = 'plain' | 'brick' | 'stone' | 'slate' | 'iron' | 'wood' | 'glass' | 'concrete';
+/** Material strips with measured colour: use a near-white vertex colour (`NATURAL`) for truth. */
+export type MaterialStripId = 'oak' | 'pine' | 'wood_weathered' | 'wood_painted' | 'iron_rust' | 'iron_cast' | 'steel_painted' | 'steel_galvanised' | 'brass' | 'copper' | 'aluminium' | 'chrome' | 'rubber' | 'canvas' | 'leather' | 'plastic';
+export type BuiltinStripId = ClassicStripId | MaterialStripId;
+/** A project material's id, as returned by `defineMaterial` (a branded string). */
+export type CustomStripId = string & {
+    readonly __ts23dMaterial: true;
+};
+export type StripId = BuiltinStripId | CustomStripId;
+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;
+}
+/** Strip rows in the atlas: built-ins first, then `CUSTOM_STRIP_SLOTS` project materials. */
+export declare const STRIP_ROWS = 28;
+export declare const CUSTOM_STRIP_SLOTS: number;
+export declare const TRIM_SHEET_SIZE = 2048;
+/** Atlas row of a strip id, or −1 when it is neither built in nor defined. */
+export declare function stripRow(id: string): number;
+export declare function stripRect(id: StripId): UvRect;
+export declare function cellRect(id: CellId): UvRect;
+/** Every built-in strip, classic first. */
+export declare const STRIPS: readonly BuiltinStripId[];
+export declare const CLASSIC_STRIPS: readonly ClassicStripId[];
+export declare const MATERIAL_STRIPS: readonly MaterialStripId[];
+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-6b05mnmx.js";
+import"../chunk-hg7pf34j.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;