@aethervtt/shard-terrain 0.0.1 → 0.2.0

package/dist/cube-sphere.js

@@ -0,0 +1,224 @@
+import { faceToDirection, neighborNode, nodeExtent } from "./cube.js";
+import { QuadTree } from "./quadtree.js";
+const POINTS = 9;
+class CubeSphere {
+  roots = 6;
+  radius = 1;
+  shape = new Float64Array([1, 1, 1]);
+  /** Horizon test directions (unit, 9 per node). */
+  dirs = new Float64Array(0);
+  /**
+   * 1 / cos(half the widest angle between neighboring test points, diagonals included): lifting
+   * the points by it puts the surface between them inside their hull (horizon test, bulge).
+   */
+  lift = new Float64Array(0);
+  grow(capacity) {
+    const dirs = new Float64Array(capacity * POINTS * 3);
+    dirs.set(this.dirs);
+    this.dirs = dirs;
+    const lift = new Float64Array(capacity);
+    lift.set(this.lift);
+    this.lift = lift;
+  }
+  initNode(tree, n) {
+    const face = tree.root[n];
+    const ext = nodeExtent(tree.depth[n]);
+    const u0 = -1 + tree.x[n] * ext;
+    const v0 = -1 + tree.y[n] * ext;
+    let k = n * POINTS * 3;
+    for (let j = 0; j < 3; j++) {
+      for (let i = 0; i < 3; i++) {
+        faceToDirection(face, u0 + ext * i / 2, v0 + ext * j / 2, this.dirs, k);
+        k += 3;
+      }
+    }
+    let widest = 0;
+    const base = n * POINTS * 3;
+    for (let a = 0; a < POINTS; a++) {
+      for (let b = a + 1; b < POINTS; b++) {
+        if (Math.abs(a % 3 - b % 3) > 1 || Math.abs(Math.floor(a / 3) - Math.floor(b / 3)) > 1)
+          continue;
+        const d = this.dirs;
+        const cos = d[base + a * 3] * d[base + b * 3] + d[base + a * 3 + 1] * d[base + b * 3 + 1] + d[base + a * 3 + 2] * d[base + b * 3 + 2];
+        widest = Math.max(widest, Math.acos(Math.min(1, cos)));
+      }
+    }
+    this.lift[n] = 1 / Math.cos(widest / 2) + 1e-9;
+  }
+  /** Bounding sphere of the node's 9 test points at its lowest and highest heights, plus bulge. */
+  updateSphere(tree, n) {
+    const d = this.dirs;
+    const s = this.shape;
+    const lo = this.radius + tree.minH[n];
+    const hi = this.radius + tree.maxH[n];
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    for (let p = 0; p < POINTS; p++) {
+      const o2 = (n * POINTS + p) * 3;
+      for (let k = 0; k < 2; k++) {
+        const r = k === 0 ? lo : hi;
+        const x = d[o2] * s[0] * r;
+        const y = d[o2 + 1] * s[1] * r;
+        const z = d[o2 + 2] * s[2] * r;
+        if (x < minX) minX = x;
+        if (y < minY) minY = y;
+        if (z < minZ) minZ = z;
+        if (x > maxX) maxX = x;
+        if (y > maxY) maxY = y;
+        if (z > maxZ) maxZ = z;
+      }
+    }
+    const cx = (minX + maxX) / 2;
+    const cy = (minY + maxY) / 2;
+    const cz = (minZ + maxZ) / 2;
+    let r2 = 0;
+    for (let p = 0; p < POINTS; p++) {
+      const o2 = (n * POINTS + p) * 3;
+      for (let k = 0; k < 2; k++) {
+        const r = k === 0 ? lo : hi;
+        const x = d[o2] * s[0] * r - cx;
+        const y = d[o2 + 1] * s[1] * r - cy;
+        const z = d[o2 + 2] * s[2] * r - cz;
+        const q = x * x + y * y + z * z;
+        if (q > r2) r2 = q;
+      }
+    }
+    const bulge = hi * (this.lift[n] - 1) + 1e-3;
+    const o = n * 4;
+    tree.sphere[o] = cx;
+    tree.sphere[o + 1] = cy;
+    tree.sphere[o + 2] = cz;
+    tree.sphere[o + 3] = Math.sqrt(r2) + bulge;
+  }
+  /**
+   * Axis-aligned bounds of the node relative to `center`, from its test points at its lowest and
+   * highest heights plus the bulge between them.
+   */
+  bounds(tree, n, center, out) {
+    const d = this.dirs;
+    const s = this.shape;
+    const lo = this.radius + tree.minH[n];
+    const hi = this.radius + tree.maxH[n];
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    for (let p = 0; p < POINTS; p++) {
+      const o = (n * POINTS + p) * 3;
+      for (let k = 0; k < 2; k++) {
+        const r = k === 0 ? lo : hi;
+        const x = d[o] * s[0] * r - center[0];
+        const y = d[o + 1] * s[1] * r - center[1];
+        const z = d[o + 2] * s[2] * r - center[2];
+        if (x < minX) minX = x;
+        if (y < minY) minY = y;
+        if (z < minZ) minZ = z;
+        if (x > maxX) maxX = x;
+        if (y > maxY) maxY = y;
+        if (z > maxZ) maxZ = z;
+      }
+    }
+    const bulge = hi * (this.lift[n] - 1) + 1e-3;
+    out[0] = minX - bulge;
+    out[1] = minY - bulge;
+    out[2] = minZ - bulge;
+    out[3] = maxX + bulge;
+    out[4] = maxY + bulge;
+    out[5] = maxZ + bulge;
+  }
+  culled(tree, n, view, params) {
+    const s = tree.sphere;
+    const o = n * 4;
+    const cx = s[o];
+    const cy = s[o + 1];
+    const cz = s[o + 2];
+    const r = s[o + 3];
+    const f = view.frustum;
+    const d = this.dirs;
+    const sh = this.shape;
+    const lo = this.radius + tree.minH[n];
+    const hi = (this.radius + tree.maxH[n]) * this.lift[n];
+    for (let p = 0; p < view.planes; p++) {
+      const q = p * 4;
+      const nx = f[q];
+      const ny = f[q + 1];
+      const nz = f[q + 2];
+      const dist = nx * cx + ny * cy + nz * cz + f[q + 3];
+      if (dist < -r) return true;
+      if (dist > r) continue;
+      let inside = false;
+      for (let k = 0; k < POINTS && !inside; k++) {
+        const i = (n * POINTS + k) * 3;
+        const dx = d[i] * sh[0];
+        const dy = d[i + 1] * sh[1];
+        const dz = d[i + 2] * sh[2];
+        const along = nx * dx + ny * dy + nz * dz;
+        if (along * lo + f[q + 3] >= 0 || along * hi + f[q + 3] >= 0) inside = true;
+      }
+      if (!inside) return true;
+    }
+    if (params.occluder <= 0) return false;
+    const inv = 1 / params.occluder;
+    const px = view.position[0] / sh[0] * inv;
+    const py = view.position[1] / sh[1] * inv;
+    const pz = view.position[2] / sh[2] * inv;
+    const vh2 = px * px + py * py + pz * pz - 1;
+    if (vh2 <= 0) return false;
+    const top = hi * inv;
+    for (let k = 0; k < POINTS; k++) {
+      const i = (n * POINTS + k) * 3;
+      const tx = d[i] * top - px;
+      const ty = d[i + 1] * top - py;
+      const tz = d[i + 2] * top - pz;
+      const dot = -(tx * px + ty * py + tz * pz);
+      if (dot <= vh2) return false;
+      if (dot * dot / (tx * tx + ty * ty + tz * tz) <= vh2) return false;
+    }
+    return true;
+  }
+  /** Across a cube edge the neighbor is on another face: there always is one. */
+  neighbor(root, depth, x, y, edge, out) {
+    neighborNode(root, depth, x, y, edge, out);
+    return true;
+  }
+}
+class NodeTree extends QuadTree {
+  cube;
+  constructor(capacity = 1024) {
+    const cube = new CubeSphere();
+    super(cube, capacity);
+    this.cube = cube;
+  }
+  /** Each node's cube face (its root). */
+  get face() {
+    return this.root;
+  }
+  get radius() {
+    return this.cube.radius;
+  }
+  get shape() {
+    return this.cube.shape;
+  }
+  /** Clears every node and makes the six roots (after a planet's shape or graphs change). */
+  reset(radius, shape, lowest, highest) {
+    this.cube.radius = radius;
+    this.cube.shape[0] = shape[0];
+    this.cube.shape[1] = shape[1];
+    this.cube.shape[2] = shape[2];
+    this.resetRoots(lowest, highest);
+  }
+  /** Root of a face (nodes 0–5). */
+  rootOf(face) {
+    return face;
+  }
+}
+export {
+  CubeSphere,
+  NodeTree
+};

