@developerz.ai/ts23d 0.0.0-stage → 0.2.0

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

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

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

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

package/dist/primitives/sculpt.d.ts

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

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

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

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

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

package/dist/primitives/sdf.d.ts

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

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

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

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

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

package/dist/primitives/sweep.d.ts

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

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

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

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

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

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

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

package/dist/primitives/text.d.ts

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

package/dist/primitives/tiled.d.ts

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

package/dist/primitives/transport.d.ts

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

package/dist/primitives/triangulate.d.ts

@@ -0,0 +1,2 @@
+import type { Vec2 } from '../core/index.js';
+export declare function triangulate(poly: readonly Vec2[]): [number, number, number][];

package/dist/primitives/value-noise.d.ts

@@ -0,0 +1,10 @@
+import type { Rng } from '../core/index.js';
+import type { Field } from './sdf-ops.js';
+/**
+ * Seeded fractal value noise in [−1, 1]: `scale` = metres per feature, `octaves` halve the scale
+ * and amplitude each time. Same Rng state → same field, bit for bit.
+ */
+export declare function valueNoise(rng: Rng, o?: {
+    readonly scale?: number;
+    readonly octaves?: number;
+}): Field;

package/dist/qa/checks.d.ts

@@ -0,0 +1,11 @@
+import type { Check, CheckFinding } from '../core/index.js';
+/** Nothing matching `a` sinks into anything matching `b` (closed solids), with optional min gap. */
+export declare const clear: (a: string, b: string, minGap?: number) => Check;
+/** No two parts matching the selector interpenetrate (interleaved wheels, stacked crates). */
+export declare const noOverlap: (selector: string) => Check;
+/** `a` must touch `b` (surface within 2 cm): a turret sits on its ring, a lamp on its post. */
+export declare const touches: (a: string, b: string, eps?: number) => Check;
+/** Every part containing `left` has a mirror part (with `right`) reflected across the axis plane. */
+export declare const symmetric: (left: string, right: string, axis?: 'x' | 'y' | 'z', tol?: number) => Check;
+/** Run a recipe's checks; the QA gate calls this. */
+export declare const runChecks: (asset: Parameters<Check>[0]) => CheckFinding[];

package/dist/qa/clash.d.ts

@@ -0,0 +1,2 @@
+import { type Gate } from './types.js';
+export declare const clashes: Gate;

package/dist/qa/floating.d.ts

@@ -0,0 +1,5 @@
+import { type Mesh } from '../core/index.js';
+import { TriangleGrid } from './geometry.js';
+import { type Gate } from './types.js';
+export declare function touching(a: Mesh, b: Mesh, grid: TriangleGrid, eps?: number): boolean;
+export declare const floatingParts: Gate;

package/dist/qa/gates.d.ts

@@ -0,0 +1,12 @@
+import { type CompiledAsset } from '../core/index.js';
+import type { Finding, Gate } from './types.js';
+export declare const triangleBudget: Gate;
+export declare const partNames: Gate;
+/** Overall bounding box vs the recipe's `real` dimensions: catches a 6 m tank modelled at 7.4 m. */
+export declare const proportions: Gate;
+/** Planned gates, signatures fixed: docs/idea/06-qa.md. */
+export declare const silhouetteIoU: (_asset: CompiledAsset, _referencePng: Uint8Array) => number;
+/** The recipe's own `checks`, each finding reported under the gate name `check`. */
+export declare const recipeChecks: Gate;
+export declare const DEFAULT_GATES: readonly Gate[];
+export declare function runQa(asset: CompiledAsset, gates?: readonly Gate[]): Finding[];

package/dist/qa/geometry.d.ts

