@hello-terrain/three 0.0.0-alpha.10 → 0.0.0-alpha.11

package/dist/index.d.cts

@@ -13,7 +13,14 @@ import * as three_tsl from 'three/tsl';
  * This geometry ensures that corner triangles are subdivided correctly.
  */
 declare class TerrainGeometry extends BufferGeometry {
-    constructor(innerSegments?: number, extendUV?: boolean);
+    /**
+     * @param flipWinding Reverse triangle winding so front faces point the
+     *   opposite way. The default winding makes flat tiles front-face `+Y`; the
+     *   cube-sphere maps `(u→right, v→up)`, which would otherwise leave the
+     *   planet's outer shell back-facing, so it passes `flipWinding` to render
+     *   the outer surface with `FrontSide`.
+     */
+    constructor(innerSegments?: number, extendUV?: boolean, flipWinding?: boolean);
     /**
      * Generate indices for terrain geometry with proper skirt corner handling.
      * The key improvement is in how corner triangles are subdivided.
@@ -96,218 +103,6 @@ declare class TerrainGeometry extends BufferGeometry {
     private generateNormals;
 }
 
-type TerrainFieldStorageBackendType = "array-texture" | "atlas" | "texture-3d";
-type TerrainFieldStorageFormat = "rgba16float" | "rgba32float";
-type TerrainFieldStorageOptions = {
-    backend?: TerrainFieldStorageBackendType;
-    filter?: "nearest" | "linear";
-    format?: TerrainFieldStorageFormat;
-};
-interface TerrainFieldStorage {
-    readonly backendType: TerrainFieldStorageBackendType;
-    readonly edgeVertexCount: number;
-    readonly tileCount: number;
-    readonly texture: StorageArrayTexture | StorageTexture;
-    uv(ix: Node, iy: Node, tileIndex: Node): Node;
-    texel(ix: Node, iy: Node, tileIndex: Node): Node;
-    /** UV-based filtered sample. `u, v` in [0, 1] tile-local space. */
-    sample(u: Node, v: Node, tileIndex: Node): Node;
-    resize(width: number, height: number, tileCount: number): void;
-}
-declare function ArrayTextureBackend(edgeVertexCount: number, tileCount: number, options: Required<Pick<TerrainFieldStorageOptions, "format" | "filter">>): TerrainFieldStorage;
-declare function AtlasBackend(edgeVertexCount: number, tileCount: number, options: Required<Pick<TerrainFieldStorageOptions, "format" | "filter">>): TerrainFieldStorage;
-/**
- * Placeholder backend for future true 3D storage-texture support in Three.js.
- * We keep it present to preserve the backend API shape.
- */
-declare function Texture3DBackend(edgeVertexCount: number, tileCount: number, options: Required<Pick<TerrainFieldStorageOptions, "format" | "filter">>): TerrainFieldStorage;
-declare function createTerrainFieldStorage(edgeVertexCount: number, tileCount: number, renderer?: WebGPURenderer, options?: TerrainFieldStorageOptions): TerrainFieldStorage;
-declare function storeTerrainField(storage: TerrainFieldStorage, ix: Node, iy: Node, tileIndex: Node, value: Node): Node;
-declare function loadTerrainField(storage: TerrainFieldStorage, ix: Node, iy: Node, tileIndex: Node): Node;
-declare function loadTerrainFieldElevation(storage: TerrainFieldStorage, ix: Node, iy: Node, tileIndex: Node): Node;
-declare function loadTerrainFieldNormal(storage: TerrainFieldStorage, ix: Node, iy: Node, tileIndex: Node): Node;
-/**
- * UV-based filtered sample. `u, v` are in [0, 1] tile-local space.
- * Respects the filter mode (nearest / linear) set on the storage.
- */
-declare function sampleTerrainField(storage: TerrainFieldStorage, u: Node, v: Node, tileIndex: Node): Node;
-declare function sampleTerrainFieldElevation(storage: TerrainFieldStorage, u: Node, v: Node, tileIndex: Node): Node;
-declare function sampleTerrainFieldNormal(storage: TerrainFieldStorage, u: Node, v: Node, tileIndex: Node): Node;
-declare function packTerrainFieldSample(height: Node, normalXZ: Node, extra?: Node): Node;
-
-interface ElevationParams {
-    worldPosition: Node$1;
-    rootSize: Node$1;
-    rootUV: Node$1;
-    tileUV: Node$1;
-    tileLevel: Node$1;
-    tileSize: Node$1;
-    tileOriginVec2: Node$1;
-    nodeIndex: Node$1;
-}
-type ElevationCallback = (params: ElevationParams) => Node$1;
-
-interface TerrainUniformsParams {
-    rootSize: number;
-    rootOrigin: Vector3Like;
-    innerTileSegments: number;
-    skirtScale: number;
-    elevationScale: number;
-    instanceId: string;
-}
-interface TerrainUniformsContext {
-    uRootOrigin: UniformNode<Vector3>;
-    uRootSize: UniformNode<number>;
-    uInnerTileSegments: UniformNode<number>;
-    uSkirtScale: UniformNode<number>;
-    uElevationScale: UniformNode<number>;
-}
-interface LeafStorageState {
-    data: Int32Array<ArrayBuffer>;
-    attribute: StorageBufferAttribute;
-    node: StorageBufferNode;
-}
-
-interface GpuSpatialIndexContext {
-    data: Uint32Array<ArrayBuffer>;
-    size: number;
-    mask: number;
-    stampGen: UniformNode<number>;
-    attribute: StorageBufferAttribute;
-    node: StorageBufferNode;
-}
-interface TerrainSampler {
-    sampleElevation: (worldX: Node, worldZ: Node) => Node;
-    sampleNormal: (worldX: Node, worldZ: Node) => Node;
-    sampleTerrain: (worldX: Node, worldZ: Node) => Node;
-    sampleValidity: (worldX: Node, worldZ: Node) => Node;
-    evaluateElevation: (worldX: Node, worldZ: Node) => Node;
-    evaluateNormal: (worldX: Node, worldZ: Node, epsilon?: Node) => Node;
-}
-interface CreateTerrainSamplerParams {
-    terrainFieldStorage: TerrainFieldStorage;
-    spatialIndex: GpuSpatialIndexContext;
-    uniforms: TerrainUniformsContext;
-    elevationCallback: ElevationCallback;
-}
-interface TerrainSample {
-    elevation: number;
-    normal: Vector3$1;
-    valid: boolean;
-}
-interface TerrainElevationSample {
-    elevation: number;
-    valid: boolean;
-}
-interface TerrainSampleBatch {
-    elevations: Float32Array;
-    normals: Float32Array;
-    valid: Uint8Array;
-    generation: number;
-}
-interface TerrainTile {
-    level: number;
-    x: number;
-    y: number;
-    index: number;
-}
-interface TerrainTileBounds extends TerrainTile {
-    minElevation: number;
-    maxElevation: number;
-}
-interface ElevationRange {
-    min: number;
-    max: number;
-}
-interface TerrainQuery {
-    getElevation(worldX: number, worldZ: number): number | null;
-    getNormal(worldX: number, worldZ: number): Vector3$1 | null;
-    getTile(worldX: number, worldZ: number): TerrainTile | null;
-    getTileBounds(worldX: number, worldZ: number): TerrainTileBounds | null;
-    getGlobalElevationRange(): ElevationRange | null;
-    sampleTerrain(worldX: number, worldZ: number): TerrainSample;
-    sampleTerrainBatch(positions: Float32Array): TerrainSampleBatch;
-    readonly generation: number;
-}
-interface RaycastOptions {
-    maxSteps?: number;
-    refinementSteps?: number;
-    maxDistance?: number;
-}
-interface TerrainRaycastResult {
-    position: Vector3$1;
-    normal: Vector3$1;
-    distance: number;
-}
-interface TerrainRaycast {
-    pick(ray: Ray, options?: RaycastOptions): TerrainRaycastResult | null;
-}
-
-type TerrainMeshParams = {
-    innerTileSegments: number;
-    maxNodes: number;
-    material: NodeMaterial;
-};
-declare class TerrainMesh extends InstancedMesh {
-    private _innerTileSegments;
-    private _maxNodes;
-    terrainRaycast: TerrainRaycast | null;
-    constructor(params?: Partial<TerrainMeshParams>);
-    get innerTileSegments(): number;
-    set innerTileSegments(tileSegments: number);
-    get maxNodes(): number;
-    set maxNodes(maxNodes: number);
-    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
-}
-
-interface TileBoundsContext {
-    data: Float32Array<ArrayBuffer>;
-    attribute: StorageBufferAttribute;
-    node: StorageBufferNode;
-}
-
-type ComputeStageCallback = (nodeIndex: Node, globalVertexIndex: Node, uv: Node, localCoordinates: Node, texelSize: Node) => void;
-type ComputePipeline = ComputeStageCallback[];
-
-/** Default compile task — uses terrainFieldStageTask as the leaf. */
-declare const compileComputeTask: _hello_terrain_work.Task<{
-    execute: (renderer: WebGPURenderer, instanceCount: number) => void;
-}, string, unknown>;
-/** Default execute task — dispatches the compiled kernel. */
-declare const executeComputeTask: _hello_terrain_work.Task<any, string, {
-    renderer: WebGPURenderer;
-}>;
-/**
- * Factory for user-extensible pipelines.
- *
- * Users who add custom compute stages create their own stage tasks using
- * the accumulation pattern (`get()` predecessor, spread, append), then pass
- * their leaf stage to this helper to get compile + execute tasks.
- *
- * @example
- * ```ts
- * const erosionStageTask = task((get, work) => {
- *   const upstream = get(elevationFieldStageTask);
- *   return work((): ComputePipeline => [
- *     ...upstream,
- *     (nodeIndex, globalVertexIndex, uv) => {
- *       // custom erosion logic
- *     },
- *   ]);
- * });
- *
- * const { compile, execute } = createComputePipelineTasks(erosionStageTask);
- * ```
- */
-declare function createComputePipelineTasks(leafStageTask: TaskRef<ComputePipeline>): {
-    compile: _hello_terrain_work.Task<{
-        execute: (renderer: WebGPURenderer, instanceCount: number) => void;
-    }, string, unknown>;
-    execute: _hello_terrain_work.Task<any, string, {
-        renderer: WebGPURenderer;
-    }>;
-};
-
 declare const Dir: {
     readonly LEFT: 0;
     readonly RIGHT: 1;
@@ -333,10 +128,27 @@ type TileBounds = {
     /** conservative radius */
     r: number;
 };
-type Surface = {
+type TopologyProjection = "flat" | "cubeSphere";
+type Topology = {
     spaceCount: number;
     /** maximum number of roots returned by `rootTiles` */
     maxRootCount: number;
+    /**
+     * GPU position/normal assembly projection. Defaults to `flat` when absent.
+     * `cubeSphere` selects radial sphere mapping from cube faces.
+     */
+    projection?: TopologyProjection;
+    /** Sphere radius in world units (cube-sphere projection only). */
+    radius?: number;
+    /**
+     * Planet center in world space (cube-sphere projection only). Used to apply
+     * the camera elevation offset along the radial up-direction during LOD.
+     */
+    center?: {
+        x: number;
+        y: number;
+        z: number;
+    };
     /**
      * Compute the same-level neighbor TileId in the requested direction.
      * Returns false if the neighbor is outside the valid topology.
@@ -400,9 +212,11 @@ type UpdateParams = {
         z: number;
     };
     /**
-     * Terrain elevation at the camera's XZ position (from previous frame).
-     * Subtracted from `cameraOrigin.y` during refinement so that LOD
-     * distance is measured relative to the terrain surface, not the datum.
+     * Terrain elevation beneath the camera (from the previous frame). During
+     * refinement it offsets the camera toward the terrain surface so LOD distance
+     * is measured relative to the surface rather than the datum:
+     * - flat: subtracted from `cameraOrigin.y`.
+     * - cube-sphere: subtracted along the radial up-direction from the planet center.
      */
     elevationAtCameraXZ?: number;
     /**
@@ -488,18 +302,18 @@ type QuadtreeState = {
     scratchNeighbor: TileId;
     scratchBounds: TileBounds;
     scratchRootTiles: TileId[];
-    /** surface space count is fixed for a given state */
+    /** topology space count is fixed for a given state */
     spaceCount: number;
 };
-declare function createState(cfg: QuadtreeConfig, surface: Surface): QuadtreeState;
-declare function beginUpdate(state: QuadtreeState, surface: Surface, params: UpdateParams): void;
+declare function createState(cfg: QuadtreeConfig, topology: Topology): QuadtreeState;
+declare function beginUpdate(state: QuadtreeState, topology: Topology, params: UpdateParams): void;
 
 /**
- * Update the quadtree for the given surface + camera parameters.
+ * Update the quadtree for the given topology + camera parameters.
  *
  * Produces a LeafSet of TileIds (SoA typed arrays).
  */
-declare function update(state: QuadtreeState, surface: Surface, params: UpdateParams, outLeaves?: LeafSet): LeafSet;
+declare function update(state: QuadtreeState, topology: Topology, params: UpdateParams, outLeaves?: LeafSet): LeafSet;
 
 /**
  * Build a fixed-width seam/neighbor table for balanced leaves (2:1).
@@ -507,9 +321,9 @@ declare function update(state: QuadtreeState, surface: Surface, params: UpdatePa
  * Output neighbors are leaf-list indices, with U32_EMPTY for missing entries.
  * Layout: neighbors[leafIndex * 8 + edge*2 + slot].
  */
-declare function buildSeams2to1(surface: Surface, leaves: LeafSet, outSeams: SeamTable, outIndex?: SpatialIndex): SeamTable;
+declare function buildSeams2to1(topology: Topology, leaves: LeafSet, outSeams: SeamTable, outIndex?: SpatialIndex): SeamTable;
 
-type FlatSurfaceConfig = {
+type FlatTopologyConfig = {
     /**
      * World-space size of the root tile edge.
      * The root tile covers [-rootSize/2, +rootSize/2] around origin in X/Z.
@@ -523,9 +337,9 @@ type FlatSurfaceConfig = {
     /** optional conservative vertical extent, included in bounds radius */
     maxHeight?: number;
 };
-declare function createFlatSurface(cfg: FlatSurfaceConfig): Surface;
+declare function createFlatTopology(cfg: FlatTopologyConfig): Topology;
 
-type InfiniteFlatSurfaceConfig = {
+type InfiniteFlatTopologyConfig = {
     rootSize: number;
     origin: {
         x: number;
@@ -537,24 +351,368 @@ type InfiniteFlatSurfaceConfig = {
     /** half-width of root grid in root tiles (1 => 3x3 roots) */
     rootGridRadius?: number;
 };
-declare function createInfiniteFlatSurface(cfg: InfiniteFlatSurfaceConfig): Surface;
+declare function createInfiniteFlatTopology(cfg: InfiniteFlatTopologyConfig): Topology;
 
-type CubeSphereSurfaceConfig = {
+type CubeSphereTopologyConfig = {
+    /** Sphere radius in world units. */
     radius: number;
+    /** Planet center in world space (defaults to origin). */
+    center?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Optional conservative vertical extent, included in bounds radius. */
     maxHeight?: number;
 };
 /**
- * Placeholder cube-sphere surface.
+ * Cube-sphere topology: six quadtree faces wrapped onto a sphere.
+ *
+ * Topology (`neighborSameLevel`) is derived numerically from the shared
+ * `CUBE_FACES` basis so cross-face edges (including rotated pole edges)
+ * resolve to the correct neighbor tile without hand-coded transforms.
+ */
+declare function createCubeSphereTopology(cfg: CubeSphereTopologyConfig): Topology;
+
+/**
+ * Canonical cube-sphere face basis.
+ *
+ * Shared single source of truth between the CPU surface topology
+ * (`cubeSphere.ts`) and the GPU position/normal assembly (`tsl/cubeSphere.ts`)
+ * so both agree on geometry and faces seam correctly.
+ *
+ * Each face maps a face-local coordinate (u, v) in [0, 1] to a point on the
+ * cube `[-1, 1]^3` via:
+ *
+ *   s = 2u - 1, t = 2v - 1
+ *   cube = forward + s * right + t * up
+ *
+ * Normalizing `cube` yields the unit-sphere direction for that vertex.
+ *
+ * Bases are right-handed (`forward = right x up`) and outward-facing.
+ * Space indices: 0:+X 1:-X 2:+Y 3:-Y 4:+Z 5:-Z.
+ */
+type Vec3 = readonly [number, number, number];
+type CubeFace = {
+    forward: Vec3;
+    right: Vec3;
+    up: Vec3;
+};
+declare const CUBE_FACE_COUNT = 6;
+declare const CUBE_FACES: readonly CubeFace[];
+
+type Vec3Mutable = [number, number, number];
+/**
+ * Cube-space point for a face-local coordinate (u, v) in [0, 1]:
+ *   cube = forward + (2u-1) * right + (2v-1) * up
+ * The result is unnormalized; normalize it to obtain the sphere direction.
+ */
+declare function faceUVToCube(face: number, u: number, v: number, out: Vec3Mutable): void;
+/** Pick the cube face whose normal axis dominates the direction. */
+declare function directionToFace(d: Vec3): number;
+/** Face-local (u, v) in [0, 1] for a direction known to fall on `face`. */
+declare function directionToFaceUV(face: number, d: Vec3, out: [number, number]): void;
+/**
+ * Convert latitude/longitude (degrees) to a unit sphere direction.
+ *
+ * Convention matches `CUBE_FACES` (+Y is the north pole):
+ * - latitude is the angle above the equator, in `[-90, 90]`
+ * - longitude is the angle around the +Y axis, in `[-180, 180]`,
+ *   measured from +Z toward +X (lon = 0 points along +Z).
+ */
+declare function latLongToDirection(latDeg: number, lonDeg: number, out: Vec3Mutable): void;
+/** Inverse of {@link latLongToDirection}; returns degrees. */
+declare function directionToLatLong(d: Vec3): {
+    latitude: number;
+    longitude: number;
+};
+
+type TerrainFieldStorageBackendType = "array-texture" | "atlas" | "texture-3d";
+type TerrainFieldStorageFormat = "rgba16float" | "rgba32float";
+type TerrainFieldStorageOptions = {
+    backend?: TerrainFieldStorageBackendType;
+    filter?: "nearest" | "linear";
+    format?: TerrainFieldStorageFormat;
+};
+interface TerrainFieldStorage {
+    readonly backendType: TerrainFieldStorageBackendType;
+    readonly edgeVertexCount: number;
+    readonly tileCount: number;
+    readonly texture: StorageArrayTexture | StorageTexture;
+    uv(ix: Node, iy: Node, tileIndex: Node): Node;
+    texel(ix: Node, iy: Node, tileIndex: Node): Node;
+    /** UV-based filtered sample. `u, v` in [0, 1] tile-local space. */
+    sample(u: Node, v: Node, tileIndex: Node): Node;
+    resize(width: number, height: number, tileCount: number): void;
+}
+declare function ArrayTextureBackend(edgeVertexCount: number, tileCount: number, options: Required<Pick<TerrainFieldStorageOptions, "format" | "filter">>): TerrainFieldStorage;
+declare function AtlasBackend(edgeVertexCount: number, tileCount: number, options: Required<Pick<TerrainFieldStorageOptions, "format" | "filter">>): TerrainFieldStorage;
+declare function createTerrainFieldStorage(edgeVertexCount: number, tileCount: number, renderer?: WebGPURenderer, options?: TerrainFieldStorageOptions): TerrainFieldStorage;
+declare function storeTerrainField(storage: TerrainFieldStorage, ix: Node, iy: Node, tileIndex: Node, value: Node): Node;
+declare function loadTerrainField(storage: TerrainFieldStorage, ix: Node, iy: Node, tileIndex: Node): Node;
+declare function loadTerrainFieldElevation(storage: TerrainFieldStorage, ix: Node, iy: Node, tileIndex: Node): Node;
+declare function loadTerrainFieldNormal(storage: TerrainFieldStorage, ix: Node, iy: Node, tileIndex: Node): Node;
+/**
+ * UV-based filtered sample. `u, v` are in [0, 1] tile-local space.
+ * Respects the filter mode (nearest / linear) set on the storage.
+ */
+declare function sampleTerrainField(storage: TerrainFieldStorage, u: Node, v: Node, tileIndex: Node): Node;
+declare function sampleTerrainFieldElevation(storage: TerrainFieldStorage, u: Node, v: Node, tileIndex: Node): Node;
+declare function packTerrainFieldSample(height: Node, normalXZ: Node, extra?: Node): Node;
+
+interface ElevationParams {
+    worldPosition: Node$1;
+    rootSize: Node$1;
+    rootUV: Node$1;
+    tileUV: Node$1;
+    tileLevel: Node$1;
+    tileSize: Node$1;
+    tileOriginVec2: Node$1;
+    nodeIndex: Node$1;
+}
+type ElevationCallback = (params: ElevationParams) => Node$1;
+
+interface TerrainUniformsParams {
+    rootSize: number;
+    rootOrigin: Vector3Like;
+    innerTileSegments: number;
+    skirtScale: number;
+    elevationScale: number;
+    radius: number;
+    instanceId: string;
+}
+interface TerrainUniformsContext {
+    uRootOrigin: UniformNode<Vector3>;
+    uRootSize: UniformNode<number>;
+    uInnerTileSegments: UniformNode<number>;
+    uSkirtScale: UniformNode<number>;
+    uElevationScale: UniformNode<number>;
+    uRadius: UniformNode<number>;
+}
+interface LeafStorageState {
+    data: Int32Array<ArrayBuffer>;
+    attribute: StorageBufferAttribute;
+    node: StorageBufferNode;
+}
+
+interface GpuSpatialIndexContext {
+    data: Uint32Array<ArrayBuffer>;
+    size: number;
+    mask: number;
+    stampGen: UniformNode<number>;
+    attribute: StorageBufferAttribute;
+    node: StorageBufferNode;
+}
+interface TerrainSampler {
+    sampleElevation: (worldX: Node, worldZ: Node) => Node;
+    sampleNormal: (worldX: Node, worldZ: Node) => Node;
+    sampleTerrain: (worldX: Node, worldZ: Node) => Node;
+    sampleValidity: (worldX: Node, worldZ: Node) => Node;
+    evaluateElevation: (worldX: Node, worldZ: Node) => Node;
+    evaluateNormal: (worldX: Node, worldZ: Node, epsilon?: Node) => Node;
+    /** Packed `vec4(elevation, nx, ny, nz)` where the normal is tangent-space. */
+    sampleTerrainByDirection?: (direction: Node) => Node;
+    sampleElevationByDirection?: (direction: Node) => Node;
+    /** World-space surface normal reconstructed in the sphere tangent frame. */
+    sampleNormalByDirection?: (direction: Node) => Node;
+    sampleValidityByDirection?: (direction: Node) => Node;
+}
+interface CreateTerrainSamplerParams {
+    terrainFieldStorage: TerrainFieldStorage;
+    spatialIndex: GpuSpatialIndexContext;
+    uniforms: TerrainUniformsContext;
+    elevationCallback: ElevationCallback;
+    /** Maximum quadtree level to probe during tile lookup. */
+    maxLevel: number;
+    projection?: TopologyProjection;
+}
+interface TerrainSample {
+    elevation: number;
+    normal: Vector3$1;
+    valid: boolean;
+}
+interface TerrainSampleBatch {
+    elevations: Float32Array;
+    normals: Float32Array;
+    valid: Uint8Array;
+    generation: number;
+}
+/**
+ * Result of sampling a cube-sphere surface from a direction/position/lat-long.
+ *
+ * `elevation` is the radial displacement above the base radius (already scaled
+ * by `elevationScale`); `position` is the full world-space surface point
+ * `center + direction * (radius + elevation)`.
+ */
+interface TerrainSurfaceSample {
+    position: Vector3$1;
+    normal: Vector3$1;
+    direction: Vector3$1;
+    elevation: number;
+    valid: boolean;
+}
+interface TerrainSurfaceSampleBatch {
+    positions: Float32Array;
+    normals: Float32Array;
+    elevations: Float32Array;
+    valid: Uint8Array;
+    generation: number;
+}
+interface TerrainTile {
+    /** Surface space index: 0 for flat terrain, 0..5 for cube-sphere faces. */
+    space: number;
+    level: number;
+    x: number;
+    y: number;
+    index: number;
+}
+interface TerrainTileBounds extends TerrainTile {
+    minElevation: number;
+    maxElevation: number;
+}
+interface ElevationRange {
+    min: number;
+    max: number;
+}
+/**
+ * Flat (heightfield) terrain query, keyed on world XZ. For cube-sphere
+ * surfaces use {@link TerrainSphereQuery} instead.
+ */
+interface TerrainQuery {
+    getElevation(worldX: number, worldZ: number): number | null;
+    getNormal(worldX: number, worldZ: number): Vector3$1 | null;
+    getTile(worldX: number, worldZ: number): TerrainTile | null;
+    getTileBounds(worldX: number, worldZ: number): TerrainTileBounds | null;
+    getGlobalElevationRange(): ElevationRange | null;
+    sampleTerrain(worldX: number, worldZ: number): TerrainSample;
+    sampleTerrainBatch(positions: Float32Array): TerrainSampleBatch;
+    readonly generation: number;
+}
+/**
+ * Cube-sphere terrain query. A surface location is identified by a direction
+ * from the planet center (the canonical form); `ByPosition` projects any world
+ * point onto its direction, and `ByLatLong` takes degrees (latitude
+ * `[-90, 90]`, longitude `[-180, 180]`). Elevation is the radial displacement
+ * above the base radius.
+ *
+ * Exposed only when the active surface uses the `cubeSphere` projection
+ * (otherwise `null` on the query context / runtime).
+ */
+interface TerrainSphereQuery {
+    readonly generation: number;
+    getElevationByDirection(direction: Vector3$1): number | null;
+    getElevationByPosition(position: Vector3$1): number | null;
+    getElevationByLatLong(latitudeDeg: number, longitudeDeg: number): number | null;
+    getNormalByDirection(direction: Vector3$1): Vector3$1 | null;
+    getNormalByPosition(position: Vector3$1): Vector3$1 | null;
+    getNormalByLatLong(latitudeDeg: number, longitudeDeg: number): Vector3$1 | null;
+    sampleTerrainByDirection(direction: Vector3$1): TerrainSurfaceSample;
+    sampleTerrainByPosition(position: Vector3$1): TerrainSurfaceSample;
+    sampleTerrainByLatLong(latitudeDeg: number, longitudeDeg: number): TerrainSurfaceSample;
+    getTileByDirection(direction: Vector3$1): TerrainTile | null;
+    getTileByPosition(position: Vector3$1): TerrainTile | null;
+    getTileByLatLong(latitudeDeg: number, longitudeDeg: number): TerrainTile | null;
+    getTileBoundsByDirection(direction: Vector3$1): TerrainTileBounds | null;
+    getTileBoundsByPosition(position: Vector3$1): TerrainTileBounds | null;
+    getTileBoundsByLatLong(latitudeDeg: number, longitudeDeg: number): TerrainTileBounds | null;
+    /** Batch sample; `directions` is a Float32Array of xyz triples. */
+    sampleTerrainBatchByDirection(directions: Float32Array): TerrainSurfaceSampleBatch;
+}
+interface RaycastOptions {
+    maxSteps?: number;
+    refinementSteps?: number;
+    maxDistance?: number;
+}
+interface TerrainRaycastResult {
+    position: Vector3$1;
+    normal: Vector3$1;
+    distance: number;
+}
+interface TerrainRaycast {
+    pick(ray: Ray, options?: RaycastOptions): TerrainRaycastResult | null;
+}
+
+type TerrainMeshParams = {
+    innerTileSegments: number;
+    maxNodes: number;
+    material: NodeMaterial;
+    /**
+     * Reverse tile triangle winding. Cube-sphere surfaces set this so the
+     * planet's outer shell is front-facing and renders with `FrontSide`.
+     */
+    flipWinding: boolean;
+};
+declare class TerrainMesh extends InstancedMesh {
+    private _innerTileSegments;
+    private _maxNodes;
+    private _flipWinding;
+    terrainRaycast: TerrainRaycast | null;
+    constructor(params?: Partial<TerrainMeshParams>);
+    get innerTileSegments(): number;
+    set innerTileSegments(tileSegments: number);
+    get flipWinding(): boolean;
+    set flipWinding(flip: boolean);
+    get maxNodes(): number;
+    set maxNodes(maxNodes: number);
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+}
+
+interface TileBoundsContext {
+    data: Float32Array<ArrayBuffer>;
+    attribute: StorageBufferAttribute;
+    node: StorageBufferNode;
+}
+
+type ComputeStageCallback = (nodeIndex: Node, globalVertexIndex: Node, uv: Node, localCoordinates: Node, texelSize: Node) => void;
+type ComputePipeline = ComputeStageCallback[];
+
+/**
+ * Default compile + execute tasks — uses terrainFieldStageTask as the leaf.
+ * Derived from the same factory as user pipelines to avoid duplicated logic.
+ */
+declare const compileComputeTask: _hello_terrain_work.Task<{
+    execute: (renderer: WebGPURenderer, instanceCount: number) => void;
+}, string, unknown>;
+declare const executeComputeTask: _hello_terrain_work.Task<any, string, {
+    renderer: WebGPURenderer;
+}>;
+/**
+ * Factory for user-extensible pipelines.
+ *
+ * Users who add custom compute stages create their own stage tasks using
+ * the accumulation pattern (`get()` predecessor, spread, append), then pass
+ * their leaf stage to this helper to get compile + execute tasks.
+ *
+ * @example
+ * ```ts
+ * const erosionStageTask = task((get, work) => {
+ *   const upstream = get(elevationFieldStageTask);
+ *   return work((): ComputePipeline => [
+ *     ...upstream,
+ *     (nodeIndex, globalVertexIndex, uv) => {
+ *       // custom erosion logic
+ *     },
+ *   ]);
+ * });
  *
- * This exists to localize future planet work behind the `Surface` interface.
- * Topology remapping across face edges is intentionally TODO.
+ * const { compile, execute } = createComputePipelineTasks(erosionStageTask);
+ * ```
  */
-declare function createCubeSphereSurface(_cfg: CubeSphereSurfaceConfig): Surface;
+declare function createComputePipelineTasks(leafStageTask: TaskRef<ComputePipeline>): {
+    compile: _hello_terrain_work.Task<{
+        execute: (renderer: WebGPURenderer, instanceCount: number) => void;
+    }, string, unknown>;
+    execute: _hello_terrain_work.Task<any, string, {
+        renderer: WebGPURenderer;
+    }>;
+};
 
-declare function createTileCompute(leafStorage: LeafStorageState, uniforms: TerrainUniformsContext): {
+declare function createTileCompute(leafStorage: LeafStorageState, uniforms: TerrainUniformsContext, projection?: TopologyProjection): {
     tileLevel: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node]>;
+    tileFace: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node]>;
     tileOriginVec2: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node]>;
     tileSize: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node]>;
+    tileFaceUV: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node, number | Node, number | Node]>;
     rootUVCompute: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node, number | Node, number | Node]>;
     tileVertexWorldPositionCompute: three_src_nodes_TSL_js.ShaderNodeFn<[number | Node, number | Node, number | Node]>;
 };
@@ -567,6 +725,10 @@ type TerrainQueryConfig = {
     innerTileSegments: number;
     elevationScale: number;
     maxLevel: number;
+    /** Topology projection; `cubeSphere` enables the direction/lat-long queries. */
+    projection: TopologyProjection;
+    /** Sphere radius in world units (cube-sphere projection only). */
+    radius: number;
 };
 interface CpuTerrainCache {
     readonly generation: number;
@@ -580,11 +742,27 @@ interface CpuTerrainCache {
     getGlobalElevationRange(): ElevationRange | null;
     sampleTerrainBatch(positions: Float32Array): TerrainSampleBatch;
     sampleTerrain(worldX: number, worldZ: number): TerrainSample;
+    getElevationByDirection(direction: Vector3$1): number | null;
+    getElevationByPosition(position: Vector3$1): number | null;
+    getElevationByLatLong(latitudeDeg: number, longitudeDeg: number): number | null;
+    getNormalByDirection(direction: Vector3$1): Vector3$1 | null;
+    getNormalByPosition(position: Vector3$1): Vector3$1 | null;
+    getNormalByLatLong(latitudeDeg: number, longitudeDeg: number): Vector3$1 | null;
+    sampleTerrainByDirection(direction: Vector3$1): TerrainSurfaceSample;
+    sampleTerrainByPosition(position: Vector3$1): TerrainSurfaceSample;
+    sampleTerrainByLatLong(latitudeDeg: number, longitudeDeg: number): TerrainSurfaceSample;
+    getTileByDirection(direction: Vector3$1): TerrainTile | null;
+    getTileByPosition(position: Vector3$1): TerrainTile | null;
+    getTileByLatLong(latitudeDeg: number, longitudeDeg: number): TerrainTile | null;
+    getTileBoundsByDirection(direction: Vector3$1): TerrainTileBounds | null;
+    getTileBoundsByPosition(position: Vector3$1): TerrainTileBounds | null;
+    getTileBoundsByLatLong(latitudeDeg: number, longitudeDeg: number): TerrainTileBounds | null;
+    sampleTerrainBatchByDirection(directions: Float32Array): TerrainSurfaceSampleBatch;
 }
 
 interface QuadtreeConfigState {
     state: QuadtreeState;
-    surface: Surface;
+    topology: Topology;
 }
 interface LeafGpuBufferState extends LeafStorageState {
     count: number;
@@ -597,6 +775,8 @@ interface ElevationFieldContext {
 interface TerrainQueryContext {
     cache: CpuTerrainCache;
     query: TerrainQuery;
+    /** Cube-sphere query; `null` unless the topology uses the cubeSphere projection. */
+    sphereQuery: TerrainSphereQuery | null;
     shapeKey: string;
 }
 /** Task refs for the standard terrain pipeline. */
@@ -604,7 +784,7 @@ interface TerrainTasks {
     instanceId: TaskRef<string>;
     quadtreeConfig: TaskRef<QuadtreeConfigState>;
     quadtreeUpdate: TaskRef<LeafSet>;
-    surface: TaskRef<Surface>;
+    topology: TaskRef<Topology>;
     leafStorage: TaskRef<LeafStorageState>;
     leafGpuBuffer: TaskRef<LeafGpuBufferState>;
     gpuSpatialIndexStorage: TaskRef<GpuSpatialIndexContext>;
@@ -641,8 +821,10 @@ declare const createElevationFieldContextTask: _hello_terrain_work.Task<{
 }, string, unknown>;
 declare const tileNodesTask: _hello_terrain_work.Task<{
     tileLevel: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node]>;
+    tileFace: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node]>;
     tileOriginVec2: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node]>;
     tileSize: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node]>;
+    tileFaceUV: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node, number | three_webgpu.Node, number | three_webgpu.Node]>;
     rootUVCompute: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node, number | three_webgpu.Node, number | three_webgpu.Node]>;
     tileVertexWorldPositionCompute: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node, number | three_webgpu.Node, number | three_webgpu.Node]>;
 }, string, unknown>;