package/dist/grid-mesh.d.ts

@@ -0,0 +1,49 @@
+/**
+ * How a chunk's vertices are laid out, per resolution `n` (vertices per edge, 2^k + 1). The border
+ * ring comes first (so edge locks rewrite one contiguous block), then the interior row by row, then
+ * one skirt vertex under each ring vertex. Every chunk of a resolution shares one index buffer.
+ */
+export interface ChunkLayout {
+    resolution: number;
+    /** Ring vertices: 4 (n − 1), counter-clockwise from (0, 0) seen from outside. */
+    ring: number;
+    /** Surface vertices: n². */
+    surface: number;
+    /** Surface plus skirt: n² + 4 (n − 1). */
+    vertexCount: number;
+    /** Vertex index of grid point (i, j), at `i + j * n`. */
+    index: Uint16Array;
+    /** Grid point of each ring vertex: i, j pairs. */
+    ringPoints: Uint16Array;
+    /** Triangles: the surface, then the skirts (`chunkIndices` with every quadrant, no stitching). */
+    indices: Uint16Array;
+    /** Triangles without skirts (the surface only): colliders, and planets with skirts off. */
+    surfaceIndices: Uint16Array;
+}
+/**
+ * A chunk's triangles (cached per combination, so chunks share the array and its GPU index buffer).
+ * `mask` picks quadrants (bit q: quadrant q, in child order (x, y), (x+1, y), (x, y+1),
+ * (x+1, y+1)): a split waiting for children draws its own quadrants where they're missing and the
+ * children elsewhere. `stitch` bit e marks edge e (0 bottom, 1 right, 2 top, 3 left) as meeting a
+ * coarser neighbor: that edge's triangles use only its even vertices, the neighbor's, so there's no
+ * T-junction (a vertex on the neighbor's edge only up to rounding shows pixel-sized holes).
+ *
+ * Quads fill the interior; each edge's strip (between the border and the first inner row) is
+ * zipped per half, so no triangle crosses a quadrant boundary. Skirts follow the drawn border.
+ *
+ * `diagonal: 'anti'` (heightfields, 0071) splits every quad along (i+1, j)–(i, j+1), Rapier's
+ * heightfield split, border cells included: only a stitched edge's strip is zipped. What's drawn is
+ * then exactly the collider's triangles wherever no edge is stitched. Its triangles face +Y with
+ * i along +X and j along +Z (clockwise in (i, j)).
+ */
+export declare function chunkIndices(n: number, mask: number, stitch: number, skirts: boolean, diagonal?: 'main' | 'anti'): Uint16Array;
+/** Throws `terrain/bad-resolution` unless `n` is 2^k + 1 (5 to 129). */
+export declare function checkResolution(n: number): void;
+export declare function chunkLayout(n: number): ChunkLayout;
+/**
+ * A vertex's lock code (uv1.x): its edge for ring vertices (0 bottom, 1 right, 2 top, 3 left, where
+ * the instance's lock bits apply), the quadrant boundary for vertices on the center lines (4 and 5
+ * the vertical line's lower and upper half, 6 and 7 the horizontal line's left and right half, 8
+ * the center; locked to this level where a partial draw meets a child), else −1.
+ */
+export declare function lockCode(i: number, j: number, n: number, vi: number, ring: number): number;

