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

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { BufferGeometry, Ray, Vector3 as Vector3$1, Raycaster, Intersection } from 'three';
+import { BufferGeometry, Vector3 as Vector3$1, Ray, Raycaster, Intersection } from 'three';
 import * as three_webgpu from 'three/webgpu';
 import { StorageArrayTexture, StorageTexture, Node, WebGPURenderer, StorageBufferAttribute, StorageBufferNode, UniformNode, Vector3, Vector3Like, InstancedMesh, NodeMaterial, ConstNode } from 'three/webgpu';
 import Node$1 from 'three/src/nodes/core/Node.js';
-import * as three_src_nodes_TSL_js from 'three/src/nodes/TSL.js';
-import { ShaderCallNodeInternal } from 'three/src/nodes/TSL.js';
 import * as _hello_terrain_work from '@hello-terrain/work';
 import { TaskRef, Graph } from '@hello-terrain/work';
+import * as three_src_nodes_TSL_js from 'three/src/nodes/TSL.js';
+import { ShaderCallNodeInternal } from 'three/src/nodes/TSL.js';
 import * as three_tsl from 'three/tsl';
 
 /**
@@ -103,6 +103,100 @@ 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;
+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;
+/**
+ * Pack a terrain field sample into RGBA: `[height, Nx, Ny, Nz]` where
+ * `(Nx, Ny, Nz)` is the unit world-space surface normal. Storing the full
+ * world normal (rather than a face-local tangent pair) keeps shading
+ * continuous across cube-face seams, since adjacent faces no longer rotate the
+ * normal through their own parametric tangent frame.
+ */
+declare function packTerrainFieldSample(height: Node, normal: Node): Node;
+
+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;
+}
+
+/** Shared (projection-independent) tile-compute helpers. */
+type SharedTileCompute = {
+    tileLevel: (nodeIndex: Node) => Node;
+    tileFace: (nodeIndex: Node) => Node;
+    tileOriginVec2: (nodeIndex: Node) => Node;
+    /** Face-local (u, v) in [0, 1] for a grid sample, including skirt border. */
+    tileFaceUV: (nodeIndex: Node, ix: Node, iy: Node) => Node;
+};
+/** Projection-specific tile-compute builders. */
+type TileComputeParts = {
+    tileSize: (nodeIndex: Node) => Node;
+    rootUV: (nodeIndex: Node, ix: Node, iy: Node) => Node;
+    tileVertexWorldPosition: (nodeIndex: Node, ix: Node, iy: Node) => Node;
+};
+type TileComputePartsContext = {
+    leafStorage: LeafStorageState;
+    uniforms: TerrainUniformsContext;
+    shared: SharedTileCompute;
+};
+type TileCompute = SharedTileCompute & {
+    tileSize: (nodeIndex: Node) => Node;
+    rootUVCompute: (nodeIndex: Node, ix: Node, iy: Node) => Node;
+    tileVertexWorldPositionCompute: (nodeIndex: Node, ix: Node, iy: Node) => Node;
+};
+/**
+ * Build the per-tile compute helpers, composing projection-independent
+ * decoders with the projection-specific position/size/uv builders supplied by
+ * `projection.gpu.createTileComputeParts`.
+ */
+declare function createTileCompute(leafStorage: LeafStorageState, uniforms: TerrainUniformsContext, projection: SurfaceProjection): TileCompute;
+
 declare const Dir: {
     readonly LEFT: 0;
     readonly RIGHT: 1;
@@ -128,27 +222,21 @@ type TileBounds = {
     /** conservative radius */
     r: number;
 };
-type TopologyProjection = "flat" | "cubeSphere";
+/** Scaled world-space elevation displacement range for a tile. */
+type ElevationRangeOut = {
+    min: number;
+    max: number;
+};
 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.
+     * Injected surface projection strategy. Encapsulates the GPU position/normal
+     * assembly and the CPU query/raycast/LOD behavior for this topology, so the
+     * pipeline never branches on a projection kind.
      */
-    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;
-    };
+    projection: SurfaceProjection;
     /**
      * Compute the same-level neighbor TileId in the requested direction.
      * Returns false if the neighbor is outside the valid topology.
@@ -159,12 +247,13 @@ type Topology = {
     /**
      * Conservative camera-relative bounds for LOD decisions.
      * Avoids absolute world coordinates so Earth-scale worlds remain stable.
+     * When `elevationRange` is provided, bounds should account for displaced geometry.
      */
     tileBounds(tile: TileId, cameraOrigin: {
         x: number;
         y: number;
         z: number;
-    }, out: TileBounds): void;
+    }, out: TileBounds, elevationRange?: ElevationRangeOut): void;
     /**
      * Fill root tiles for the current frame and return the count.
      * Implementations should write level-0 tiles into `out[0..count)`.
@@ -205,37 +294,36 @@ type SeamTable = {
 declare function allocSeamTable(capacity: number): SeamTable;
 declare function resetSeamTable(seams: SeamTable): void;
 type LodMode = "distance" | "screen";
+/**
+ * How subdivision decisions are made. A discriminated union so each mode only
+ * carries (and requires) its own thresholds.
+ * - `distance` (default): split when the camera is within `distanceFactor × r`.
+ * - `screen`: split when the projected pixel radius exceeds `targetPixels`.
+ */
+type LodCriteria = {
+    mode?: "distance";
+    distanceFactor?: number;
+} | {
+    mode: "screen";
+    /** Screen-space projection factor = screenHeight / (2*tan(fovY/2)). */
+    projectionFactor: number;
+    /** Target pixel radius/size threshold for screen-space refinement. */
+    targetPixels: number;
+};
+/**
+ * Per-tile elevation range provider: previous-frame world-space displacement
+ * min/max (already scaled by `elevationScale`). Returns false when no data is
+ * available yet. Allocation-free via the `out` scratch.
+ */
+type TileElevationRangeFn = (tile: TileId, out: ElevationRangeOut) => boolean;
 type UpdateParams = {
     cameraOrigin: {
         x: number;
         y: number;
         z: number;
     };
-    /**
-     * 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;
-    /**
-     * Controls how subdivision decisions are made.
-     * `distance` is the initial focus; `screen` is supported for future parity.
-     */
-    mode?: LodMode;
-    /**
-     * Distance-based refinement threshold.
-     * Interpretation is criteria-dependent; keep it stable across surfaces by using bounds.
-     */
-    distanceFactor?: number;
-    /** Screen-space projection factor = screenHeight / (2*tan(fovY/2)) */
-    projectionFactor?: number;
-    /** Target pixel radius/size threshold for screen-space refinement */
-    targetPixels?: number;
-    /** Prevent flicker by separating split/merge thresholds (0..1 typical) */
-    hysteresis?: number;
-};
+    tileElevationRange?: TileElevationRangeFn;
+} & LodCriteria;
 type QuadtreeConfig = {
     maxNodes: number;
     maxLevel: number;
@@ -301,6 +389,7 @@ type QuadtreeState = {
     scratchTile: TileId;
     scratchNeighbor: TileId;
     scratchBounds: TileBounds;
+    scratchElevationRange: ElevationRangeOut;
     scratchRootTiles: TileId[];
     /** topology space count is fixed for a given state */
     spaceCount: number;
@@ -334,8 +423,6 @@ type FlatTopologyConfig = {
         y: number;
         z: number;
     };
-    /** optional conservative vertical extent, included in bounds radius */
-    maxHeight?: number;
 };
 declare function createFlatTopology(cfg: FlatTopologyConfig): Topology;
 
@@ -346,8 +433,6 @@ type InfiniteFlatTopologyConfig = {
         y: number;
         z: number;
     };
-    /** optional conservative vertical extent, included in bounds radius */
-    maxHeight?: number;
     /** half-width of root grid in root tiles (1 => 3x3 roots) */
     rootGridRadius?: number;
 };
