@threenative/terrain 0.0.0-stage → 0.1.2

package/dist/terrain-gPnkCU6S.d.ts

@@ -0,0 +1,141 @@
+import { L as Layer, O as OperationType, a as IMask, b as LayerParams, c as ITerrainConfig, d as ITerrainDocument, e as IEvaluateOptions, I as ITerrainState, f as ICopyRegionOptions } from './types-Ant8-Axc.js';
+
+type OperationOptions<T extends OperationType> = LayerParams[T] & {
+    id?: string;
+    label?: string;
+    enabled?: boolean;
+    opacity?: number;
+    mask?: IMask;
+};
+type LayerPatch = {
+    type?: OperationType;
+    name?: string;
+    enabled?: boolean;
+    opacity?: number;
+    mask?: IMask | null;
+    params?: Partial<LayerParams[OperationType]>;
+};
+type PatchCommand = {
+    op: "upsert";
+    layer: Layer;
+} | {
+    op: "update";
+    id: string;
+    patch: LayerPatch;
+} | {
+    op: "remove";
+    id: string;
+} | {
+    op: "move";
+    id: string;
+    index: number;
+} | {
+    op: "toggle";
+    id: string;
+    enabled?: boolean;
+};
+/**
+ * Recovered prefix-caching authoring evaluator. Returned buffers belong to the caller.
+ * @requires npm i @threenative/terrain
+ * @situation reuse terrain evaluation prefixes while authoring a finite heightfield
+ * @constraint evaluates authoring documents only; games consume pre-baked arrays
+ * @example const terrain = new Terrain({ resolution: 17 }); const evaluator = new TerrainEvaluator(); const state = evaluator.evaluate(terrain.toJSON());
+ * @override cacheMB bounds retained prefix data
+ */
+declare class TerrainEvaluator {
+    private cache;
+    private bytes;
+    private limit;
+    constructor({ cacheMB }?: {
+        cacheMB?: number | undefined;
+    });
+    clear(): void;
+    evaluate(doc: ITerrainDocument, { resolution, signal, onProgress }?: IEvaluateOptions): ITerrainState;
+}
+/**
+ * Ordered, stable-ID terrain authoring with synchronous atomic transactions.
+ * @requires npm i @threenative/terrain
+ * @situation author seeded terrain with noise, sculpting, erosion, roads, rivers and scatter
+ * @situation generate a procedural heightmap landscape or island for a game
+ * @constraint authoring stays outside the game's steady-play graph; no renderer or physics is created
+ * @constraint units are metres with Y up; `size` is the world edge in metres (1 to 100000), centred on the origin
+ * @constraint `resolution` counts vertices per edge and must be one of 17, 33, 65, 129, 257, 513 or 1025
+ * @constraint `seed` is an integer from 0 to 4294967295; one document and seed evaluate to the same arrays
+ * @constraint `evaluate()` is synchronous on the calling thread: run it in a build script, never per frame
+ * @constraint no art is chosen or shipped: materials, models and texture paths belong to the game
+ * @example const terrain = new Terrain({ size: 512, resolution: 257, seed: 73 }).noise({ id: "hills", amplitude: 35 });
+ * @override size, resolution, seed and all layer parameters are caller choices
+ */
+declare class Terrain {
+    private _doc;
+    private _undo;
+    private _redo;
+    private _listeners;
+    private _historyLimit;
+    private _transactionDepth;
+    private _evaluator;
+    constructor({ size, resolution, seed, historyLimit, }?: Partial<ITerrainConfig> & {
+        historyLimit?: number;
+    });
+    static fromJSON(json: string | ITerrainDocument): Terrain;
+    get layers(): Layer[];
+    get config(): ITerrainConfig;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    toJSON(): ITerrainDocument;
+    subscribe(fn: (terrain: Terrain) => void): () => boolean;
+    private _emit;
+    private _change;
+    private _id;
+    add(layer: Layer): this;
+    private _operation;
+    layer(id: string): Layer;
+    update(id: string, patch: LayerPatch): this;
+    toggle(id: string, enabled?: boolean): this;
+    move(id: string, index: number): this;
+    remove(id: string): this;
+    setConfig(patch: Partial<ITerrainConfig>): this;
+    loadJSON(json: string | ITerrainDocument): this;
+    transaction(fn: (terrain: this) => unknown): this;
+    applyPatch(commands: readonly PatchCommand[]): this;
+    undo(): this;
+    redo(): this;
+    evaluate(options?: IEvaluateOptions): ITerrainState;
+    clearCache(): void;
+    copyRegion({ at, size, resolution }?: ICopyRegionOptions): {
+        width: number;
+        height: number;
+        values: number[];
+    };
+    inspect(options?: IEvaluateOptions): {
+        size: number;
+        resolution: number;
+        layers: number;
+        vertices: number;
+        triangles: number;
+        minHeight: number;
+        maxHeight: number;
+        instances: number;
+        diagnostics: string[];
+    };
+    noise(options?: OperationOptions<"noise">): this;
+    sculpt(options?: OperationOptions<"sculpt">): this;
+    smooth(options?: OperationOptions<"smooth">): this;
+    flatten(options?: OperationOptions<"flatten">): this;
+    ramp(options: OperationOptions<"ramp">): this;
+    stamp(options?: OperationOptions<"stamp">): this;
+    erode(options?: OperationOptions<"erode">): this;
+    terrace(options?: OperationOptions<"terrace">): this;
+    materials(options: OperationOptions<"materials">): this;
+    paint(options?: OperationOptions<"paint">): this;
+    biome(options?: OperationOptions<"biome">): this;
+    scatter(options?: OperationOptions<"scatter">): this;
+    clear(options: OperationOptions<"clear">): this;
+    road(options: OperationOptions<"road">): this;
+    river(options: OperationOptions<"river">): this;
+    water(options?: OperationOptions<"water">): this;
+    heightmap(options: OperationOptions<"heightmap">): this;
+    paste(options: OperationOptions<"paste">): this;
+}
+
+export { type LayerPatch as L, type OperationOptions as O, type PatchCommand as P, Terrain as T, TerrainEvaluator as a };