@@ -0,0 +1,21 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+export declare function triangle(m: Mesh, t: number): [Vec3, Vec3, Vec3];
+/** Distance from p to triangle abc (Ericson, Real-Time Collision Detection §5.1.5). */
+export declare function pointTriangleDistance(p: Vec3, a: Vec3, b: Vec3, c: Vec3): number;
+/** Triangles bucketed by a uniform grid, so a point only tests its neighbourhood. */
+export declare class TriangleGrid {
+    private readonly cells;
+    /** Cell edge: 25 cm for props and vehicles, growing with big meshes (a 330 m tower) so one
+     *  long triangle never lands in 10⁵ cells. */
+    private readonly cell;
+    private readonly tris;
+    /** Per-triangle AABB (min xyz, max xyz) for a cheap reject before the exact distance. */
+    private readonly boxes;
+    private readonly stamp;
+    private query;
+    constructor(mesh: Mesh);
+    /** Distance from p to the nearest triangle, if one is within `radius`; else Infinity. */
+    nearest(p: Vec3, radius: number): number;
+}
+/** Vertices plus points along every edge every `step` metres (catches crossing members). */
+export declare function surfaceSamples(m: Mesh, step?: number, maxPerEdge?: number): Vec3[];

package/dist/qa/index.d.ts

@@ -0,0 +1,12 @@
+export { clear, noOverlap, runChecks, symmetric, touches } from './checks.js';
+export { clashes } from './clash.js';
+export { floatingParts, touching } from './floating.js';
+export { DEFAULT_GATES, partNames, proportions, runQa, silhouetteIoU, triangleBudget, } from './gates.js';
+export { pointTriangleDistance, surfaceSamples, TriangleGrid } from './geometry.js';
+export { insideSolid } from './inside.js';
+export { glob, type Inspector, inspect, type Penetration } from './inspect.js';
+export { DEFAULT_LOD_GATES, type LodGate, lodPivots, lodSilhouette, lodTriangles, runLodQa, } from './lods.js';
+export { measure, measures } from './measures.js';
+export { hiddenParts, zFighting } from './occlusion.js';
+export { degenerateTriangles, nonFinite, normalsMatchWinding, vertexColors } from './sanity.js';
+export { CLASH_EPS, CONTACT_EPS, type Finding, type Gate } from './types.js';

package/dist/qa/index.js

@@ -0,0 +1,78 @@
+import {
+  pointTriangleDistance2,
+  TriangleGrid2,
+  surfaceSamples2,
+  insideSolid2,
+  glob2,
+  inspect2,
+  clear2,
+  noOverlap2,
+  touches2,
+  symmetric2,
+  runChecks2,
+  CONTACT_EPS2,
+  CLASH_EPS2,
+  clashes2,
+  touching2,
+  floatingParts2,
+  measure2,
+  measures2,
+  zFighting2,
+  hiddenParts2,
+  nonFinite2,
+  vertexColors2,
+  normalsMatchWinding2,
+  degenerateTriangles2,
+  triangleBudget2,
+  partNames2,
+  proportions2,
+  silhouetteIoU2,
+  DEFAULT_GATES2,
+  runQa2,
+  lodTriangles2,
+  lodSilhouette2,
+  lodPivots2,
+  DEFAULT_LOD_GATES2,
+  runLodQa2
+} from "../chunk-jq4e17tj.js";
+import"../chunk-hg7pf34j.js";
+export {
+  CLASH_EPS2 as CLASH_EPS,
+  CONTACT_EPS2 as CONTACT_EPS,
+  DEFAULT_GATES2 as DEFAULT_GATES,
+  DEFAULT_LOD_GATES2 as DEFAULT_LOD_GATES,
+  TriangleGrid2 as TriangleGrid,
+  clashes2 as clashes,
+  clear2 as clear,
+  degenerateTriangles2 as degenerateTriangles,
+  floatingParts2 as floatingParts,
+  glob2 as glob,
+  hiddenParts2 as hiddenParts,
+  insideSolid2 as insideSolid,
+  inspect2 as inspect,
+  lodPivots2 as lodPivots,
+  lodSilhouette2 as lodSilhouette,
+  lodTriangles2 as lodTriangles,
+  measure2 as measure,
+  measures2 as measures,
+  noOverlap2 as noOverlap,
+  nonFinite2 as nonFinite,
+  normalsMatchWinding2 as normalsMatchWinding,
+  partNames2 as partNames,
+  pointTriangleDistance2 as pointTriangleDistance,
+  proportions2 as proportions,
+  runChecks2 as runChecks,
+  runLodQa2 as runLodQa,
+  runQa2 as runQa,
+  silhouetteIoU2 as silhouetteIoU,
+  surfaceSamples2 as surfaceSamples,
+  symmetric2 as symmetric,
+  touches2 as touches,
+  touching2 as touching,
+  triangleBudget2 as triangleBudget,
+  vertexColors2 as vertexColors,
+  zFighting2 as zFighting
+};
+
+//# debugId=D85390BDB209BC4364756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/qa/index.js.map

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

