@aethervtt/shard-terrain 0.1.0 → 0.2.1

package/dist/heightfield/root-grid.d.ts

@@ -0,0 +1,38 @@
+import type { QuadSurface, QuadTree, SelectionParams, SelectionView } from '../quadtree.js';
+/**
+ * A heightfield's roots as a quadtree surface (spec 0071): a grid of `rootsX` × `rootsZ` square
+ * roots of `rootSize` metres, in the terrain's frame (x along +X, height along +Y, a node's y index
+ * along +Z). A node is a box from its square and height range; there's no horizon. Neighbors
+ * cross into the next root and stop at the terrain's edge.
+ */
+export declare class RootGrid implements QuadSurface {
+    roots: number;
+    rootsX: number;
+    rootsZ: number;
+    rootSize: number;
+    /**
+     * Called for every new node: may set its height range (`tree.setHeights`-style, flags included)
+     * and its ready flag and slot, from what's known of its page.
+     */
+    onInit: ((tree: QuadTree, n: number, depth: number, x: number, z: number) => void) | undefined;
+    /** Sets the grid. The tree must be reset after. */
+    configure(rootsX: number, rootsZ: number, rootSize: number): void;
+    grow(): void;
+    /** A node's global coordinates at its depth: [x, z]. */
+    globalOf(tree: QuadTree, n: number, out: {
+        [i: number]: number;
+    }): void;
+    private readonly g;
+    initNode(tree: QuadTree, n: number): void;
+    /** The node's square: [x0, z0, size]. */
+    private square;
+    updateSphere(tree: QuadTree, n: number): void;
+    bounds(tree: QuadTree, n: number, center: ArrayLike<number>, out: {
+        [i: number]: number;
+    }): void;
+    /** Outside the frustum: the box's corner furthest along a plane's normal is behind it. */
+    culled(tree: QuadTree, n: number, view: SelectionView, _params: SelectionParams): boolean;
+    neighbor(root: number, depth: number, x: number, y: number, edge: number, out: {
+        [i: number]: number;
+    }): boolean;
+}

package/dist/heightfield/root-grid.js

@@ -0,0 +1,109 @@
+import { EDGE_BOTTOM, EDGE_RIGHT, EDGE_TOP } from "../cube.js";
+class RootGrid {
+  roots = 1;
+  rootsX = 1;
+  rootsZ = 1;
+  rootSize = 1;
+  /**
+   * Called for every new node: may set its height range (`tree.setHeights`-style, flags included)
+   * and its ready flag and slot, from what's known of its page.
+   */
+  onInit;
+  /** Sets the grid. The tree must be reset after. */
+  configure(rootsX, rootsZ, rootSize) {
+    this.rootsX = rootsX;
+    this.rootsZ = rootsZ;
+    this.roots = rootsX * rootsZ;
+    this.rootSize = rootSize;
+  }
+  grow() {
+  }
+  /** A node's global coordinates at its depth: [x, z]. */
+  globalOf(tree, n, out) {
+    const root = tree.root[n];
+    const d = tree.depth[n];
+    out[0] = root % this.rootsX * 2 ** d + tree.x[n];
+    out[1] = Math.floor(root / this.rootsX) * 2 ** d + tree.y[n];
+  }
+  g = new Float64Array(2);
+  initNode(tree, n) {
+    if (!this.onInit) return;
+    this.globalOf(tree, n, this.g);
+    this.onInit(tree, n, tree.depth[n], this.g[0], this.g[1]);
+  }
+  /** The node's square: [x0, z0, size]. */
+  square(tree, n, out) {
+    this.globalOf(tree, n, out);
+    const size = this.rootSize / 2 ** tree.depth[n];
+    out[0] = out[0] * size;
+    out[1] = out[1] * size;
+    out[2] = size;
+    return out;
+  }
+  updateSphere(tree, n) {
+    this.square(tree, n, sq);
+    const size = sq[2];
+    const lo = tree.minH[n];
+    const hi = tree.maxH[n];
+    const o = n * 4;
+    tree.sphere[o] = sq[0] + size / 2;
+    tree.sphere[o + 1] = (lo + hi) / 2;
+    tree.sphere[o + 2] = sq[1] + size / 2;
+    const hy = (hi - lo) / 2;
+    tree.sphere[o + 3] = Math.sqrt(size * size * 0.5 + hy * hy) + 1e-3;
+  }
+  bounds(tree, n, center, out) {
+    this.square(tree, n, sq);
+    const size = sq[2];
+    out[0] = sq[0] - center[0];
+    out[1] = tree.minH[n] - center[1];
+    out[2] = sq[1] - center[2];
+    out[3] = sq[0] + size - center[0];
+    out[4] = tree.maxH[n] - center[1];
+    out[5] = sq[1] + size - center[2];
+  }
+  /** Outside the frustum: the box's corner furthest along a plane's normal is behind it. */
+  culled(tree, n, view, _params) {
+    const s = tree.sphere;
+    const o = n * 4;
+    const f = view.frustum;
+    this.square(tree, n, sq);
+    const size = sq[2];
+    const lo = tree.minH[n];
+    const hi = tree.maxH[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 * s[o] + ny * s[o + 1] + nz * s[o + 2] + f[q + 3];
+      if (dist < -s[o + 3]) return true;
+      if (dist > s[o + 3]) continue;
+      const x = nx >= 0 ? sq[0] + size : sq[0];
+      const y = ny >= 0 ? hi : lo;
+      const z = nz >= 0 ? sq[1] + size : sq[1];
+      if (nx * x + ny * y + nz * z + f[q + 3] < 0) return true;
+    }
+    return false;
+  }
+  neighbor(root, depth, x, y, edge, out) {
+    const n = 2 ** depth;
+    let gx = root % this.rootsX * n + x;
+    let gz = Math.floor(root / this.rootsX) * n + y;
+    if (edge === EDGE_BOTTOM) gz--;
+    else if (edge === EDGE_RIGHT) gx++;
+    else if (edge === EDGE_TOP) gz++;
+    else gx--;
+    if (gx < 0 || gz < 0 || gx >= this.rootsX * n || gz >= this.rootsZ * n) return false;
+    const rx = Math.floor(gx / n);
+    const rz = Math.floor(gz / n);
+    out[0] = rz * this.rootsX + rx;
+    out[1] = gx - rx * n;
+    out[2] = gz - rz * n;
+    return true;
+  }
+}
+const sq = new Float64Array(3);
+export {
+  RootGrid
+};