@@ -689,22 +871,24 @@ declare const origin: _hello_terrain_work.ParamRef<{
     z: number;
 }>;
 /**
- * Number of segments per inner tile edge.
- * Effective edge vertex count is `innerTileSegments + 3`.
+ * Default number of segments per inner tile edge. The effective edge vertex
+ * count is `innerTileSegments + 3`
  */
 declare const innerTileSegments: _hello_terrain_work.ParamRef<number>;
 /** Skirt scale factor. */
 declare const skirtScale: _hello_terrain_work.ParamRef<number>;
 /** Elevation vertical scale. */
 declare const elevationScale: _hello_terrain_work.ParamRef<number>;
+/** Sphere radius in world units (cube-sphere projection only). */
+declare const radius: _hello_terrain_work.ParamRef<number>;
 /** Maximum quadtree nodes. */
 declare const maxNodes: _hello_terrain_work.ParamRef<number>;
 /** Maximum quadtree subdivision level. */
 declare const maxLevel: _hello_terrain_work.ParamRef<number>;
 /** Quadtree update configuration (camera, mode, etc.). */
 declare const quadtreeUpdate: _hello_terrain_work.ParamRef<UpdateParams>;
-/** Optional custom terrain surface; defaults to bounded flat surface when null. */
-declare const surface: _hello_terrain_work.ParamRef<Surface | null>;
+/** Optional custom terrain topology; defaults to bounded flat topology when null. */
+declare const topology: _hello_terrain_work.ParamRef<Topology | null>;
 /** Terrain field texture filter mode. */
 declare const terrainFieldFilter: _hello_terrain_work.ParamRef<"nearest" | "linear">;
 /** Terrain elevation control function (per vertex, in gpu compute) */
