@aethervtt/shard-terrain 0.1.0 → 0.2.0

package/dist/heightfield/testing.js

@@ -0,0 +1,441 @@
+import { hash32, quat } from "@aethervtt/shard-core";
+import { loadNoiseKernel, NoiseGraph, NoiseGraphs } from "@aethervtt/shard-noise";
+import {
+  CharacterController,
+  CharacterIntent,
+  CharacterState,
+  PhysicsConfig,
+  physics3dPlugin
+} from "@aethervtt/shard-physics";
+import {
+  Camera3d,
+  captureView,
+  DirectionalLight,
+  Exposure,
+  forwardPlugin,
+  Gpu,
+  OffscreenTarget,
+  RenderTargets,
+  renderPlugin,
+  Shaders,
+  Tonemapping
+} from "@aethervtt/shard-render";
+import { App } from "@aethervtt/shard-runtime";
+import {
+  FloatingOrigin,
+  Grid,
+  placeInGrid,
+  Transform,
+  TransformPlugin,
+  worldPosition64
+} from "@aethervtt/shard-transform";
+import { TerrainBudget } from "../components.js";
+import { lockCode } from "../grid-mesh.js";
+import { TerrainWorld } from "../heights.js";
+import { morphFactor } from "../lod.js";
+import { terrainPlugin } from "../plugin.js";
+import { tilesOf } from "./colliders.js";
+import { Terrain } from "./component.js";
+import { Heightmaps } from "./heightmap.js";
+import { dequantize, LEAF_SIDE, PAGE, SIDE } from "./kernel.js";
+import { nodeKey } from "./pages.js";
+import { pageHeight } from "./queries.js";
+import { parseTerrainSource, terrainLayout } from "./source.js";
+import { TerrainSourceAsset, TerrainSources } from "./source-asset.js";
+import { mainNoise } from "./stack.js";
+function sourceAsset(world, o) {
+  const source = parseTerrainSource(o.source);
+  const layout = terrainLayout(source, o.block);
+  const deps = {};
+  const graphs = world.initResource(NoiseGraphs);
+  for (const [path, graph] of Object.entries(o.noise ?? {})) {
+    const ref = graphs.add(graph, path);
+    deps[path] = { guid: ref.guid, type: "NoiseGraph", hash: graph.hash };
+  }
+  const maps = world.initResource(Heightmaps);
+  for (const [path, map] of Object.entries(o.heightmaps ?? {})) {
+    const ref = maps.add({ ...map, version: 0 }, path);
+    deps[path] = { guid: ref.guid, type: "Heightmap", hash: path };
+  }
+  return new TerrainSourceAsset({
+    format: 1,
+    source,
+    layout,
+    deps,
+    hash: JSON.stringify([o.source, Object.keys(deps)])
+  });
+}
+async function heightfieldApp(gpu, o) {
+  const app = new App().addPlugin(TransformPlugin);
+  if (gpu) app.addPlugin(renderPlugin({ gpu, windowView: false }), forwardPlugin({ msaa: 1 }));
+  if (o.physics) app.addPlugin(physics3dPlugin());
+  app.addPlugin(terrainPlugin({ workers: o.workers, fs: o.fs }), ...o.extra ?? []);
+  await app.init();
+  const world = app.world;
+  if (o.physics) world.resource(PhysicsConfig).gravity = [0, -9.81, 0];
+  if (o.pages !== void 0) world.resource(TerrainBudget).pages = o.pages;
+  if (o.pagesPerFrame !== void 0) world.resource(TerrainBudget).pagesPerFrame = o.pagesPerFrame;
+  const asset = sourceAsset(world, o);
+  const sources = world.initResource(TerrainSources);
+  let ref = sources.add(asset, "test.terrain.json");
+  if (o.name) {
+    sources.set(o.name, asset);
+    ref = { type: "terrain/TerrainSource", guid: o.name, path: `${o.name}.terrain.json` };
+  }
+  const terrain = world.spawn(
+    [Grid, { cellSize: 2e3 }],
+    [
+      Terrain,
+      {
+        source: ref,
+        skirts: o.skirts ?? true,
+        errorPixels: o.errorPixels ?? 2,
+        ...o.vertexPixels !== void 0 ? { vertexPixels: o.vertexPixels } : {}
+      }
+    ],
+    [Transform, { translation: o.at ?? [0, 0, 0] }]
+  );
+  let view = "";
+  let camera = -1;
+  let sun = -1;
+  if (gpu) {
+    const target = new OffscreenTarget(gpu, {
+      label: "heightfield-test",
+      width: o.width ?? 96,
+      height: o.heightPx ?? 64
+    });
+    const targetRef = world.resource(RenderTargets).add(target, "heightfield-test");
+    camera = world.spawn(
+      [
+        Camera3d,
+        {
+          target: targetRef,
+          fovY: o.fovY ?? 60,
+          near: 0.05,
+          far: 1e6,
+          clearColor: o.clearColor ?? [1, 0, 1, 1]
+        }
+      ],
+      [Exposure, { ev100: 14 }],
+      [Tonemapping, { curve: "none", dither: false }],
+      Transform,
+      FloatingOrigin
+    );
+    view = `camera:${camera}`;
+    sun = world.spawn(
+      [DirectionalLight, { illuminance: 5e4, shadows: false }],
+      [
+        Transform,
+        {
+          rotation: quat.fromEuler([0, 0, 0, 1], -0.8, 0.4, 0)
+        }
+      ]
+    );
+  }
+  app.update(1 / 60);
+  return {
+    app,
+    world,
+    terrain,
+    camera,
+    sun,
+    view,
+    runtime: () => world.resource(TerrainWorld).heightfields.get(terrain),
+    render: () => world.resource(TerrainWorld).heightfields.get(terrain)?.parts.get("render")
+  };
+}
+function lookAt(p, eye, target) {
+  const f = [target[0] - eye[0], target[1] - eye[1], target[2] - eye[2]];
+  const rotation = quat.lookRotation([0, 0, 0, 1], f, [0, 1, 0]);
+  placeInGrid(p.world, p.camera, p.terrain, eye);
+  p.world.set(p.camera, Transform, { ...p.world.get(p.camera, Transform), rotation });
+}
+async function untilStreaming(p, maxMs = 12e4) {
+  const start = performance.now();
+  while (performance.now() - start < maxMs) {
+    p.app.update(1 / 60);
+    const rt = p.runtime();
+    if (rt?.problem) throw rt.problem;
+    if (rt?.streaming) return;
+    await new Promise((r) => setTimeout(r, 5));
+  }
+  throw new Error(
+    `terrain not streaming after ${maxMs} ms (bake: ${p.runtime()?.bake}, waiting: ${p.runtime()?.waiting})`
+  );
+}
+async function settleHeightfield(p, maxFrames = 600) {
+  const gpu = p.world.tryResource(Gpu);
+  let quiet = 0;
+  for (let f = 0; f < maxFrames; f++) {
+    p.app.update(1 / 60);
+    const rt = p.runtime();
+    const r = p.render();
+    if (gpu) {
+      await p.world.resource(Shaders).whenIdle();
+      await gpu.pipelines.whenIdle();
+    }
+    await new Promise((res) => setTimeout(res, 1));
+    const busy = !rt?.streaming || rt.selection.requestedCount > 0 || (rt.pages?.pendingReads ?? 0) > 0 || (r ? r.arrived.length > 0 || r.pending.size > 0 : true) || (gpu ? gpu.pipelines.pending > 0 : false);
+    quiet = busy ? 0 : quiet + 1;
+    if (quiet >= 3) return f;
+  }
+  return maxFrames;
+}
+async function capture(p) {
+  const shot = captureView(p.world, p.view);
+  p.app.update(1 / 60);
+  return shot;
+}
+function holes(data, W, H, fov, eye, right, up, forward, lowest, rect) {
+  let count = 0;
+  const ty = Math.tan(fov / 2 * Math.PI / 180);
+  const tx = ty * (W / H);
+  for (let py = 0; py < H; py++) {
+    for (let px = 0; px < W; px++) {
+      const a = (px + 0.5) / W * 2 - 1;
+      const b = 1 - (py + 0.5) / H * 2;
+      const d = [0, 1, 2].map((k) => forward[k] + right[k] * a * tx + up[k] * b * ty);
+      if (d[1] >= -1e-6) continue;
+      const t = (lowest - eye[1]) / d[1];
+      if (t <= 0) continue;
+      const x = eye[0] + d[0] * t;
+      const z = eye[2] + d[2] * t;
+      if (x < rect[0] || z < rect[1] || x > rect[2] || z > rect[3]) continue;
+      const o = (py * W + px) * 4;
+      if (data[o] > 200 && data[o + 1] < 60 && data[o + 2] > 200) count++;
+    }
+  }
+  return count;
+}
+function valleySource(size = 2048, spacing = 0.5) {
+  const bowl = new Float32Array(64 * 64);
+  for (let y = 0; y < 64; y++)
+    for (let x = 0; x < 64; x++)
+      bowl[y * 64 + x] = Math.max(0, 1 - Math.hypot(x - 31.5, y - 31.5) / 32);
+  return {
+    source: {
+      size: [size, size],
+      spacing,
+      heightRange: [-150, 350],
+      seed: 7,
+      splines: {
+        road: {
+          points: [
+            [size * 0.05, "ground", size * 0.1],
+            [size * 0.45, "ground", size * 0.35],
+            [size * 0.7, "ground", size * 0.85]
+          ],
+          width: 8,
+          falloff: 14
+        }
+      },
+      height: [
+        { noise: { path: "hills" }, scale: 80 },
+        {
+          image: { path: "valley" },
+          at: [size * 0.6, size * 0.45],
+          size: [size * 0.3, size * 0.22],
+          rotation: 20,
+          range: [0, -60],
+          blend: "add",
+          falloff: 80
+        },
+        { spline: "road", mode: "flatten" }
+      ],
+      layers: [{ name: "grass" }, { name: "rock", triplanar: true }, { name: "gravel" }],
+      paint: [
+        { layer: "grass" },
+        { layer: "rock", slope: [32, 90], blend: 6 },
+        { layer: "gravel", spline: "road", blend: 2 }
+      ]
+    },
+    heightmaps: { valley: { width: 64, height: 64, data: bowl } }
+  };
+}
+const VALLEY_HILLS = {
+  output: "h",
+  nodes: {
+    base: { fbm: { source: "simplex", octaves: 6, frequency: 12e-4, seed: 1 } },
+    ridges: { ridged: { source: "simplex", octaves: 4, frequency: 5e-3, seed: 2 } },
+    h: { add: ["base", { multiply: ["ridges", 0.12] }] }
+  }
+};
+function snapshotDrawn(p) {
+  const rt = p.runtime();
+  const r = p.render();
+  const t = rt.tree;
+  const nodes = /* @__PURE__ */ new Map();
+  const g = new Float64Array(2);
+  for (let i = 0; i < rt.selection.renderedCount; i++) {
+    const n = rt.selection.rendered[i];
+    rt.grid.globalOf(t, n, g);
+    const slot = t.slot[n];
+    nodes.set(nodeKey(t.depth[n], g[0], g[1]), {
+      depth: t.depth[n],
+      x: g[0],
+      z: g[1],
+      locks: Array.from(t.locks.subarray(n * 4, n * 4 + 4)),
+      mask: t.mask[n],
+      fade: slot >= 0 ? r.table[slot * 4 + 2] / 255 : 0,
+      anchored: slot >= 0 && r.table[slot * 4 + 3] >= 128
+    });
+  }
+  return {
+    nodes,
+    camera: Array.from(r.view.position),
+    splitScale: r.camera[3],
+    errors: Float32Array.from(rt.errors)
+  };
+}
+function drawnHeightAt(rt, f, x, z, skipStitched = true) {
+  const layout = rt.layout;
+  for (let depth = layout.depth; depth >= 0; depth--) {
+    const size = rt.nodeSize(depth);
+    const nx = Math.floor(x / size);
+    const nz = Math.floor(z / size);
+    const node = f.nodes.get(nodeKey(depth, nx, nz));
+    if (!node) continue;
+    const page = rt.pages?.get(nodeKey(depth, nx, nz));
+    if (!page) return void 0;
+    const side = page.leaf ? LEAF_SIDE : SIDE;
+    const off = page.leaf ? 1 : 0;
+    const spacing = size / PAGE;
+    const fx = (x - nx * size) / spacing;
+    const fz = (z - nz * size) / spacing;
+    const ci = Math.min(PAGE - 1, Math.floor(fx));
+    const cj = Math.min(PAGE - 1, Math.floor(fz));
+    if (skipStitched) {
+      const near = [cj === 0, ci === PAGE - 1, cj === PAGE - 1, ci === 0];
+      for (let e = 0; e < 4; e++) if (near[e] && node.locks[e] === 1) return void 0;
+    }
+    const h = (i, j) => dequantize(page.heights[(j + off) * side + i + off], rt.lo, rt.hi);
+    const vertex = (i, j) => {
+      const own = h(i, j);
+      const oi = (i & 1) === 1;
+      const oj = (j & 1) === 1;
+      const parent = oi && oj ? 0.5 * (h(i + 1, j - 1) + h(i - 1, j + 1)) : oi ? 0.5 * (h(i - 1, j) + h(i + 1, j)) : oj ? 0.5 * (h(i, j - 1) + h(i, j + 1)) : own;
+      const wx = nx * size + i * spacing;
+      const wz = nz * size + j * spacing;
+      const split = depth === 0 || node.anchored ? 0 : f.errors[depth] * f.splitScale;
+      const d = Math.hypot(wx - f.camera[0], own - f.camera[1], wz - f.camera[2]);
+      let t = morphFactor(d, split);
+      const code = lockCode(
+        i,
+        j,
+        PAGE + 1,
+        i === 0 || j === 0 || i === PAGE || j === PAGE ? ringIndex(i, j) : PAGE * 4,
+        PAGE * 4
+      );
+      if (code >= 0 && code < 4) {
+        const lock = node.locks[code];
+        if (lock >= 0) t = lock === 1 ? 1 : 0;
+      } else if (code >= 4 && node.mask !== 15) {
+        const [qa, qb] = code === 5 ? [2, 3] : code === 6 ? [0, 2] : code === 7 ? [1, 3] : [0, 1];
+        const differ = (node.mask >> qa & 1) !== (node.mask >> qb & 1);
+        t = differ || code === 8 && node.mask !== 0 ? 0 : Math.max(t, node.fade);
+      } else t = Math.max(t, node.fade);
+      return own + (parent - own) * t;
+    };
+    const u = fx - ci;
+    const v = fz - cj;
+    const h00 = vertex(ci, cj);
+    const h10 = vertex(ci + 1, cj);
+    const h01 = vertex(ci, cj + 1);
+    const h11 = vertex(ci + 1, cj + 1);
+    return u + v <= 1 ? h00 + u * (h10 - h00) + v * (h01 - h00) : h11 + (1 - u) * (h01 - h11) + (1 - v) * (h10 - h11);
+  }
+  return void 0;
+}
+function ringIndex(i, j) {
+  const s = PAGE;
+  if (j === 0 && i < s) return i;
+  if (i === s && j < s) return s + j;
+  if (j === s && i > 0) return 2 * s + (s - i);
+  return 3 * s + (s - j);
+}
+async function heightfieldWalk(characters = 4, seconds = 3, workers) {
+  const t0 = performance.now();
+  await loadNoiseKernel();
+  const hills = await NoiseGraph.create(VALLEY_HILLS);
+  const p = await heightfieldApp(void 0, {
+    ...valleySource(),
+    noise: { hills },
+    physics: true,
+    ...workers ? { workers } : {}
+  });
+  const w = p.world;
+  const rt = p.runtime();
+  const walked = [];
+  const bytes = new Uint8Array(characters * 24 + 4);
+  const f64 = new Float64Array(bytes.buffer, 0, characters * 3);
+  const p0 = new Float64Array(3);
+  const pos = new Float64Array(3);
+  let lowest = Infinity;
+  const ground = (x, z) => {
+    const size = rt.layout.leafSize;
+    const page = rt.pages.leafNow(
+      mainNoise(),
+      rt.stack,
+      Math.floor(x / size),
+      Math.floor(z / size)
+    );
+    return pageHeight(rt, page, x, z);
+  };
+  for (let k = 0; k < characters; k++) {
+    const x = 200 + hash32(71, k) / 2 ** 32 * 1600;
+    const z = 400 + hash32(72, k) / 2 ** 32 * 1400;
+    const c = w.spawn(
+      [CharacterController, { radius: 0.35, height: 1.8 }],
+      [CharacterIntent, {}],
+      [CharacterState, {}],
+      Transform,
+      FloatingOrigin
+    );
+    placeInGrid(w, c, p.terrain, [x, ground(x, z) + 1.2, z]);
+    for (let f = 0; f < 60; f++) p.app.update(1 / 60);
+    worldPosition64(w, c, p0, p.terrain);
+    w.set(c, CharacterIntent, { move: [0, 0, -5] });
+    for (let f = 0; f < seconds * 60; f++) {
+      p.app.update(1 / 60);
+      worldPosition64(w, c, pos, p.terrain);
+      if (pos[0] > 0 && pos[2] > 0 && pos[0] < 2048 && pos[2] < 2048)
+        lowest = Math.min(lowest, pos[1] - 0.9 - ground(pos[0], pos[2]));
+    }
+    walked.push(Math.hypot(pos[0] - p0[0], pos[2] - p0[2]));
+    f64.set(pos, k * 3);
+    w.despawn(c);
+  }
+  const tiles = tilesOf(rt).tiles.size;
+  new DataView(bytes.buffer).setUint32(characters * 24, tiles, true);
+  let hash = 2166136261;
+  for (let i = 0; i < bytes.length; i++) hash = Math.imul(hash ^ bytes[i], 16777619);
+  await p.app.dispose();
+  return {
+    checksum: (hash >>> 0).toString(16).padStart(8, "0"),
+    walked,
+    lowest,
+    tiles,
+    ms: performance.now() - t0
+  };
+}
+function openWorldSource() {
+  const v = valleySource(16384, 1);
+  const height = v.source.height;
+  height[0] = { noise: { path: "hills" }, scale: 260 };
+  return { ...v, source: { ...v.source, heightRange: [-300, 700] } };
+}
+export {
+  VALLEY_HILLS,
+  capture,
+  drawnHeightAt,
+  heightfieldApp,
+  heightfieldWalk,
+  holes,
+  lookAt,
+  openWorldSource,
+  settleHeightfield,
+  snapshotDrawn,
+  sourceAsset,
+  untilStreaming,
+  valleySource
+};