package/dist/heightfield/runtime.d.ts

@@ -0,0 +1,105 @@
+import { type AssetRef, type Entity, ShardError, type World } from '@aethervtt/shard-core';
+import type { PlatformFileSystem, Workers } from '@aethervtt/shard-platform';
+import { PlanetFrame } from '../frame.js';
+import { QuadTree } from '../quadtree.js';
+import { type BakeManifest, type BakeReport } from './bake.js';
+import { type Stack } from './kernel.js';
+import { type PackStore } from './pack.js';
+import { PageStore } from './pages.js';
+import { RootGrid } from './root-grid.js';
+import type { TerrainLayout } from './source.js';
+import { type TerrainSourceAsset } from './source-asset.js';
+/** GPU bytes a page takes in the pool: its texels and its control texels. */
+export declare function pageGpuBytes(layout: TerrainLayout): number;
+/** Coarse levels kept loaded by default: the deepest whose pages, with every coarser level's, fit here. */
+export declare const RESIDENT_BYTES: number;
+export interface HeightfieldSettings {
+    source: AssetRef | null;
+    errorPixels: number;
+    vertexPixels: number;
+    colliderRadius: number;
+    skirts: boolean;
+    residentDepth: number;
+}
+/** Where a terrain is in getting ready to stream. */
+export type BakeState = 'idle' | 'checking' | 'baking' | 'current' | 'failed';
+/**
+ * Everything the terrain keeps per `Terrain` entity (spec 0071): its source and compiled stack,
+ * its packs (baked on first use when missing or stale), the pages it has read, its quadtree over
+ * the root grid with the per-depth errors from the bake, its frame, and its anchors. Colliders and
+ * the render side keep their state in `parts`.
+ */
+export declare class HeightfieldRuntime {
+    readonly entity: Entity;
+    settings: HeightfieldSettings | undefined;
+    tick: number;
+    asset: TerrainSourceAsset | undefined;
+    private assetVersion;
+    stack: Stack | undefined;
+    layout: TerrainLayout | undefined;
+    /** Bumps when what the pages hold changes (a source edit, after its rebake). */
+    version: number;
+    problem: ShardError | null;
+    waiting: string | null;
+    store: PackStore | undefined;
+    pages: PageStore | undefined;
+    manifest: BakeManifest | undefined;
+    bake: BakeState;
+    lastBake: BakeReport | undefined;
+    /** Blocks the last bake rebaked ("bx,bz"), for terrain.map's bake mode. */
+    dirtied: string[];
+    readonly grid: RootGrid;
+    readonly tree: QuadTree;
+    readonly selection: import("..").Selection;
+    /** Per depth: the measured errors from the bake (selection's table, 0043's convention), and capped. */
+    rawErrors: Float32Array;
+    errors: Float32Array;
+    lodBias: number;
+    /** Coarse levels kept loaded; the pages of depths up to it are pinned. */
+    residentDepth: number;
+    /** Resident pages loaded: the GPU side can draw coarse ground. */
+    streaming: boolean;
+    readonly frame: PlanetFrame;
+    anchorPos: Float64Array<ArrayBuffer>;
+    anchorRadius: Float64Array<ArrayBuffer>;
+    anchorEntity: Entity[];
+    anchors: number;
+    readonly parts: Map<string, unknown>;
+    /** The source hash the pages and manifest match. */
+    private bakedHash;
+    private generation;
+    constructor(entity: Entity);
+    /** Whether colliders and height queries can run: the source and its assets are loaded. */
+    get ready(): boolean;
+    get lo(): number;
+    get hi(): number;
+    /** Vertex spacing at a depth (m). */
+    spacing(depth: number): number;
+    /** Metres a node at `depth` covers. */
+    nodeSize(depth: number): number;
+    /** New tree nodes take what's known of their page: its exact height range. */
+    private initNode;
+    /**
+     * Brings the runtime up to date with its component and source: reads settings, resolves and
+     * compiles the source, and (in the background) checks its packs, bakes them if they're missing
+     * or stale, and loads the coarse levels.
+     */
+    refresh(world: World, env: {
+        fs: PlatformFileSystem | undefined;
+        workers: Workers | undefined;
+    }): void;
+    private report;
+    /** Errors capped by vertex spacing (`vertexPixels`), as planets have them. */
+    capErrors(): void;
+    /**
+     * Checks the packs against the source; bakes them when missing or stale (into the project's
+     * cache where the file service writes, else in memory); then reads the manifest's errors and
+     * loads the coarse levels. A later edit runs it again; pages already drawn are replaced in place.
+     */
+    private prepare;
+    private readonly g;
+    /** A tree node's height range from its pack entry, when known. */
+    refreshBounds(n: number): void;
+    /** The tree node for a page, if the tree has one at that depth. */
+    nodeOf(depth: number, x: number, z: number): number;
+}