package/dist/qa/inside.d.ts

@@ -0,0 +1,12 @@
+import { type Mesh, type Vec3 } from '../core/index.js';
+export declare class SolidIndex {
+    private readonly tri;
+    private readonly columns;
+    private readonly cell;
+    constructor(mesh: Mesh);
+    /** Odd number of crossings of the ray from p along +axis ⇒ inside (for that ray). */
+    private parity;
+    inside(point: Vec3): boolean;
+}
+/** One-off query; build a SolidIndex yourself when testing many points against one mesh. */
+export declare const insideSolid: (p: Vec3, m: Mesh) => boolean;

package/dist/qa/inspect.d.ts

@@ -0,0 +1,18 @@
+import { type Bounds, type CompiledAsset, type Mesh } from '../core/index.js';
+export declare const glob: (pattern: string) => RegExp;
+export interface Penetration {
+    /** Deepest sampled point of A inside B's solid, metres (0 = none). */
+    readonly depth: number;
+    readonly samples: number;
+}
+export interface Inspector {
+    readonly asset: CompiledAsset;
+    parts(selector: string): string[];
+    mesh(selector: string): Mesh | null;
+    bounds(selector: string): Bounds | null;
+    /** Smallest surface-to-surface distance (0 when touching or intersecting), capped at `max`. */
+    distance(a: string, b: string, max?: number): number;
+    /** How deep A's surface goes inside B's closed solid. */
+    penetration(a: string, b: string): Penetration;
+}
+export declare function inspect(asset: CompiledAsset): Inspector;

package/dist/qa/lods.d.ts

@@ -0,0 +1,12 @@
+import { type CompiledAsset } from '../core/index.js';
+import type { Finding } from './types.js';
+/** A gate over the whole LOD chain, index = LOD. */
+export type LodGate = (lods: readonly CompiledAsset[]) => Finding[];
+export declare const lodTriangles: LodGate;
+/** LOD1/LOD2 overall box within `tol` of LOD0's span per side (min 5 cm). */
+export declare const lodSilhouette: (tol?: number) => LodGate;
+export declare const lodPivots: LodGate;
+/** Default chain gates: only what every gallery recipe passes today. `lodSilhouette` and
+ *  `lodPivots` are opt-in until the recipes they flag are fixed (see their findings). */
+export declare const DEFAULT_LOD_GATES: readonly LodGate[];
+export declare function runLodQa(lods: readonly CompiledAsset[], gates?: readonly LodGate[]): Finding[];

package/dist/qa/measures.d.ts

@@ -0,0 +1,4 @@
+import { type CompiledAsset, type Measure } from '../core/index.js';
+import type { Gate } from './types.js';
+export declare function measure(asset: CompiledAsset, m: Measure): number | null;
+export declare const measures: Gate;

package/dist/qa/occlusion.d.ts

@@ -0,0 +1,3 @@
+import type { Gate } from './types.js';
+export declare const zFighting: Gate;
+export declare const hiddenParts: Gate;

package/dist/qa/sanity.d.ts

@@ -0,0 +1,7 @@
+import type { Gate } from './types.js';
+export declare const nonFinite: Gate;
+export declare const vertexColors: Gate;
+/** Shading normals must agree with the winding (the side a renderer culls/lights). */
+export declare const normalsMatchWinding: Gate;
+/** Zero-area triangles: invisible, but they cost index bandwidth and skew QA sampling. */
+export declare const degenerateTriangles: Gate;