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

package/dist/index.cjs

@@ -1,7 +1,10 @@
 'use strict';
 
 const three = require('three');
+const webgpu = require('three/webgpu');
+const work = require('@hello-terrain/work');
 const tsl = require('three/tsl');
+const TSL_js = require('three/src/nodes/TSL.js');
 
 class TerrainGeometry extends three.BufferGeometry {
   constructor(innerSegments = 14, extendUV = false) {
@@ -61,17 +64,19 @@ class TerrainGeometry extends three.BufferGeometry {
    *  | / | \ | / | \ |
    *  o---o---o---o---o
    *
-   * INNER GRID (consistent diagonal, no rotational symmetry):
-   *        o---o---o
-   *        | \ | \ |
-   *        o---o---o
-   *        | \ | \ |
-   *        o---o---o
+   * INNER GRID (alternating diagonals — checkerboard pattern):
+   *        o---o---o---o---o
+   *        | \ | / | \ | / |
+   *        o---o---o---o---o
+   *        | / | \ | / | \ |
+   *        o---o---o---o---o
+   *        | \ | / | \ | / |
+   *        o---o---o---o---o
    *
    * Where o = vertex
    * Each square cell is split into 2 triangles.
    * - Skirt cells (outer ring): diagonal flip based on quadrant for corner correctness
-   * - Inner cells: consistent diagonal direction (all triangles "point" the same way)
+   * - Inner cells: alternating diagonal via (x+y)%2 to reduce interpolation artifacts
    *
    * Vertex layout (for innerSegments = 2):
    *
@@ -117,7 +122,7 @@ class TerrainGeometry extends three.BufferGeometry {
           const topHalf = y < mid;
           useDefaultDiagonal = leftHalf && topHalf || !leftHalf && !topHalf;
         } else {
-          useDefaultDiagonal = true;
+          useDefaultDiagonal = (x + y) % 2 === 0;
         }
         if (useDefaultDiagonal) {
           indices.push(a, d, b);
@@ -215,6 +220,2203 @@ class TerrainGeometry extends three.BufferGeometry {
   }
 }
 
+const defaultTerrainMeshParams = {
+  innerTileSegments: 14,
+  maxNodes: 1024,
+  material: new webgpu.MeshStandardNodeMaterial()
+};
+class TerrainMesh extends webgpu.InstancedMesh {
+  _innerTileSegments;
+  _maxNodes;
+  terrainRaycast = null;
+  constructor(params = defaultTerrainMeshParams) {
+    const mergedParams = { ...defaultTerrainMeshParams, ...params };
+    const { innerTileSegments, maxNodes, material } = mergedParams;
+    const geometry = new TerrainGeometry(innerTileSegments, true);
+    super(geometry, material, maxNodes);
+    this.frustumCulled = false;
+    this._innerTileSegments = innerTileSegments;
+    this._maxNodes = maxNodes;
+  }
+  get innerTileSegments() {
+    return this._innerTileSegments;
+  }
+  set innerTileSegments(tileSegments) {
+    const oldGeometry = this.geometry;
+    this.geometry = new TerrainGeometry(tileSegments, true);
+    this._innerTileSegments = tileSegments;
+    setTimeout(oldGeometry.dispose);
+  }
+  get maxNodes() {
+    return this._maxNodes;
+  }
+  set maxNodes(maxNodes) {
+    if (!Number.isInteger(maxNodes) || maxNodes < 1) {
+      throw new Error(`Invalid maxNodes: ${maxNodes}. Must be a positive integer.`);
+    }
+    if (maxNodes === this._maxNodes) return;
+    const oldMax = this._maxNodes;
+    const nextMatrix = new Float32Array(maxNodes * 16);
+    const oldMatrixArray = this.instanceMatrix.array;
+    nextMatrix.set(oldMatrixArray.subarray(0, Math.min(oldMatrixArray.length, nextMatrix.length)));
+    this.instanceMatrix = new webgpu.InstancedBufferAttribute(nextMatrix, 16);
+    if (this.instanceColor) {
+      const itemSize = this.instanceColor.itemSize;
+      const nextColor = new Float32Array(maxNodes * itemSize);
+      const oldColorArray = this.instanceColor.array;
+      nextColor.set(oldColorArray.subarray(0, Math.min(oldColorArray.length, nextColor.length)));
+      this.instanceColor = new webgpu.InstancedBufferAttribute(nextColor, itemSize);
+    }
+    this._maxNodes = maxNodes;
+    this.count = Math.min(this.count, maxNodes);
+    this.instanceMatrix.needsUpdate = true;
+    if (this.instanceColor) this.instanceColor.needsUpdate = true;
+    if (maxNodes < oldMax && this.count >= maxNodes) {
+      this.count = maxNodes;
+    }
+  }
+  raycast(raycaster, intersects) {
+    if (!this.terrainRaycast) {
+      super.raycast(raycaster, intersects);
+      return;
+    }
+    const result = this.terrainRaycast.pick(raycaster.ray);
+    if (!result) return;
+    intersects.push({
+      distance: result.distance,
+      point: result.position.clone(),
+      normal: result.normal.clone(),
+      object: this,
+      face: null,
+      faceIndex: -1
+    });
+  }
+}
+
+function getDeviceComputeLimits(renderer) {
+  const backend = renderer.backend;
+  const limits = backend?.device?.limits;
+  return {
+    maxWorkgroupSizeX: limits?.maxComputeWorkgroupSizeX ?? 256,
+    maxWorkgroupSizeY: limits?.maxComputeWorkgroupSizeY ?? 256,
+    maxWorkgroupInvocations: limits?.maxComputeWorkgroupInvocations ?? 256
+  };
+}
+
+const WORKGROUP_X = 16;
+const WORKGROUP_Y = 16;
+function compileComputePipeline(stages, width, options) {
+  const bindings = options?.bindings;
+  const preferredWorkgroup = options?.workgroupSize ?? [
+    WORKGROUP_X,
+    WORKGROUP_Y
+  ];
+  const preferSingleKernelWhenPossible = options?.preferSingleKernelWhenPossible ?? true;
+  const uInstanceCount = tsl.uniform(0, "uint");
+  let singleKernel;
+  const stagedKernelCache = /* @__PURE__ */ new Map();
+  function canRunSingleKernel(widthValue, limits) {
+    return widthValue <= limits.maxWorkgroupSizeX && widthValue <= limits.maxWorkgroupSizeY && widthValue * widthValue <= limits.maxWorkgroupInvocations;
+  }
+  function clampWorkgroupToLimits(requested, limits) {
+    let x = Math.max(1, Math.floor(requested[0]));
+    let y = Math.max(1, Math.floor(requested[1]));
+    x = Math.min(x, limits.maxWorkgroupSizeX);
+    y = Math.min(y, limits.maxWorkgroupSizeY);
+    y = Math.min(
+      y,
+      Math.max(1, Math.floor(limits.maxWorkgroupInvocations / x))
+    );
+    x = Math.min(
+      x,
+      Math.max(1, Math.floor(limits.maxWorkgroupInvocations / y))
+    );
+    return [x, y];
+  }
+  function buildSingleKernel(workgroupSize) {
+    return tsl.Fn(() => {
+      bindings?.forEach((b) => b.toVar());
+      const fWidth = tsl.float(width);
+      const activeIndex = tsl.globalId.z;
+      const nodeIndex = tsl.int(activeIndex).toVar();
+      const iWidth = tsl.int(width);
+      const ix = tsl.int(tsl.globalId.x);
+      const iy = tsl.int(tsl.globalId.y);
+      const texelSize = tsl.vec2(1, 1).div(fWidth);
+      const localCoordinates = tsl.vec2(tsl.globalId.x, tsl.globalId.y);
+      const localUVCoords = localCoordinates.div(fWidth);
+      const verticesPerNode = iWidth.mul(iWidth);
+      const globalIndex = tsl.int(nodeIndex).mul(verticesPerNode).add(iy.mul(iWidth).add(ix));
+      const inBounds = ix.lessThan(iWidth).and(iy.lessThan(iWidth)).and(tsl.uint(activeIndex).lessThan(uInstanceCount)).toVar();
+      for (let i = 0; i < stages.length; i++) {
+        if (i > 0) {
+          tsl.workgroupBarrier();
+        }
+        tsl.If(inBounds, () => {
+          stages[i](
+            nodeIndex,
+            globalIndex,
+            localUVCoords,
+            localCoordinates,
+            texelSize
+          );
+        });
+      }
+    })().computeKernel(workgroupSize);
+  }
+  function buildStagedKernels(workgroupSize) {
+    return stages.map(
+      (stage) => tsl.Fn(() => {
+        bindings?.forEach((b) => b.toVar());
+        const fWidth = tsl.float(width);
+        const activeIndex = tsl.globalId.z;
+        const nodeIndex = tsl.int(activeIndex).toVar();
+        const iWidth = tsl.int(width);
+        const ix = tsl.int(tsl.globalId.x);
+        const iy = tsl.int(tsl.globalId.y);
+        const texelSize = tsl.vec2(1, 1).div(fWidth);
+        const localCoordinates = tsl.vec2(tsl.globalId.x, tsl.globalId.y);
+        const localUVCoords = localCoordinates.div(fWidth);
+        const verticesPerNode = iWidth.mul(iWidth);
+        const globalIndex = tsl.int(nodeIndex).mul(verticesPerNode).add(iy.mul(iWidth).add(ix));
+        const inBounds = ix.lessThan(iWidth).and(iy.lessThan(iWidth)).and(tsl.uint(activeIndex).lessThan(uInstanceCount)).toVar();
+        tsl.If(inBounds, () => {
+          stage(
+            nodeIndex,
+            globalIndex,
+            localUVCoords,
+            localCoordinates,
+            texelSize
+          );
+        });
+      })().computeKernel(workgroupSize)
+    );
+  }
+  function execute(renderer, instanceCount) {
+    const limits = getDeviceComputeLimits(renderer);
+    const canUseSingleKernel = preferSingleKernelWhenPossible && canRunSingleKernel(width, limits);
+    uInstanceCount.value = instanceCount;
+    if (canUseSingleKernel) {
+      if (!singleKernel) {
+        singleKernel = buildSingleKernel([width, width, 1]);
+      }
+      renderer.compute(singleKernel, [1, 1, instanceCount]);
+      return;
+    }
+    const [workgroupX, workgroupY] = clampWorkgroupToLimits(
+      preferredWorkgroup,
+      limits
+    );
+    const cacheKey = `${workgroupX}x${workgroupY}`;
+    let stagedKernels = stagedKernelCache.get(cacheKey);
+    if (!stagedKernels) {
+      stagedKernels = buildStagedKernels([workgroupX, workgroupY, 1]);
+      stagedKernelCache.set(cacheKey, stagedKernels);
+    }
+    const dispatchX = Math.ceil(width / workgroupX);
+    const dispatchY = Math.ceil(width / workgroupY);
+    for (const kernel of stagedKernels) {
+      renderer.compute(kernel, [dispatchX, dispatchY, instanceCount]);
+    }
+  }
+  return { execute };
+}
+
+function resolveType(format) {
+  return format === "rgba16float" ? three.HalfFloatType : three.FloatType;
+}
+function resolveFilter(mode) {
+  return mode === "linear" ? three.LinearFilter : three.NearestFilter;
+}
+function configureStorageTexture(texture2, format, filter) {
+  texture2.format = three.RGBAFormat;
+  texture2.type = resolveType(format);
+  texture2.magFilter = resolveFilter(filter);
+  texture2.minFilter = resolveFilter(filter);
+  texture2.wrapS = three.ClampToEdgeWrapping;
+  texture2.wrapT = three.ClampToEdgeWrapping;
+  texture2.generateMipmaps = false;
+  texture2.needsUpdate = true;
+}
+function ArrayTextureBackend(edgeVertexCount, tileCount, options) {
+  let currentEdgeVertexCount = edgeVertexCount;
+  let currentTileCount = tileCount;
+  const tex = new webgpu.StorageArrayTexture(
+    edgeVertexCount,
+    edgeVertexCount,
+    tileCount
+  );
+  configureStorageTexture(tex, options.format, options.filter);
+  return {
+    backendType: "array-texture",
+    get edgeVertexCount() {
+      return currentEdgeVertexCount;
+    },
+    get tileCount() {
+      return currentTileCount;
+    },
+    texture: tex,
+    uv(ix, iy, _tileIndex) {
+      return tsl.vec2(ix.toFloat(), iy.toFloat());
+    },
+    texel(ix, iy, tileIndex) {
+      return tsl.ivec3(ix, iy, tileIndex);
+    },
+    sample(u, v, tileIndex) {
+      return tsl.texture(tex, tsl.vec2(u, v)).depth(tsl.int(tileIndex));
+    },
+    resize(width, height, nextTileCount) {
+      currentEdgeVertexCount = width;
+      currentTileCount = nextTileCount;
+      tex.setSize(width, height, nextTileCount);
+      tex.needsUpdate = true;
+    }
+  };
+}
+function atlasCoord(tilesPerRow, edgeVertexCount, ix, iy, tileIndex) {
+  const tilesPerRowNode = tsl.int(tilesPerRow);
+  const edge = tsl.int(edgeVertexCount);
+  const tile = tsl.int(tileIndex);
+  const col = tile.mod(tilesPerRowNode);
+  const row = tile.div(tilesPerRowNode);
+  const atlasX = col.mul(edge).add(tsl.int(ix));
+  const atlasY = row.mul(edge).add(tsl.int(iy));
+  return { atlasX, atlasY };
+}
+function AtlasBackend(edgeVertexCount, tileCount, options) {
+  let currentEdgeVertexCount = edgeVertexCount;
+  let currentTileCount = tileCount;
+  let tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(tileCount)));
+  const atlasSize = tilesPerRow * edgeVertexCount;
+  const tex = new webgpu.StorageTexture(atlasSize, atlasSize);
+  configureStorageTexture(tex, options.format, options.filter);
+  return {
+    backendType: "atlas",
+    get edgeVertexCount() {
+      return currentEdgeVertexCount;
+    },
+    get tileCount() {
+      return currentTileCount;
+    },
+    texture: tex,
+    uv(ix, iy, tileIndex) {
+      const { atlasX, atlasY } = atlasCoord(
+        tilesPerRow,
+        currentEdgeVertexCount,
+        ix,
+        iy,
+        tileIndex
+      );
+      const currentAtlasSize = tsl.float(tilesPerRow * currentEdgeVertexCount);
+      return tsl.vec2(
+        atlasX.toFloat().add(0.5).div(currentAtlasSize),
+        atlasY.toFloat().add(0.5).div(currentAtlasSize)
+      );
+    },
+    texel(ix, iy, tileIndex) {
+      const { atlasX, atlasY } = atlasCoord(
+        tilesPerRow,
+        currentEdgeVertexCount,
+        ix,
+        iy,
+        tileIndex
+      );
+      return tsl.ivec2(atlasX, atlasY);
+    },
+    sample(u, v, tileIndex) {
+      const tile = tsl.int(tileIndex);
+      const tilesPerRowNode = tsl.int(tilesPerRow);
+      const col = tile.mod(tilesPerRowNode);
+      const row = tile.div(tilesPerRowNode);
+      const invTilesPerRow = tsl.float(1 / tilesPerRow);
+      const atlasU = col.toFloat().add(u).mul(invTilesPerRow);
+      const atlasV = row.toFloat().add(v).mul(invTilesPerRow);
+      return tsl.texture(tex, tsl.vec2(atlasU, atlasV));
+    },
+    resize(width, height, nextTileCount) {
+      currentEdgeVertexCount = width;
+      currentTileCount = nextTileCount;
+      tilesPerRow = Math.max(1, Math.ceil(Math.sqrt(nextTileCount)));
+      const nextAtlasSize = tilesPerRow * width;
+      const image = tex.image;
+      image.width = nextAtlasSize;
+      image.height = nextAtlasSize;
+      tex.needsUpdate = true;
+    }
+  };
+}
+function Texture3DBackend(edgeVertexCount, tileCount, options) {
+  let currentEdgeVertexCount = edgeVertexCount;
+  let currentTileCount = tileCount;
+  const tex = new webgpu.StorageArrayTexture(
+    edgeVertexCount,
+    edgeVertexCount,
+    tileCount
+  );
+  configureStorageTexture(tex, options.format, options.filter);
+  return {
+    backendType: "texture-3d",
+    get edgeVertexCount() {
+      return currentEdgeVertexCount;
+    },
+    get tileCount() {
+      return currentTileCount;
+    },
+    texture: tex,
+    uv(ix, iy, _tileIndex) {
+      return tsl.vec2(ix.toFloat(), iy.toFloat());
+    },
+    texel(ix, iy, tileIndex) {
+      return tsl.ivec3(ix, iy, tileIndex);
+    },
+    sample(u, v, tileIndex) {
+      return tsl.texture(tex, tsl.vec2(u, v)).depth(tsl.int(tileIndex));
+    },
+    resize(width, height, nextTileCount) {
+      currentEdgeVertexCount = width;
+      currentTileCount = nextTileCount;
+      tex.setSize(width, height, nextTileCount);
+      tex.needsUpdate = true;
+    }
+  };
+}
+function tryGetDeviceLimits(renderer) {
+  const backend = renderer;
+  return backend.backend?.device?.limits ?? {};
+}
+function createTerrainFieldStorage(edgeVertexCount, tileCount, renderer, options = {}) {
+  const filter = options.filter ?? "linear";
+  const format = options.format ?? "rgba16float";
+  const forcedBackend = options.backend;
+  if (forcedBackend === "atlas") {
+    return AtlasBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  if (forcedBackend === "texture-3d") {
+    return Texture3DBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  if (forcedBackend === "array-texture") {
+    return ArrayTextureBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  const DEFAULT_MAX_TEXTURE_ARRAY_LAYERS = 256;
+  const maxLayers = renderer ? tryGetDeviceLimits(renderer).maxTextureArrayLayers ?? DEFAULT_MAX_TEXTURE_ARRAY_LAYERS : DEFAULT_MAX_TEXTURE_ARRAY_LAYERS;
+  if (tileCount > maxLayers) {
+    return AtlasBackend(edgeVertexCount, tileCount, { filter, format });
+  }
+  return ArrayTextureBackend(edgeVertexCount, tileCount, { filter, format });
+}
+function storeTerrainField(storage, ix, iy, tileIndex, value) {
+  if (storage.backendType === "array-texture" || storage.backendType === "texture-3d") {
+    return tsl.textureStore(
+      storage.texture,
+      tsl.uvec3(tsl.int(ix), tsl.int(iy), tsl.int(tileIndex)),
+      value
+    );
+  }
+  return tsl.textureStore(storage.texture, storage.texel(ix, iy, tileIndex), value);
+}
+function loadTerrainField(storage, ix, iy, tileIndex) {
+  if (storage.backendType === "array-texture" || storage.backendType === "texture-3d") {
+    return tsl.textureLoad(storage.texture, tsl.ivec2(tsl.int(ix), tsl.int(iy)), tsl.int(0)).depth(
+      tsl.int(tileIndex)
+    );
+  }
+  return tsl.textureLoad(storage.texture, storage.texel(ix, iy, tileIndex), tsl.int(0));
+}
+function loadTerrainFieldElevation(storage, ix, iy, tileIndex) {
+  return loadTerrainField(storage, ix, iy, tileIndex).r;
+}
+function loadTerrainFieldNormal(storage, ix, iy, tileIndex) {
+  const raw = loadTerrainField(storage, ix, iy, tileIndex);
+  return tsl.vec2(raw.g, raw.b);
+}
+function sampleTerrainField(storage, u, v, tileIndex) {
+  return storage.sample(u, v, tileIndex);
+}
+function sampleTerrainFieldElevation(storage, u, v, tileIndex) {
+  return sampleTerrainField(storage, u, v, tileIndex).r;
+}
+function sampleTerrainFieldNormal(storage, u, v, tileIndex) {
+  const raw = sampleTerrainField(storage, u, v, tileIndex);
+  return tsl.vec2(raw.g, raw.b);
+}
+function packTerrainFieldSample(height, normalXZ, extra = tsl.float(0)) {
+  return tsl.vec4(height, normalXZ.x, normalXZ.y, extra);
+}
+
+const createElevation = (tile, uniforms, elevationFn) => {
+  return function perVertexElevation(nodeIndex, localCoordinates) {
+    const ix = tsl.int(localCoordinates.x);
+    const iy = tsl.int(localCoordinates.y);
+    const edgeVertexCount = uniforms.uInnerTileSegments.toVar().add(tsl.int(3));
+    const tileUV = localCoordinates.toFloat().div(edgeVertexCount.toFloat());
+    const rootUV = tile.rootUVCompute(nodeIndex, ix, iy);
+    const worldPosition = tile.tileVertexWorldPositionCompute(nodeIndex, ix, iy).setName("worldPositionWithSkirt");
+    const rootSize = uniforms.uRootSize.toVar();
+    return elevationFn({
+      worldPosition,
+      rootSize,
+      rootUV,
+      tileOriginVec2: tile.tileOriginVec2(nodeIndex),
+      tileSize: tile.tileSize(nodeIndex),
+      tileLevel: tile.tileLevel(nodeIndex),
+      nodeIndex: tsl.int(nodeIndex),
+      tileUV
+    });
+  };
+};
+
+function createTileCompute(leafStorage, uniforms) {
+  const tileLevel = tsl.Fn(([nodeIndex]) => {
+    const nodeOffset = nodeIndex.mul(tsl.int(4));
+    return leafStorage.node.element(nodeOffset).toInt();
+  });
+  const tileOriginVec2 = tsl.Fn(([nodeIndex]) => {
+    const nodeOffset = nodeIndex.mul(tsl.int(4));
+    const nodeX = leafStorage.node.element(nodeOffset.add(tsl.int(1))).toFloat();
+    const nodeY = leafStorage.node.element(nodeOffset.add(tsl.int(2))).toFloat();
+    return tsl.vec2(nodeX, nodeY);
+  });
+  const tileSize = tsl.Fn(([nodeIndex]) => {
+    const rootSize = uniforms.uRootSize.toVar();
+    const level = tileLevel(nodeIndex);
+    return tsl.float(rootSize).div(tsl.pow(tsl.float(2), level.toFloat()));
+  });
+  const rootUVCompute = tsl.Fn(([nodeIndex, ix, iy]) => {
+    const nodeVec2 = tileOriginVec2(nodeIndex);
+    const nodeX = nodeVec2.x;
+    const nodeY = nodeVec2.y;
+    const rootSize = uniforms.uRootSize.toVar();
+    const rootOrigin = uniforms.uRootOrigin.toVar();
+    const size = tileSize(nodeIndex);
+    const half = tsl.float(0.5);
+    const halfRoot = tsl.float(rootSize).mul(half);
+    const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
+    const texelSpacing = size.div(fInnerSegments);
+    const absX = nodeX.mul(fInnerSegments).add(tsl.int(ix).toFloat().sub(tsl.float(1)));
+    const absY = nodeY.mul(fInnerSegments).add(tsl.int(iy).toFloat().sub(tsl.float(1)));
+    const worldX = rootOrigin.x.add(absX.mul(texelSpacing)).sub(halfRoot);
+    const worldZ = rootOrigin.z.add(absY.mul(texelSpacing)).sub(halfRoot);
+    const centeredX = worldX.sub(rootOrigin.x);
+    const centeredZ = worldZ.sub(rootOrigin.z);
+    return tsl.vec2(
+      centeredX.div(rootSize).add(half),
+      centeredZ.div(rootSize).mul(tsl.float(-1)).add(half)
+    );
+  });
+  const tileVertexWorldPositionCompute = tsl.Fn(
+    ([nodeIndex, ix, iy]) => {
+      const rootOrigin = uniforms.uRootOrigin.toVar();
+      const nodeVec2 = tileOriginVec2(nodeIndex);
+      const nodeX = nodeVec2.x;
+      const nodeY = nodeVec2.y;
+      const rootSize = uniforms.uRootSize.toVar();
+      const size = tileSize(nodeIndex);
+      const half = tsl.float(0.5);
+      const halfRoot = tsl.float(rootSize).mul(half);
+      const fInnerSegments = uniforms.uInnerTileSegments.toVar().toFloat();
+      const texelSpacing = size.div(fInnerSegments);
+      const absX = nodeX.mul(fInnerSegments).add(tsl.int(ix).toFloat().sub(tsl.float(1)));
+      const absY = nodeY.mul(fInnerSegments).add(tsl.int(iy).toFloat().sub(tsl.float(1)));
+      const worldX = rootOrigin.x.add(absX.mul(texelSpacing)).sub(halfRoot);
+      const worldZ = rootOrigin.z.add(absY.mul(texelSpacing)).sub(halfRoot);
+      return tsl.vec3(worldX, rootOrigin.y, worldZ);
+    }
+  );
+  return {
+    tileLevel,
+    tileOriginVec2,
+    tileSize,
+    rootUVCompute,
+    tileVertexWorldPositionCompute
+  };
+}
+function tileLocalToFieldUV$1(localCoord, innerSegments) {
+  const edge = tsl.float(innerSegments).add(tsl.float(3));
+  return tsl.float(localCoord).mul(tsl.float(innerSegments)).add(tsl.float(1.5)).div(edge);
+}
+
+const rootSize = work.param(256).displayName("rootSize");
+const origin = work.param({
+  x: 0,
+  y: 0,
+  z: 0
+}).displayName("origin");
+const innerTileSegments = work.param(13).displayName("innerTileSegments");
+const skirtScale = work.param(100).displayName("skirtScale");
+const elevationScale = work.param(1).displayName("elevationScale");
+const maxNodes = work.param(1024).displayName("maxNodes");
+const maxLevel = work.param(16).displayName("maxLevel");
+const quadtreeUpdate = work.param({
+  cameraOrigin: { x: 0, y: 0, z: 0 },
+  mode: "distance",
+  distanceFactor: 1.5
+}).displayName("quadtreeUpdate");
+const surface = work.param(null).displayName("surface");
+const terrainFieldFilter = work.param("linear").displayName("terrainFieldFilter");
+const elevationFn = work.param(() => tsl.float(0));
+
+function createLeafStorage(maxNodes) {
+  const data = new Int32Array(maxNodes * 4);
+  const attribute = new webgpu.StorageBufferAttribute(data, 4);
+  const node = tsl.storage(attribute, "i32", 1).toReadOnly().setName("leafStorage");
+  return { data, attribute, node };
+}
+
+const Dir = {
+  LEFT: 0,
+  RIGHT: 1,
+  TOP: 2,
+  BOTTOM: 3
+};
+const U32_EMPTY = 4294967295;
+function allocLeafSet(capacity) {
+  return {
+    capacity,
+    count: 0,
+    space: new Uint8Array(capacity),
+    level: new Uint8Array(capacity),
+    x: new Int32Array(capacity),
+    y: new Int32Array(capacity)
+  };
+}
+function resetLeafSet(leaves) {
+  leaves.count = 0;
+}
+function allocSeamTable(capacity) {
+  return {
+    capacity,
+    count: 0,
+    stride: 8,
+    neighbors: new Uint32Array(capacity * 8)
+  };
+}
+function resetSeamTable(seams) {
+  seams.count = 0;
+}
+
+function createNodeStore(maxNodes, spaceCount) {
+  return {
+    maxNodes,
+    nodesUsed: 0,
+    currentGen: 1,
+    gen: new Uint16Array(maxNodes),
+    space: new Uint8Array(maxNodes),
+    level: new Uint8Array(maxNodes),
+    x: new Int32Array(maxNodes),
+    y: new Int32Array(maxNodes),
+    firstChild: new Uint32Array(maxNodes),
+    flags: new Uint8Array(maxNodes),
+    roots: new Uint32Array(spaceCount)
+  };
+}
+function beginFrame(store) {
+  store.nodesUsed = 0;
+  store.currentGen = store.currentGen + 1 & 65535;
+  if (store.currentGen === 0) {
+    store.gen.fill(0);
+    store.currentGen = 1;
+  }
+}
+function allocNode(store, tile) {
+  const id = store.nodesUsed;
+  if (id >= store.maxNodes) return U32_EMPTY;
+  store.nodesUsed = id + 1;
+  store.gen[id] = store.currentGen;
+  store.space[id] = tile.space;
+  store.level[id] = tile.level;
+  store.x[id] = tile.x;
+  store.y[id] = tile.y;
+  store.firstChild[id] = U32_EMPTY;
+  store.flags[id] = 0;
+  return id;
+}
+function hasChildren(store, nodeId) {
+  return store.firstChild[nodeId] !== U32_EMPTY;
+}
+function ensureChildren(store, parentId) {
+  const existing = store.firstChild[parentId];
+  if (existing !== U32_EMPTY) return existing;
+  const childBase = store.nodesUsed;
+  if (childBase + 4 > store.maxNodes) return U32_EMPTY;
+  const space = store.space[parentId];
+  const level = store.level[parentId] + 1;
+  const px = store.x[parentId] << 1;
+  const py = store.y[parentId] << 1;
+  allocNode(store, { space, level, x: px, y: py });
+  allocNode(store, { space, level, x: px + 1, y: py });
+  allocNode(store, { space, level, x: px, y: py + 1 });
+  allocNode(store, { space, level, x: px + 1, y: py + 1 });
+  store.firstChild[parentId] = childBase;
+  return childBase;
+}
+
+function nextPow2$1(n) {
+  let x = 1;
+  while (x < n) x <<= 1;
+  return x;
+}
+function mix32$1(x) {
+  x >>>= 0;
+  x ^= x >>> 16;
+  x = Math.imul(x, 2146121005) >>> 0;
+  x ^= x >>> 15;
+  x = Math.imul(x, 2221713035) >>> 0;
+  x ^= x >>> 16;
+  return x >>> 0;
+}
+function hashKey$1(space, level, x, y) {
+  const h = space & 255 ^ (level & 255) << 8 ^ mix32$1(x) >>> 0 ^ mix32$1(y) >>> 0;
+  return mix32$1(h);
+}
+function createSpatialIndex(maxEntries) {
+  const size = nextPow2$1(Math.max(2, maxEntries * 2));
+  return {
+    size,
+    mask: size - 1,
+    stampGen: 1,
+    stamp: new Uint16Array(size),
+    keysSpace: new Uint8Array(size),
+    keysLevel: new Uint8Array(size),
+    keysX: new Uint32Array(size),
+    keysY: new Uint32Array(size),
+    values: new Uint32Array(size)
+  };
+}
+function resetSpatialIndex(index) {
+  index.stampGen = index.stampGen + 1 & 65535;
+  if (index.stampGen === 0) {
+    index.stamp.fill(0);
+    index.stampGen = 1;
+  }
+}
+function insertSpatialIndexRaw(index, space, level, x, y, value) {
+  const s = space & 255;
+  const l = level & 255;
+  const xx = x >>> 0;
+  const yy = y >>> 0;
+  let slot = hashKey$1(s, l, xx, yy) & index.mask;
+  for (let probes = 0; probes < index.size; probes++) {
+    if (index.stamp[slot] !== index.stampGen) {
+      index.stamp[slot] = index.stampGen;
+      index.keysSpace[slot] = s;
+      index.keysLevel[slot] = l;
+      index.keysX[slot] = xx;
+      index.keysY[slot] = yy;
+      index.values[slot] = value >>> 0;
+      return;
+    }
+    if (index.keysSpace[slot] === s && index.keysLevel[slot] === l && index.keysX[slot] === xx && index.keysY[slot] === yy) {
+      index.values[slot] = value >>> 0;
+      return;
+    }
+    slot = slot + 1 & index.mask;
+  }
+  throw new Error("SpatialIndex is full (no empty slot found).");
+}
+function lookupSpatialIndexRaw(index, space, level, x, y) {
+  const s = space & 255;
+  const l = level & 255;
+  const xx = x >>> 0;
+  const yy = y >>> 0;
+  let slot = hashKey$1(s, l, xx, yy) & index.mask;
+  for (let probes = 0; probes < index.size; probes++) {
+    if (index.stamp[slot] !== index.stampGen) return U32_EMPTY;
+    if (index.keysSpace[slot] === s && index.keysLevel[slot] === l && index.keysX[slot] === xx && index.keysY[slot] === yy) {
+      return index.values[slot];
+    }
+    slot = slot + 1 & index.mask;
+  }
+  return U32_EMPTY;
+}
+
+function buildLeafIndex(leaves, out) {
+  const index = out ?? createSpatialIndex(leaves.count);
+  resetSpatialIndex(index);
+  for (let i = 0; i < leaves.count; i++) {
+    insertSpatialIndexRaw(index, leaves.space[i], leaves.level[i], leaves.x[i], leaves.y[i], i);
+  }
+  return index;
+}
+
+function createState(cfg, surface) {
+  const store = createNodeStore(cfg.maxNodes, surface.spaceCount);
+  const scratchRootTiles = [];
+  for (let i = 0; i < surface.maxRootCount; i++) {
+    scratchRootTiles.push({ space: 0, level: 0, x: 0, y: 0 });
+  }
+  return {
+    cfg,
+    store,
+    leaves: allocLeafSet(cfg.maxNodes),
+    leafNodeIds: new Uint32Array(cfg.maxNodes),
+    leafIndex: createSpatialIndex(cfg.maxNodes),
+    stack: new Uint32Array(cfg.maxNodes),
+    rootNodeIds: new Uint32Array(surface.maxRootCount),
+    rootCount: 0,
+    splitQueue: new Uint32Array(cfg.maxNodes),
+    splitStamp: new Uint16Array(cfg.maxNodes),
+    splitGen: 1,
+    scratchTile: { space: 0, level: 0, x: 0, y: 0 },
+    scratchNeighbor: { space: 0, level: 0, x: 0, y: 0 },
+    scratchBounds: { cx: 0, cy: 0, cz: 0, r: 0 },
+    scratchRootTiles,
+    spaceCount: surface.spaceCount
+  };
+}
+function beginUpdate(state, surface, params) {
+  if (surface.spaceCount !== state.spaceCount) {
+    throw new Error(
+      `Surface spaceCount changed (${state.spaceCount} -> ${surface.spaceCount}). Create a new quadtree state.`
+    );
+  }
+  if (surface.maxRootCount !== state.rootNodeIds.length) {
+    throw new Error(
+      `Surface maxRootCount changed (${state.rootNodeIds.length} -> ${surface.maxRootCount}). Create a new quadtree state.`
+    );
+  }
+  beginFrame(state.store);
+  state.rootCount = 0;
+  const rootCount = surface.rootTiles(params.cameraOrigin, state.scratchRootTiles);
+  if (rootCount < 0 || rootCount > surface.maxRootCount) {
+    throw new Error(`Surface returned invalid root count (${rootCount}).`);
+  }
+  for (let i = 0; i < rootCount; i++) {
+    const rootId = allocNode(state.store, state.scratchRootTiles[i]);
+    if (rootId === U32_EMPTY) {
+      throw new Error("Failed to allocate root node (maxNodes too small).");
+    }
+    state.rootNodeIds[i] = rootId;
+    state.rootCount = i + 1;
+  }
+}
+
+function shouldSplit(bounds, level, maxLevel, params) {
+  if (level >= maxLevel) return false;
+  const mode = params.mode ?? "distance";
+  const cx = bounds.cx;
+  const cy = bounds.cy;
+  const cz = bounds.cz;
+  const distSq = cx * cx + cy * cy + cz * cz;
+  const safeDistSq = distSq > 1e-12 ? distSq : 1e-12;
+  if (mode === "screen") {
+    const proj = params.projectionFactor ?? 0;
+    const target = params.targetPixels ?? 0;
+    if (proj <= 0 || target <= 0) {
+      const f2 = params.distanceFactor ?? 2;
+      const threshold2 = bounds.r * f2;
+      return safeDistSq < threshold2 * threshold2;
+    }
+    const left = bounds.r * bounds.r * proj * proj;
+    const right = safeDistSq * target * target;
+    return left > right;
+  }
+  const f = params.distanceFactor ?? 2;
+  const threshold = bounds.r * f;
+  return safeDistSq < threshold * threshold;
+}
+
+function refineLeaves(state, surface, params, outLeaves) {
+  const leaves = outLeaves ?? state.leaves;
+  resetLeafSet(leaves);
+  const store = state.store;
+  const stack = state.stack;
+  let sp = 0;
+  for (let i = 0; i < state.rootCount; i++) {
+    stack[sp++] = state.rootNodeIds[i];
+  }
+  while (sp > 0) {
+    const nodeId = stack[--sp];
+    const level = store.level[nodeId];
+    const space = store.space[nodeId];
+    const x = store.x[nodeId];
+    const y = store.y[nodeId];
+    const tile = state.scratchTile;
+    tile.space = space;
+    tile.level = level;
+    tile.x = x;
+    tile.y = y;
+    const bounds = state.scratchBounds;
+    surface.tileBounds(tile, params.cameraOrigin, bounds);
+    if (hasChildren(store, nodeId)) {
+      const base = store.firstChild[nodeId];
+      stack[sp++] = base + 3;
+      stack[sp++] = base + 2;
+      stack[sp++] = base + 1;
+      stack[sp++] = base + 0;
+      continue;
+    }
+    const split = shouldSplit(bounds, level, state.cfg.maxLevel, params);
+    if (split) {
+      const base = ensureChildren(store, nodeId);
+      if (base !== U32_EMPTY) {
+        stack[sp++] = base + 3;
+        stack[sp++] = base + 2;
+        stack[sp++] = base + 1;
+        stack[sp++] = base + 0;
+        continue;
+      }
+    }
+    const i = leaves.count;
+    if (i >= leaves.capacity) {
+      throw new Error("LeafSet capacity exceeded.");
+    }
+    leaves.space[i] = space;
+    leaves.level[i] = level;
+    leaves.x[i] = x;
+    leaves.y[i] = y;
+    state.leafNodeIds[i] = nodeId;
+    leaves.count = i + 1;
+  }
+  return leaves;
+}
+
+function resetSplitMarks(state) {
+  state.splitGen = state.splitGen + 1 & 65535;
+  if (state.splitGen === 0) {
+    state.splitStamp.fill(0);
+    state.splitGen = 1;
+  }
+}
+function scheduleSplit(state, nodeId, count) {
+  if (nodeId === U32_EMPTY) return count;
+  if (state.splitStamp[nodeId] === state.splitGen) return count;
+  state.splitStamp[nodeId] = state.splitGen;
+  state.splitQueue[count] = nodeId;
+  return count + 1;
+}
+function balance2to1(state, surface, params, leaves) {
+  const maxIters = state.cfg.maxLevel + 1;
+  for (let iter = 0; iter < maxIters; iter++) {
+    const index = buildLeafIndex(leaves, state.leafIndex);
+    resetSplitMarks(state);
+    let splitCount = 0;
+    for (let i = 0; i < leaves.count; i++) {
+      const leafLevel = leaves.level[i];
+      if (leafLevel < 2) continue;
+      const leafSpace = leaves.space[i];
+      const leafX = leaves.x[i];
+      const leafY = leaves.y[i];
+      for (let dir = 0; dir < 4; dir++) {
+        for (let candidateLevel = leafLevel - 2; candidateLevel >= 0; candidateLevel--) {
+          const shift = leafLevel - candidateLevel;
+          const tile = state.scratchTile;
+          tile.space = leafSpace;
+          tile.level = candidateLevel;
+          tile.x = leafX >>> shift;
+          tile.y = leafY >>> shift;
+          const neighbor = state.scratchNeighbor;
+          if (!surface.neighborSameLevel(tile, dir, neighbor)) break;
+          const j = lookupSpatialIndexRaw(
+            index,
+            neighbor.space,
+            neighbor.level,
+            neighbor.x,
+            neighbor.y
+          );
+          if (j !== U32_EMPTY) {
+            splitCount = scheduleSplit(state, state.leafNodeIds[j], splitCount);
+            break;
+          }
+        }
+      }
+    }
+    if (splitCount === 0) return leaves;
+    let anySplit = false;
+    for (let k = 0; k < splitCount; k++) {
+      const nodeId = state.splitQueue[k];
+      if (state.store.level[nodeId] >= state.cfg.maxLevel) continue;
+      const base = ensureChildren(state.store, nodeId);
+      if (base !== U32_EMPTY) anySplit = true;
+    }
+    if (!anySplit) return leaves;
+    refineLeaves(state, surface, params, leaves);
+  }
+  return leaves;
+}
+
+function update(state, surface, params, outLeaves) {
+  const origY = params.cameraOrigin.y;
+  params.cameraOrigin.y -= params.elevationAtCameraXZ ?? 0;
+  beginUpdate(state, surface, params);
+  const leaves = refineLeaves(state, surface, params, outLeaves);
+  const result = balance2to1(state, surface, params, leaves);
+  params.cameraOrigin.y = origY;
+  return result;
+}
+
+const scratchTile = { space: 0, level: 0, x: 0, y: 0 };
+const scratchNbr = { space: 0, level: 0, x: 0, y: 0 };
+const scratchParentTile = { space: 0, level: 0, x: 0, y: 0 };
+const scratchParentNbr = { space: 0, level: 0, x: 0, y: 0 };
+function buildSeams2to1(surface, leaves, outSeams, outIndex) {
+  if (outSeams.capacity < leaves.count) {
+    throw new Error("SeamTable capacity is smaller than LeafSet.count.");
+  }
+  const index = buildLeafIndex(leaves, outIndex);
+  outSeams.count = leaves.count;
+  const neighbors = outSeams.neighbors;
+  for (let i = 0; i < leaves.count; i++) {
+    const base = i * 8;
+    const space = leaves.space[i];
+    const level = leaves.level[i];
+    const x = leaves.x[i];
+    const y = leaves.y[i];
+    for (let dir = 0; dir < 4; dir++) {
+      const outOffset = base + dir * 2;
+      neighbors[outOffset + 0] = U32_EMPTY;
+      neighbors[outOffset + 1] = U32_EMPTY;
+      scratchTile.space = space;
+      scratchTile.level = level;
+      scratchTile.x = x;
+      scratchTile.y = y;
+      if (!surface.neighborSameLevel(scratchTile, dir, scratchNbr)) continue;
+      let j = lookupSpatialIndexRaw(index, scratchNbr.space, scratchNbr.level, scratchNbr.x, scratchNbr.y);
+      if (j !== U32_EMPTY) {
+        neighbors[outOffset + 0] = j;
+        continue;
+      }
+      if (level > 0) {
+        const px = x >>> 1;
+        const py = y >>> 1;
+        scratchParentTile.space = space;
+        scratchParentTile.level = level - 1;
+        scratchParentTile.x = px;
+        scratchParentTile.y = py;
+        if (surface.neighborSameLevel(scratchParentTile, dir, scratchParentNbr)) {
+          j = lookupSpatialIndexRaw(
+            index,
+            scratchParentNbr.space,
+            scratchParentNbr.level,
+            scratchParentNbr.x,
+            scratchParentNbr.y
+          );
+          if (j !== U32_EMPTY) {
+            neighbors[outOffset + 0] = j;
+            continue;
+          }
+        }
+      }
+      const childLevel = scratchNbr.level + 1;
+      const x2 = scratchNbr.x << 1 >>> 0;
+      const y2 = scratchNbr.y << 1 >>> 0;
+      let ax = 0;
+      let ay = 0;
+      let bx = 0;
+      let by = 0;
+      switch (dir) {
+        case Dir.LEFT:
+          ax = x2 + 1;
+          ay = y2;
+          bx = x2 + 1;
+          by = y2 + 1;
+          break;
+        case Dir.RIGHT:
+          ax = x2;
+          ay = y2;
+          bx = x2;
+          by = y2 + 1;
+          break;
+        case Dir.TOP:
+          ax = x2;
+          ay = y2 + 1;
+          bx = x2 + 1;
+          by = y2 + 1;
+          break;
+        case Dir.BOTTOM:
+          ax = x2;
+          ay = y2;
+          bx = x2 + 1;
+          by = y2;
+          break;
+      }
+      j = lookupSpatialIndexRaw(index, scratchNbr.space, childLevel, ax, ay);
+      if (j !== U32_EMPTY) neighbors[outOffset + 0] = j;
+      j = lookupSpatialIndexRaw(index, scratchNbr.space, childLevel, bx, by);
+      if (j !== U32_EMPTY) neighbors[outOffset + 1] = j;
+    }
+  }
+  return outSeams;
+}
+
+function createFlatSurface(cfg) {
+  const halfRoot = 0.5 * cfg.rootSize;
+  const maxHeight = cfg.maxHeight ?? 0;
+  const surface = {
+    spaceCount: 1,
+    maxRootCount: 1,
+    neighborSameLevel(tile, dir, out) {
+      const level = tile.level;
+      const x = tile.x;
+      const y = tile.y;
+      let nx = x;
+      let ny = y;
+      switch (dir) {
+        case Dir.LEFT:
+          nx = x - 1;
+          break;
+        case Dir.RIGHT:
+          nx = x + 1;
+          break;
+        case Dir.TOP:
+          ny = y - 1;
+          break;
+        case Dir.BOTTOM:
+          ny = y + 1;
+          break;
+      }
+      if (nx < 0 || ny < 0) return false;
+      const maxCoord = (1 << level) - 1;
+      if (nx > maxCoord || ny > maxCoord) return false;
+      out.space = 0;
+      out.level = level;
+      out.x = nx;
+      out.y = ny;
+      return true;
+    },
+    tileBounds(tile, cameraOrigin, out) {
+      const level = tile.level;
+      const scale = 1 / (1 << level);
+      const size = cfg.rootSize * scale;
+      const minX = cfg.origin.x + (tile.x * size - halfRoot);
+      const minZ = cfg.origin.z + (tile.y * size - halfRoot);
+      const centerX = minX + 0.5 * size;
+      const centerY = cfg.origin.y;
+      const centerZ = minZ + 0.5 * size;
+      out.cx = centerX - cameraOrigin.x;
+      out.cy = centerY - cameraOrigin.y;
+      out.cz = centerZ - cameraOrigin.z;
+      out.r = 0.7071067811865476 * size + maxHeight;
+    },
+    rootTiles(_cameraOrigin, out) {
+      const root = out[0];
+      root.space = 0;
+      root.level = 0;
+      root.x = 0;
+      root.y = 0;
+      return 1;
+    }
+  };
+  return surface;
+}
+
+function createInfiniteFlatSurface(cfg) {
+  const halfRoot = 0.5 * cfg.rootSize;
+  const maxHeight = cfg.maxHeight ?? 0;
+  const rootGridRadius = Math.max(0, Math.floor(cfg.rootGridRadius ?? 1));
+  const rootWidth = rootGridRadius * 2 + 1;
+  return {
+    spaceCount: 1,
+    maxRootCount: rootWidth * rootWidth,
+    neighborSameLevel(tile, dir, out) {
+      let nx = tile.x;
+      let ny = tile.y;
+      switch (dir) {
+        case Dir.LEFT:
+          nx = tile.x - 1;
+          break;
+        case Dir.RIGHT:
+          nx = tile.x + 1;
+          break;
+        case Dir.TOP:
+          ny = tile.y - 1;
+          break;
+        case Dir.BOTTOM:
+          ny = tile.y + 1;
+          break;
+      }
+      out.space = tile.space;
+      out.level = tile.level;
+      out.x = nx;
+      out.y = ny;
+      return true;
+    },
+    tileBounds(tile, cameraOrigin, out) {
+      const level = tile.level;
+      const scale = 1 / (1 << level);
+      const size = cfg.rootSize * scale;
+      const minX = cfg.origin.x + (tile.x * size - halfRoot);
+      const minZ = cfg.origin.z + (tile.y * size - halfRoot);
+      const centerX = minX + 0.5 * size;
+      const centerY = cfg.origin.y;
+      const centerZ = minZ + 0.5 * size;
+      out.cx = centerX - cameraOrigin.x;
+      out.cy = centerY - cameraOrigin.y;
+      out.cz = centerZ - cameraOrigin.z;
+      out.r = 0.7071067811865476 * size + maxHeight;
+    },
+    rootTiles(cameraOrigin, out) {
+      const camRootX = Math.floor((cameraOrigin.x - cfg.origin.x + halfRoot) / cfg.rootSize);
+      const camRootY = Math.floor((cameraOrigin.z - cfg.origin.z + halfRoot) / cfg.rootSize);
+      let index = 0;
+      for (let dy = -rootGridRadius; dy <= rootGridRadius; dy++) {
+        for (let dx = -rootGridRadius; dx <= rootGridRadius; dx++) {
+          const root = out[index];
+          root.space = 0;
+          root.level = 0;
+          root.x = camRootX + dx;
+          root.y = camRootY + dy;
+          index++;
+        }
+      }
+      return index;
+    }
+  };
+}
+
+function createCubeSphereSurface(_cfg) {
+  return {
+    spaceCount: 6,
+    maxRootCount: 6,
+    neighborSameLevel(_tile, _dir, _out) {
+      return false;
+    },
+    tileBounds(_tile, _cameraOrigin, out) {
+      out.cx = 0;
+      out.cy = 0;
+      out.cz = 0;
+      out.r = Number.MAX_VALUE;
+    },
+    rootTiles(_cameraOrigin, out) {
+      for (let s = 0; s < 6; s++) {
+        const root = out[s];
+        root.space = s;
+        root.level = 0;
+        root.x = 0;
+        root.y = 0;
+      }
+      return 6;
+    }
+  };
+}
+
+function cloneSpatialIndex(target, source) {
+  if (target.size !== source.size) {
+    throw new Error(
+      `SpatialIndex size mismatch (target=${target.size}, source=${source.size}).`
+    );
+  }
+  target.mask = source.mask;
+  target.stampGen = source.stampGen;
+  target.stamp.set(source.stamp);
+  target.keysSpace.set(source.keysSpace);
+  target.keysLevel.set(source.keysLevel);
+  target.keysX.set(source.keysX);
+  target.keysY.set(source.keysY);
+  target.values.set(source.values);
+}
+function tileLocalToFieldUV(localCoord, innerSegments) {
+  const edge = innerSegments + 3;
+  return (localCoord * innerSegments + 1.5) / edge;
+}
+function createCpuTerrainCache(maxNodes, initialConfig) {
+  let config = initialConfig;
+  let edgeVertexCount = config.innerTileSegments + 3;
+  let verticesPerNode = edgeVertexCount * edgeVertexCount;
+  let totalElements = maxNodes * verticesPerNode;
+  let frontElevation = new Float32Array(totalElements);
+  let backElevation = new Float32Array(totalElements);
+  let frontIndex = createSpatialIndex(maxNodes);
+  let backIndex = createSpatialIndex(maxNodes);
+  let frontTileBounds = new Float32Array(maxNodes * 2);
+  let backTileBounds = new Float32Array(maxNodes * 2);
+  let frontLeafCount = 0;
+  let globalRange = null;
+  let hasSnapshot = false;
+  let readbackPending = false;
+  let generationCount = 0;
+  let lastScheduledStampGen = -1;
+  const readHeight = (leafIndex, ix, iy) => {
+    const base = leafIndex * verticesPerNode;
+    return frontElevation[base + iy * edgeVertexCount + ix] ?? 0;
+  };
+  const sampleGridBilinear = (leafIndex, gx, gy) => {
+    const max = edgeVertexCount - 1;
+    const x = Math.max(0, Math.min(max, gx));
+    const y = Math.max(0, Math.min(max, gy));
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const x1 = Math.min(max, x0 + 1);
+    const y1 = Math.min(max, y0 + 1);
+    const tx = x - x0;
+    const ty = y - y0;
+    const h00 = readHeight(leafIndex, x0, y0);
+    const h10 = readHeight(leafIndex, x1, y0);
+    const h01 = readHeight(leafIndex, x0, y1);
+    const h11 = readHeight(leafIndex, x1, y1);
+    const hx0 = h00 + (h10 - h00) * tx;
+    const hx1 = h01 + (h11 - h01) * tx;
+    return hx0 + (hx1 - hx0) * ty;
+  };
+  const computeNormal = (leafIndex, gx, gy, tileSize) => {
+    const hLeft = sampleGridBilinear(leafIndex, gx - 1, gy);
+    const hRight = sampleGridBilinear(leafIndex, gx + 1, gy);
+    const hUp = sampleGridBilinear(leafIndex, gx, gy - 1);
+    const hDown = sampleGridBilinear(leafIndex, gx, gy + 1);
+    const stepWorld = tileSize / config.innerTileSegments;
+    const inv2Step = 0.5 / stepWorld;
+    const dhdx = (hRight - hLeft) * config.elevationScale * inv2Step;
+    const dhdz = (hDown - hUp) * config.elevationScale * inv2Step;
+    return new three.Vector3(-dhdx, 1, -dhdz).normalize();
+  };
+  const lookupTile = (worldX, worldZ) => {
+    const halfRoot = config.rootSize * 0.5;
+    for (let level = config.maxLevel; level >= 0; level -= 1) {
+      const scale = 2 ** level;
+      const tileSize = config.rootSize / scale;
+      const tileX = Math.floor((worldX - config.originX + halfRoot) / tileSize);
+      const tileY = Math.floor((worldZ - config.originZ + halfRoot) / tileSize);
+      const leafIndex = lookupSpatialIndexRaw(
+        frontIndex,
+        0,
+        level,
+        tileX,
+        tileY
+      );
+      if (leafIndex !== U32_EMPTY) {
+        const tileMinX = config.originX + tileX * tileSize - halfRoot;
+        const tileMinZ = config.originZ + tileY * tileSize - halfRoot;
+        return {
+          found: true,
+          leafIndex,
+          level,
+          tileX,
+          tileY,
+          tileSize,
+          localU: (worldX - tileMinX) / tileSize,
+          localV: (worldZ - tileMinZ) / tileSize
+        };
+      }
+    }
+    return {
+      found: false,
+      leafIndex: -1,
+      level: -1,
+      tileX: -1,
+      tileY: -1,
+      tileSize: 0,
+      localU: 0,
+      localV: 0
+    };
+  };
+  const sampleFromLookup = (lookup) => {
+    const fieldU = tileLocalToFieldUV(lookup.localU, config.innerTileSegments);
+    const fieldV = tileLocalToFieldUV(lookup.localV, config.innerTileSegments);
+    const gx = fieldU * (edgeVertexCount - 1);
+    const gy = fieldV * (edgeVertexCount - 1);
+    const height = sampleGridBilinear(lookup.leafIndex, gx, gy);
+    const scaledHeight = config.originY + height * config.elevationScale;
+    const normal = computeNormal(lookup.leafIndex, gx, gy, lookup.tileSize);
+    return { elevation: scaledHeight, normal, valid: true };
+  };
+  const sampleElevationFromLookup = (lookup) => {
+    const fieldU = tileLocalToFieldUV(lookup.localU, config.innerTileSegments);
+    const fieldV = tileLocalToFieldUV(lookup.localV, config.innerTileSegments);
+    const gx = fieldU * (edgeVertexCount - 1);
+    const gy = fieldV * (edgeVertexCount - 1);
+    const height = sampleGridBilinear(lookup.leafIndex, gx, gy);
+    const scaledHeight = config.originY + height * config.elevationScale;
+    return { elevation: scaledHeight, valid: true };
+  };
+  const sampleTerrain = (worldX, worldZ) => {
+    if (!hasSnapshot) {
+      return { elevation: 0, normal: new three.Vector3(0, 1, 0), valid: false };
+    }
+    const lookup = lookupTile(worldX, worldZ);
+    if (!lookup.found) {
+      return { elevation: 0, normal: new three.Vector3(0, 1, 0), valid: false };
+    }
+    return sampleFromLookup(lookup);
+  };
+  const getElevation = (worldX, worldZ) => {
+    if (!hasSnapshot) {
+      return { elevation: 0, valid: false };
+    }
+    const lookup = lookupTile(worldX, worldZ);
+    if (!lookup.found) {
+      return { elevation: 0, valid: false };
+    }
+    return sampleElevationFromLookup(lookup);
+  };
+  const api = {
+    get generation() {
+      return generationCount;
+    },
+    get ready() {
+      return hasSnapshot;
+    },
+    updateConfig(nextConfig) {
+      config = nextConfig;
+      edgeVertexCount = config.innerTileSegments + 3;
+      verticesPerNode = edgeVertexCount * edgeVertexCount;
+      totalElements = maxNodes * verticesPerNode;
+    },
+    triggerReadback(renderer, attribute, spatialIndex, boundsAttribute, activeLeafCount) {
+      if (readbackPending) return;
+      const withReadback = renderer;
+      if (!withReadback.getArrayBufferAsync) return;
+      if (spatialIndex.stampGen === lastScheduledStampGen) return;
+      cloneSpatialIndex(backIndex, spatialIndex);
+      lastScheduledStampGen = spatialIndex.stampGen;
+      const capturedLeafCount = activeLeafCount ?? 0;
+      const capturedScale = config.elevationScale;
+      const capturedOriginY = config.originY;
+      readbackPending = true;
+      const elevationPromise = withReadback.getArrayBufferAsync(attribute);
+      const boundsPromise = boundsAttribute ? withReadback.getArrayBufferAsync(boundsAttribute) : null;
+      const onComplete = (elevResult, boundsResult) => {
+        const data = new Float32Array(elevResult);
+        backElevation.fill(0);
+        backElevation.set(data.subarray(0, totalElements));
+        let boundsValid = capturedLeafCount === 0;
+        if (boundsResult) {
+          const rawBounds = new Float32Array(boundsResult);
+          backTileBounds.fill(0);
+          backTileBounds.set(rawBounds.subarray(0, capturedLeafCount * 2));
+          for (let i = 0; i < capturedLeafCount; i += 1) {
+            if ((rawBounds[i * 2 + 1] ?? 0) !== 0) {
+              boundsValid = true;
+              break;
+            }
+          }
+        }
+        const oldFrontElevation = frontElevation;
+        const oldFrontIndex = frontIndex;
+        frontElevation = backElevation;
+        frontIndex = backIndex;
+        frontLeafCount = capturedLeafCount;
+        backElevation = oldFrontElevation;
+        backIndex = oldFrontIndex;
+        if (boundsResult && boundsValid) {
+          const oldFrontBounds = frontTileBounds;
+          frontTileBounds = backTileBounds;
+          backTileBounds = oldFrontBounds;
+        }
+        if (boundsResult && boundsValid && capturedLeafCount > 0) {
+          let gMin = Infinity;
+          let gMax = -Infinity;
+          for (let i = 0; i < capturedLeafCount; i++) {
+            const rawMin = frontTileBounds[i * 2];
+            const rawMax = frontTileBounds[i * 2 + 1];
+            const a = capturedOriginY + rawMin * capturedScale;
+            const b = capturedOriginY + rawMax * capturedScale;
+            gMin = Math.min(gMin, a, b);
+            gMax = Math.max(gMax, a, b);
+          }
+          globalRange = { min: gMin, max: gMax };
+        }
+        hasSnapshot = true;
+        generationCount += 1;
+      };
+      if (boundsPromise) {
+        Promise.all([elevationPromise, boundsPromise]).then(([elev, bounds]) => onComplete(elev, bounds)).finally(() => {
+          readbackPending = false;
+        });
+      } else {
+        elevationPromise.then((elev) => onComplete(elev, null)).finally(() => {
+          readbackPending = false;
+        });
+      }
+    },
+    getElevation(worldX, worldZ) {
+      const sample = getElevation(worldX, worldZ);
+      return sample.valid ? sample.elevation : null;
+    },
+    getNormal(worldX, worldZ) {
+      return sampleTerrain(worldX, worldZ).normal;
+    },
+    getTile(worldX, worldZ) {
+      if (!hasSnapshot) return null;
+      const lookup = lookupTile(worldX, worldZ);
+      if (!lookup.found) return null;
+      return {
+        level: lookup.level,
+        x: lookup.tileX,
+        y: lookup.tileY,
+        index: lookup.leafIndex
+      };
+    },
+    getTileBounds(worldX, worldZ) {
+      if (!hasSnapshot) return null;
+      const lookup = lookupTile(worldX, worldZ);
+      if (!lookup.found || lookup.leafIndex >= frontLeafCount) return null;
+      const rawMin = frontTileBounds[lookup.leafIndex * 2];
+      const rawMax = frontTileBounds[lookup.leafIndex * 2 + 1];
+      const a = config.originY + rawMin * config.elevationScale;
+      const b = config.originY + rawMax * config.elevationScale;
+      return {
+        level: lookup.level,
+        x: lookup.tileX,
+        y: lookup.tileY,
+        index: lookup.leafIndex,
+        minElevation: Math.min(a, b),
+        maxElevation: Math.max(a, b)
+      };
+    },
+    getGlobalElevationRange() {
+      return globalRange;
+    },
+    sampleTerrainBatch(positions) {
+      const count = Math.floor(positions.length / 2);
+      const elevations = new Float32Array(count);
+      const normals = new Float32Array(count * 3);
+      const valid = new Uint8Array(count);
+      if (!hasSnapshot) {
+        return { elevations, normals, valid, generation: generationCount };
+      }
+      let lastTile;
+      for (let i = 0; i < count; i += 1) {
+        const worldX = positions[i * 2] ?? 0;
+        const worldZ = positions[i * 2 + 1] ?? 0;
+        let lookup;
+        if (lastTile && worldX >= lastTile.tileMinX && worldX <= lastTile.tileMinX + lastTile.tileSize && worldZ >= lastTile.tileMinZ && worldZ <= lastTile.tileMinZ + lastTile.tileSize) {
+          lookup = {
+            found: true,
+            leafIndex: lastTile.leafIndex,
+            level: lastTile.level,
+            tileX: lastTile.tileX,
+            tileY: lastTile.tileY,
+            tileSize: lastTile.tileSize,
+            localU: (worldX - lastTile.tileMinX) / lastTile.tileSize,
+            localV: (worldZ - lastTile.tileMinZ) / lastTile.tileSize
+          };
+        } else {
+          lookup = lookupTile(worldX, worldZ);
+          if (lookup.found) {
+            lastTile = {
+              leafIndex: lookup.leafIndex,
+              level: lookup.level,
+              tileX: lookup.tileX,
+              tileY: lookup.tileY,
+              tileSize: lookup.tileSize,
+              tileMinX: worldX - lookup.localU * lookup.tileSize,
+              tileMinZ: worldZ - lookup.localV * lookup.tileSize
+            };
+          } else {
+            lastTile = void 0;
+          }
+        }
+        if (!lookup?.found) {
+          normals[i * 3 + 1] = 1;
+          continue;
+        }
+        const sample = sampleFromLookup(lookup);
+        elevations[i] = sample.elevation;
+        normals[i * 3] = sample.normal.x;
+        normals[i * 3 + 1] = sample.normal.y;
+        normals[i * 3 + 2] = sample.normal.z;
+        valid[i] = 1;
+      }
+      return { elevations, normals, valid, generation: generationCount };
+    },
+    sampleTerrain
+  };
+  return api;
+}
+
+function createTerrainQuery(cache) {
+  return {
+    get generation() {
+      return cache.generation;
+    },
+    getElevation(worldX, worldZ) {
+      return cache.getElevation(worldX, worldZ);
+    },
+    getNormal(worldX, worldZ) {
+      return cache.getNormal(worldX, worldZ);
+    },
+    getTile(worldX, worldZ) {
+      return cache.getTile(worldX, worldZ);
+    },
+    getTileBounds(worldX, worldZ) {
+      return cache.getTileBounds(worldX, worldZ);
+    },
+    getGlobalElevationRange() {
+      return cache.getGlobalElevationRange();
+    },
+    sampleTerrain(worldX, worldZ) {
+      return cache.sampleTerrain(worldX, worldZ);
+    },
+    sampleTerrainBatch(positions) {
+      return cache.sampleTerrainBatch(positions);
+    }
+  };
+}
+
+const WGSIZE = 64;
+function buildReductionKernel(elevationFieldNode, boundsNode, verticesPerNode) {
+  const elemsPerThread = Math.ceil(verticesPerNode / WGSIZE);
+  return tsl.Fn(() => {
+    const sharedMin = tsl.workgroupArray("float", WGSIZE);
+    const sharedMax = tsl.workgroupArray("float", WGSIZE);
+    const tid = tsl.int(tsl.localId.x);
+    const tileIdx = tsl.int(tsl.workgroupId.z);
+    const baseOffset = tileIdx.mul(tsl.int(verticesPerNode));
+    const start = tid.mul(tsl.int(elemsPerThread));
+    const end = tsl.min(start.add(tsl.int(elemsPerThread)), tsl.int(verticesPerNode));
+    const localMin = tsl.float(1e10).toVar("localMin");
+    const localMax = tsl.float(-1e10).toVar("localMax");
+    tsl.Loop({ start, end, type: "int", condition: "<" }, ({ i }) => {
+      const h = elevationFieldNode.element(baseOffset.add(i));
+      localMin.assign(tsl.min(localMin, h));
+      localMax.assign(tsl.max(localMax, h));
+    });
+    sharedMin.element(tid).assign(localMin);
+    sharedMax.element(tid).assign(localMax);
+    tsl.workgroupBarrier();
+    tsl.If(tid.equal(tsl.int(0)), () => {
+      const finalMin = tsl.float(1e10).toVar("finalMin");
+      const finalMax = tsl.float(-1e10).toVar("finalMax");
+      tsl.Loop(WGSIZE, ({ i }) => {
+        finalMin.assign(tsl.min(finalMin, sharedMin.element(i)));
+        finalMax.assign(tsl.max(finalMax, sharedMax.element(i)));
+      });
+      const outIdx = tileIdx.mul(tsl.int(2));
+      boundsNode.element(outIdx).assign(finalMin);
+      boundsNode.element(outIdx.add(tsl.int(1))).assign(finalMax);
+    });
+  })().computeKernel([WGSIZE, 1, 1]);
+}
+const tileBoundsContextTask = work.task((get, work) => {
+  const elevationFieldContext = get(createElevationFieldContextTask);
+  const maxNodesValue = get(maxNodes);
+  const edgeVertexCount = get(innerTileSegments) + 3;
+  return work(() => {
+    const data = new Float32Array(maxNodesValue * 2);
+    const attribute = new webgpu.StorageBufferAttribute(data, 1);
+    const node = tsl.storage(attribute, "float", maxNodesValue * 2);
+    const verticesPerNode = edgeVertexCount * edgeVertexCount;
+    const kernel = buildReductionKernel(elevationFieldContext.node, node, verticesPerNode);
+    return { data, attribute, node, kernel };
+  });
+}).displayName("tileBoundsContextTask");
+const tileBoundsReductionTask = work.task(
+  (get, work, { resources }) => {
+    get(executeComputeTask);
+    const boundsContext = get(tileBoundsContextTask);
+    const leafState = get(leafGpuBufferTask);
+    return work(() => {
+      if (resources?.renderer && leafState.count > 0) {
+        resources.renderer.compute(boundsContext.kernel, [1, 1, leafState.count]);
+      }
+      return boundsContext;
+    });
+  }
+).displayName("tileBoundsReductionTask").lane("gpu");
+
+const terrainQueryTask = work.task((get, work) => {
+  const maxNodesValue = get(maxNodes);
+  const innerTileSegmentsValue = get(innerTileSegments);
+  const maxLevelValue = get(maxLevel);
+  const rootSizeValue = get(rootSize);
+  const originValue = get(origin);
+  const elevationScaleValue = get(elevationScale);
+  return work((prev) => {
+    const shapeKey = `${maxNodesValue}:${innerTileSegmentsValue}`;
+    const configValues = {
+      rootSize: rootSizeValue,
+      originX: originValue.x,
+      originY: originValue.y,
+      originZ: originValue.z,
+      innerTileSegments: innerTileSegmentsValue,
+      elevationScale: elevationScaleValue,
+      maxLevel: maxLevelValue
+    };
+    let cache = prev?.cache;
+    let query = prev?.query;
+    if (!cache || !query || prev?.shapeKey !== shapeKey) {
+      cache = createCpuTerrainCache(maxNodesValue, configValues);
+      query = createTerrainQuery(cache);
+    }
+    cache.updateConfig(configValues);
+    return { cache, query, shapeKey };
+  });
+}).displayName("terrainQueryTask");
+const terrainReadbackTask = work.task(
+  (get, work, { resources }) => {
+    const boundsContext = get(tileBoundsReductionTask);
+    const elevationFieldContext = get(createElevationFieldContextTask);
+    const quadtreeConfig = get(quadtreeConfigTask);
+    const leafState = get(leafGpuBufferTask);
+    const { cache } = get(terrainQueryTask);
+    return work(() => {
+      if (!resources?.renderer) return;
+      cache.triggerReadback(
+        resources.renderer,
+        elevationFieldContext.attribute,
+        quadtreeConfig.state.leafIndex,
+        boundsContext.attribute,
+        leafState.count
+      );
+    });
+  }
+).displayName("terrainReadbackTask").lane("gpu");
+
+const surfaceTask = work.task((get, work) => {
+  const customSurface = get(surface);
+  const rootSizeVal = get(rootSize);
+  const originVal = get(origin);
+  return work(() => {
+    if (customSurface) return customSurface;
+    return createFlatSurface({ rootSize: rootSizeVal, origin: originVal });
+  });
+}).displayName("surfaceTask");
+const quadtreeConfigTask = work.task((get, work) => {
+  const surfaceVal = get(surfaceTask);
+  const maxNodesVal = get(maxNodes);
+  const maxLevelVal = get(maxLevel);
+  return work(() => {
+    const state = createState({ maxNodes: maxNodesVal, maxLevel: maxLevelVal }, surfaceVal);
+    return {
+      state,
+      surface: surfaceVal
+    };
+  });
+}).displayName("quadtreeConfigTask");
+const quadtreeUpdateTask = work.task((get, work) => {
+  const quadtreeConfig = get(quadtreeConfigTask);
+  const quadtreeUpdateConfig = get(quadtreeUpdate);
+  const { query: terrainQuery } = get(terrainQueryTask);
+  let outLeaves = void 0;
+  return work(() => {
+    const cam = quadtreeUpdateConfig.cameraOrigin;
+    quadtreeUpdateConfig.elevationAtCameraXZ = terrainQuery.getElevation(cam.x, cam.z) ?? 0;
+    outLeaves = update(
+      quadtreeConfig.state,
+      quadtreeConfig.surface,
+      quadtreeUpdateConfig,
+      outLeaves
+    );
+    return outLeaves;
+  });
+}).displayName("quadtreeUpdateTask");
+const leafStorageTask = work.task((get, work) => {
+  const maxNodesVal = get(maxNodes);
+  return work(() => createLeafStorage(maxNodesVal));
+}).displayName("leafStorageTask");
+const leafGpuBufferTask = work.task((get, work) => {
+  const leafSet = get(quadtreeUpdateTask);
+  const leafStorage = get(leafStorageTask);
+  return work(() => {
+    const bufferCapacity = leafStorage.data.length / 4;
+    const leafCount = Math.min(leafSet.count, bufferCapacity);
+    for (let i = 0; i < leafCount; i += 1) {
+      const offset = i * 4;
+      leafStorage.data[offset] = leafSet.level[i] ?? 0;
+      leafStorage.data[offset + 1] = leafSet.x[i] ?? 0;
+      leafStorage.data[offset + 2] = leafSet.y[i] ?? 0;
+      leafStorage.data[offset + 3] = 1;
+    }
+    leafStorage.attribute.needsUpdate = true;
+    leafStorage.node.needsUpdate = true;
+    return {
+      count: leafCount,
+      data: leafStorage.data,
+      attribute: leafStorage.attribute,
+      node: leafStorage.node
+    };
+  });
+}).displayName("leafGpuBufferTask");
+
+function createElevationFunction(callback) {
+  const tslFunction = (args) => {
+    const params = {
+      worldPosition: args.worldPosition,
+      rootSize: args.rootSize,
+      rootUV: args.rootUV,
+      tileUV: args.tileUV,
+      tileLevel: args.tileLevel,
+      tileSize: args.tileSize,
+      tileOriginVec2: args.tileOriginVec2,
+      nodeIndex: args.nodeIndex
+    };
+    return callback(params);
+  };
+  return TSL_js.Fn(tslFunction);
+}
+
+function createTerrainUniforms(params) {
+  const sanitizedId = params.instanceId?.replace(/-/g, "_");
+  const suffix = sanitizedId ? `_${sanitizedId}` : "";
+  const uRootOrigin = tsl.uniform(
+    new webgpu.Vector3(params.rootOrigin.x, params.rootOrigin.y, params.rootOrigin.z)
+  ).setName(`uRootOrigin${suffix}`);
+  const uRootSize = tsl.uniform(tsl.float(params.rootSize)).setName(`uRootSize${suffix}`);
+  const uInnerTileSegments = tsl.uniform(tsl.int(params.innerTileSegments)).setName(
+    `uInnerTileSegments${suffix}`
+  );
+  const uSkirtScale = tsl.uniform(tsl.float(params.skirtScale)).setName(`uSkirtScale${suffix}`);
+  const uElevationScale = tsl.uniform(tsl.float(params.elevationScale)).setName(`uElevationScale${suffix}`);
+  return {
+    uRootOrigin,
+    uRootSize,
+    uInnerTileSegments,
+    uSkirtScale,
+    uElevationScale
+  };
+}
+
+const instanceIdTask = work.task(() => crypto.randomUUID()).displayName("instanceIdTask").cache("once");
+
+const scratchVector3 = new three.Vector3();
+const createUniformsTask = work.task((get, work) => {
+  const uniformParams = {
+    rootOrigin: get(origin),
+    rootSize: get(rootSize),
+    innerTileSegments: get(innerTileSegments),
+    skirtScale: get(skirtScale),
+    elevationScale: get(elevationScale),
+    instanceId: get(instanceIdTask)
+  };
+  return work(() => createTerrainUniforms(uniformParams));
+}).displayName("createUniformsTask").cache("once");
+const updateUniformsTask = work.task((get, work) => {
+  const terrainUniformsContext = get(createUniformsTask);
+  const rootSizeVal = get(rootSize);
+  const rootOrigin = get(origin);
+  const innerTileSegmentsVal = get(innerTileSegments);
+  const skirtScaleVal = get(skirtScale);
+  const elevationScaleVal = get(elevationScale);
+  return work(() => {
+    terrainUniformsContext.uRootSize.value = rootSizeVal;
+    terrainUniformsContext.uRootOrigin.value = scratchVector3.set(
+      rootOrigin.x,
+      rootOrigin.y,
+      rootOrigin.z
+    );
+    terrainUniformsContext.uInnerTileSegments.value = innerTileSegmentsVal;
+    terrainUniformsContext.uSkirtScale.value = skirtScaleVal;
+    terrainUniformsContext.uElevationScale.value = elevationScaleVal;
+    return terrainUniformsContext;
+  });
+}).displayName("updateUniformsTask");
+
+const createElevationFieldContextTask = work.task((get, work) => {
+  const edgeVertexCount = get(innerTileSegments) + 3;
+  const verticesPerNode = edgeVertexCount * edgeVertexCount;
+  const totalElements = get(maxNodes) * verticesPerNode;
+  return work(() => {
+    const data = new Float32Array(totalElements);
+    const attribute = new webgpu.StorageBufferAttribute(data, 1);
+    const node = tsl.storage(attribute, "float", totalElements);
+    return {
+      data,
+      attribute,
+      node
+    };
+  });
+}).displayName("createElevationFieldContextTask");
+const tileNodesTask = work.task((get, work) => {
+  const leafStorage = get(leafStorageTask);
+  const uniforms = get(updateUniformsTask);
+  return work(() => {
+    return createTileCompute(leafStorage, uniforms);
+  });
+}).displayName("tileNodesTask");
+const elevationFieldStageTask = work.task((get, work) => {
+  const tile = get(tileNodesTask);
+  const uniforms = get(updateUniformsTask);
+  const elevationFieldContext = get(createElevationFieldContextTask);
+  const userElevationFn = get(elevationFn);
+  return work(() => {
+    const heightFn = createElevationFunction(userElevationFn);
+    const heightWriteFn = createElevation(tile, uniforms, heightFn);
+    return [
+      (nodeIndex, globalVertexIndex, _uv, localCoordinates) => {
+        const height = heightWriteFn(nodeIndex, localCoordinates);
+        elevationFieldContext.node.element(globalVertexIndex).assign(height);
+      }
+    ];
+  });
+}).displayName("elevationFieldStageTask");
+
+const createTerrainFieldTextureTask = work.task(
+  (get, work, { resources }) => {
+    const edgeVertexCount = get(innerTileSegments) + 3;
+    const maxNodesValue = get(maxNodes);
+    const filter = get(terrainFieldFilter);
+    return work(
+      () => createTerrainFieldStorage(
+        edgeVertexCount,
+        maxNodesValue,
+        resources?.renderer,
+        { filter }
+      )
+    );
+  }
+).displayName("createTerrainFieldTextureTask");
+function createNormalFromElevationField(elevationFieldNode, edgeVertexCount) {
+  return tsl.Fn(
+    ([nodeIndex, tileSize, ix, iy, elevationScale]) => {
+      const iEdge = tsl.int(edgeVertexCount);
+      const verticesPerNode = iEdge.mul(iEdge);
+      const baseOffset = tsl.int(nodeIndex).mul(verticesPerNode);
+      const xLeft = tsl.int(ix).sub(tsl.int(1));
+      const xRight = tsl.int(ix).add(tsl.int(1));
+      const yUp = tsl.int(iy).sub(tsl.int(1));
+      const yDown = tsl.int(iy).add(tsl.int(1));
+      const hLeft = elevationFieldNode.element(baseOffset.add(tsl.int(iy).mul(iEdge).add(xLeft))).mul(elevationScale);
+      const hRight = elevationFieldNode.element(baseOffset.add(tsl.int(iy).mul(iEdge).add(xRight))).mul(elevationScale);
+      const hUp = elevationFieldNode.element(baseOffset.add(yUp.mul(iEdge).add(tsl.int(ix)))).mul(elevationScale);
+      const hDown = elevationFieldNode.element(baseOffset.add(yDown.mul(iEdge).add(tsl.int(ix)))).mul(elevationScale);
+      const innerSegments = tsl.float(iEdge).sub(tsl.float(3));
+      const stepWorld = tileSize.div(innerSegments);
+      const inv2Step = tsl.float(0.5).div(stepWorld);
+      const dhdx = tsl.float(hRight).sub(tsl.float(hLeft)).mul(inv2Step);
+      const dhdz = tsl.float(hDown).sub(tsl.float(hUp)).mul(inv2Step);
+      const normal = tsl.vec3(dhdx.negate(), tsl.float(1), dhdz.negate()).normalize();
+      return tsl.vec2(normal.x, normal.z);
+    }
+  );
+}
+const terrainFieldStageTask = work.task((get, work) => {
+  const upstream = get(elevationFieldStageTask);
+  const elevationFieldContext = get(createElevationFieldContextTask);
+  const terrainFieldStorage = get(createTerrainFieldTextureTask);
+  const tileEdgeVertexCount = get(innerTileSegments) + 3;
+  const tile = get(tileNodesTask);
+  const uniforms = get(updateUniformsTask);
+  return work(() => {
+    const computeNormal = createNormalFromElevationField(
+      elevationFieldContext.node,
+      tileEdgeVertexCount
+    );
+    return [
+      ...upstream,
+      (nodeIndex, globalVertexIndex, _uv, localCoordinates) => {
+        const ix = tsl.int(localCoordinates.x);
+        const iy = tsl.int(localCoordinates.y);
+        const tileSize = tile.tileSize(nodeIndex);
+        const height = elevationFieldContext.node.element(globalVertexIndex);
+        const normalXZ = computeNormal(
+          nodeIndex,
+          tileSize,
+          ix,
+          iy,
+          uniforms.uElevationScale
+        );
+        storeTerrainField(
+          terrainFieldStorage,
+          ix,
+          iy,
+          nodeIndex,
+          packTerrainFieldSample(height, normalXZ)
+        );
+      }
+    ];
+  });
+}).displayName("terrainFieldStageTask");
+
+const compileComputeTask = work.task((get, work) => {
+  const pipeline = get(terrainFieldStageTask);
+  const edgeVertexCount = get(innerTileSegments) + 3;
+  return work(
+    () => compileComputePipeline(pipeline, edgeVertexCount, {
+      preferSingleKernelWhenPossible: false
+    })
+  );
+}).displayName("compileComputeTask");
+const executeComputeTask = work.task(
+  (get, work, { resources }) => {
+    const { execute } = get(compileComputeTask);
+    const leafState = get(leafGpuBufferTask);
+    return work(
+      () => resources?.renderer ? execute(resources.renderer, leafState.count) : () => {
+      }
+    );
+  }
+).displayName("executeComputeTask").lane("gpu");
+function createComputePipelineTasks(leafStageTask) {
+  const compile = work.task((get, work) => {
+    const pipeline = get(leafStageTask);
+    const edgeVertexCount = get(innerTileSegments) + 3;
+    return work(
+      () => compileComputePipeline(pipeline, edgeVertexCount, {
+        preferSingleKernelWhenPossible: false
+      })
+    );
+  }).displayName("compileComputeTask");
+  const execute = work.task(
+    (get, work, { resources }) => {
+      const { execute: run } = get(compile);
+      const leafState = get(leafGpuBufferTask);
+      return work(
+        () => resources?.renderer ? run(resources.renderer, leafState.count) : () => {
+        }
+      );
+    }
+  ).displayName("executeComputeTask").lane("gpu");
+  return { compile, execute };
+}
+
+const SLOT_STRIDE = 6;
+function nextPow2(n) {
+  let x = 1;
+  while (x < n) x <<= 1;
+  return x;
+}
+function createGpuSpatialIndex(maxEntries) {
+  const size = nextPow2(Math.max(2, maxEntries * 2));
+  const data = new Uint32Array(size * SLOT_STRIDE);
+  const attribute = new webgpu.StorageBufferAttribute(data, SLOT_STRIDE);
+  const node = tsl.storage(attribute, "u32", 1).toReadOnly().setName("gpuSpatialIndex");
+  const stampGen = tsl.uniform(tsl.uint(1)).setName("uGpuSpatialIndexStampGen");
+  return {
+    data,
+    size,
+    mask: size - 1,
+    stampGen,
+    attribute,
+    node
+  };
+}
+function uploadGpuSpatialIndex(gpuIndex, cpuIndex) {
+  if (gpuIndex.size !== cpuIndex.size) {
+    throw new Error(
+      `Spatial index size mismatch (gpu=${gpuIndex.size}, cpu=${cpuIndex.size}).`
+    );
+  }
+  for (let i = 0; i < cpuIndex.size; i += 1) {
+    const base = i * SLOT_STRIDE;
+    gpuIndex.data[base] = cpuIndex.stamp[i] ?? 0;
+    gpuIndex.data[base + 1] = cpuIndex.keysSpace[i] ?? 0;
+    gpuIndex.data[base + 2] = cpuIndex.keysLevel[i] ?? 0;
+    gpuIndex.data[base + 3] = cpuIndex.keysX[i] ?? 0;
+    gpuIndex.data[base + 4] = cpuIndex.keysY[i] ?? 0;
+    gpuIndex.data[base + 5] = cpuIndex.values[i] ?? 0;
+  }
+  gpuIndex.stampGen.value = cpuIndex.stampGen >>> 0;
+  gpuIndex.attribute.needsUpdate = true;
+  gpuIndex.node.needsUpdate = true;
+}
+function readGpuSpatialIndexValue(spatialIndex, slot, fieldOffset) {
+  const offset = tsl.int(slot).mul(tsl.int(SLOT_STRIDE)).add(tsl.int(fieldOffset));
+  return spatialIndex.node.element(offset).toUint();
+}
+const mix32 = tsl.Fn(([x]) => {
+  const v = tsl.uint(x).toVar();
+  v.assign(v.bitXor(v.shiftRight(tsl.uint(16))));
+  v.assign(v.mul(tsl.uint(2146121005)));
+  v.assign(v.bitXor(v.shiftRight(tsl.uint(15))));
+  v.assign(v.mul(tsl.uint(2221713035)));
+  v.assign(v.bitXor(v.shiftRight(tsl.uint(16))));
+  return v;
+});
+const hashKey = tsl.Fn(([space, level, x, y]) => {
+  const s = tsl.uint(space).bitAnd(tsl.uint(255));
+  const l = tsl.uint(level).bitAnd(tsl.uint(255));
+  const h = s.bitXor(l.shiftLeft(tsl.uint(8))).bitXor(mix32(tsl.uint(x))).bitXor(mix32(tsl.uint(y)));
+  return mix32(h);
+});
+const createGpuSpatialLookup = (spatialIndex) => {
+  const slotCount = spatialIndex.size;
+  const mask = tsl.uint(spatialIndex.mask);
+  const stampGen = spatialIndex.stampGen.toUint();
+  const emptyValue = tsl.int(-1);
+  return tsl.Fn(([space, level, x, y]) => {
+    const s = tsl.uint(space).bitAnd(tsl.uint(255));
+    const l = tsl.uint(level).bitAnd(tsl.uint(255));
+    const xx = tsl.uint(x);
+    const yy = tsl.uint(y);
+    const result = emptyValue.toVar();
+    const slot = hashKey(s, l, xx, yy).bitAnd(mask).toVar();
+    const probes = tsl.int(0).toVar();
+    tsl.Loop(slotCount, () => {
+      const stamp = readGpuSpatialIndexValue(spatialIndex, slot, 0);
+      tsl.If(stamp.notEqual(stampGen), () => {
+        tsl.Break();
+      });
+      const ks = readGpuSpatialIndexValue(spatialIndex, slot, 1);
+      const kl = readGpuSpatialIndexValue(spatialIndex, slot, 2);
+      const kx = readGpuSpatialIndexValue(spatialIndex, slot, 3);
+      const ky = readGpuSpatialIndexValue(spatialIndex, slot, 4);
+      tsl.If(
+        ks.equal(s).and(kl.equal(l)).and(kx.equal(xx)).and(ky.equal(yy)),
+        () => {
+          result.assign(tsl.int(readGpuSpatialIndexValue(spatialIndex, slot, 5)));
+          tsl.Break();
+        }
+      );
+      slot.assign(slot.add(tsl.uint(1)).bitAnd(mask));
+      probes.addAssign(1);
+    });
+    return result;
+  });
+};
+const createTileIndexFromWorldPosition = (spatialIndex, uniforms, maxLevel) => {
+  const lookup = createGpuSpatialLookup(spatialIndex);
+  const levelCount = Math.max(1, maxLevel + 1);
+  return tsl.Fn(([worldX, worldZ]) => {
+    const rootOrigin = uniforms.uRootOrigin.toVar();
+    const rootSize = uniforms.uRootSize.toVar();
+    const halfRoot = rootSize.mul(tsl.float(0.5));
+    const tileIndex = tsl.int(-1).toVar();
+    const tileU = tsl.float(0).toVar();
+    const tileV = tsl.float(0).toVar();
+    const i = tsl.int(0).toVar();
+    tsl.Loop(levelCount, () => {
+      const level = tsl.int(maxLevel).sub(i).toVar();
+      const scale = tsl.pow(tsl.float(2), level.toFloat());
+      const tileSize = rootSize.div(scale);
+      const tileX = worldX.sub(rootOrigin.x).add(halfRoot).div(tileSize).floor().toInt();
+      const tileY = worldZ.sub(rootOrigin.z).add(halfRoot).div(tileSize).floor().toInt();
+      const maybeIndex = lookup(tsl.int(0), level, tileX, tileY).toVar();
+      tsl.If(maybeIndex.greaterThanEqual(tsl.int(0)), () => {
+        const minX = rootOrigin.x.add(tileX.toFloat().mul(tileSize)).sub(halfRoot);
+        const minZ = rootOrigin.z.add(tileY.toFloat().mul(tileSize)).sub(halfRoot);
+        tileIndex.assign(maybeIndex);
+        tileU.assign(worldX.sub(minX).div(tileSize));
+        tileV.assign(worldZ.sub(minZ).div(tileSize));
+        tsl.Break();
+      });
+      i.addAssign(1);
+    });
+    return tsl.vec3(tileIndex.toFloat(), tileU, tileV);
+  });
+};
+
+const gpuSpatialIndexStorageTask = work.task((get, work) => {
+  const maxNodesValue = get(maxNodes);
+  return work(() => createGpuSpatialIndex(maxNodesValue));
+}).displayName("gpuSpatialIndexStorageTask");
+const gpuSpatialIndexUploadTask = work.task((get, work) => {
+  const quadtreeConfig = get(quadtreeConfigTask);
+  get(quadtreeUpdateTask);
+  const gpuSpatialIndex = get(gpuSpatialIndexStorageTask);
+  return work(() => {
+    uploadGpuSpatialIndex(gpuSpatialIndex, quadtreeConfig.state.leafIndex);
+    return gpuSpatialIndex;
+  });
+}).displayName("gpuSpatialIndexUploadTask");
+
+function createTerrainSampleNode(params) {
+  const tileLookup = createTileIndexFromWorldPosition(
+    params.spatialIndex,
+    params.uniforms,
+    maxLevel.get()
+  );
+  return tsl.Fn(([worldX, worldZ]) => {
+    const tileResult = tileLookup(worldX, worldZ).toVar();
+    const tileIndex = tsl.int(tileResult.x).toVar();
+    const safeTileIndex = tileIndex.max(tsl.int(0)).toVar();
+    const u = tileResult.y.toVar();
+    const v = tileResult.z.toVar();
+    const fieldU = tileLocalToFieldUV$1(
+      u,
+      params.uniforms.uInnerTileSegments
+    ).toVar();
+    const fieldV = tileLocalToFieldUV$1(
+      v,
+      params.uniforms.uInnerTileSegments
+    ).toVar();
+    const found = tileIndex.greaterThanEqual(tsl.int(0)).toVar();
+    const sampled = sampleTerrainField(
+      params.terrainFieldStorage,
+      fieldU,
+      fieldV,
+      safeTileIndex
+    ).toVar();
+    const nx = sampled.g.toVar();
+    const nz = sampled.b.toVar();
+    const ny = tsl.float(1).sub(nx.mul(nx)).sub(nz.mul(nz)).max(0).sqrt();
+    const valid = found.select(tsl.float(1), tsl.float(0)).toVar();
+    return tsl.vec4(
+      sampled.r.mul(valid),
+      nx.mul(valid),
+      ny.mul(valid),
+      nz.mul(valid)
+    );
+  });
+}
+function createTerrainSampler(params) {
+  const elevationNode = createElevationFunction(params.elevationCallback);
+  const terrainSampleAt = createTerrainSampleNode(params);
+  const evaluateElevationAt = tsl.Fn(([worldX, worldZ]) => {
+    const rootOrigin = params.uniforms.uRootOrigin.toVar();
+    const rootSize = params.uniforms.uRootSize.toVar();
+    const centeredX = worldX.sub(rootOrigin.x);
+    const centeredZ = worldZ.sub(rootOrigin.z);
+    const rootUV = tsl.vec2(
+      centeredX.div(rootSize).add(0.5),
+      centeredZ.div(rootSize).mul(tsl.float(-1)).add(0.5)
+    ).toVar();
+    return elevationNode({
+      worldPosition: tsl.vec3(worldX, rootOrigin.y, worldZ),
+      rootSize,
+      rootUV,
+      tileUV: rootUV,
+      tileLevel: tsl.int(0),
+      tileSize: rootSize,
+      tileOriginVec2: tsl.vec2(0, 0),
+      nodeIndex: tsl.int(0)
+    });
+  });
+  const sampleTerrain = tsl.Fn(
+    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ)
+  );
+  const sampleElevation = tsl.Fn(
+    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ).x
+  );
+  const sampleNormal = tsl.Fn(
+    ([worldX, worldZ]) => tsl.vec3(
+      terrainSampleAt(worldX, worldZ).y,
+      terrainSampleAt(worldX, worldZ).z,
+      terrainSampleAt(worldX, worldZ).w
+    )
+  );
+  const sampleValidity = tsl.Fn(
+    ([worldX, worldZ]) => terrainSampleAt(worldX, worldZ).y.abs().add(terrainSampleAt(worldX, worldZ).z.abs()).add(terrainSampleAt(worldX, worldZ).w.abs()).greaterThan(tsl.float(0)).select(tsl.float(1), tsl.float(0))
+  );
+  const evaluateElevation = tsl.Fn(
+    ([worldX, worldZ]) => evaluateElevationAt(worldX, worldZ)
+  );
+  const evaluateNormalNode = tsl.Fn(
+    ([worldX, worldZ, epsilon]) => {
+      const eps = epsilon ?? tsl.float(0.1);
+      const elevationScale = params.uniforms.uElevationScale.toVar();
+      const hL = evaluateElevationAt(worldX.sub(eps), worldZ).mul(
+        elevationScale
+      );
+      const hR = evaluateElevationAt(worldX.add(eps), worldZ).mul(
+        elevationScale
+      );
+      const hD = evaluateElevationAt(worldX, worldZ.sub(eps)).mul(
+        elevationScale
+      );
+      const hU = evaluateElevationAt(worldX, worldZ.add(eps)).mul(
+        elevationScale
+      );
+      const inv2eps = tsl.float(0.5).div(eps);
+      const dhdx = hR.sub(hL).mul(inv2eps);
+      const dhdz = hU.sub(hD).mul(inv2eps);
+      return tsl.vec3(dhdx.negate(), tsl.float(1), dhdz.negate()).normalize();
+    }
+  );
+  const evaluateNormal = (worldX, worldZ, epsilon) => evaluateNormalNode(worldX, worldZ, epsilon ?? tsl.float(0.1));
+  return {
+    sampleElevation,
+    sampleNormal,
+    sampleTerrain,
+    sampleValidity,
+    evaluateElevation,
+    evaluateNormal
+  };
+}
+
+const createTerrainSamplerTask = work.task((get, work) => {
+  const terrainFieldStorage = get(createTerrainFieldTextureTask);
+  const spatialIndex = get(gpuSpatialIndexStorageTask);
+  const uniforms = get(updateUniformsTask);
+  const elevationCallback = get(elevationFn);
+  return work(
+    () => createTerrainSampler({
+      terrainFieldStorage,
+      spatialIndex,
+      uniforms,
+      elevationCallback
+    })
+  );
+}).displayName("createTerrainSamplerTask");
+
 const isSkirtVertex = tsl.Fn(([segments]) => {
   const segmentsNode = typeof segments === "number" ? tsl.int(segments) : segments;
   const vIndex = tsl.int(tsl.vertexIndex);
@@ -235,6 +2437,483 @@ const isSkirtUV = tsl.Fn(([segments]) => {
   return innerX.and(innerY).not();
 });
 
+function createTileBaseWorldPosition(leafStorage, terrainUniforms) {
+  return tsl.Fn(() => {
+    const nodeIndex = tsl.int(tsl.instanceIndex);
+    const nodeOffset = nodeIndex.mul(tsl.int(4));
+    const nodeLevel = leafStorage.node.element(nodeOffset).toInt();
+    const nodeX = leafStorage.node.element(nodeOffset.add(tsl.int(1))).toFloat();
+    const nodeY = leafStorage.node.element(nodeOffset.add(tsl.int(2))).toFloat();
+    const rootSize = terrainUniforms.uRootSize.toVar();
+    const rootOrigin = terrainUniforms.uRootOrigin.toVar();
+    const half = tsl.float(0.5);
+    const size = rootSize.div(tsl.pow(tsl.float(2), nodeLevel.toFloat()));
+    const halfRoot = rootSize.mul(half);
+    const centerX = rootOrigin.x.add(nodeX.add(half).mul(size)).sub(halfRoot);
+    const centerZ = rootOrigin.z.add(nodeY.add(half).mul(size)).sub(halfRoot);
+    const clampedX = tsl.positionLocal.x.max(half.negate()).min(half);
+    const clampedZ = tsl.positionLocal.z.max(half.negate()).min(half);
+    const worldX = centerX.add(clampedX.mul(size));
+    const worldZ = centerZ.add(clampedZ.mul(size));
+    return tsl.vec3(worldX, rootOrigin.y, worldZ);
+  });
+}
+function createTileElevation(terrainUniforms, terrainFieldStorage) {
+  if (!terrainFieldStorage) return tsl.float(0);
+  const innerSegs = terrainUniforms.uInnerTileSegments;
+  const u = tileLocalToFieldUV$1(tsl.positionLocal.x.add(tsl.float(0.5)), innerSegs);
+  const v = tileLocalToFieldUV$1(tsl.positionLocal.z.add(tsl.float(0.5)), innerSegs);
+  return sampleTerrainFieldElevation(
+    terrainFieldStorage,
+    u,
+    v,
+    tsl.int(tsl.instanceIndex)
+  ).mul(terrainUniforms.uElevationScale);
+}
+function createNormalAssignment(terrainUniforms, terrainFieldStorage) {
+  if (!terrainFieldStorage) return;
+  const nodeIndex = tsl.int(tsl.instanceIndex);
+  const edgeVertexCount = tsl.int(terrainUniforms.uInnerTileSegments.add(3));
+  const localVertexIndex = tsl.int(tsl.vertexIndex);
+  const ix = localVertexIndex.mod(edgeVertexCount);
+  const iy = localVertexIndex.div(edgeVertexCount);
+  const normalXZ = loadTerrainFieldNormal(
+    terrainFieldStorage,
+    ix,
+    iy,
+    nodeIndex
+  );
+  const nx = normalXZ.x;
+  const nz = normalXZ.y;
+  const nySq = tsl.float(1).sub(nx.mul(nx)).sub(nz.mul(nz)).max(tsl.float(0));
+  const ny = nySq.sqrt();
+  tsl.normalLocal.assign(tsl.vec3(nx, ny, nz));
+}
+function createTileWorldPosition(leafStorage, terrainUniforms, terrainFieldStorage) {
+  const baseWorldPosition = createTileBaseWorldPosition(
+    leafStorage,
+    terrainUniforms
+  );
+  return tsl.Fn(() => {
+    const base = baseWorldPosition();
+    const yElevation = createTileElevation(
+      terrainUniforms,
+      terrainFieldStorage
+    );
+    const skirtVertex = isSkirtVertex(terrainUniforms.uInnerTileSegments);
+    const skirtY = base.y.add(yElevation).sub(terrainUniforms.uSkirtScale.toVar());
+    const worldY = tsl.select(skirtVertex, skirtY, base.y.add(yElevation));
+    createNormalAssignment(terrainUniforms, terrainFieldStorage);
+    return tsl.vec3(base.x, worldY, base.z);
+  })();
+}
+
+const positionNodeTask = work.task((get, work) => {
+  const leafStorage = get(leafStorageTask);
+  const terrainUniforms = get(updateUniformsTask);
+  const terrainFieldStorage = get(createTerrainFieldTextureTask);
+  return work(
+    () => createTileWorldPosition(
+      leafStorage,
+      terrainUniforms,
+      terrainFieldStorage
+    )
+  );
+}).displayName("positionNodeTask");
+
+function intersectRayAabb(ray, minX, minY, minZ, maxX, maxY, maxZ) {
+  let tMin = -Infinity;
+  let tMax = Infinity;
+  const origin = ray.origin;
+  const dir = ray.direction;
+  const slab = (originAxis, dirAxis, minAxis, maxAxis) => {
+    if (Math.abs(dirAxis) < 1e-8) {
+      if (originAxis < minAxis || originAxis > maxAxis) return false;
+      return true;
+    }
+    const inv = 1 / dirAxis;
+    let t0 = (minAxis - originAxis) * inv;
+    let t1 = (maxAxis - originAxis) * inv;
+    if (t0 > t1) {
+      const tmp = t0;
+      t0 = t1;
+      t1 = tmp;
+    }
+    tMin = Math.max(tMin, t0);
+    tMax = Math.min(tMax, t1);
+    return tMax >= tMin;
+  };
+  if (!slab(origin.x, dir.x, minX, maxX) || !slab(origin.y, dir.y, minY, maxY) || !slab(origin.z, dir.z, minZ, maxZ)) {
+    return null;
+  }
+  return { tMin, tMax };
+}
+function getTerrainBounds(config) {
+  const halfRoot = config.rootSize * 0.5;
+  return {
+    minX: config.originX - halfRoot,
+    maxX: config.originX + halfRoot,
+    minZ: config.originZ - halfRoot,
+    maxZ: config.originZ + halfRoot
+  };
+}
+function terrainSignedDistanceFromBounds(query, worldX, worldY, worldZ) {
+  const tileBounds = query.getTileBounds(worldX, worldZ);
+  if (tileBounds) {
+    if (worldY > tileBounds.maxElevation) {
+      return worldY - tileBounds.maxElevation;
+    }
+    if (worldY < tileBounds.minElevation) {
+      return worldY - tileBounds.minElevation;
+    }
+  }
+  const elevation = query.getElevation(worldX, worldZ);
+  if (!Number.isFinite(elevation)) return void 0;
+  return worldY - elevation;
+}
+function terrainSignedDistancePrecise(query, worldX, worldY, worldZ) {
+  const elevation = query.getElevation(worldX, worldZ);
+  if (!Number.isFinite(elevation)) return void 0;
+  return worldY - elevation;
+}
+function cpuRaycast(query, ray, config, options) {
+  const bounds = getTerrainBounds(config);
+  const segment = intersectRayAabb(
+    ray,
+    bounds.minX,
+    config.minY,
+    bounds.minZ,
+    bounds.maxX,
+    config.maxY,
+    bounds.maxZ
+  );
+  if (!segment) return null;
+  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
+  let startT = Math.max(0, segment.tMin);
+  const endT = Math.min(segment.tMax, maxDistance);
+  if (endT < startT) return null;
+  const maxSteps = Math.max(8, options?.maxSteps ?? 128);
+  const refinementSteps = Math.max(1, options?.refinementSteps ?? 8);
+  const point = new three.Vector3();
+  let prevT = startT;
+  ray.at(prevT, point);
+  let prevSignedDistance = terrainSignedDistanceFromBounds(
+    query,
+    point.x,
+    point.y,
+    point.z
+  );
+  if (prevSignedDistance !== void 0 && prevSignedDistance <= 0) {
+    const sample = query.sampleTerrain(point.x, point.z);
+    if (!sample.valid) return null;
+    point.y = sample.elevation;
+    return {
+      position: point.clone(),
+      normal: sample.normal.clone(),
+      distance: ray.origin.distanceTo(point)
+    };
+  }
+  for (let i = 1; i <= maxSteps; i += 1) {
+    const t = startT + (endT - startT) * i / maxSteps;
+    ray.at(t, point);
+    const signedDistance = terrainSignedDistanceFromBounds(
+      query,
+      point.x,
+      point.y,
+      point.z
+    );
+    if (signedDistance === void 0) {
+      prevSignedDistance = void 0;
+      prevT = t;
+      continue;
+    }
+    if (prevSignedDistance !== void 0 && prevSignedDistance > 0 && signedDistance <= 0) {
+      let lo = prevT;
+      let hi = t;
+      for (let r = 0; r < refinementSteps; r += 1) {
+        const mid = (lo + hi) * 0.5;
+        ray.at(mid, point);
+        const midDistance = terrainSignedDistancePrecise(
+          query,
+          point.x,
+          point.y,
+          point.z
+        );
+        if (midDistance === void 0) {
+          lo = mid;
+          continue;
+        }
+        if (midDistance > 0) lo = mid;
+        else hi = mid;
+      }
+      const hitT = hi;
+      ray.at(hitT, point);
+      const sample = query.sampleTerrain(point.x, point.z);
+      if (!sample.valid) return null;
+      point.y = sample.elevation;
+      return {
+        position: point.clone(),
+        normal: sample.normal.clone(),
+        distance: ray.origin.distanceTo(point)
+      };
+    }
+    prevSignedDistance = signedDistance;
+    prevT = t;
+  }
+  return null;
+}
+function cpuRaycastBoundsOnly(ray, config, options) {
+  const bounds = getTerrainBounds(config);
+  const planeY = (config.minY + config.maxY) * 0.5;
+  const dirY = ray.direction.y;
+  if (Math.abs(dirY) < 1e-8) return null;
+  const t = (planeY - ray.origin.y) / dirY;
+  if (t < 0) return null;
+  const maxDistance = options?.maxDistance ?? Number.POSITIVE_INFINITY;
+  if (t > maxDistance) return null;
+  const point = new three.Vector3();
+  ray.at(t, point);
+  if (point.x < bounds.minX || point.x > bounds.maxX || point.z < bounds.minZ || point.z > bounds.maxZ) {
+    return null;
+  }
+  return {
+    position: point,
+    normal: new three.Vector3(0, 1, 0),
+    distance: ray.origin.distanceTo(point)
+  };
+}
+
+function createTerrainRaycast(params) {
+  return {
+    pick(ray, options) {
+      const config = params.getConfig();
+      const terrainQuery = params.getTerrainQuery();
+      if (terrainQuery) {
+        const precise = cpuRaycast(terrainQuery, ray, config, options);
+        if (precise) return precise;
+      }
+      const coarse = cpuRaycastBoundsOnly(ray, config, options);
+      if (coarse && terrainQuery) {
+        const sample = terrainQuery.sampleTerrain(
+          coarse.position.x,
+          coarse.position.z
+        );
+        if (sample.valid) {
+          coarse.position.y = sample.elevation;
+          coarse.normal.copy(sample.normal);
+        }
+      }
+      return coarse;
+    }
+  };
+}
+
+const BOUNDS_PADDING = 1;
+const RAYCAST_STATE = Symbol("terrainRaycastTaskState");
+const terrainRaycastTask = work.task(
+  (get, work) => {
+    const { query: terrainQuery } = get(terrainQueryTask);
+    const rootSizeValue = get(rootSize);
+    const originValue = get(origin);
+    const elevationScaleValue = get(elevationScale);
+    return work((prev) => {
+      let raycast = prev;
+      let state = raycast?.[RAYCAST_STATE];
+      if (!state) {
+        state = {
+          terrainQuery: null,
+          bounds: {
+            rootSize: 0,
+            originX: 0,
+            originZ: 0,
+            minY: 0,
+            maxY: 0
+          }
+        };
+      }
+      state.terrainQuery = terrainQuery;
+      state.bounds.rootSize = rootSizeValue;
+      state.bounds.originX = originValue.x;
+      state.bounds.originZ = originValue.z;
+      const range = terrainQuery.getGlobalElevationRange();
+      if (range) {
+        state.bounds.minY = range.min - BOUNDS_PADDING;
+        state.bounds.maxY = range.max + BOUNDS_PADDING;
+      } else {
+        const verticalExtent = Math.max(1, Math.abs(elevationScaleValue) * 2);
+        state.bounds.minY = originValue.y - verticalExtent;
+        state.bounds.maxY = originValue.y + verticalExtent;
+      }
+      if (!raycast) {
+        raycast = createTerrainRaycast({
+          getTerrainQuery: () => state.terrainQuery,
+          getConfig: () => state.bounds
+        });
+      }
+      raycast[RAYCAST_STATE] = state;
+      return raycast;
+    });
+  }
+).displayName("terrainRaycastTask");
+
+function terrainGraph() {
+  return work.graph().add(instanceIdTask).add(quadtreeConfigTask).add(quadtreeUpdateTask).add(leafStorageTask).add(surfaceTask).add(leafGpuBufferTask).add(gpuSpatialIndexStorageTask).add(gpuSpatialIndexUploadTask).add(createUniformsTask).add(updateUniformsTask).add(positionNodeTask).add(createElevationFieldContextTask).add(tileNodesTask).add(createTerrainFieldTextureTask).add(createTerrainSamplerTask).add(elevationFieldStageTask).add(terrainFieldStageTask).add(compileComputeTask).add(executeComputeTask).add(tileBoundsContextTask).add(tileBoundsReductionTask).add(terrainQueryTask).add(terrainReadbackTask).add(terrainRaycastTask);
+}
+const terrainTasks = {
+  instanceId: instanceIdTask,
+  quadtreeConfig: quadtreeConfigTask,
+  quadtreeUpdate: quadtreeUpdateTask,
+  leafStorage: leafStorageTask,
+  surface: surfaceTask,
+  leafGpuBuffer: leafGpuBufferTask,
+  gpuSpatialIndexStorage: gpuSpatialIndexStorageTask,
+  gpuSpatialIndexUpload: gpuSpatialIndexUploadTask,
+  createUniforms: createUniformsTask,
+  updateUniforms: updateUniformsTask,
+  positionNode: positionNodeTask,
+  createElevationFieldContext: createElevationFieldContextTask,
+  createTileNodes: tileNodesTask,
+  createTerrainFieldTexture: createTerrainFieldTextureTask,
+  createTerrainSampler: createTerrainSamplerTask,
+  elevationFieldStage: elevationFieldStageTask,
+  terrainFieldStage: terrainFieldStageTask,
+  compileCompute: compileComputeTask,
+  executeCompute: executeComputeTask,
+  tileBoundsContext: tileBoundsContextTask,
+  tileBoundsReduction: tileBoundsReductionTask,
+  terrainQuery: terrainQueryTask,
+  terrainReadback: terrainReadbackTask,
+  terrainRaycast: terrainRaycastTask
+};
+
+const textureSpaceToVectorSpace = tsl.Fn(([value]) => {
+  return tsl.remap(value, tsl.float(0), tsl.float(1), tsl.float(-1), tsl.float(1));
+});
+const vectorSpaceToTextureSpace = tsl.Fn(([value]) => {
+  return tsl.remap(value, tsl.float(-1), tsl.float(1), tsl.float(0), tsl.float(1));
+});
+const blendAngleCorrectedNormals = tsl.Fn(([n1, n2]) => {
+  const t = tsl.vec3(n1.x, n1.y, n1.z.add(1));
+  const u = tsl.vec3(n2.x.negate(), n2.y.negate(), n2.z);
+  const r = t.mul(tsl.dot(t, u)).sub(u.mul(t.z)).normalize();
+  return r;
+});
+const deriveNormalZ = tsl.Fn(([normalXY]) => {
+  const xy = normalXY.toVar();
+  const z = xy.x.mul(xy.x).add(xy.y.mul(xy.y)).oneMinus().max(0).sqrt();
+  return tsl.vec3(xy.x, xy.y, z);
+});
+
+const vGlobalVertexIndex = /* @__PURE__ */ tsl.varyingProperty("int", "vGlobalVertexIndex");
+const vElevation = /* @__PURE__ */ tsl.varyingProperty("f32", "vElevation");
+
+const cellCenter = tsl.Fn(({ cell }) => {
+  return cell.add(tsl.mx_noise_float(cell.mul(Math.PI)));
+});
+const voronoiCells = tsl.Fn((params) => {
+  const scale = tsl.float(params.scale);
+  const facet = tsl.float(params.facet);
+  const seed = tsl.float(params.seed);
+  const pos = params.uv.mul(scale).add(seed);
+  const midCell = pos.round().toVar();
+  const minCell = midCell.toVar();
+  const minDist = tsl.float(1).toVar();
+  const cell = tsl.vec3(0, 0, 0).toVar();
+  const dist = tsl.float().toVar();
+  const i = tsl.float(0).toVar();
+  tsl.Loop(27, () => {
+    const ix = i.mod(3).sub(1);
+    const iy = i.div(3).floor().mod(3).sub(1);
+    const iz = i.div(9).floor().sub(1);
+    cell.assign(midCell.add(tsl.vec3(ix, iy, iz)));
+    dist.assign(pos.distance(cellCenter({ cell })).add(tsl.mx_noise_float(pos).div(5)));
+    tsl.If(dist.lessThan(minDist), () => {
+      minDist.assign(dist);
+      minCell.assign(cell);
+    });
+    i.addAssign(1);
+  });
+  const n = tsl.mx_noise_float(minCell.mul(Math.PI)).toVar();
+  const k = tsl.mix(minDist, n.add(1).div(2), facet);
+  return k;
+});
+
+exports.ArrayTextureBackend = ArrayTextureBackend;
+exports.AtlasBackend = AtlasBackend;
+exports.Dir = Dir;
 exports.TerrainGeometry = TerrainGeometry;
+exports.TerrainMesh = TerrainMesh;
+exports.Texture3DBackend = Texture3DBackend;
+exports.U32_EMPTY = U32_EMPTY;
+exports.allocLeafSet = allocLeafSet;
+exports.allocSeamTable = allocSeamTable;
+exports.beginUpdate = beginUpdate;
+exports.blendAngleCorrectedNormals = blendAngleCorrectedNormals;
+exports.buildLeafIndex = buildLeafIndex;
+exports.buildSeams2to1 = buildSeams2to1;
+exports.compileComputeTask = compileComputeTask;
+exports.createComputePipelineTasks = createComputePipelineTasks;
+exports.createCubeSphereSurface = createCubeSphereSurface;
+exports.createElevationFieldContextTask = createElevationFieldContextTask;
+exports.createFlatSurface = createFlatSurface;
+exports.createInfiniteFlatSurface = createInfiniteFlatSurface;
+exports.createSpatialIndex = createSpatialIndex;
+exports.createState = createState;
+exports.createTerrainFieldStorage = createTerrainFieldStorage;
+exports.createTerrainFieldTextureTask = createTerrainFieldTextureTask;
+exports.createTerrainQuery = createTerrainQuery;
+exports.createTerrainRaycast = createTerrainRaycast;
+exports.createTerrainSampler = createTerrainSampler;
+exports.createTerrainSamplerTask = createTerrainSamplerTask;
+exports.createTerrainUniforms = createTerrainUniforms;
+exports.createUniformsTask = createUniformsTask;
+exports.deriveNormalZ = deriveNormalZ;
+exports.elevationFieldStageTask = elevationFieldStageTask;
+exports.elevationFn = elevationFn;
+exports.elevationScale = elevationScale;
+exports.executeComputeTask = executeComputeTask;
+exports.getDeviceComputeLimits = getDeviceComputeLimits;
+exports.gpuSpatialIndexStorageTask = gpuSpatialIndexStorageTask;
+exports.gpuSpatialIndexUploadTask = gpuSpatialIndexUploadTask;
+exports.innerTileSegments = innerTileSegments;
+exports.instanceIdTask = instanceIdTask;
 exports.isSkirtUV = isSkirtUV;
 exports.isSkirtVertex = isSkirtVertex;
+exports.leafGpuBufferTask = leafGpuBufferTask;
+exports.leafStorageTask = leafStorageTask;
+exports.loadTerrainField = loadTerrainField;
+exports.loadTerrainFieldElevation = loadTerrainFieldElevation;
+exports.loadTerrainFieldNormal = loadTerrainFieldNormal;
+exports.maxLevel = maxLevel;
+exports.maxNodes = maxNodes;
+exports.origin = origin;
+exports.packTerrainFieldSample = packTerrainFieldSample;
+exports.positionNodeTask = positionNodeTask;
+exports.quadtreeConfigTask = quadtreeConfigTask;
+exports.quadtreeUpdate = quadtreeUpdate;
+exports.quadtreeUpdateTask = quadtreeUpdateTask;
+exports.resetLeafSet = resetLeafSet;
+exports.resetSeamTable = resetSeamTable;
+exports.rootSize = rootSize;
+exports.sampleTerrainField = sampleTerrainField;
+exports.sampleTerrainFieldElevation = sampleTerrainFieldElevation;
+exports.sampleTerrainFieldNormal = sampleTerrainFieldNormal;
+exports.skirtScale = skirtScale;
+exports.storeTerrainField = storeTerrainField;
+exports.surface = surface;
+exports.surfaceTask = surfaceTask;
+exports.terrainFieldFilter = terrainFieldFilter;
+exports.terrainFieldStageTask = terrainFieldStageTask;
+exports.terrainGraph = terrainGraph;
+exports.terrainQueryTask = terrainQueryTask;
+exports.terrainRaycastTask = terrainRaycastTask;
+exports.terrainReadbackTask = terrainReadbackTask;
+exports.terrainTasks = terrainTasks;
+exports.textureSpaceToVectorSpace = textureSpaceToVectorSpace;
+exports.tileNodesTask = tileNodesTask;
+exports.update = update;
+exports.updateUniformsTask = updateUniformsTask;
+exports.vElevation = vElevation;
+exports.vGlobalVertexIndex = vGlobalVertexIndex;
+exports.vectorSpaceToTextureSpace = vectorSpaceToTextureSpace;
+exports.voronoiCells = voronoiCells;