@@ -362,8 +447,8 @@ type CubeSphereTopologyConfig = {
         y: number;
         z: number;
     };
-    /** Optional conservative vertical extent, included in bounds radius. */
-    maxHeight?: number;
+    /** When true, elevation displaces inward and skirts point outward. */
+    invert?: boolean;
 };
 /**
  * Cube-sphere topology: six quadtree faces wrapped onto a sphere.
@@ -401,13 +486,13 @@ type CubeFace = {
 declare const CUBE_FACE_COUNT = 6;
 declare const CUBE_FACES: readonly CubeFace[];
 
-type Vec3Mutable = [number, number, number];
+type Vec3Mutable$1 = [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;
+declare function faceUVToCube(face: number, u: number, v: number, out: Vec3Mutable$1): 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`. */
@@ -420,45 +505,258 @@ declare function directionToFaceUV(face: number, d: Vec3, out: [number, number])
  * - 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;
+declare function latLongToDirection(latDeg: number, lonDeg: number, out: Vec3Mutable$1): 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;
+type TorusTopologyConfig = {
+    /** Distance from the torus center to the tube center (the donut radius). */
+    majorRadius: number;
+    /** Radius of the tube cross-section. */
+    minorRadius: number;
+    /** Torus center in world space (defaults to origin). */
+    center?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** When true, elevation displaces inward and skirts point outward. */
+    invert?: boolean;
 };