@@ -727,11 +911,11 @@ declare const elevationFn: _hello_terrain_work.ParamRef<ElevationCallback>;
 declare const positionNodeTask: _hello_terrain_work.Task<three_src_nodes_TSL_js.ShaderCallNodeInternal, string, unknown>;
 
 /**
- * Derives the terrain surface from `rootSize` and `origin`.
+ * Derives the terrain topology from `rootSize` and `origin`.
  * Automatically recomputes when either param changes, keeping the
  * quadtree refinement in sync with the GPU-side tile positioning.
  */
-declare const surfaceTask: _hello_terrain_work.Task<Surface, string, unknown>;
+declare const topologyTask: _hello_terrain_work.Task<Topology, string, unknown>;
 declare const quadtreeConfigTask: _hello_terrain_work.Task<QuadtreeConfigState, string, unknown>;
 declare const quadtreeUpdateTask: _hello_terrain_work.Task<LeafSet, string, unknown>;
 /**
@@ -763,14 +947,13 @@ declare const createUniformsTask: _hello_terrain_work.Task<TerrainUniformsContex
  */
 declare const updateUniformsTask: _hello_terrain_work.Task<TerrainUniformsContext, string, unknown>;
 
-declare function terrainGraph(): TerrainGraph;
 /** All terrain task refs for direct access. */
 declare const terrainTasks: {
     readonly instanceId: _hello_terrain_work.Task<`${string}-${string}-${string}-${string}-${string}`, string, unknown>;
     readonly quadtreeConfig: _hello_terrain_work.Task<QuadtreeConfigState, string, unknown>;
     readonly quadtreeUpdate: _hello_terrain_work.Task<LeafSet, string, unknown>;
     readonly leafStorage: _hello_terrain_work.Task<LeafStorageState, string, unknown>;
-    readonly surface: _hello_terrain_work.Task<Surface, string, unknown>;
+    readonly topology: _hello_terrain_work.Task<Topology, string, unknown>;
     readonly leafGpuBuffer: _hello_terrain_work.Task<{
         count: number;
         data: Int32Array<ArrayBuffer>;
@@ -789,8 +972,10 @@ declare const terrainTasks: {
     }, string, unknown>;
     readonly createTileNodes: _hello_terrain_work.Task<{
         tileLevel: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node]>;
+        tileFace: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node]>;
         tileOriginVec2: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node]>;
         tileSize: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node]>;