package/dist/grid-mesh.js

@@ -0,0 +1,208 @@
+import { ShardError } from "@aethervtt/shard-core";
+const layouts = /* @__PURE__ */ new Map();
+const sets = /* @__PURE__ */ new Map();
+function chunkIndices(n, mask, stitch, skirts, diagonal = "main") {
+  if (diagonal === "anti") return antiIndices(n, mask, stitch, skirts);
+  const key = `${n}:${mask}:${stitch}:${skirts}`;
+  let out = sets.get(key);
+  if (out) return out;
+  const layout = chunkLayout(n);
+  const index = layout.index;
+  const side = n - 1;
+  const h = side / 2;
+  const parts = [];
+  const quadrant = (i, j) => (i >= h ? 1 : 0) + (j >= h ? 2 : 0);
+  for (let j = 1; j < side - 1; j++) {
+    for (let i = 1; i < side - 1; i++) {
+      if (!(mask & 1 << quadrant(i, j))) continue;
+      const a = index[i + j * n];
+      const b = index[i + 1 + j * n];
+      const c = index[i + 1 + (j + 1) * n];
+      const d = index[i + (j + 1) * n];
+      parts.push(a, b, c, a, c, d);
+    }
+  }
+  const at = (e, s, depth) => {
+    const i = e === 0 ? s : e === 1 ? side - depth : e === 2 ? side - s : depth;
+    const j = e === 0 ? depth : e === 1 ? s : e === 2 ? side - depth : side - s;
+    return index[i + j * n];
+  };
+  const skirt = [];
+  const outer = [];
+  const inner = [];
+  for (let e = 0; e < 4; e++) {
+    const step = stitch & 1 << e ? 2 : 1;
+    for (let half = 0; half < 2; half++) {
+      const s0 = half * h;
+      const s1 = s0 + h;
+      const m = s0 + h / 2;
+      const q = e === 0 ? quadrant(m, 0) : e === 1 ? quadrant(side, m) : e === 2 ? quadrant(side - m, side) : quadrant(0, side - m);
+      if (!(mask & 1 << q)) continue;
+      outer.length = 0;
+      inner.length = 0;
+      for (let s = s0; s <= s1; s += step) outer.push(s);
+      for (let s = Math.max(1, s0); s <= Math.min(side - 1, s1); s++) inner.push(s);
+      let a = 0;
+      let b = 0;
+      while (a < outer.length - 1 || b < inner.length - 1) {
+        const advanceOuter = b === inner.length - 1 || a < outer.length - 1 && outer[a + 1] <= inner[b + 1];
+        if (advanceOuter) {
+          parts.push(at(e, outer[a], 0), at(e, outer[a + 1], 0), at(e, inner[b], 1));
+          a++;
+        } else {
+          parts.push(at(e, outer[a], 0), at(e, inner[b + 1], 1), at(e, inner[b], 1));
+          b++;
+        }
+      }
+      if (!skirts) continue;
+      for (let k = 0; k + 1 < outer.length; k++) {
+        const va = at(e, outer[k], 0);
+        const vb = at(e, outer[k + 1], 0);
+        const sa = layout.surface + va;
+        const sb = layout.surface + vb;
+        skirt.push(va, sa, vb, vb, sa, sb, va, vb, sa, vb, sb, sa);
+      }
+    }
+  }
+  for (const v of skirt) parts.push(v);
+  out = Uint16Array.from(parts);
+  sets.set(key, out);
+  return out;
+}
+function antiIndices(n, mask, stitch, skirts) {
+  const key = `${n}:${mask}:${stitch}:${skirts}:anti`;
+  let out = sets.get(key);
+  if (out) return out;
+  const layout = chunkLayout(n);
+  const index = layout.index;
+  const side = n - 1;
+  const h = side / 2;
+  const parts = [];
+  const quadrant = (i, j) => (i >= h ? 1 : 0) + (j >= h ? 2 : 0);
+  const stitched = (e) => (stitch & 1 << e) !== 0;
+  for (let j = 0; j < side; j++) {
+    for (let i = 0; i < side; i++) {
+      if (j === 0 && stitched(0) || i === side - 1 && stitched(1) || j === side - 1 && stitched(2) || i === 0 && stitched(3))
+        continue;
+      if (!(mask & 1 << quadrant(i, j))) continue;
+      const a = index[i + j * n];
+      const b = index[i + 1 + j * n];
+      const c = index[i + 1 + (j + 1) * n];
+      const d = index[i + (j + 1) * n];
+      parts.push(a, b, d, b, c, d);
+    }
+  }
+  const at = (e, s, depth) => {
+    const i = e === 0 ? s : e === 1 ? side - depth : e === 2 ? side - s : depth;
+    const j = e === 0 ? depth : e === 1 ? s : e === 2 ? side - depth : side - s;
+    return index[i + j * n];
+  };
+  const skirt = [];
+  const outer = [];
+  const inner = [];
+  for (let e = 0; e < 4; e++) {
+    const step = stitched(e) ? 2 : 1;
+    const lo = stitched((e + 3) % 4) ? 1 : 0;
+    const hi = stitched((e + 1) % 4) ? side - 1 : side;
+    for (let half = 0; half < 2; half++) {
+      const s0 = half * h;
+      const s1 = s0 + h;
+      const m = s0 + h / 2;
+      const q = e === 0 ? quadrant(m, 0) : e === 1 ? quadrant(side, m) : e === 2 ? quadrant(side - m, side) : quadrant(0, side - m);
+      if (!(mask & 1 << q)) continue;
+      outer.length = 0;
+      for (let s = s0; s <= s1; s += step) outer.push(s);
+      if (stitched(e)) {
+        inner.length = 0;
+        for (let s = Math.max(lo, s0); s <= Math.min(hi, s1); s++) inner.push(s);
+        let a = 0;
+        let b = 0;
+        while (a < outer.length - 1 || b < inner.length - 1) {
+          const advanceOuter = b === inner.length - 1 || a < outer.length - 1 && outer[a + 1] <= inner[b + 1];
+          if (advanceOuter) {
+            parts.push(at(e, outer[a], 0), at(e, outer[a + 1], 0), at(e, inner[b], 1));
+            a++;
+          } else {
+            parts.push(at(e, outer[a], 0), at(e, inner[b + 1], 1), at(e, inner[b], 1));
+            b++;
+          }
+        }
+      }
+      if (!skirts) continue;
+      for (let k = 0; k + 1 < outer.length; k++) {
+        const va = at(e, outer[k], 0);
+        const vb = at(e, outer[k + 1], 0);
+        const sa = layout.surface + va;
+        const sb = layout.surface + vb;
+        skirt.push(va, sa, vb, vb, sa, sb, va, vb, sa, vb, sb, sa);
+      }
+    }
+  }
+  for (const v of skirt) parts.push(v);
+  for (let t = 0; t < parts.length; t += 3) {
+    const b = parts[t + 1];
+    parts[t + 1] = parts[t + 2];
+    parts[t + 2] = b;
+  }
+  out = Uint16Array.from(parts);
+  sets.set(key, out);
+  return out;
+}
+function checkResolution(n) {
+  const k = Math.log2(n - 1);
+  if (!Number.isInteger(k) || k < 2 || k > 7) {
+    throw new ShardError("terrain/bad-resolution", `Planet resolution ${n} isn't 2^n + 1`, {
+      hint: "Use 17, 33 (the default), 65, or 129 vertices per chunk edge."
+    });
+  }
+}
+function chunkLayout(n) {
+  let layout = layouts.get(n);
+  if (layout) return layout;
+  checkResolution(n);
+  const ring = 4 * (n - 1);
+  const surface = n * n;
+  const index = new Uint16Array(surface);
+  const ringPoints = new Uint16Array(ring * 2);
+  let r = 0;
+  const put = (i, j) => {
+    index[i + j * n] = r;
+    ringPoints[r * 2] = i;
+    ringPoints[r * 2 + 1] = j;
+    r++;
+  };
+  for (let i = 0; i < n - 1; i++) put(i, 0);
+  for (let j = 0; j < n - 1; j++) put(n - 1, j);
+  for (let i = n - 1; i > 0; i--) put(i, n - 1);
+  for (let j = n - 1; j > 0; j--) put(0, j);
+  let v = ring;
+  for (let j = 1; j < n - 1; j++) for (let i = 1; i < n - 1; i++) index[i + j * n] = v++;
+  layout = {
+    resolution: n,
+    ring,
+    surface,
+    vertexCount: surface + ring,
+    index,
+    ringPoints,
+    indices: new Uint16Array(0),
+    surfaceIndices: new Uint16Array(0)
+  };
+  layouts.set(n, layout);
+  layout.indices = chunkIndices(n, 15, 0, true);
+  layout.surfaceIndices = chunkIndices(n, 15, 0, false);
+  return layout;
+}
+function lockCode(i, j, n, vi, ring) {
+  if (vi < ring) return Math.floor(vi / (n - 1));
+  const h = (n - 1) / 2;
+  if (i === h && j === h) return 8;
+  if (i === h) return j < h ? 4 : 5;
+  if (j === h) return i < h ? 6 : 7;
+  return -1;
+}
+export {
+  checkResolution,
+  chunkIndices,
+  chunkLayout,
+  lockCode
+};