package/dist/heightfield/worker.js

@@ -0,0 +1,47 @@
+// Pool jobs for heightfield terrain (spec 0071). Plain JavaScript: workers import it with no bundler
+// or loader. The noise kernel comes by URL with its compiled module, so a worker samples exactly as
+// the main thread does.
+import { bakeBlock as bake, LEAF_SIDE, leafNormals, pageTexels, readPage, SIDE } from './kernel.js'
+
+const kernels = new Map()
+
+/**
+ * This worker's noise kernel: imported once per URL and instantiated from the first module posted
+ * (every job posts the same build; a posted module arrives as a new object each time).
+ */
+function noiseFor(url, module) {
+  let k = kernels.get(url)
+  if (!k) {
+    k = import(/* @vite-ignore */ url).then((m) => ({
+      state: m.instantiate(module),
+      computeOrigins: m.computeOrigins,
+      evalProgram: m.evalProgram,
+    }))
+    kernels.set(url, k)
+  }
+  return k
+}
+
+/** Bakes one block (kernel.js bakeBlock) on this thread. */
+export async function bakeBlock(url, module, stack, layout, bx, bz) {
+  return bake(await noiseFor(url, module), stack, layout, bx, bz)
+}
+
+/**
+ * Inflates and decodes a page, and lays it out as the GPU pool holds it: what streaming needs
+ * from a read, off the main thread. Leaves' normals come from their heights here.
+ */
+export function loadPage(packed, leaf, cells, lo, hi, spacing) {
+  const page = readPage(packed, leaf, cells)
+  const normals =
+    page.normals ?? leafNormals(page.heights, lo, hi, spacing, new Uint8Array(SIDE * SIDE * 2))
+  const texels = pageTexels(
+    { heights: page.heights, normals, control: page.control },
+    leaf,
+    lo,
+    hi,
+    spacing,
+    new Uint8Array(LEAF_SIDE * LEAF_SIDE * 4),
+  )
+  return { heights: page.heights, normals, control: page.control, texels }
+}