+        tileFaceUV: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node, number | three_webgpu.Node, number | three_webgpu.Node]>;
         rootUVCompute: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node, number | three_webgpu.Node, number | three_webgpu.Node]>;
         tileVertexWorldPositionCompute: three_src_nodes_TSL_js.ShaderNodeFn<[number | three_webgpu.Node, number | three_webgpu.Node, number | three_webgpu.Node]>;
     }, string, unknown>;
@@ -818,6 +1003,7 @@ declare const terrainTasks: {
     }>;
     readonly terrainRaycast: _hello_terrain_work.Task<TerrainRaycast, string, unknown>;
 };
+declare function terrainGraph(): TerrainGraph;
 
 type ComputeDeviceLimits = {
     maxWorkgroupSizeX: number;
@@ -828,7 +1014,10 @@ declare function getDeviceComputeLimits(renderer: WebGPURenderer): ComputeDevice
 
 declare function createTerrainSampler(params: CreateTerrainSamplerParams): TerrainSampler;
 
+/** Flat (heightfield) query, keyed on world XZ. */
 declare function createTerrainQuery(cache: CpuTerrainCache): TerrainQuery;
+/** Cube-sphere query, keyed on a direction / position / lat-long. */
+declare function createTerrainSphereQuery(cache: CpuTerrainCache): TerrainSphereQuery;
 
 type CpuRaycastConfig = {
     rootSize: number;
@@ -836,14 +1025,68 @@ type CpuRaycastConfig = {
     originZ: number;
     minY: number;
     maxY: number;
+    /** Topology projection; `cubeSphere` selects the radial sphere raycast. */
+    projection?: TopologyProjection;
+    /** Planet center (cube-sphere only). */
+    centerX?: number;
+    centerY?: number;
+    centerZ?: number;
+    /** Base sphere radius (cube-sphere only). */
+    radius?: number;
+    /** Inner/outer radial bounds of the terrain shell (cube-sphere only). */
+    minRadius?: number;
+    maxRadius?: number;
 };
 
 type TerrainRaycastConfig = CpuRaycastConfig;
 declare function createTerrainRaycast(params: {
     getTerrainQuery: () => TerrainQuery | null;
+    getSphereQuery: () => TerrainSphereQuery | null;
     getConfig: () => TerrainRaycastConfig;
 }): TerrainRaycast;
 
+type CubeFaceBasis = {
+    forward: Node;
+    right: Node;
+    up: Node;
+};
+/** Per-face basis vectors selected by the dynamic face index. */
+declare function cubeFaceBasis(face: Node): CubeFaceBasis;
+/**
+ * Cube-space point for face-local (u, v) in [0, 1]:
+ *   cube = forward + (2u-1) * right + (2v-1) * up
+ */
+declare function cubeFacePoint(basis: CubeFaceBasis, u: Node, v: Node): Node;
+/** Unit-sphere direction for face-local (u, v). */
+declare function cubeFaceDirection(basis: CubeFaceBasis, u: Node, v: Node): Node;
+/**
+ * Project a basis axis onto the tangent plane at `dir` and normalize.
+ * Used to build the sphere tangent frame for normal reconstruction.
+ */
+declare function tangentFromAxis(dir: Node, axis: Node): Node;
+/**
+ * Reconstruct a unit tangent-space normal from its packed horizontal
+ * components: `ny = sqrt(max(0, 1 - nx² - nz²))`.
+ */
+declare function unpackTangentNormal(nx: Node, nz: Node): Node;
+/**
+ * Rotate a tangent-space normal into the sphere tangent frame
+ * `(tu, dir, tv)` at `dir` and normalize.
+ *
+ * Mirrors: the CPU `computeSphereNormal` in `query/cpu-terrain-cache.ts`.
+ */
+declare function sphereTangentFrameNormal(dir: Node, basis: CubeFaceBasis, tangentNormal: Node): Node;
+/**
+ * Pick the cube face index (0..5) whose normal axis dominates `dir`.
+ * GPU mirror of `directionToFace` in `quadtree/topology/cubeSphereInverse.ts`.
+ */
+declare function cubeFaceFromDirection(dir: Node): Node;
+/**
+ * Face-local (u, v) in [0, 1] for a direction known to fall on `face`.
+ * GPU mirror of `directionToFaceUV` in `quadtree/topology/cubeSphereInverse.ts`.
+ */
+declare function cubeFaceUVFromDirection(basis: CubeFaceBasis, dir: Node): Node;
+
 /**
  * Maps a value or node from texture space [0, 1] to vector space [-1, 1].
  *
@@ -916,5 +1159,5 @@ declare const voronoiCells: three_src_nodes_TSL_js.ShaderNodeFn<[three_tsl.Proxi
     uv: Node;
 }>]>;
 
-export { ArrayTextureBackend, AtlasBackend, Dir, TerrainGeometry, TerrainMesh, Texture3DBackend, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereSurface, createElevationFieldContextTask, createFlatSurface, createInfiniteFlatSurface, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainQuery, createTerrainRaycast, createTerrainSampler, createTerrainSamplerTask, createTerrainUniforms, createUniformsTask, deriveNormalZ, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, getDeviceComputeLimits, gpuSpatialIndexStorageTask, gpuSpatialIndexUploadTask, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, sampleTerrainFieldNormal, skirtScale, storeTerrainField, surface, surfaceTask, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainQueryTask, terrainRaycastTask, terrainReadbackTask, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };
-export type { ComputePipeline, ComputeStageCallback, CreateTerrainSamplerParams, CubeSphereSurfaceConfig, ElevationCallback, ElevationFieldContext, ElevationParams, ElevationRange, FlatSurfaceConfig, GpuSpatialIndexContext, InfiniteFlatSurfaceConfig, IntNodeInput, LeafGpuBufferState, LeafSet, LeafStorageState, LodMode, QuadtreeConfig, QuadtreeConfigState, QuadtreeState, RaycastOptions, SeamTable, SpatialIndex, Surface, TerrainElevationSample, TerrainFieldStorage, TerrainFieldStorageBackendType, TerrainFieldStorageFormat, TerrainFieldStorageOptions, TerrainGraph, TerrainQuery, TerrainQueryContext, TerrainRaycast, TerrainRaycastConfig, TerrainRaycastResult, TerrainSample, TerrainSampleBatch, TerrainSampler, TerrainTasks, TerrainTile, TerrainTileBounds, TerrainUniformsContext, TerrainUniformsParams, TileBounds, TileId, UpdateParams };
+export { ArrayTextureBackend, AtlasBackend, CUBE_FACES, CUBE_FACE_COUNT, Dir, TerrainGeometry, TerrainMesh, U32_EMPTY, allocLeafSet, allocSeamTable, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereTopology, createElevationFieldContextTask, createFlatTopology, createInfiniteFlatTopology, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainQuery, createTerrainRaycast, createTerrainSampler, createTerrainSamplerTask, createTerrainSphereQuery, createTerrainUniforms, createUniformsTask, cubeFaceBasis, cubeFaceDirection, cubeFaceFromDirection, cubeFacePoint, cubeFaceUVFromDirection, deriveNormalZ, directionToFace, directionToFaceUV, directionToLatLong, elevationFieldStageTask, elevationFn, elevationScale, executeComputeTask, faceUVToCube, getDeviceComputeLimits, gpuSpatialIndexStorageTask, gpuSpatialIndexUploadTask, innerTileSegments, instanceIdTask, isSkirtUV, isSkirtVertex, latLongToDirection, leafGpuBufferTask, leafStorageTask, loadTerrainField, loadTerrainFieldElevation, loadTerrainFieldNormal, maxLevel, maxNodes, origin, packTerrainFieldSample, positionNodeTask, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, radius, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, skirtScale, sphereTangentFrameNormal, storeTerrainField, tangentFromAxis, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainQueryTask, terrainRaycastTask, terrainReadbackTask, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, topology, topologyTask, unpackTangentNormal, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells };
+export type { ComputePipeline, ComputeStageCallback, CreateTerrainSamplerParams, CubeFace, CubeFaceBasis, CubeSphereTopologyConfig, ElevationCallback, ElevationFieldContext, ElevationParams, ElevationRange, FlatTopologyConfig, GpuSpatialIndexContext, InfiniteFlatTopologyConfig, IntNodeInput, LeafGpuBufferState, LeafSet, LeafStorageState, LodMode, QuadtreeConfig, QuadtreeConfigState, QuadtreeState, RaycastOptions, SeamTable, SpatialIndex, TerrainFieldStorage, TerrainFieldStorageBackendType, TerrainFieldStorageFormat, TerrainFieldStorageOptions, TerrainGraph, TerrainQuery, TerrainQueryContext, TerrainRaycast, TerrainRaycastConfig, TerrainRaycastResult, TerrainSample, TerrainSampleBatch, TerrainSampler, TerrainSphereQuery, TerrainSurfaceSample, TerrainSurfaceSampleBatch, TerrainTasks, TerrainTile, TerrainTileBounds, TerrainUniformsContext, TerrainUniformsParams, TileBounds, TileId, Topology, TopologyProjection, UpdateParams, Vec3, Vec3Mutable };