package/dist/heightfield/runtime.js

@@ -0,0 +1,312 @@
+import { assetServer } from "@aethervtt/shard-assets";
+import { ShardError } from "@aethervtt/shard-core";
+import { LogResource } from "@aethervtt/shard-runtime";
+import { PlanetFrame } from "../frame.js";
+import { capErrors } from "../lod.js";
+import { createSelection, NODE_BOUNDS, NODE_READY, QuadTree } from "../quadtree.js";
+import { bakeTerrain, readManifest } from "./bake.js";
+import { Terrain } from "./component.js";
+import { dequantize, LEAF_SIDE, PAGE } from "./kernel.js";
+import { fsPackStore, memoryPackStore } from "./pack.js";
+import { nodeKey, PageStore } from "./pages.js";
+import { stackFor, terrainCacheDir } from "./project.js";
+import { RootGrid } from "./root-grid.js";
+import { TerrainSources } from "./source-asset.js";
+function pageGpuBytes(layout) {
+  return LEAF_SIDE * LEAF_SIDE * 4 + (layout.cells + 1) * (layout.cells + 1) * 4;
+}
+const RESIDENT_BYTES = 8 * 1024 * 1024;
+class HeightfieldRuntime {
+  entity;
+  settings;
+  tick = -1;
+  asset;
+  assetVersion = -1;
+  stack;
+  layout;
+  /** Bumps when what the pages hold changes (a source edit, after its rebake). */
+  version = 0;
+  problem = null;
+  waiting = null;
+  store;
+  pages;
+  manifest;
+  bake = "idle";
+  lastBake;
+  /** Blocks the last bake rebaked ("bx,bz"), for terrain.map's bake mode. */
+  dirtied = [];
+  grid = new RootGrid();
+  tree = new QuadTree(this.grid, 1024);
+  selection = createSelection();
+  /** Per depth: the measured errors from the bake (selection's table, 0043's convention), and capped. */
+  rawErrors = new Float32Array(2);
+  errors = new Float32Array(2);
+  lodBias = 1;
+  /** Coarse levels kept loaded; the pages of depths up to it are pinned. */
+  residentDepth = 0;
+  /** Resident pages loaded: the GPU side can draw coarse ground. */
+  streaming = false;
+  frame = new PlanetFrame();
+  anchorPos = new Float64Array(0);
+  anchorRadius = new Float64Array(0);
+  anchorEntity = [];
+  anchors = 0;
+  parts = /* @__PURE__ */ new Map();
+  /** The source hash the pages and manifest match. */
+  bakedHash = "";
+  generation = 0;
+  constructor(entity) {
+    this.entity = entity;
+    this.grid.onInit = (tree, n, depth, x, z) => this.initNode(tree, n, depth, x, z);
+  }
+  /** Whether colliders and height queries can run: the source and its assets are loaded. */
+  get ready() {
+    return this.problem === null && this.stack !== void 0 && this.layout !== void 0;
+  }
+  get lo() {
+    return this.asset?.source.heightRange[0] ?? 0;
+  }
+  get hi() {
+    return this.asset?.source.heightRange[1] ?? 1;
+  }
+  /** Vertex spacing at a depth (m). */
+  spacing(depth) {
+    const l = this.layout;
+    return l ? l.rootSize / 2 ** depth / PAGE : 1;
+  }
+  /** Metres a node at `depth` covers. */
+  nodeSize(depth) {
+    return (this.layout?.rootSize ?? 1) / 2 ** depth;
+  }
+  /** New tree nodes take what's known of their page: its exact height range. */
+  initNode(tree, n, depth, x, z) {
+    const e = this.pages?.entry(depth, x, z);
+    if (!e) return;
+    tree.minH[n] = dequantize(e.min, this.lo, this.hi);
+    tree.maxH[n] = dequantize(e.max, this.lo, this.hi);
+    tree.flags[n] |= NODE_BOUNDS;
+    const ready = this.parts.get("ready");
+    if (ready) {
+      const slot = ready(nodeKey(depth, x, z));
+      if (slot >= 0) {
+        tree.flags[n] |= NODE_READY;
+        tree.slot[n] = slot;
+      }
+    }
+  }
+  /**
+   * Brings the runtime up to date with its component and source: reads settings, resolves and
+   * compiles the source, and (in the background) checks its packs, bakes them if they're missing
+   * or stale, and loads the coarse levels.
+   */
+  refresh(world, env) {
+    const table = world.entityTable(this.entity);
+    const tick = table.changedTicks(Terrain)[world.entityRow(this.entity)];
+    let settingsChanged = false;
+    if (tick !== this.tick || !this.settings) {
+      this.tick = tick;
+      const v = world.get(this.entity, Terrain);
+      this.settings = {
+        source: v.source,
+        errorPixels: v.errorPixels,
+        vertexPixels: v.vertexPixels,
+        colliderRadius: v.colliderRadius,
+        skirts: v.skirts,
+        residentDepth: v.residentDepth
+      };
+      settingsChanged = true;
+    }
+    const ref = this.settings.source;
+    if (!ref || ref.guid === void 0 && ref.path === void 0) {
+      this.waiting = "a source (Terrain.source)";
+      return;
+    }
+    const asset = resolve(world, ref);
+    if (!asset) {
+      this.waiting = `terrain source ${ref.path ?? ref.guid}`;
+      return;
+    }
+    if (asset !== this.asset || asset.version !== this.assetVersion) {
+      try {
+        this.stack = stackFor(world, asset);
+      } catch (err) {
+        const e = err;
+        if (e.code === "terrain/not-ready") {
+          this.waiting = e.path ?? "its assets";
+          return;
+        }
+        this.report(world, e);
+        return;
+      }
+      const layoutChanged = JSON.stringify(asset.layout) !== JSON.stringify(this.layout);
+      this.asset = asset;
+      this.assetVersion = asset.version;
+      this.problem = null;
+      this.waiting = null;
+      if (layoutChanged) {
+        this.layout = asset.layout;
+        this.grid.configure(asset.layout.rootsX, asset.layout.rootsZ, asset.layout.rootSize);
+        this.tree.resetRoots(this.lo, this.hi);
+        this.store = env.fs ? fsPackStore(env.fs, terrainCacheDir(guidOf(world, ref) ?? "memory")) : memoryPackStore();
+        this.pages = new PageStore(this.store, asset.layout, this.lo, this.hi, env.workers);
+        this.manifest = void 0;
+        this.streaming = false;
+        this.bakedHash = "";
+        this.rawErrors = new Float32Array(asset.layout.depth + 2);
+        this.errors = new Float32Array(asset.layout.depth + 2);
+        for (let d = 0; d <= asset.layout.depth; d++) this.rawErrors[d] = this.spacing(d) * 8;
+        settingsChanged = true;
+      }
+      void this.prepare(world, env);
+    }
+    if (settingsChanged) this.capErrors();
+  }
+  report(world, err) {
+    this.problem = err;
+    this.waiting = null;
+    world.tryResource(LogResource)?.error(err);
+  }
+  /** Errors capped by vertex spacing (`vertexPixels`), as planets have them. */
+  capErrors() {
+    const s = this.settings;
+    if (!s) return;
+    this.errors = capErrors(
+      this.rawErrors,
+      (d) => this.spacing(d),
+      s.errorPixels,
+      s.vertexPixels,
+      this.errors.length === this.rawErrors.length ? this.errors : void 0
+    );
+  }
+  /**
+   * Checks the packs against the source; bakes them when missing or stale (into the project's
+   * cache where the file service writes, else in memory); then reads the manifest's errors and
+   * loads the coarse levels. A later edit runs it again; pages already drawn are replaced in place.
+   */
+  async prepare(world, env) {
+    const generation = ++this.generation;
+    const asset = this.asset;
+    const stack = this.stack;
+    const pages = this.pages;
+    let store = this.store;
+    this.bake = "checking";
+    try {
+      let manifest = await readManifest(store);
+      if (manifest?.sourceHash !== asset.hash) {
+        if (!store.writable) {
+          store = memoryPackStore();
+          this.store = store;
+          pages.store = store;
+        }
+        this.bake = "baking";
+        const report = await bakeTerrain(asset, stack, store, {
+          ...env.workers ? { workers: env.workers } : {},
+          warn: (problem) => world.tryResource(LogResource)?.warn(problem.message, { code: problem.code })
+        });
+        if (generation !== this.generation) return;
+        this.lastBake = report;
+        this.dirtied = report.dirtied;
+        manifest = await readManifest(store);
+      }
+      if (generation !== this.generation) return;
+      if (!manifest)
+        throw new ShardError("terrain/bake-failed", "The terrain bake wrote no manifest", {
+          hint: "Check the project cache is writable (.shard/cache/terrain), then run `shard terrain bake --force`."
+        });
+      const rebaked = this.bakedHash !== "" && this.bakedHash !== manifest.sourceHash;
+      this.manifest = manifest;
+      this.bakedHash = manifest.sourceHash;
+      if (rebaked) {
+        pages.clear();
+        this.version++;
+      }
+      const D = this.layout.depth;
+      const raw = new Float32Array(D + 2);
+      for (let d = 1; d <= D + 1; d++) raw[d] = manifest.depthErrors[d - 1] ?? 0;
+      raw[0] = raw[1] * 2;
+      for (let d = D; d >= 0; d--) raw[d] = Math.max(raw[d], raw[d + 1]);
+      this.rawErrors = raw;
+      this.capErrors();
+      const per = pageGpuBytes(this.layout);
+      let resident = this.settings.residentDepth;
+      if (resident < 0) {
+        resident = 0;
+        let bytes = 0;
+        for (let d = 0; d <= D; d++) {
+          const [nx, nz] = pages.nodesAt(d);
+          bytes += nx * nz * per;
+          if (bytes > RESIDENT_BYTES) break;
+          resident = d;
+        }
+      }
+      this.residentDepth = Math.min(D, resident);
+      const loads = [];
+      for (let d = 0; d <= this.residentDepth; d++) {
+        const [nx, nz] = pages.nodesAt(d);
+        for (let z = 0; z < nz; z++) {
+          for (let x = 0; x < nx; x++) {
+            pages.pin(nodeKey(d, x, z));
+            loads.push(pages.load(d, x, z));
+          }
+        }
+      }
+      await Promise.all(loads);
+      if (generation !== this.generation) return;
+      for (let n = 0; n < this.tree.count; n++) this.refreshBounds(n);
+      this.bake = "current";
+      this.streaming = true;
+    } catch (err) {
+      if (generation !== this.generation) return;
+      this.bake = "failed";
+      this.report(
+        world,
+        err instanceof ShardError ? err : new ShardError("terrain/bake-failed", String(err))
+      );
+    }
+  }
+  g = new Float64Array(2);
+  /** A tree node's height range from its pack entry, when known. */
+  refreshBounds(n) {
+    this.grid.globalOf(this.tree, n, this.g);
+    const e = this.pages?.entry(this.tree.depth[n], this.g[0], this.g[1]);
+    if (!e) return;
+    this.tree.setHeights(
+      n,
+      dequantize(e.min, this.lo, this.hi),
+      dequantize(e.max, this.lo, this.hi)
+    );
+  }
+  /** The tree node for a page, if the tree has one at that depth. */
+  nodeOf(depth, x, z) {
+    const l = this.layout;
+    if (!l) return -1;
+    const rx = x >> depth;
+    const rz = z >> depth;
+    if (rx >= l.rootsX || rz >= l.rootsZ) return -1;
+    const mask = 2 ** depth - 1;
+    const n = this.tree.find(rz * l.rootsX + rx, depth, x & mask, z & mask);
+    return this.tree.depth[n] === depth ? n : -1;
+  }
+}
+function guidOf(world, ref) {
+  if (ref.guid !== void 0) return ref.guid;
+  return world.tryResource(TerrainSources) ? assetServer(world).entry(ref)?.guid : void 0;
+}
+function resolve(world, ref) {
+  const store = world.initResource(TerrainSources);
+  if (ref.guid !== void 0) {
+    const v = store.get(ref);
+    if (v) return v;
+  }
+  const server = assetServer(world);
+  const entry = server.entry(ref);
+  if (!entry) return void 0;
+  if (entry.state !== "failed") void server.request(entry.guid).catch(() => {
+  });
+  return store.get({ guid: entry.guid });
+}
+export {
+  HeightfieldRuntime,
+  RESIDENT_BYTES,
+  pageGpuBytes
+};