package/dist/three.d.ts

@@ -0,0 +1,14 @@
+import { BufferGeometry } from 'three';
+import { g as IBakedMesh } from './types-Ant8-Axc.js';
+
+/**
+ * Converts baked arrays to ordinary geometry using the consumer's installed Three.js.
+ * @requires npm i @threenative/terrain
+ * @situation put an authored terrain mesh in a game-owned Three.js scene
+ * @constraint creates only geometry; the caller owns its material, scene and disposal
+ * @example const geometry = toGeometry(bakeMesh(new Terrain({ resolution: 17 }).evaluate()));
+ * @override every surface choice remains in game source
+ */
+declare function toGeometry(mesh: IBakedMesh): BufferGeometry;
+
+export { toGeometry };

package/dist/three.js

@@ -0,0 +1,40 @@
+import { BufferGeometry, BufferAttribute } from 'three';
+
+// src/three.ts
+
+// src/core/bake.ts
+function validateBakedMesh(mesh) {
+  if (![mesh.positions, mesh.normals, mesh.uvs, ...mesh.colors ? [mesh.colors] : []].every(
+    (array) => array instanceof Float32Array
+  ) || !(mesh.indices instanceof Uint32Array))
+    throw new TypeError("Baked mesh requires Float32 attributes and Uint32 indices");
+  const count = mesh.positions.length / 3;
+  if (!count || !Number.isInteger(count) || mesh.normals.length !== count * 3 || mesh.uvs.length !== count * 2 || mesh.colors && mesh.colors.length !== count * 3 || !mesh.indices.length || mesh.indices.length % 3)
+    throw new RangeError("Baked mesh attribute counts do not agree");
+  for (const array of [
+    mesh.positions,
+    mesh.normals,
+    mesh.uvs,
+    ...mesh.colors ? [mesh.colors] : []
+  ])
+    if (!array.every(Number.isFinite)) throw new RangeError("Baked mesh attributes must be finite");
+  if (mesh.indices.some((index) => index >= count))
+    throw new RangeError("Baked mesh index outside vertex range");
+}
+
+// src/three.ts
+function toGeometry(mesh) {
+  validateBakedMesh(mesh);
+  const geometry = new BufferGeometry();
+  geometry.name = mesh.name;
+  geometry.setAttribute("position", new BufferAttribute(mesh.positions, 3));
+  geometry.setAttribute("normal", new BufferAttribute(mesh.normals, 3));
+  geometry.setAttribute("uv", new BufferAttribute(mesh.uvs, 2));
+  if (mesh.colors) geometry.setAttribute("color", new BufferAttribute(mesh.colors, 3));
+  geometry.setIndex(new BufferAttribute(mesh.indices, 1));
+  geometry.computeBoundingBox();
+  geometry.computeBoundingSphere();
+  return geometry;
+}
+
+export { toGeometry };