package/dist/heights.d.ts

@@ -1,15 +1,20 @@
 import { type Entity, type World } from '@aethervtt/shard-core';
-import type { Workers } from '@aethervtt/shard-platform';
+import type { PlatformFileSystem, Workers } from '@aethervtt/shard-platform';
+import type { HeightfieldRuntime } from './heightfield/runtime.js';
 import type { PlanetRuntime } from './planet.js';
-/** Every planet's runtime state, and the frame counter terrain systems stamp with. */
+/** Every planet's and heightfield's runtime state, and the frame counter terrain systems stamp with. */
 export declare class TerrainState {
     readonly planets: Map<number, PlanetRuntime>;
+    /** Heightfield terrains (0071), by `Terrain` entity. */
+    readonly heightfields: Map<number, HeightfieldRuntime>;
     frame: number;
     workers: Workers | undefined;
+    /** Where heightfield packs are read and baked (`.shard/cache/terrain`); memory without one. */
+    fs: PlatformFileSystem | undefined;
     /** Set when a graph or biome asset (re)loaded: planets re-resolve their assets. */
     dirty: boolean;
 }
-export declare const Terrain: import("@aethervtt/shard-core").ResourceDef<TerrainState>;
+export declare const TerrainWorld: import("@aethervtt/shard-core").ResourceDef<TerrainState>;
 /** The runtime for a planet entity, ready to sample, or a `terrain/not-ready` error. */
 export declare function planetRuntime(world: World, planet: Entity): PlanetRuntime;
 /** Height-graph metres above radius at a unit direction in the planet's frame. Sync, CPU. */