package/dist/heightfield/source-asset.d.ts

@@ -0,0 +1,39 @@
+import { AssetStore } from '@aethervtt/shard-assets';
+import { type TerrainLayout, type TerrainSource } from './source.js';
+/** An asset a terrain source uses: its guid, type, and the hash of its imported contents. */
+export interface SourceDependency {
+    guid: string;
+    type: string;
+    hash: string;
+}
+/** What `*.terrain.json` imports to (spec 0071). */
+export interface TerrainSourceArtifact {
+    format: 1;
+    source: TerrainSource;
+    layout: TerrainLayout;
+    /** Every asset it uses, by project path. */
+    deps: Record<string, SourceDependency>;
+    /** SHA-256 of the source and its dependencies' hashes: changes with anything a bake reads. */
+    hash: string;
+}
+/** A loaded terrain source: what a `Terrain` entity bakes and streams. */
+export declare class TerrainSourceAsset {
+    source: TerrainSource;
+    layout: TerrainLayout;
+    deps: Record<string, SourceDependency>;
+    hash: string;
+    /** Bumps on hot reload. */
+    version: number;
+    constructor(a: TerrainSourceArtifact);
+}
+export declare const TerrainSources: import("@aethervtt/shard-core").ResourceDef<AssetStore<TerrainSourceAsset, "terrain/TerrainSource">>;
+export declare const TerrainSourceAssetType: import("@aethervtt/shard-assets").AssetTypeDef<TerrainSourceAsset>;
+/**
+ * `*.terrain.json`: a heightfield terrain's layer stack (spec 0071), validated with pointers into
+ * the file, its assets resolved to guids and recorded as import dependencies (editing a noise graph
+ * or heightmap re-imports it, and the next bake rebakes the blocks it touches).
+ */
+export declare const TerrainSourceImporter: import("@aethervtt/shard-assets").ImporterDef;
+/** The JSON Schema of `*.terrain.json` (written to `.shard/schemas/terrain.schema.json`). */
+export declare function terrainJsonSchema(): Record<string, unknown>;
+export declare const terrainSchema: () => unknown;