-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;
+/**
+ * Torus (donut) topology: a single quadtree space whose `(u, v)` axes wrap
+ * around the major circle and the tube cross-section. Both axes are periodic,
+ * so every same-level neighbor exists (wrapping modulo the level resolution).
+ *
+ * Level-0 resolution is anisotropic: `baseU = round(major/minor)` tiles along
+ * `u` and `baseV = 1` along `v`, so root tiles are approximately square in
+ * world space before isotropic LOD subdivision.
+ */
+declare function createTorusTopology(cfg: TorusTopologyConfig): Topology;
+
+type Vec3Mutable = [number, number, number];
+/** Wrap a value into [0, 1). */
+declare function wrap01(t: number): number;
+/**
+ * Torus surface point for parameters (u, v) in [0, 1].
+ *
+ * Convention (matches `latLongToDirection`'s longitude axis):
+ * - `theta = 2*pi*u` sweeps around the +Y axis, measured from +Z toward +X.
+ * - `phi = 2*pi*v` sweeps around the tube cross-section, `phi = 0` pointing
+ *   radially outward in the XZ plane and `phi = pi/2` pointing toward +Y.
+ *
+ * `displacement` is the elevation added to the tube (minor) radius.
+ */
+declare function torusUVToPoint(u: number, v: number, majorRadius: number, minorRadius: number, displacement: number, center: {
+    x: number;
+    y: number;
+    z: number;
+}, out: Vec3Mutable, invert?: boolean): void;
+/** Outward unit surface normal of the base (undisplaced) torus at (u, v). */
+declare function torusOutwardNormal(u: number, v: number, out: Vec3Mutable, invert?: boolean): void;
+type TorusSurfaceParams = {
+    /** Wrapped major-circle parameter in [0, 1). */
+    u: number;
+    /** Wrapped tube parameter in [0, 1). */
+    v: number;
+    /** Distance from the point to the tube center circle. */
+    tubeDistance: number;
+};
+/**
+ * Map a world point to torus surface parameters. `tubeDistance - minorRadius`
+ * is the signed radial displacement of the point relative to the base torus.
+ */
+declare function positionToTorusParams(px: number, py: number, pz: number, majorRadius: number, center: {
+    x: number;
+    y: number;
+    z: number;
+}, out: TorusSurfaceParams): void;
+
+type TerrainQueryConfig = {
+    rootSize: number;
+    originX: number;
+    originY: number;
+    originZ: number;
+    innerTileSegments: number;
+    elevationScale: number;
+    maxLevel: number;
+    /** Representative surface radius (curved projections only). */
+    radius: number;
+    /** Level-0 tile count along u before LOD subdivision (defaults to 1). */
+    baseU?: number;
+    /** Level-0 tile count along v before LOD subdivision (defaults to 1). */
+    baseV?: number;
+};
+interface CpuTerrainCache {
+    readonly generation: number;
+    readonly ready: boolean;
+    updateConfig(config: TerrainQueryConfig): void;
+    triggerReadback(renderer: WebGPURenderer, attribute: StorageBufferAttribute, spatialIndex: SpatialIndex, boundsAttribute?: StorageBufferAttribute, activeLeafCount?: number): void;
+    /** Release GPU readback staging buffers owned by this cache. */
+    dispose(): void;
+    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;
+    sampleTerrainBatch(positions: Float32Array): TerrainSampleBatch;
+    sampleTerrain(worldX: number, worldZ: number): TerrainSample;
+    /** True when the active projection supplies surface ops. */
+    readonly hasSurface: boolean;
+    /**
+     * Swap the projection surface ops (CPU position/normal math). Used when the
+     * surface geometry changes (e.g. cube-sphere radius/center) without changing
+     * the buffer shape, so picks/queries stay in sync without reallocating.
+     */
+    setSurfaceOps(surfaceOps: CpuSurfaceOps | null): void;
+    sampleSurfaceByPosition(px: number, py: number, pz: number): TerrainSurfaceSample;
+    getElevationBySurfacePosition(px: number, py: number, pz: number): number | null;
+    getNormalBySurfacePosition(px: number, py: number, pz: number): Vector3$1 | null;
+    getTileBySurfacePosition(px: number, py: number, pz: number): TerrainTile | null;
+    getTileBoundsBySurfacePosition(px: number, py: number, pz: number): TerrainTileBounds | null;
+    sampleSurfaceBatchByPosition(positions: Float32Array): TerrainSurfaceSampleBatch;
+    /**
+     * Previous-frame raw elevation min/max for a tile (unscaled field values).
+     * Returns false when no snapshot data is available for the tile.
+     */
+    getTileElevationRange(space: number, level: number, x: number, y: number, out: {
+        min: number;
+        max: number;
+    }): boolean;
 }