package/dist/heights.js

@@ -3,17 +3,21 @@ import { biomeWeights, dominantBiome, MAX_BIOMES } from "./biomes.js";
 import { samplePoint } from "./points.js";
 class TerrainState {
   planets = /* @__PURE__ */ new Map();
+  /** Heightfield terrains (0071), by `Terrain` entity. */
+  heightfields = /* @__PURE__ */ new Map();
   frame = 0;
   workers;
+  /** Where heightfield packs are read and baked (`.shard/cache/terrain`); memory without one. */
+  fs;
   /** Set when a graph or biome asset (re)loaded: planets re-resolve their assets. */
   dirty = true;
 }
-const Terrain = defineResource("terrain/Terrain", {
-  description: "Per-planet terrain state: quadtrees, collider chunks, and resolved assets.",
+const TerrainWorld = defineResource("terrain/World", {
+  description: "Terrain state per planet and heightfield: quadtrees, pages, collider chunks, and resolved assets.",
   init: () => new TerrainState()
 });
 function planetRuntime(world, planet) {
-  const rt = world.tryResource(Terrain)?.planets.get(planet);
+  const rt = world.tryResource(TerrainWorld)?.planets.get(planet);
   if (!rt) {
     throw new ShardError("terrain/not-a-planet", `Entity ${planet} has no terrain/Planet`, {
       hint: "Add terrain/Planet (and a Grid) to the planet entity, and the terrain plugin to the app."
@@ -127,8 +131,8 @@ function terrainSample(rt, direction) {
   };
 }
 export {
-  Terrain,
   TerrainState,
+  TerrainWorld,
   heightAt,
   planetHeightAt,
   planetRuntime,

package/dist/index.d.ts

@@ -1,19 +1,36 @@
 export { Biome, type BiomeInputs, BiomeSet, type BiomeSetValue, type BiomeTable, type BiomeValue, BLENDED_BIOMES, biomeTable, biomeWeights, biomeWindow, dominantBiome, effectiveTemperature, MAX_BIOMES, MAX_LAYERS, } from './biomes.js';
-export { assembleChunk, buildChunk, type ChunkLayout, type ChunkMesh, type ChunkSpec, checkResolution, chunkCenter, chunkLayout, } from './chunk.js';
-export { COLLIDER_DELAY, type ColliderChunk, ColliderSet, collidersOf, skirtDepth, } from './colliders.js';
+export { assembleChunk, buildChunk, type ChunkMesh, type ChunkSpec, chunkCenter, } from './chunk.js';
+export { type ChunkSampling, COLLIDER_DELAY, type ColliderChunk, ColliderSet, chunkSpec, collidersOf, sampleChunkAsync, skirtDepth, } from './colliders.js';
 export { Chunk, Planet, PlanetNav, TerrainAnchor, TerrainBudget, type TerrainBudgetValue, } from './components.js';
 export { directionToFace, EDGE_BOTTOM, EDGE_LEFT, EDGE_RIGHT, EDGE_TOP, faceToDirection, keyString, MAX_DEPTH, MAX_RADIUS, maxDepthFor, type NodeAddress, neighborNode, nodeAt, nodeExtent, nodeSpacing, packKey, parseKey, unpackKey, } from './cube.js';
+export { CubeSphere, NodeTree } from './cube-sphere.js';
 export { PlanetFrame } from './frame.js';
-export { heightAt, type PlanetSurface, planetHeightAt, planetRuntime, planetSurfaceAt, Terrain, type TerrainSample, TerrainState, terrainSample, } from './heights.js';
+export { type ChunkLayout, checkResolution, chunkIndices, chunkLayout, lockCode, } from './grid-mesh.js';
+export { type BakeInput, type BakeManifest, type BakeOptions, type BakeReport, type BlockRecord, bakeTerrain, blockKeys, type OutOfRange, packHash, readManifest, type TerrainStats, terrainStats, } from './heightfield/bake.js';
+export { type ColliderTile, type TileSet, tilesOf, } from './heightfield/colliders.js';
+export { Terrain, TerrainChunk } from './heightfield/component.js';
+export { decodeHeightPng, type Heightmap, HeightmapAssetType, HeightmapImporter, Heightmaps, } from './heightfield/heightmap.js';
+export { BAKE_VERSION, BLOCK, type DecodedPage, deflate, inflate, LEAF_SIDE, PAGE, SIDE, type Stack, } from './heightfield/kernel.js';
+export { TerrainSurfaceMaterial } from './heightfield/material.js';
+export { fsPackStore, memoryPackStore, PACK, type PackEntry, type PackIndex, type PackStore, packOf, readIndex, writePack, } from './heightfield/pack.js';
+export { type BakeHost, bakeIsCurrent, bakeProjectTerrains, type ProjectBake, stackFor, terrainCacheDir, } from './heightfield/project.js';
+export { finestPage, type HeightfieldSample, heightfieldRuntime, heightfieldSample, loadTerrainRegion, pageHeight, type TerrainHeight, terrainHeightAt, } from './heightfield/queries.js';
+export { HeightfieldDebug, type HeightfieldRender } from './heightfield/render.js';
+export { HeightfieldRuntime } from './heightfield/runtime.js';
+export { MAX_MATERIAL_LAYERS, parseTerrainSource, type SourceHeightLayer, type SourcePaint, type SourceSpline, sourceDependencies, type TerrainLayout, type TerrainSource, terrainLayout, } from './heightfield/source.js';
+export { type SourceDependency, type TerrainSourceArtifact, TerrainSourceAsset, TerrainSourceAssetType, TerrainSourceImporter, TerrainSources, terrainJsonSchema, } from './heightfield/source-asset.js';
+export { compileStack, mainNoise, type StackAssets } from './heightfield/stack.js';
+export { heightfieldUpdates, updateHeightfields } from './heightfield/system.js';
+export { heightAt, type PlanetSurface, planetHeightAt, planetRuntime, planetSurfaceAt, type TerrainSample, TerrainState, TerrainWorld, terrainSample, } from './heights.js';
 export { GEN_CLIMATE, GEN_HEIGHT, GEN_OCEAN, GEN_ROOT, type KernelGraph, kernelGraph, PARAMS_BYTES, POINT_FLOATS, sampleKernel, VERTEX_KERNEL, } from './kernel.js';
-export { measureErrors } from './lod.js';
+export { adaptLodBias, capErrors, MAX_LOD_BIAS, MORPH_WGSL, measureErrors, morphFactor, } from './lod.js';
 export { OceanMaterial, PlanetMaterial, TERRAIN_SHADERS, TEXTURE_PERIOD } from './material.js';
 export { resolvePlanet, terrainMap, terrainMethods } from './methods.js';
 export { clearPlanetNav, planetAgents, planetNavMesh, updatePlanetNav } from './nav.js';
-export { terrainBiomesOverlay, terrainCollidersOverlay, terrainLodOverlay } from './overlays.js';
+export { terrainBiomesOverlay, terrainCollidersOverlay, terrainLodOverlay, terrainPagesOverlay, } from './overlays.js';
 export { COLLIDER_SPACING, PlanetRuntime, type PlanetSettings } from './planet.js';
 export { type TerrainPluginOptions, terrainPlugin, updatePlanets } from './plugin.js';
-export { type ChunkPoints, createChunkPoints, gridDirection, prepareChunkPoints, SNAP, sampleChunkPoints, samplePoint, } from './points.js';
-export { createSelection, NODE_BOUNDS, NODE_READY, NodeTree, type Selection, type SelectionParams, type SelectionView, selectNodes, } from './quadtree.js';
+export { type ChunkPoints, createChunkPoints, gridDirection, NOISE_OFFSET, prepareChunkPoints, SNAP, sampleChunkPoints, samplePoint, } from './points.js';
+export { createSelection, NODE_BOUNDS, NODE_READY, type QuadSurface, QuadTree, type Selection, type SelectionParams, type SelectionView, selectNodes, } from './quadtree.js';
 export { PlanetRender, renderOf, selectChunks, TerrainDebug } from './render.js';
 export { createView, omniView, perspectiveView } from './view.js';