@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/dist/cli/run.d.ts

@@ -0,0 +1 @@
+export declare function run(argv: readonly string[]): Promise<number>;

package/dist/core/asset.d.ts

@@ -0,0 +1,10 @@
+import type { Asset, AssetDefinition, CompiledAsset } from './definition.js';
+import type { Lod } from './part.js';
+export * from './definition.js';
+export * from './part.js';
+export declare function defineAsset(def: AssetDefinition): Asset;
+export declare const isAsset: (value: unknown) => value is Asset;
+export declare function compile(asset: Asset, options?: {
+    lod?: Lod;
+    seed?: number;
+}): CompiledAsset;

package/dist/core/definition.d.ts

@@ -0,0 +1,148 @@
+import type { Mesh } from './mesh.js';
+import type { EmitterOptions, Lod, Part, PartOptions, SocketOptions, UseOptions } from './part.js';
+import type { Rng } from './rng.js';
+export interface BuildContext {
+    readonly lod: Lod;
+    readonly seed: number;
+    readonly rng: Rng;
+    /** The value for this LOD: `ctx.pick([24, 12, 6])` — segments, counts, sizes per detail level. */
+    pick<T>(perLod: readonly [T, T, T]): T;
+    /** Add a named part. Names are the contract with the engine: `axle_*`, `door_*`, `rotor_*`. */
+    part(name: string, mesh: Mesh | null, options?: PartOptions): void;
+    /** An empty pivot that other parts parent to. */
+    group(name: string, options?: PartOptions): void;
+    /** Declare a particle source (smoke, steam, dust, muzzle…) as a named node. */
+    emitter(name: string, options: EmitterOptions): void;
+    /** Declare an attachment point (seat, mount, camera, audio, light…) as a named node. */
+    socket(name: string, options: SocketOptions): void;
+    /** Instance another asset inside this one, compiled at this LOD — the composition primitive. */
+    use(asset: Asset, options: UseOptions): void;
+}
+export interface Budget {
+    /** Triangle ceiling per LOD; QA fails the build above it. */
+    readonly triangles: readonly [number, number, number];
+}
+/** Real-world overall dimensions (metres) the QA `proportions` gate holds the model to. */
+export interface RealDimensions {
+    /** Along X (front-back). */
+    readonly length: number;
+    /** Along Y. */
+    readonly width: number;
+    /** Along Z. */
+    readonly height: number;
+    /** Allowed relative error per axis; default 0.05. */
+    readonly tolerance?: number;
+    /** Named spec-sheet dimensions checked against the model (QA `measures`). */
+    readonly measures?: readonly Measure[];
+}
+/**
+ * One real-world dimension from a source, checked against the model at LOD0: the world-space
+ * extent of `parts` (union of their bounds) along `axis`, or the distance between two parts'
+ * centres. E.g. driver diameter = extent of `axle_driver_0` on Z; gauge = centre distance of the
+ * two rail parts on Y; turret width = extent of `turret_body` on Y.
+ */
+export interface Measure {
+    readonly label: string;
+    readonly value: number;
+    readonly axis: 'x' | 'y' | 'z';
+    /** Extent of these parts (prefix match: 'axle_driver_0' includes its wheels). */
+    readonly parts?: readonly string[];
+    /** Or: distance between the centres of exactly two parts along `axis`. */
+    readonly between?: readonly [string, string];
+    readonly tolerance?: number;
+    /** Where this number comes from (one of `sources`, or a page reference). */
+    readonly source?: string;
+}
+/** One problem a recipe's own check found. QA turns these into findings named `check`. */
+export interface CheckFinding {
+    readonly message: string;
+    readonly fix: string;
+    readonly part?: string;
+}
+/**
+ * A recipe-declared assertion about its own geometry, run by the QA gate at every LOD:
+ * "tracks clear the hull", "wheels never overlap", "left matches right". Plain functions —
+ * build them with the helpers in /qa (`clear`, `touches`, `noOverlap`, `symmetric`) or write one.
+ */
+export type Check = (asset: CompiledAsset) => readonly CheckFinding[];
+/**
+ * Triangle budgets per class (LOD0 / LOD1 / LOD2): a starting point, measured on real recipes.
+ * `budget: BUDGETS.vehicle` — raise one with a measured reason, never to hide a regression.
+ */
+export declare const BUDGETS: {
+    readonly prop: {
+        readonly triangles: readonly [800, 300, 80];
+    };
+    readonly detailedProp: {
+        readonly triangles: readonly [5000, 1500, 300];
+    };
+    readonly building: {
+        readonly triangles: readonly [20000, 6000, 800];
+    };
+    readonly vehicle: {
+        readonly triangles: readonly [60000, 15000, 1000];
+    };
+    readonly hero: {
+        readonly triangles: readonly [150000, 40000, 2000];
+    };
+    readonly tree: {
+        readonly triangles: readonly [25000, 6000, 300];
+    };
+    readonly scene: {
+        readonly triangles: readonly [500000, 120000, 15000];
+    };
+};
+/** A part set that emits light (lamp lenses, lit windows): an emissive material in the GLB. */
+export interface Glow {
+    /** Part names or globs: 'headlamp_*', 'window_*'. */
+    readonly parts: readonly string[];
+    /** Linear RGB 0..1 (`hex('#ffd9a0')`). Default warm white. */
+    readonly color?: readonly [number, number, number];
+    /** Brightness multiplier (KHR_materials_emissive_strength); 1 = plain glTF. Default 4. */
+    readonly strength?: number;
+}
+/** Provenance written into every GLB: `asset.copyright` + an XMP packet. */
+export interface AssetMeta {
+    readonly description?: string;
+    readonly sources?: readonly string[];
+    /** SPDX id or licence URL, e.g. 'CC0-1.0', 'MIT'. */
+    readonly license?: string;
+    /** e.g. '© 2026 Jane Doe'. */
+    readonly copyright?: string;
+    readonly creators?: readonly string[];
+}
+export interface AssetDefinition {
+    readonly name: string;
+    readonly kind: string;
+    readonly description?: string;
+    /** Where the numbers came from: spec sheets, rosters, drawings, photos. Required for `real`. */
+    readonly sources?: readonly string[];
+    readonly real?: RealDimensions;
+    readonly tags?: readonly string[];
+    readonly budget: Budget;
+    readonly seed?: number;
+    /** The recipe's own physical intent, enforced by QA (see Check). */
+    readonly checks?: readonly Check[];
+    /** SPDX id or licence URL for the generated asset, e.g. 'CC0-1.0'. Written into the GLB. */
+    readonly license?: string;
+    readonly copyright?: string;
+    readonly creators?: readonly string[];
+    /** Emissive part sets; `t3d build` writes them as glowing materials. */
+    readonly glow?: readonly Glow[];
+    build(ctx: BuildContext): void;
+}
+export interface Asset extends AssetDefinition {
+    readonly __ts23d: 'asset';
+}
+export interface CompiledAsset {
+    readonly name: string;
+    readonly kind: string;
+    readonly lod: Lod;
+    readonly budget: Budget;
+    readonly real: RealDimensions | null;
+    readonly checks: readonly Check[];
+    readonly parts: readonly Part[];
+    /** Provenance carried from the definition (absent when the recipe declares none). */
+    readonly meta?: AssetMeta;
+    readonly glow?: readonly Glow[];
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,17 @@
+export type ErrorCode = 'T3D_NOT_IMPLEMENTED' | 'T3D_GRAMMAR_SYNTAX' | 'T3D_GRAMMAR_OVERFLOW' | 'T3D_PART_DUPLICATE' | 'T3D_PART_UNKNOWN' | 'T3D_RECIPE_INVALID' | 'T3D_NO_ASSET_EXPORT' | 'T3D_QA_FAILED' | 'T3D_RENDER_OPTIONS' | 'T3D_AMBIENT_RANDOM' | 'T3D_RELEASE' | 'T3D_BENCH';
+export interface ErrorDetails {
+    readonly cause: string;
+    readonly fix: string;
+}
+export declare class Ts23dError extends Error {
+    readonly code: ErrorCode;
+    readonly fix: string;
+    constructor(code: ErrorCode, details: ErrorDetails);
+    toJSON(): {
+        code: ErrorCode;
+        message: string;
+        fix: string;
+    };
+}
+/** Placeholder for a planned seam. Names the plan so the agent knows where the work is tracked. */
+export declare function notImplemented(what: string, plan?: string): never;

package/dist/core/family.d.ts

@@ -0,0 +1,23 @@
+import { type Asset, type AssetDefinition, type BuildContext } from './asset.js';
+type Shared = Omit<AssetDefinition, 'name' | 'build'>;
+export interface FamilyDefinition<P extends object> extends Shared {
+    /** Defaults for every parameter; variants override a subset. */
+    readonly defaults: P;
+    build(ctx: BuildContext, params: Readonly<P>): void;
+}
+export interface Variant<P> extends Partial<Shared> {
+    readonly name: string;
+    readonly params?: Partial<P>;
+}
+export interface Family<P extends object> {
+    readonly defaults: Readonly<P>;
+    /** Make one asset of this family. */
+    variant(v: Variant<P>): Asset;
+    /** Derive a family: new defaults (may add parameters) and optionally a build that wraps ours. */
+    extend<Q extends object>(o: {
+        readonly defaults: Q;
+        readonly build?: (ctx: BuildContext, params: Readonly<P & Q>, base: () => void) => void;
+    } & Partial<Shared>): Family<P & Q>;
+}
+export declare function defineFamily<P extends object>(def: FamilyDefinition<P>): Family<P>;
+export {};

package/dist/core/index.d.ts

@@ -0,0 +1,9 @@
+export { type Asset, type AssetDefinition, BUDGETS, type Budget, type BuildContext, type Check, type CheckFinding, type CompiledAsset, compile, defineAsset, type Emitter, type EmitterOptions, isAsset, type Lod, type Measure, type Motion, type Part, type PartOptions, type RealDimensions, type Slide, type Socket, type SocketOptions, type Spin, type Surface, type Sway, type UseOptions, } from './asset.js';
+export { type ErrorCode, type ErrorDetails, notImplemented, Ts23dError } from './errors.js';
+export { defineFamily, type Family, type FamilyDefinition, type Variant } from './family.js';
+export { type Bounds, boundsOf, type Mesh, MeshBuilder, merge, translate, triangleCount, type Vertex, } from './mesh.js';
+export { encodePng } from './png.js';
+export { createRng, type Rng } from './rng.js';
+export { type Affine, affine, applyAffine, frame, type Placement, place } from './transform.js';
+export { add, cross, dot, length, normalize, type Quat, quatFromAxisAngle, scale, sub, type Vec2, type Vec3, } from './vec.js';
+export { rotateZ, toWorld, type WorldTransform, worldMesh, worldMeshes, worldTransforms, } from './world.js';

package/dist/core/index.js

@@ -0,0 +1,69 @@
+import {
+  Ts23dError2,
+  notImplemented2,
+  createRng2,
+  BUDGETS2,
+  defineAsset2,
+  isAsset2,
+  compile2,
+  defineFamily2,
+  MeshBuilder2,
+  triangleCount2,
+  boundsOf2,
+  translate2,
+  merge2,
+  encodePng2,
+  affine2,
+  frame2,
+  applyAffine2,
+  place2,
+  add2,
+  sub2,
+  scale2,
+  dot2,
+  cross2,
+  length2,
+  normalize2,
+  quatFromAxisAngle2,
+  worldTransforms2,
+  toWorld2,
+  rotateZ2,
+  worldMesh2,
+  worldMeshes2
+} from "../chunk-4ddzsqtc.js";
+export {
+  BUDGETS2 as BUDGETS,
+  MeshBuilder2 as MeshBuilder,
+  Ts23dError2 as Ts23dError,
+  add2 as add,
+  affine2 as affine,
+  applyAffine2 as applyAffine,
+  boundsOf2 as boundsOf,
+  compile2 as compile,
+  createRng2 as createRng,
+  cross2 as cross,
+  defineAsset2 as defineAsset,
+  defineFamily2 as defineFamily,
+  dot2 as dot,
+  encodePng2 as encodePng,
+  frame2 as frame,
+  isAsset2 as isAsset,
+  length2 as length,
+  merge2 as merge,
+  normalize2 as normalize,
+  notImplemented2 as notImplemented,
+  place2 as place,
+  quatFromAxisAngle2 as quatFromAxisAngle,
+  rotateZ2 as rotateZ,
+  scale2 as scale,
+  sub2 as sub,
+  toWorld2 as toWorld,
+  translate2 as translate,
+  triangleCount2 as triangleCount,
+  worldMesh2 as worldMesh,
+  worldMeshes2 as worldMeshes,
+  worldTransforms2 as worldTransforms
+};
+
+//# debugId=2D08A3E11E7129B164756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

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

package/dist/core/mesh.d.ts

@@ -0,0 +1,35 @@
+import type { Vec2, Vec3 } from './vec.js';
+export interface Bounds {
+    readonly min: Vec3;
+    readonly max: Vec3;
+}
+export interface Mesh {
+    readonly positions: Float32Array;
+    readonly normals: Float32Array;
+    readonly uvs: Float32Array;
+    readonly colors: Float32Array;
+    readonly indices: Uint32Array;
+}
+export interface Vertex {
+    readonly p: Vec3;
+    readonly n: Vec3;
+    readonly uv: Vec2;
+    readonly color: Vec3;
+}
+export declare class MeshBuilder {
+    private readonly p;
+    private readonly n;
+    private readonly uv;
+    private readonly c;
+    private readonly idx;
+    vertex(v: Vertex): number;
+    tri(a: number, b: number, c: number): this;
+    /** Counter-clockwise quad a-b-c-d as seen from the side its normal faces. */
+    quad(a: number, b: number, c: number, d: number): this;
+    build(): Mesh;
+}
+export declare const triangleCount: (m: Mesh) => number;
+export declare function boundsOf(m: Mesh): Bounds;
+/** Bake a translation into a mesh (parts are authored in parent space, then offset). */
+export declare function translate(m: Mesh, by: Vec3): Mesh;
+export declare function merge(meshes: readonly Mesh[]): Mesh;

package/dist/core/part.d.ts

@@ -0,0 +1,114 @@
+import type { Mesh } from './mesh.js';
+import type { Vec3 } from './vec.js';
+/** 0 = hero detail, 1 = mid, 2 = far. A recipe reads it and drops detail; it never decimates. */
+export type Lod = 0 | 1 | 2;
+export interface Spin {
+    readonly kind: 'spin';
+    /** Rotation axis in the part's local space. */
+    readonly axis: Vec3;
+    /** Revolutions per second of the baked loop. */
+    readonly rps: number;
+}
+export interface Slide {
+    readonly kind: 'slide';
+    /** Peak offset of a sinusoidal back-and-forth (piston rods, sliders). */
+    readonly offset: Vec3;
+    readonly hz: number;
+    /** Move only from rest to rest + offset and back (a sliding door), not to both sides. */
+    readonly oneWay?: boolean;
+}
+export interface Sway {
+    readonly kind: 'sway';
+    /** Rotation axis in the part's local space. */
+    readonly axis: Vec3;
+    /** Peak angle either side of rest: turret scan, gun elevation, wind in a crown, a door ajar. */
+    readonly degrees: number;
+    readonly hz: number;
+    /** Swing only from rest to +degrees and back (a signal arm dropping, a hatch opening). */
+    readonly oneWay?: boolean;
+}
+export type Motion = Spin | Slide | Sway;
+/**
+ * A particle source the engine spawns at runtime: exhaust smoke, loco steam, track dust, muzzle
+ * flash, chimney smoke, fire. Exported as an empty named node carrying `extras.ts23d.emitter`,
+ * so it moves with its parent (a turret, a stack) and any engine can bind its own system to it.
+ */
+export interface Emitter {
+    readonly kind: 'smoke' | 'steam' | 'dust' | 'muzzle' | 'fire' | 'sparks';
+    /** Emission direction in the parent's space; default up (+Z). */
+    readonly dir?: Vec3;
+    /** Particles per second at full intensity. */
+    readonly rate: number;
+    /** Seconds a particle lives. */
+    readonly life: number;
+    /** Start and end size in metres. */
+    readonly size: readonly [number, number];
+    /** Linear sRGB start colour; engines fade to transparent. */
+    readonly color?: Vec3;
+    /** Initial speed m/s along `dir`, with cone spread in degrees. */
+    readonly speed?: number;
+    readonly spreadDeg?: number;
+    /** 'always' (chimney), 'moving' (track dust), 'event' (muzzle — fired by game code). */
+    readonly when?: 'always' | 'moving' | 'event';
+}
+/**
+ * A named attachment point game code binds to: a seat, a weapon mount, a camera, a sound source,
+ * a hardpoint, a spawn or interaction point. An empty node with `extras.ts23d.socket`.
+ */
+export interface Socket {
+    readonly kind: 'seat' | 'mount' | 'camera' | 'audio' | 'attach' | 'spawn' | 'interact' | 'light';
+    /** Facing direction in the parent's space; default +X (forward). */
+    readonly dir?: Vec3;
+    /** Free-form, engine-facing: `{ clip: 'engine_idle' }`, `{ caliber: 88 }`, `{ fov: 60 }`. */
+    readonly data?: Readonly<Record<string, string | number | boolean>>;
+}
+export interface SocketOptions extends Socket {
+    readonly at?: Vec3;
+    readonly parent?: string;
+}
+export interface EmitterOptions extends Emitter {
+    readonly at?: Vec3;
+    readonly parent?: string;
+}
+/**
+ * How a part's surface renders. Everything stays on ONE shared texture set; the GLB carries at
+ * most four materials (one per surface in use), so batching still holds:
+ *   opaque — the default trim-sheet material
+ *   cutout — alpha-tested, double-sided: leaves, fences, grilles, ash
+ *   glass — clear: transmission + IOR 1.5 + thin volume (windows, bottles, lamp lenses)
+ *   translucent — tinted, partly see-through: plastic bottles, liquids, paper, smoke-stained glass
+ * Tint comes from vertex colour, as everywhere else.
+ */
+export type Surface = 'opaque' | 'cutout' | 'glass' | 'translucent';
+export interface PartOptions {
+    /** Pivot in the parent's space; the mesh is authored relative to it. */
+    readonly at?: Vec3;
+    readonly parent?: string;
+    /** Rotation about local Z, radians. A part that also moves goes inside a yawed group. */
+    readonly yaw?: number;
+    readonly motion?: Motion;
+    /** Parts this moving part may legitimately pass through (an axle in its bearing). QA `clashes`. */
+    readonly clearOf?: readonly string[];
+    readonly surface?: Surface;
+}
+export interface UseOptions {
+    /** Prefix for every instanced part: `house_3` → `house_3_roof`, `house_3_door_0`. */
+    readonly prefix: string;
+    readonly at?: Vec3;
+    readonly yaw?: number;
+    readonly parent?: string;
+    /** Per-instance seed, so ten copies of one recipe are ten variants. */
+    readonly seed?: number;
+}
+export interface Part {
+    readonly name: string;
+    readonly mesh: Mesh | null;
+    readonly at: Vec3;
+    readonly parent: string | null;
+    readonly yaw: number;
+    readonly motion: Motion | null;
+    readonly clearOf?: readonly string[];
+    readonly emitter?: Emitter;
+    readonly socket?: Socket;
+    readonly surface?: Surface;
+}

package/dist/core/png.d.ts

@@ -0,0 +1 @@
+export declare function encodePng(width: number, height: number, rgba: Uint8Array): Uint8Array;

package/dist/core/rng.d.ts

@@ -0,0 +1,12 @@
+export interface Rng {
+    /** Uniform in [0, 1). */
+    next(): number;
+    range(min: number, max: number): number;
+    int(min: number, maxInclusive: number): number;
+    pick<T>(items: readonly T[]): T;
+    /** An independent stream keyed by name, so adding a draw in one part never shifts another. */
+    fork(name: string): Rng;
+    /** A colour varied by ±amount per channel (relative): ten bales, ten slightly different straws. */
+    jitter(color: readonly [number, number, number], amount: number): [number, number, number];
+}
+export declare function createRng(seed: number): Rng;

package/dist/core/transform.d.ts

@@ -0,0 +1,20 @@
+import type { Mesh } from './mesh.js';
+import type { Vec3 } from './vec.js';
+/** Row-major 3×3 rotation(·scale) + translation. */
+export interface Affine {
+    readonly m: readonly [number, number, number, number, number, number, number, number, number];
+    readonly t: Vec3;
+}
+export interface Placement {
+    readonly at?: Vec3;
+    /** Radians about Z (heading), then Y (pitch), then X (roll). */
+    readonly yaw?: number;
+    readonly pitch?: number;
+    readonly roll?: number;
+    readonly scale?: number | Vec3;
+}
+export declare function affine(p: Placement): Affine;
+/** A basis from an explicit frame: local X→u, Y→v, Z→w (all world vectors). */
+export declare const frame: (u: Vec3, v: Vec3, w: Vec3, at?: Vec3) => Affine;
+export declare function applyAffine(mesh: Mesh, a: Affine): Mesh;
+export declare const place: (mesh: Mesh, p: Placement) => Mesh;

package/dist/core/vec.d.ts

@@ -0,0 +1,11 @@
+export type Vec2 = readonly [number, number];
+export type Vec3 = readonly [number, number, number];
+export type Quat = readonly [number, number, number, number];
+export declare const add: (a: Vec3, b: Vec3) => Vec3;
+export declare const sub: (a: Vec3, b: Vec3) => Vec3;
+export declare const scale: (a: Vec3, s: number) => Vec3;
+export declare const dot: (a: Vec3, b: Vec3) => number;
+export declare const cross: (a: Vec3, b: Vec3) => Vec3;
+export declare const length: (a: Vec3) => number;
+export declare const normalize: (a: Vec3) => Vec3;
+export declare function quatFromAxisAngle(axis: Vec3, radians: number): Quat;

package/dist/core/world.d.ts

@@ -0,0 +1,16 @@
+import type { Part } from './asset.js';
+import type { Mesh } from './mesh.js';
+import type { Vec3 } from './vec.js';
+export interface WorldTransform {
+    readonly origin: Vec3;
+    readonly yaw: number;
+}
+declare const rotZ: (p: Vec3, yaw: number) => Vec3;
+export declare function worldTransforms(parts: readonly Part[]): Map<string, WorldTransform>;
+export declare function toWorld(t: WorldTransform, p: Vec3): Vec3;
+export declare const rotateZ: typeof rotZ;
+/** A part's mesh baked into world space (positions and normals), ready for QA or rasterising. */
+export declare function worldMesh(mesh: Mesh, t: WorldTransform): Mesh;
+/** Every part with geometry, in world space, keyed by part name. Cached per parts array. */
+export declare function worldMeshes(parts: readonly Part[]): Map<string, Mesh>;
+export {};

package/dist/export/bin-writer.d.ts

@@ -0,0 +1,16 @@
+export declare const ARRAY_BUFFER = 34962;
+export declare const ELEMENT_ARRAY_BUFFER = 34963;
+export interface Json {
+    [key: string]: unknown;
+}
+export declare class BinWriter {
+    private readonly chunks;
+    length: number;
+    readonly views: Json[];
+    readonly accessors: Json[];
+    private push;
+    accessor(data: Float32Array | Uint32Array | Uint16Array, type: 'SCALAR' | 'VEC2' | 'VEC3' | 'VEC4', target?: number, bounds?: boolean, 
+    /** Integer data read as 0..1 (vertex colour as normalised unsigned short). */
+    normalized?: boolean): number;
+    bytes(): Uint8Array;
+}

package/dist/export/container.d.ts

@@ -0,0 +1,3 @@
+import type { Json } from './bin-writer.js';
+export declare function packGlb(gltf: Json, body: Uint8Array): Uint8Array;
+export declare function concat(a: Uint8Array, b: Uint8Array): Uint8Array;

package/dist/export/glb.d.ts

@@ -0,0 +1,38 @@
+import type { CompiledAsset } from '../core/index.js';
+import type { OptimizeOptions } from '../passes/index.js';
+import { type GlowRule } from './materials.js';
+import { type GlbMeta } from './metadata.js';
+import { type ExportReport } from './optimize-parts.js';
+import { type SheetBinding } from './textures.js';
+export interface GlbOptions {
+    /** Keep every part as its own node (debugging, per-part picking). Default merges to pivots. */
+    readonly keepParts?: boolean;
+    /**
+     * Bake each part's `motion` into a looping `run` clip. Off by default: glTF has no autoplay
+     * flag and most viewers play the first clip, while engines usually drive the named pivots
+     * from game code. Turn it on for previews, cutscenes and ambient props.
+     */
+    readonly animations?: boolean;
+    /**
+     * Bind the painted trim sheet to every material: a `PaintedSheet` embeds the three PNGs (one
+     * self-contained file); `{ external: true, prefix? }` references shared `trim_sheet_*.png` by
+     * URI. Omitted: no textures, byte-identical to the untextured output.
+     */
+    readonly sheet?: SheetBinding;
+    /**
+     * Weld + vertex-cache + vertex-fetch optimisation per primitive (passes/optimize). On by
+     * default; `false` writes the meshes exactly as compiled (debugging the IR).
+     */
+    readonly optimize?: boolean | OptimizeOptions;
+    /** Parts that emit light (lamp lenses, lit windows): one emissive material per rule. */
+    readonly glow?: readonly GlowRule[];
+    /** Provenance: asset.copyright + an XMP packet (title, creators, licence, sources). */
+    readonly meta?: GlbMeta;
+}
+/** The GLB bytes plus what the optimiser did (vertex counts, ACMR before/after, per part). */
+export interface GlbResult {
+    readonly glb: Uint8Array;
+    readonly report: ExportReport;
+}
+export declare function toGlb(input: CompiledAsset, o?: GlbOptions): Uint8Array;
+export declare function exportGlb(input: CompiledAsset, o?: GlbOptions): GlbResult;

package/dist/export/index.d.ts

@@ -0,0 +1,4 @@
+export { exportGlb, type GlbOptions, type GlbResult, toGlb } from './glb.js';
+export { mergeToPivots } from './merge-pivots.js';
+export { type ExportReport, optimizeParts, type PartOptimizeReport, summarize, } from './optimize-parts.js';
+export { type ExternalSheet, SHEET_MAPS, type SheetBinding, type SheetMap, sheetFileName, sheetPngs, } from './textures.js';

package/dist/export/index.js

@@ -0,0 +1,26 @@
+import {
+  mergeToPivots2,
+  summarize2,
+  optimizeParts2,
+  SHEET_MAPS2,
+  sheetFileName2,
+  sheetPngs2,
+  toGlb2,
+  exportGlb2
+} from "../chunk-gcyp9b4d.js";
+import"../chunk-kvcep7ft.js";
+import"../chunk-xnt2sdhf.js";
+import"../chunk-4ddzsqtc.js";
+export {
+  SHEET_MAPS2 as SHEET_MAPS,
+  exportGlb2 as exportGlb,
+  mergeToPivots2 as mergeToPivots,
+  optimizeParts2 as optimizeParts,
+  sheetFileName2 as sheetFileName,
+  sheetPngs2 as sheetPngs,
+  summarize2 as summarize,
+  toGlb2 as toGlb
+};
+
+//# debugId=E49FD25380C5362E64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/export/index.js.map

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

package/dist/export/lights.d.ts

@@ -0,0 +1,8 @@
+import type { Part, Quat } from '../core/index.js';
+import type { Json } from './bin-writer.js';
+export declare const LIGHTS = "KHR_lights_punctual";
+/** The glTF light for a light socket, or null for any other part. */
+export declare function lightOf(part: Part): {
+    light: Json;
+    rotation: Quat;
+} | null;

package/dist/export/materials.d.ts

@@ -0,0 +1,23 @@
+import type { Surface } from '../core/index.js';
+import type { Json } from './bin-writer.js';
+/** Materials for the surfaces present, plus each surface's index and the extensions used. */
+export declare function materialsFor(used: ReadonlySet<Surface>, withSheet?: boolean): {
+    materials: Json[];
+    index: Map<Surface, number>;
+    extensionsUsed: string[];
+};
+export declare const EMISSIVE_STRENGTH = "KHR_materials_emissive_strength";
+/** A lit surface: lamp lenses, windows at night, panel glow. */
+export interface GlowRule {
+    /** Part names or globs: 'headlamp_*', 'window_*'. */
+    readonly parts: readonly string[];
+    /** Linear RGB 0..1 (use `hex('#ffd9a0')` from /material). Default warm white. */
+    readonly color?: readonly [number, number, number];
+    /** Brightness multiplier (KHR_materials_emissive_strength, Ratified); 1 = plain glTF. */
+    readonly strength?: number;
+}
+/**
+ * The opaque trim material plus emission. emissiveFactor caps at 1 in core glTF; anything
+ * brighter rides KHR_materials_emissive_strength (engines without it see the clamped glow).
+ */
+export declare function glowMaterial(rule: GlowRule, i: number, withSheet: boolean): Json;

package/dist/export/merge-pivots.d.ts

@@ -0,0 +1,6 @@
+import { type CompiledAsset, type Part } from '../core/index.js';
+/** Merged layer parts that glow → index of the glow rule (read by the GLB writer). */
+export declare const glowLayer: WeakMap<Part, number>;
+/** `*`/`?` glob → anchored RegExp (export cannot import /qa: same tier). */
+export declare const globRe: (pattern: string) => RegExp;
+export declare function mergeToPivots(asset: CompiledAsset, glow?: readonly (readonly string[])[]): CompiledAsset;