-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.
+ * CPU sampling over a snapshot elevation-field buffer laid out as
+ * `maxNodes × (edgeVertexCount × edgeVertexCount)` raw heights.
+ *
+ * Plain-number math only (no three.js, no TSL); callers build vectors at the
+ * consumer-facing boundary.
  */
-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 ElevationGridShape {
+    edgeVertexCount: number;
+    verticesPerNode: number;
+}
+
+/** Stable projection identifier — for debugging/telemetry only, never switched on. */
+type ProjectionKind = "flat" | "cubeSphere" | "torus" | (string & {});
+interface Vec3Like {
+    x: number;
+    y: number;
+    z: number;
+}
+interface RenderVertexPositionContext {
+    leafStorage: LeafStorageState;
+    uniforms: TerrainUniformsContext;
+    terrainFieldStorage?: TerrainFieldStorage;
+}
+interface FieldNormalContext {
+    elevationFieldNode: Node;
+    edgeVertexCount: number;
+    tile: TileCompute;
+    uniforms: TerrainUniformsContext;
+}
+/** Per-vertex field-stage normal: `(nodeIndex, ix, iy) => unit world normal`. */
+type FieldNormalFn = (nodeIndex: Node, ix: Node, iy: Node) => Node;
+interface SurfaceProjectionGpu {
+    /** Render-path world position; also assigns the vertex normal varying. */
+    renderVertexPosition(ctx: RenderVertexPositionContext): Node;
+    /** Projection-specific compute-stage tile builders (size / uv / position). */
+    createTileComputeParts(ctx: TileComputePartsContext): TileComputeParts;
+    /** Field-stage surface normal builder. */
+    createFieldNormal(ctx: FieldNormalContext): FieldNormalFn;
+    /** Optional extra GPU samplers (e.g. sphere ByDirection); no-op for flat. */
+    augmentSampler?(sampler: TerrainSampler, params: CreateTerrainSamplerParams): void;
+}
+/** A world point projected onto a closed surface: tile space + face-local uv. */
+interface SurfaceKey {
+    /** Tile space/face index (0 for torus, 0..5 for cube-sphere faces). */
+    space: number;
+    /** Face-local u in [0, 1). */
+    u: number;
+    /** Face-local v in [0, 1). */
+    v: number;
+    /** Outward unit direction at the key (for the surface sample `direction`). */
+    dirX: number;
+    dirY: number;
+    dirZ: number;
+}
+/** Grid neighborhood passed to {@link CpuSurfaceOps.surfaceNormal}. */
+interface SurfaceNormalContext {
+    elevation: Float32Array;
+    shape: ElevationGridShape;
+    leafIndex: number;
+    /** Fractional grid coords of the sample within the leaf. */
+    gx: number;
+    gy: number;
+    innerTileSegments: number;
+    elevationScale: number;
+    level: number;
+}
+/**
+ * Projection-specific CPU surface math, injected into the terrain cache so the
+ * cache stays projection-agnostic. Implementations own their scratch (no
+ * module-scope state).
+ */
+interface CpuSurfaceOps {
+    /** Map a world position to a surface key; `false` if it has no projection. */
+    positionToKey(px: number, py: number, pz: number, out: SurfaceKey): boolean;
+    /** Displaced world position from a key + scaled elevation (writes `out`). */
+    surfacePosition(key: SurfaceKey, elevation: number, out: Vector3$1): void;
+    /** Unit world-space surface normal from a key + grid neighborhood. */
+    surfaceNormal(key: SurfaceKey, ctx: SurfaceNormalContext): Vector3$1;
+}
+interface ProjectionRaycastContext {
+    ray: Ray;
+    options?: RaycastOptions;
+    terrainQuery: TerrainQuery | null;
+    surfaceQuery: TerrainSurfaceQuery | null;
+    sphereQuery: TerrainSphereQuery | null;
+    config: TerrainRaycastConfig;
+}
+interface RuntimeQueries {
+    query: TerrainQuery;
+    /** Generic surface query (position/uv keyed); `null` on flat surfaces. */
+    surfaceQuery: TerrainSurfaceQuery | null;
+    /** Cube-sphere query (adds direction/lat-long); `null` unless cube-sphere. */
+    sphereQuery: TerrainSphereQuery | null;
+}
+interface SurfaceProjectionCpu {
+    /**
+     * Surface sampling ops injected into the terrain cache; `null` for flat
+     * surfaces (which have no closed-surface query).
+     */
+    createSurfaceOps(): CpuSurfaceOps | null;
+    /** Build the runtime query objects the projection exposes. */
+    createRuntimeQueries(cache: CpuTerrainCache): RuntimeQueries;
+    /**
+     * Projection-specific CPU raycast against the displaced surface. Returns
+     * `null` when the ray misses the surface or the query snapshot isn't ready.
+     */
+    raycast(ctx: ProjectionRaycastContext): TerrainRaycastResult | null;
+}
+interface SurfaceProjection {
+    /** Identifier; never switched on internally. */
+    readonly kind: ProjectionKind;
+    /** Representative radius (bounds/uniform helper); undefined for flat. */
+    readonly radius?: number;
+    /** Surface center in world space; undefined for flat. */
+    readonly center?: Vec3Like;
+    /** Closed surfaces face outward → flip triangle winding. */
+    readonly faceOutward: boolean;
+    /**
+     * Per-axis level-0 tile count before LOD subdivision. Defaults to `{ u: 1, v: 1 }`.
+     * At level `L`, resolution is `baseU * 2^L` by `baseV * 2^L` tiles.
+     */
+    readonly baseResolution?: {
+        u: number;
+        v: number;
+    };
+    gpu: SurfaceProjectionGpu;
+    cpu: SurfaceProjectionCpu;
+}
 
 interface ElevationParams {
     worldPosition: Node$1;
@@ -472,29 +770,6 @@ interface ElevationParams {
 }
 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;
@@ -524,7 +799,8 @@ interface CreateTerrainSamplerParams {
     elevationCallback: ElevationCallback;
     /** Maximum quadtree level to probe during tile lookup. */
     maxLevel: number;
-    projection?: TopologyProjection;
+    /** Active surface projection (drives optional GPU sampler augmentation). */
+    projection: SurfaceProjection;
 }
 interface TerrainSample {
     elevation: number;
@@ -589,31 +865,42 @@ interface TerrainQuery {
     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.
+ * Generic closed-surface terrain query, keyed on a world position projected
+ * onto the surface. Exposed for every non-flat projection (cube-sphere, torus,
+ * ...); `null` on flat surfaces. Elevation is the displacement above the base
+ * surface (already scaled by `elevationScale`); `position` is the full
+ * world-space surface point.
+ */
+interface TerrainSurfaceQuery {
+    readonly generation: number;
+    getElevationByPosition(position: Vector3$1): number | null;
+    getNormalByPosition(position: Vector3$1): Vector3$1 | null;
+    sampleTerrainByPosition(position: Vector3$1): TerrainSurfaceSample;
+    getTileByPosition(position: Vector3$1): TerrainTile | null;
+    getTileBoundsByPosition(position: Vector3$1): TerrainTileBounds | null;
+    /** Batch sample; `positions` is a Float32Array of xyz triples. */
+    sampleTerrainBatchByPosition(positions: Float32Array): TerrainSurfaceSampleBatch;
+}
+/**
+ * Cube-sphere terrain query. Extends the generic surface query with the
+ * sphere-only direction/lat-long keys. 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]`).
  *
  * Exposed only when the active surface uses the `cubeSphere` projection
  * (otherwise `null` on the query context / runtime).
  */
-interface TerrainSphereQuery {
-    readonly generation: number;
+interface TerrainSphereQuery extends TerrainSurfaceQuery {
     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;
@@ -623,6 +910,22 @@ interface RaycastOptions {
     refinementSteps?: number;
     maxDistance?: number;
 }
+/**
+ * Shared raycast bounds for the CPU marcher. Flat raycasts use the XZ extent +
+ * `[minY, maxY]`; curved projections derive their own radial shell from their
+ * geometry plus the query's global elevation range, and only read `center*`.
+ */
+interface TerrainRaycastConfig {
+    rootSize: number;
+    originX: number;
+    originY: number;
+    originZ: number;
+    minY: number;
+    maxY: number;
+    centerX: number;
+    centerY: number;
+    centerZ: number;
+}
 interface TerrainRaycastResult {
     position: Vector3$1;
     normal: Vector3$1;
@@ -707,59 +1010,6 @@ declare function createComputePipelineTasks(leafStageTask: TaskRef<ComputePipeli
     }>;
 };
 
-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]>;
-};
-
-type TerrainQueryConfig = {
-    rootSize: number;
-    originX: number;
-    originY: number;
-    originZ: number;
-    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;
-    readonly ready: boolean;
-    updateConfig(config: TerrainQueryConfig): void;
-    triggerReadback(renderer: WebGPURenderer, attribute: StorageBufferAttribute, spatialIndex: SpatialIndex, boundsAttribute?: StorageBufferAttribute, activeLeafCount?: number): void;
-    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;
-    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;
     topology: Topology;
@@ -775,9 +1025,18 @@ interface ElevationFieldContext {
 interface TerrainQueryContext {
     cache: CpuTerrainCache;
     query: TerrainQuery;
+    /** Generic closed-surface query; `null` on flat surfaces. */
+    surfaceQuery: TerrainSurfaceQuery | null;
     /** Cube-sphere query; `null` unless the topology uses the cubeSphere projection. */
     sphereQuery: TerrainSphereQuery | null;
+    /** Buffer-shape identity (maxNodes/segments/projection kind); change recreates the cache. */
     shapeKey: string;
+    /**
+     * The projection these queries close over. Recreated on any geometry change
+     * (e.g. cube-sphere radius, torus major/minor); an identity change rebuilds
+     * the surface ops + queries so picks/markers stay in sync.
+     */
+    projection: SurfaceProjection;
 }
 /** Task refs for the standard terrain pipeline. */
 interface TerrainTasks {
@@ -819,15 +1078,7 @@ declare const createElevationFieldContextTask: _hello_terrain_work.Task<{
     attribute: StorageBufferAttribute;
     node: three_webgpu.StorageBufferNode;
 }, 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>;
+declare const tileNodesTask: _hello_terrain_work.Task<TileCompute, string, unknown>;
 /**
  * Root compute stage — generates elevation data and writes to the
  * elevation field storage buffer. Returns a single-element `ComputePipeline`.
@@ -908,7 +1159,7 @@ declare const elevationFn: _hello_terrain_work.ParamRef<ElevationCallback>;
  * (e.g. buffer resize), so this task stays cached during normal quadtree
  * updates — no unnecessary shader rebuilds.
  */
-declare const positionNodeTask: _hello_terrain_work.Task<three_src_nodes_TSL_js.ShaderCallNodeInternal, string, unknown>;
+declare const positionNodeTask: _hello_terrain_work.Task<three_webgpu.Node, string, unknown>;
 
 /**
  * Derives the terrain topology from `rootSize` and `origin`.
@@ -964,21 +1215,13 @@ declare const terrainTasks: {
     readonly gpuSpatialIndexUpload: _hello_terrain_work.Task<GpuSpatialIndexContext, string, unknown>;
     readonly createUniforms: _hello_terrain_work.Task<TerrainUniformsContext, string, unknown>;
     readonly updateUniforms: _hello_terrain_work.Task<TerrainUniformsContext, string, unknown>;
-    readonly positionNode: _hello_terrain_work.Task<three_src_nodes_TSL_js.ShaderCallNodeInternal, string, unknown>;
+    readonly positionNode: _hello_terrain_work.Task<three_webgpu.Node, string, unknown>;
     readonly createElevationFieldContext: _hello_terrain_work.Task<{
         data: Float32Array<ArrayBuffer>;
         attribute: three_webgpu.StorageBufferAttribute;
         node: three_webgpu.StorageBufferNode;
     }, 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>;
+    readonly createTileNodes: _hello_terrain_work.Task<TileCompute, string, unknown>;
     readonly createTerrainFieldTexture: _hello_terrain_work.Task<any, string, {
         renderer: WebGPURenderer;
     }>;
@@ -992,7 +1235,7 @@ declare const terrainTasks: {
         renderer: WebGPURenderer;
     }>;
     readonly tileBoundsContext: _hello_terrain_work.Task<TileBoundsContext & {
-        kernel: ReturnType<(elevationFieldNode: three_webgpu.StorageBufferNode, boundsNode: three_webgpu.StorageBufferNode, verticesPerNode: number) => three_webgpu.ComputeNode>;
+        kernel: ReturnType<(elevationFieldNode: three_webgpu.StorageBufferNode, boundsNode: three_webgpu.StorageBufferNode, verticesPerNode: number, edgeVertexCount: number) => three_webgpu.ComputeNode>;
     }, string, unknown>;
     readonly tileBoundsReduction: _hello_terrain_work.Task<any, string, {
         renderer: WebGPURenderer;
@@ -1012,35 +1255,29 @@ type ComputeDeviceLimits = {
 };
 declare function getDeviceComputeLimits(renderer: WebGPURenderer): ComputeDeviceLimits;
 
+/**
+ * Add the cube-sphere direction samplers to a base sampler. Called from the
+ * cube-sphere projection's `gpu.augmentSampler` hook.
+ */
+declare function augmentCubeSphereSampler(sampler: TerrainSampler, params: CreateTerrainSamplerParams): void;
 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;
-    originX: number;
-    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;
-};
+/**
+ * Generic closed-surface query, keyed on a world position projected onto the
+ * surface. Cube-sphere extends this with direction/lat-long keys.
+ */
+declare function createTerrainSurfaceQuery(cache: CpuTerrainCache): TerrainSurfaceQuery;
 
-type TerrainRaycastConfig = CpuRaycastConfig;
+/**
+ * Build a terrain raycaster that delegates the projection-specific marching to
+ * the active surface projection — no branching on a projection kind here.
+ */
 declare function createTerrainRaycast(params: {
+    getProjection: () => SurfaceProjection;
     getTerrainQuery: () => TerrainQuery | null;
+    getSurfaceQuery: () => TerrainSurfaceQuery | null;
     getSphereQuery: () => TerrainSphereQuery | null;
     getConfig: () => TerrainRaycastConfig;
 }): TerrainRaycast;
@@ -1159,5 +1396,31 @@ declare const voronoiCells: three_src_nodes_TSL_js.ShaderNodeFn<[three_tsl.Proxi
     uv: Node;
 }>]>;
 
-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 };
+/** Flat heightfield projection: tiles in the XZ plane, elevation along +Y. */
+declare function createFlatProjection(): SurfaceProjection;
+
+interface CubeSphereProjectionConfig {
+    radius: number;
+    center?: Vec3Like;
+    /** When true, elevation displaces inward and skirts point outward. */
+    invert?: boolean;
+}
+/** Cube-sphere projection: six faces wrapped radially onto a sphere. */
+declare function createCubeSphereProjection(config: CubeSphereProjectionConfig): SurfaceProjection;
+
+interface TorusProjectionConfig {
+    majorRadius: number;
+    minorRadius: number;
+    center?: Vec3Like;
+    /** When true, elevation displaces inward and skirts point outward. */
+    invert?: boolean;
+    /** Level-0 tile count along u before LOD subdivision (defaults to 1). */
+    baseU?: number;
+    /** Level-0 tile count along v before LOD subdivision (defaults to 1). */
+    baseV?: number;
+}
+/** Torus (donut) projection: a single closed surface periodic in both axes. */
+declare function createTorusProjection(config: TorusProjectionConfig): SurfaceProjection;
+
+export { ArrayTextureBackend, AtlasBackend, CUBE_FACES, CUBE_FACE_COUNT, Dir, TerrainGeometry, TerrainMesh, U32_EMPTY, allocLeafSet, allocSeamTable, augmentCubeSphereSampler, beginUpdate, blendAngleCorrectedNormals, buildLeafIndex, buildSeams2to1, compileComputeTask, createComputePipelineTasks, createCubeSphereProjection, createCubeSphereTopology, createElevationFieldContextTask, createFlatProjection, createFlatTopology, createInfiniteFlatTopology, createSpatialIndex, createState, createTerrainFieldStorage, createTerrainFieldTextureTask, createTerrainQuery, createTerrainRaycast, createTerrainSampler, createTerrainSamplerTask, createTerrainSurfaceQuery, createTerrainUniforms, createTorusProjection, createTorusTopology, 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, positionToTorusParams, quadtreeConfigTask, quadtreeUpdate, quadtreeUpdateTask, radius, resetLeafSet, resetSeamTable, rootSize, sampleTerrainField, sampleTerrainFieldElevation, skirtScale, sphereTangentFrameNormal, storeTerrainField, tangentFromAxis, terrainFieldFilter, terrainFieldStageTask, terrainGraph, terrainQueryTask, terrainRaycastTask, terrainReadbackTask, terrainTasks, textureSpaceToVectorSpace, tileNodesTask, topology, topologyTask, torusOutwardNormal, torusUVToPoint, unpackTangentNormal, update, updateUniformsTask, vElevation, vGlobalVertexIndex, vectorSpaceToTextureSpace, voronoiCells, wrap01 };
+export type { ComputePipeline, ComputeStageCallback, CpuSurfaceOps, CreateTerrainSamplerParams, CubeFace, CubeFaceBasis, CubeSphereProjectionConfig, CubeSphereTopologyConfig, ElevationCallback, ElevationFieldContext, ElevationParams, ElevationRange, ElevationRangeOut, FieldNormalContext, FieldNormalFn, FlatTopologyConfig, GpuSpatialIndexContext, InfiniteFlatTopologyConfig, IntNodeInput, LeafGpuBufferState, LeafSet, LeafStorageState, LodCriteria, LodMode, ProjectionKind, ProjectionRaycastContext, QuadtreeConfig, QuadtreeConfigState, QuadtreeState, RaycastOptions, RenderVertexPositionContext, RuntimeQueries, SeamTable, SpatialIndex, SurfaceKey, SurfaceNormalContext, SurfaceProjection, SurfaceProjectionCpu, SurfaceProjectionGpu, TerrainFieldStorage, TerrainFieldStorageBackendType, TerrainFieldStorageFormat, TerrainFieldStorageOptions, TerrainGraph, TerrainQuery, TerrainQueryContext, TerrainRaycast, TerrainRaycastConfig, TerrainRaycastResult, TerrainSample, TerrainSampleBatch, TerrainSampler, TerrainSphereQuery, TerrainSurfaceQuery, TerrainSurfaceSample, TerrainSurfaceSampleBatch, TerrainTasks, TerrainTile, TerrainTileBounds, TerrainUniformsContext, TerrainUniformsParams, TileBounds, TileElevationRangeFn, TileId, Topology, TorusProjectionConfig, TorusSurfaceParams, TorusTopologyConfig, UpdateParams, Vec3, Vec3Like, Vec3Mutable$1 as Vec3Mutable };