package/dist/types-Ant8-Axc.d.ts

@@ -0,0 +1,486 @@
+/**
+ * Shared shapes for the recovered Strata evaluator. Every type here is derived from the recovered
+ * `src/core/*` implementation and its `PARAMS` allow-lists, with explicit landform transform extensions. A recipe is plain
+ * JSON, so the evaluator validates it at runtime and these types only describe what the evaluator
+ * accepts.
+ */
+/** The eight material channels a splat sample carries, in channel order. */
+type MaterialId = "grass" | "dirt" | "rock" | "snow" | "sand" | "mud" | "road" | "moss";
+/** Every operation type the evaluator accepts, in the recovered `OPERATION_TYPES` order. */
+type OperationType = "noise" | "sculpt" | "smooth" | "flatten" | "ramp" | "stamp" | "erode" | "terrace" | "materials" | "paint" | "biome" | "scatter" | "clear" | "road" | "river" | "water" | "heightmap" | "paste";
+/** The recoverable mask kinds; a mask is a serializable expression, never a callback. */
+type MaskType = "all" | "none" | "circle" | "rectangle" | "height" | "slope" | "noise" | "biome" | "material" | "and" | "or" | "not";
+/**
+ * A serializable mask expression. `type` selects the fields that mean anything; `validateMask`
+ * rejects every field the chosen type does not list, so this flat shape is the exact union the
+ * evaluator accepts rather than a loose bag.
+ */
+interface IMask {
+    readonly type: MaskType;
+    /** `circle` and `rectangle` centre in world metres as `[x, z]`. */
+    readonly at?: readonly [number, number];
+    readonly radius?: number;
+    readonly size?: number | readonly [number, number];
+    readonly rotation?: number;
+    readonly falloff?: number;
+    /** `height` metres and `slope` degrees. */
+    readonly min?: number;
+    readonly max?: number;
+    readonly fade?: number;
+    readonly scale?: number;
+    readonly threshold?: number;
+    readonly seed?: number;
+    /** `biome` rule name or `material` channel. */
+    readonly name?: string;
+    readonly masks?: readonly IMask[];
+    readonly mask?: IMask;
+}
+/** A mask compiled against one evaluated state: sample index in, weight out. */
+type MaskSampler = (index: number, x: number, z: number) => number;
+/** A height block copied in or out of the document, in world metres, row-major. */
+interface IHeightData {
+    readonly width: number;
+    readonly height: number;
+    /** Fluent calls accept a typed array and normalize it to a plain array before validation. */
+    readonly values: readonly number[] | Float32Array;
+}
+/** World-space grid extent; every coordinate runs from `-size / 2` to `+size / 2`, Y is up. */
+interface IGrid {
+    readonly size: number;
+    readonly resolution: number;
+}
+/** The grid fields the samplers read. Heights are absolute world elevations in metres. */
+interface ISampledGrid extends IGrid {
+    readonly height: Float32Array;
+}
+/** The subset of a world document the evaluator resolves before any operation runs. */
+interface ITerrainConfig {
+    size: number;
+    resolution: number;
+    seed: number;
+}
+/** The serializable authoring document: one config plus an ordered, ID-addressable layer stack. */
+interface ITerrainDocument {
+    version: 1;
+    config: ITerrainConfig;
+    layers: Layer[];
+}
+interface IOperationBase {
+    /** Overrides the document seed for this layer only. */
+    readonly seed?: number;
+}
+/** Stroke tools accept one `at` centre or a polyline `points`; `radius` is a radius, not a diameter. */
+interface IBrushParams extends IOperationBase {
+    readonly at?: readonly [number, number];
+    readonly points?: readonly (readonly [number, number])[];
+    readonly radius?: number;
+    /** Signed metres for `sculpt`, `0..1` for smoothing, flattening and painting. */
+    readonly strength?: number;
+    readonly falloff?: number;
+    readonly shape?: "circle" | "square";
+    readonly rotation?: number;
+    readonly spacing?: number;
+    readonly jitter?: number;
+}
+interface INoiseParams extends IOperationBase {
+    readonly amplitude?: number;
+    readonly scale?: number;
+    readonly octaves?: number;
+    readonly persistence?: number;
+    readonly lacunarity?: number;
+    readonly mode?: "fbm" | "ridged" | "billow";
+    readonly warp?: number;
+    readonly base?: number;
+    readonly blend?: "add" | "replace";
+    readonly island?: boolean;
+    readonly coastDepth?: number;
+}
+interface ISculptParams extends IBrushParams {
+}
+interface ISmoothParams extends IBrushParams {
+    readonly iterations?: number;
+}
+interface IFlattenParams extends IBrushParams {
+    /** Absolute metres; omitted or null levels the pad to the ground already under it. */
+    readonly height?: number | null;
+}
+interface IPaintParams extends IBrushParams {
+    readonly material?: MaterialId;
+}
+interface IStampParams extends IOperationBase {
+    readonly at?: readonly [number, number];
+    /** One radius, or `[x, z]` half-extents. */
+    readonly radius?: number | readonly [number, number];
+    readonly size?: number | readonly [number, number];
+    readonly amplitude?: number;
+    readonly shape?: "mountain" | "crater" | "ridge" | "valley" | "mesa" | "dune";
+    readonly rotation?: number;
+    readonly mirrorX?: boolean;
+    readonly mirrorZ?: boolean;
+    readonly blend?: "add" | "replace" | "min" | "max";
+    readonly roughness?: number;
+    /** Positive vertical gain, applied before offset; defaults to 1. */
+    readonly scale?: number;
+    /** Metres added to the scaled landform, including additive blends. */
+    readonly offset?: number;
+    readonly data?: IHeightData;
+    readonly falloff?: number;
+}
+interface IPasteParams extends Omit<IStampParams, "shape" | "roughness" | "amplitude"> {
+}
+interface IErodeParams extends IBrushParams {
+    readonly method?: "thermal" | "hydraulic";
+    readonly iterations?: number;
+    /** Maximum stable slope in degrees. */
+    readonly talus?: number;
+    readonly rate?: number;
+    readonly droplets?: number;
+    readonly maxSteps?: number;
+    readonly inertia?: number;
+    readonly capacity?: number;
+    readonly erosion?: number;
+    readonly deposition?: number;
+    readonly evaporation?: number;
+}
+interface ITerraceParams extends IOperationBase {
+    readonly step?: number;
+    readonly softness?: number;
+    readonly strength?: number;
+    readonly offset?: number;
+}
+/** One ordered surface rule; a later rule can override an earlier one. */
+interface IMaterialRule {
+    readonly material: MaterialId;
+    readonly mask?: IMask;
+    readonly strength?: number;
+}
+interface IMaterialsParams extends IOperationBase {
+    readonly base?: MaterialId;
+    readonly rules: IMaterialRule[];
+    readonly reset?: boolean;
+}
+interface IBiomeParams extends IBrushParams {
+    /** The biome key the mask's `biome` type reads, not a display name. */
+    readonly name?: string;
+    readonly value?: number;
+}
+interface IScatterParams extends IOperationBase {
+    readonly asset?: string;
+    readonly count?: number;
+    /** Guaranteed within one rule, never across rules. */
+    readonly minDistance?: number;
+    readonly scale?: number | readonly [number, number];
+    readonly minHeight?: number;
+    readonly maxHeight?: number;
+    readonly minSlope?: number;
+    readonly maxSlope?: number;
+    readonly avoidWater?: boolean;
+    readonly offsetY?: number;
+    readonly alignToNormal?: boolean;
+}
+interface IClearParams extends IOperationBase {
+    readonly target: "scatter" | "paint" | "biome" | "all";
+    readonly asset?: string;
+    readonly name?: string;
+}
+/** A spline control point; a null elevation means the spline reads the ground it crosses there. */
+type SplinePoint = readonly [number, number | null, number];
+/**
+ * Grading shared by roads, rivers and ramps. A following spline takes its elevation from the
+ * terrain it crosses — low-passed along arc length, then held inside the grade and cut/fill limits
+ * — so a corridor is a bench cut into a hillside rather than a causeway pinned above it.
+ */
+interface IGradeParams {
+    /** Defaults to true when a control point omits its elevation; absolute points keep their meaning. */
+    readonly followTerrain?: boolean;
+    /** Maximum rise per metre travelled along the centreline; default 0.12. */
+    readonly maxGrade?: number;
+    /** Maximum metres the centreline may cut below the ground it crosses; default 2.5. */
+    readonly maxCut?: number;
+    /** Maximum metres it may fill above it; default 1.5. */
+    readonly maxFill?: number;
+}
+interface IRoadParams extends IOperationBase, IGradeParams {
+    readonly points: readonly SplinePoint[];
+    readonly width?: number;
+    readonly shoulder?: number;
+    readonly material?: MaterialId;
+    readonly smooth?: boolean;
+}
+interface IRiverParams extends IRoadParams {
+    readonly depth?: number;
+    readonly water?: boolean;
+    readonly waterWidth?: number;
+    readonly color?: string | number;
+    /** Validates non-increasing control-point Y instead of rewriting the profile. */
+    readonly enforceDownhill?: boolean;
+}
+interface IRampParams extends IOperationBase, IGradeParams {
+    readonly from: SplinePoint;
+    readonly to: SplinePoint;
+    readonly width?: number;
+    readonly shoulder?: number;
+    readonly material?: MaterialId;
+}
+interface IWaterParams extends IOperationBase {
+    readonly kind?: "lake" | "ocean";
+    readonly at?: readonly [number, number];
+    readonly radius?: number;
+    readonly level?: number;
+    readonly color?: string | number;
+}
+interface IHeightmapParams extends IOperationBase {
+    readonly data: IHeightData;
+    /** Optional footprint centre in metres; without footprint fields the map fills the world. */
+    readonly at?: readonly [number, number];
+    /** Full footprint width/depth in metres; defaults to the world size. */
+    readonly size?: number | readonly [number, number];
+    /** Degrees in the terrain X/Z plane, matching stamp/paste. */
+    readonly rotation?: number;
+    readonly falloff?: number;
+    /** Positive vertical gain, applied before offset. */
+    readonly scale?: number;
+    readonly offset?: number;
+    readonly blend?: "add" | "replace";
+}
+/** One recipe layer: a stable semantic `id`, its operation type, and that type's parameters. */
+interface ILayer<T extends OperationType = OperationType> {
+    readonly id: string;
+    readonly type: T;
+    readonly params: LayerParams[T];
+    /** Human-readable name; the fluent calls spell this `label`. */
+    readonly name?: string;
+    readonly enabled?: boolean;
+    readonly opacity?: number;
+    readonly mask?: IMask;
+}
+/** Parameters accepted per operation type, exactly the recovered `PARAMS` allow-lists. */
+interface LayerParams {
+    noise: INoiseParams;
+    sculpt: ISculptParams;
+    smooth: ISmoothParams;
+    flatten: IFlattenParams;
+    ramp: IRampParams;
+    stamp: IStampParams;
+    erode: IErodeParams;
+    terrace: ITerraceParams;
+    materials: IMaterialsParams;
+    paint: IPaintParams;
+    biome: IBiomeParams;
+    scatter: IScatterParams;
+    clear: IClearParams;
+    road: IRoadParams;
+    river: IRiverParams;
+    water: IWaterParams;
+    heightmap: IHeightmapParams;
+    paste: IPasteParams;
+}
+/** The layer union, discriminated by `type`, so `params` narrows with the operation. */
+type Layer = ILayer<"noise"> | ILayer<"sculpt"> | ILayer<"smooth"> | ILayer<"flatten"> | ILayer<"ramp"> | ILayer<"stamp"> | ILayer<"erode"> | ILayer<"terrace"> | ILayer<"materials"> | ILayer<"paint"> | ILayer<"biome"> | ILayer<"scatter"> | ILayer<"clear"> | ILayer<"road"> | ILayer<"river"> | ILayer<"water"> | ILayer<"heightmap"> | ILayer<"paste">;
+/** A scatter rule deferred until the final heights exist: masks re-evaluate against them. */
+interface IScatterRule extends IScatterParams {
+    readonly id: string;
+    readonly mask?: IMask;
+    readonly opacity: number;
+    readonly clear: IScatterClear[];
+}
+interface IScatterClear {
+    readonly mask: IMask;
+    readonly opacity: number;
+}
+interface IWaterRule extends IWaterParams {
+    readonly id: string;
+    readonly mask?: IMask;
+    readonly opacity: number;
+}
+/** A flooded water body: the resolved rule, with its authoring mask replaced by the sample mask. */
+interface IWaterBody extends Omit<IWaterRule, "mask"> {
+    readonly level: number;
+    readonly mask: Uint8Array;
+}
+/** A river ribbon for rendering; authoring extents, not a flow simulation. */
+interface IRiver {
+    readonly id: string;
+    readonly points: readonly (readonly [number, number, number])[];
+    readonly width: number;
+    readonly color?: string | number;
+    readonly opacity: number;
+}
+/** One accepted scatter candidate. `rotation` is yaw in radians. */
+interface IPlacement {
+    /** Layer/seed/candidate key, independent of acceptance order; changing the seed changes identity. */
+    readonly id: string;
+    readonly layer: string;
+    readonly asset: string;
+    readonly position: [number, number, number];
+    readonly rotation: number;
+    readonly scale: number;
+    readonly normal: [number, number, number];
+    readonly alignToNormal: boolean;
+    /** Authored transform; absent means the original scatter pose, with grounding enabled. */
+    readonly transform?: IPlacementOverride;
+}
+/** A manual edit of one stable scatter candidate; model bounds remain game-owned. */
+interface IPlacementOverride {
+    readonly position: [number, number, number];
+    /** Unit quaternion in Three.js x/y/z/w order. */
+    readonly quaternion: [number, number, number, number];
+    readonly scale: [number, number, number];
+    /** False retains requested Y; clearance is still measured by the game. */
+    readonly grounding: boolean;
+}
+/** The disposable result of one evaluation: arrays the caller owns, plus its diagnostics. */
+interface ITerrainState {
+    size: number;
+    resolution: number;
+    seed: number;
+    height: Float32Array;
+    /** Sample-major: eight channels per sample, weights summing to one. */
+    splat: Float32Array;
+    biomes: Record<string, Float32Array>;
+    scatterRules: IScatterRule[];
+    waterRules: IWaterRule[];
+    rivers: IRiver[];
+    instances: IPlacement[];
+    waters: IWaterBody[];
+    diagnostics: string[];
+    /** Measured transport summed over erosion passes, on the canonical vertex grid. */
+    erosion?: IErosionMaps;
+}
+interface IErosionMaps {
+    /** Droplet water visits, bilinearly distributed at each step. */
+    flow: Float32Array;
+    /** Carried sediment visits, in metres of equivalent terrain height. */
+    sediment: Float32Array;
+    /** Hydraulic material deposited, in metres. */
+    deposition: Float32Array;
+    /** Thermal material received from unstable neighbours, in metres. */
+    talus: Float32Array;
+}
+/** Options for one evaluation call. */
+interface IEvaluateOptions {
+    /** Vertices per side; one of 17, 33, 65, 129, 257, 513, 1025. Defaults to the document's. */
+    readonly resolution?: number;
+    readonly signal?: AbortSignal;
+    readonly onProgress?: (progress: {
+        index: number;
+        total: number;
+        id: string;
+    }) => void;
+}
+/** What `inspect()` reports about an evaluation. */
+interface ITerrainInspection {
+    size: number;
+    resolution: number;
+    layers: number;
+    vertices: number;
+    triangles: number;
+    minHeight: number;
+    maxHeight: number;
+    instances: number;
+    diagnostics: string[];
+}
+/** Options for `copyRegion()`. */
+interface ICopyRegionOptions {
+    readonly at?: readonly [number, number];
+    readonly size?: number;
+    readonly resolution?: number;
+}
+/** One baked mesh: indexed arrays in world space, no Three.js types. */
+interface IBakedMesh {
+    name: string;
+    positions: Float32Array;
+    normals: Float32Array;
+    colors?: Float32Array;
+    uvs: Float32Array;
+    indices: Uint32Array;
+    side: number;
+    topVertexCount: number;
+    bounds: {
+        x: number;
+        z: number;
+        cells: number;
+        step: number;
+    };
+    skirtDepth: number;
+}
+interface IBakeMeshOptions {
+    /** Optional sRGB colours per material channel, chosen by the game. */
+    readonly palette?: readonly (readonly [number, number, number])[];
+    /** Power-of-two sample step within the chunk. */
+    readonly step?: number;
+    readonly x?: number;
+    readonly z?: number;
+    readonly cells?: number;
+    readonly skirtDepth?: number;
+}
+interface IBakeTerrainOptions {
+    readonly palette?: readonly (readonly [number, number, number])[];
+    readonly chunkCells?: number;
+    readonly lodSteps?: readonly number[];
+    readonly skirtDepth?: number;
+}
+/** The baked runtime archive: LOD chunks, collision samples and resolved placements. */
+interface IBakedTerrain {
+    version: 1;
+    size: number;
+    resolution: number;
+    lods: {
+        step: number;
+        chunks: IBakedMesh[];
+    }[];
+    collision: {
+        type: "heightfield";
+        size: number;
+        resolution: number;
+        cellSize: number;
+        /** Southwest corner in world metres. Not a `Heightfield` centre. */
+        origin: [number, number, number];
+        heights: Float32Array;
+    };
+    instances: IPlacement[];
+    materialChannels: MaterialId[];
+}
+/** One file inside an export archive. */
+interface IExportFile {
+    name: string;
+    bytes: Uint8Array;
+}
+/** An export result: `name`, MIME `type`, and the bytes. */
+interface IExportArchive {
+    name: string;
+    type: string;
+    bytes: Uint8Array;
+}
+/** The recoverable export kinds. */
+type ExportKind = "project" | "png" | "raw" | "splat" | "glb" | "runtime";
+interface IHeightRange {
+    min: number;
+    max: number;
+}
+interface IRaw16Options extends Partial<IHeightRange> {
+    readonly littleEndian?: boolean;
+}
+interface IDecodeRaw16Options extends IHeightRange {
+    readonly width: number;
+    readonly height: number;
+    readonly littleEndian?: boolean;
+}
+interface IDecodeHeightPngOptions extends Partial<IHeightRange> {
+}
+interface IDecodedHeightPng extends IHeightData {
+    readonly min: number;
+    readonly max: number;
+    readonly bitDepth: number;
+    readonly hasEmbeddedRange: boolean;
+}
+interface ISplatPng {
+    /** The four material channels this packed image carries. */
+    channels: readonly MaterialId[];
+    bytes: Uint8Array;
+}
+/** The recovered encoder's `StrataHeightRange` PNG metadata. */
+interface IHeightPngMetadata extends IHeightRange {
+}
+
+export type { ITerraceParams as $, IGrid as A, IHeightData as B, IHeightPngMetadata as C, IHeightmapParams as D, ExportKind as E, ILayer as F, IMaterialRule as G, IMaterialsParams as H, ITerrainState as I, INoiseParams as J, IPaintParams as K, Layer as L, MaterialId as M, IPasteParams as N, OperationType as O, IPlacement as P, IRampParams as Q, IRiver as R, IRiverParams as S, IRoadParams as T, IScatterClear as U, IScatterParams as V, IScatterRule as W, ISculptParams as X, ISmoothParams as Y, ISplatPng as Z, IStampParams as _, IMask as a, ITerrainInspection as a0, IWaterBody as a1, IWaterParams as a2, IWaterRule as a3, MaskSampler as a4, MaskType as a5, SplinePoint as a6, LayerParams as b, ITerrainConfig as c, ITerrainDocument as d, IEvaluateOptions as e, ICopyRegionOptions as f, IBakedMesh as g, IPlacementOverride as h, ISampledGrid as i, IBakeMeshOptions as j, IBakeTerrainOptions as k, IBakedTerrain as l, IDecodeHeightPngOptions as m, IDecodeRaw16Options as n, IHeightRange as o, IRaw16Options as p, IExportFile as q, IExportArchive as r, IBiomeParams as s, IBrushParams as t, IClearParams as u, IDecodedHeightPng as v, IErodeParams as w, IErosionMaps as x, IFlattenParams as y, IGradeParams as z };