package/dist/heightfield/bake.d.ts

@@ -0,0 +1,120 @@
+import { ShardError } from '@aethervtt/shard-core';
+import type { Workers } from '@aethervtt/shard-platform';
+import { type Stack } from './kernel.js';
+import { type PackStore } from './pack.js';
+import type { TerrainLayout, TerrainSource } from './source.js';
+/** What a bake remembers per block: its key, errors per level above the leaves, its height range. */
+export interface BlockRecord {
+    key: string;
+    /** Index L: the largest error of this block's level-L nodes (its share, above the block). 0 for leaves. */
+    errors: number[];
+    /** Quantized height range. */
+    range: [number, number];
+    /** Samples clipped by heightRange, and the unclipped extremes. */
+    clipped: number;
+    lowest: number;
+    highest: number;
+    /** Milliseconds its last bake took. */
+    ms: number;
+}
+/** `manifest.json` next to the packs: enough to rebake incrementally and to stream. */
+export interface BakeManifest {
+    format: 1;
+    bakeVersion: number;
+    /** The grid and stored range the packs were made for; a change rebakes everything. */
+    grid: {
+        sizeX: number;
+        sizeZ: number;
+        spacing: number;
+        paintSpacing: number;
+        depth: number;
+        block: number;
+        heightRange: [number, number];
+    };
+    /** "bx,bz" → record. */
+    blocks: Record<string, BlockRecord>;
+    /** Per depth (0 roots … depth leaves): the largest node error there. */
+    depthErrors: number[];
+    /** The source hash the packs match. */
+    sourceHash: string;
+}
+export interface OutOfRange {
+    /** [x0, z0, x1, z1] metres. */
+    rect: [number, number, number, number];
+    samples: number;
+    lowest: number;
+    highest: number;
+}
+export interface BakeReport {
+    blocks: number;
+    rebaked: number;
+    /** Blocks this bake rebaked, as "bx,bz" (terrain.map's bake mode shades them). */
+    dirtied: string[];
+    /** Pages written (leaves and every rebuilt ancestor). */
+    pages: number;
+    /** Pages above the blocks rebuilt from their children. */
+    ancestors: number;
+    /** Pack bytes written. */
+    bytes: number;
+    ms: number;
+    /** Mean milliseconds per rebaked block (pool time, not wall time). */
+    msPerBlock: number;
+    outOfRange: OutOfRange[];
+}
+export interface BakeOptions {
+    /** Blocks bake here; inline (on the calling thread) without one. */
+    workers?: Workers;
+    /** Rebake every block. */
+    force?: boolean;
+    /** Problems worth a warning (terrain/out-of-range, once per block). */
+    warn?: (problem: ShardError) => void;
+    onProgress?: (done: number, total: number) => void;
+}
+/** What a bake reads of a terrain source asset (TerrainSourceAsset). */
+export interface BakeInput {
+    source: TerrainSource;
+    layout: TerrainLayout;
+    deps: Record<string, {
+        hash: string;
+    }>;
+    hash: string;
+}
+export declare function readManifest(store: PackStore): Promise<BakeManifest | undefined>;
+/**
+ * Each block's key (spec 0071): SHA-256 of the bake version, the grid, the seed, and every layer
+ * (height and paint) whose region plus falloff touches the block's samples, with its dependency's
+ * hash and, for splines, its resolved centerline. Layers elsewhere don't change it.
+ */
+export declare function blockKeys(input: BakeInput, stack: Stack): Promise<string[]>;
+/**
+ * Bakes a terrain source into page packs (spec 0071), incrementally: blocks whose key changed are
+ * rebaked (on the pool when there is one), every ancestor of a rebaked block is rebuilt from its
+ * children, and only the packs holding changed pages are rewritten. A changed grid rebakes it all.
+ */
+export declare function bakeTerrain(input: BakeInput, stack: Stack, store: PackStore, options?: BakeOptions): Promise<BakeReport>;
+export interface TerrainStats {
+    baked: boolean;
+    /** The packs match the source. */
+    current: boolean;
+    size: [number, number];
+    spacing: number;
+    roots: number;
+    depth: number;
+    blocks: number;
+    pages: number;
+    /** Page bytes before deflate, and every file's bytes on disk. */
+    rawBytes: number;
+    bytesOnDisk: number;
+    /** Per leaf sample. */
+    bytesPerSample: number;
+    diskBytesPerSample: number;
+    msPerBlock: number;
+    slowestBlockMs: number;
+}
+/** What `shard terrain stats` prints: size on disk, pages, bytes per sample, time per block. */
+export declare function terrainStats(input: BakeInput, store: PackStore, manifest: BakeManifest | undefined): Promise<TerrainStats>;
+/**
+ * SHA-256 over every pack (path and bytes, sorted by path; not the manifest, which records
+ * timings): equal hashes mean byte-identical bakes, as Node's and Chrome's must be (0071).
+ */
+export declare function packHash(files: ReadonlyMap<string, Uint8Array>): Promise<string>;