nucleation 0.10.21 → 0.10.23

package/renderer/BuildingTool.d.mts

@@ -0,0 +1,46 @@
+// generated by diplomat-tool
+import type { Brush } from "./Brush.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { Shape } from "./Shape.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Namespace for the fill operations that combine a schematic, a shape and a
+ * brush (the old `buildingtool_*` free functions).
+ */
+export class BuildingTool {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Fill `shape` into `schematic` using `brush`.
+     */
+    static fill(schematic: Schematic, shape: Shape, brush: Brush): void;
+
+    /**
+     * Fill `count` copies of `shape`, each offset by `offset * i`.
+     */
+    static rstack(schematic: Schematic, shape: Shape, brush: Brush, count: number, offsetX: number, offsetY: number, offsetZ: number): void;
+
+    /**
+     * Masked fill that preserves everything already placed: `brush` is
+     * only written where `schematic` currently has air (or nothing at
+     * all), so existing structures inside `shape` survive untouched.
+     */
+    static fillOnlyAir(schematic: Schematic, shape: Shape, brush: Brush): void;
+
+    /**
+     * Masked fill that only overwrites the listed blocks: `targets_json`
+     * is a JSON array of block ids (e.g. `["minecraft:stone"]`, state
+     * properties ignored) and every cell of `shape` whose current block
+     * id is in the list is replaced by `brush` — everything else,
+     * including air, is left alone.
+     */
+    static fillReplacing(schematic: Schematic, shape: Shape, brush: Brush, targetsJson: string): void;
+}

package/renderer/BuildingTool.d.ts

@@ -0,0 +1,46 @@
+// generated by diplomat-tool
+import type { Brush } from "./Brush.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { Shape } from "./Shape.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Namespace for the fill operations that combine a schematic, a shape and a
+ * brush (the old `buildingtool_*` free functions).
+ */
+export class BuildingTool {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Fill `shape` into `schematic` using `brush`.
+     */
+    static fill(schematic: Schematic, shape: Shape, brush: Brush): void;
+
+    /**
+     * Fill `count` copies of `shape`, each offset by `offset * i`.
+     */
+    static rstack(schematic: Schematic, shape: Shape, brush: Brush, count: number, offsetX: number, offsetY: number, offsetZ: number): void;
+
+    /**
+     * Masked fill that preserves everything already placed: `brush` is
+     * only written where `schematic` currently has air (or nothing at
+     * all), so existing structures inside `shape` survive untouched.
+     */
+    static fillOnlyAir(schematic: Schematic, shape: Shape, brush: Brush): void;
+
+    /**
+     * Masked fill that only overwrites the listed blocks: `targets_json`
+     * is a JSON array of block ids (e.g. `["minecraft:stone"]`, state
+     * properties ignored) and every cell of `shape` whose current block
+     * id is in the list is replaced by `brush` — everything else,
+     * including air, is left alone.
+     */
+    static fillReplacing(schematic: Schematic, shape: Shape, brush: Brush, targetsJson: string): void;
+}

package/renderer/BuildingTool.mjs

@@ -0,0 +1,121 @@
+// generated by diplomat-tool
+import { Brush } from "./Brush.mjs"
+import { NucleationError } from "./NucleationError.mjs"
+import { Schematic } from "./Schematic.mjs"
+import { Shape } from "./Shape.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const BuildingTool_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.BuildingTool_destroy(ptr);
+});
+
+/**
+ * Namespace for the fill operations that combine a schematic, a shape and a
+ * brush (the old `buildingtool_*` free functions).
+ */
+export class BuildingTool {
+    // Internal ptr reference:
+    #ptr = null;
+
+    // Lifetimes are only to keep dependencies alive.
+    // Since JS won't garbage collect until there are no incoming edges.
+    #selfEdge = [];
+
+    #internalConstructor(symbol, ptr, selfEdge) {
+        if (symbol !== diplomatRuntime.internalConstructor) {
+            console.error("BuildingTool is an Opaque type. You cannot call its constructor.");
+            return;
+        }
+        this.#ptr = ptr;
+        this.#selfEdge = selfEdge;
+
+        // Are we being borrowed? If not, we can register.
+        if (this.#selfEdge.length === 0) {
+            BuildingTool_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Fill `shape` into `schematic` using `brush`.
+     */
+    static fill(schematic, shape, brush) {
+    wasm.BuildingTool_fill(schematic.ffiValue, shape.ffiValue, brush.ffiValue);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Fill `count` copies of `shape`, each offset by `offset * i`.
+     */
+    static rstack(schematic, shape, brush, count, offsetX, offsetY, offsetZ) {
+    wasm.BuildingTool_rstack(schematic.ffiValue, shape.ffiValue, brush.ffiValue, count, offsetX, offsetY, offsetZ);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Masked fill that preserves everything already placed: `brush` is
+     * only written where `schematic` currently has air (or nothing at
+     * all), so existing structures inside `shape` survive untouched.
+     */
+    static fillOnlyAir(schematic, shape, brush) {
+    wasm.BuildingTool_fill_only_air(schematic.ffiValue, shape.ffiValue, brush.ffiValue);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Masked fill that only overwrites the listed blocks: `targets_json`
+     * is a JSON array of block ids (e.g. `["minecraft:stone"]`, state
+     * properties ignored) and every cell of `shape` whose current block
+     * id is in the list is replaced by `brush` — everything else,
+     * including air, is left alone.
+     */
+    static fillReplacing(schematic, shape, brush, targetsJson) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const targetsJsonSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, targetsJson)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.BuildingTool_fill_replacing(diplomatReceive.buffer, schematic.ffiValue, shape.ffiValue, brush.ffiValue, targetsJsonSlice.ptr);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/renderer/CellExecutor.d.mts

@@ -0,0 +1,51 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { Value } from "./Value.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A typed executor bound to a self-describing cell: the schematic's
+ * EMBEDDED contract (autodetected, Insign fallback) supplies the port
+ * names, types and positions; the vanilla-accurate mc-tick engine
+ * supplies the physics. Wraps
+ * {@link crate::simulation::typed_executor::BackendCircuitExecutor}.
+ */
+export class CellExecutor {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Bind the schematic's embedded cell contract to the mc-tick
+     * engine (needs the `mc-tick` feature, else errors). Cells deploy
+     * BAKED: the backend trusts saved block states; an unbaked build
+     * sits inert until the first input flip.
+     */
+    static forSchematic(schematic: Schematic): CellExecutor;
+
+    /**
+     * Set an input port by name and typed value.
+     */
+    setInput(name: string, value: Value): void;
+
+    /**
+     * Run until quiescent within `budget` ticks; true when settled.
+     */
+    settle(budget: number): boolean;
+
+    /**
+     * Read an output port by name.
+     */
+    readOutput(name: string): Value;
+
+    /**
+     * Rebuild the engine from the original schematic (all inputs back
+     * to their saved states).
+     */
+    reset(): void;
+}

package/renderer/CellExecutor.d.ts

@@ -0,0 +1,51 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { Value } from "./Value.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A typed executor bound to a self-describing cell: the schematic's
+ * EMBEDDED contract (autodetected, Insign fallback) supplies the port
+ * names, types and positions; the vanilla-accurate mc-tick engine
+ * supplies the physics. Wraps
+ * {@link crate::simulation::typed_executor::BackendCircuitExecutor}.
+ */
+export class CellExecutor {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Bind the schematic's embedded cell contract to the mc-tick
+     * engine (needs the `mc-tick` feature, else errors). Cells deploy
+     * BAKED: the backend trusts saved block states; an unbaked build
+     * sits inert until the first input flip.
+     */
+    static forSchematic(schematic: Schematic): CellExecutor;
+
+    /**
+     * Set an input port by name and typed value.
+     */
+    setInput(name: string, value: Value): void;
+
+    /**
+     * Run until quiescent within `budget` ticks; true when settled.
+     */
+    settle(budget: number): boolean;
+
+    /**
+     * Read an output port by name.
+     */
+    readOutput(name: string): Value;
+
+    /**
+     * Rebuild the engine from the original schematic (all inputs back
+     * to their saved states).
+     */
+    reset(): void;
+}

package/renderer/CellExecutor.mjs

@@ -0,0 +1,171 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import { Schematic } from "./Schematic.mjs"
+import { Value } from "./Value.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const CellExecutor_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.CellExecutor_destroy(ptr);
+});
+
+/**
+ * A typed executor bound to a self-describing cell: the schematic's
+ * EMBEDDED contract (autodetected, Insign fallback) supplies the port
+ * names, types and positions; the vanilla-accurate mc-tick engine
+ * supplies the physics. Wraps
+ * {@link crate::simulation::typed_executor::BackendCircuitExecutor}.
+ */
+export class CellExecutor {
+    // Internal ptr reference:
+    #ptr = null;
+
+    // Lifetimes are only to keep dependencies alive.
+    // Since JS won't garbage collect until there are no incoming edges.
+    #selfEdge = [];
+
+    #internalConstructor(symbol, ptr, selfEdge) {
+        if (symbol !== diplomatRuntime.internalConstructor) {
+            console.error("CellExecutor is an Opaque type. You cannot call its constructor.");
+            return;
+        }
+        this.#ptr = ptr;
+        this.#selfEdge = selfEdge;
+
+        // Are we being borrowed? If not, we can register.
+        if (this.#selfEdge.length === 0) {
+            CellExecutor_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Bind the schematic's embedded cell contract to the mc-tick
+     * engine (needs the `mc-tick` feature, else errors). Cells deploy
+     * BAKED: the backend trusts saved block states; an unbaked build
+     * sits inert until the first input flip.
+     */
+    static forSchematic(schematic) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.CellExecutor_for_schematic(diplomatReceive.buffer, schematic.ffiValue);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new CellExecutor(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Set an input port by name and typed value.
+     */
+    setInput(name, value) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const nameSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, name)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.CellExecutor_set_input(diplomatReceive.buffer, this.ffiValue, nameSlice.ptr, value.ffiValue);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Run until quiescent within `budget` ticks; true when settled.
+     */
+    settle(budget) {
+
+        const result = wasm.CellExecutor_settle(this.ffiValue, budget);
+
+        try {
+            return result === 1;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Read an output port by name.
+     */
+    readOutput(name) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const nameSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, name)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.CellExecutor_read_output(diplomatReceive.buffer, this.ffiValue, nameSlice.ptr);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new Value(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Rebuild the engine from the original schematic (all inputs back
+     * to their saved states).
+     */
+    reset() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.CellExecutor_reset(diplomatReceive.buffer, this.ffiValue);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/renderer/CellularSdfConfig.d.mts

@@ -0,0 +1,22 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Immutable hashed-cell variation shared by coordinated SDF source layers.
+ */
+export class CellularSdfConfig {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Validates every field up front, so a config that constructs here is
+     * never rejected for its own values by a later `cellular_sdf` call.
+     */
+    static create(cellSizeX: number, cellSizeZ: number, seed: bigint, maxJitterX: number, maxJitterZ: number, maxYawDegrees: number, minScale: number, maxScale: number, minYOffset: number, maxYOffset: number, presenceNumerator: number, presenceDenominator: number, featureSalt: bigint): CellularSdfConfig;
+}

package/renderer/CellularSdfConfig.d.ts

@@ -0,0 +1,22 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Immutable hashed-cell variation shared by coordinated SDF source layers.
+ */
+export class CellularSdfConfig {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Validates every field up front, so a config that constructs here is
+     * never rejected for its own values by a later `cellular_sdf` call.
+     */
+    static create(cellSizeX: number, cellSizeZ: number, seed: bigint, maxJitterX: number, maxJitterZ: number, maxYawDegrees: number, minScale: number, maxScale: number, minYOffset: number, maxYOffset: number, presenceNumerator: number, presenceDenominator: number, featureSalt: bigint): CellularSdfConfig;
+}

package/renderer/CellularSdfConfig.mjs

@@ -0,0 +1,69 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const CellularSdfConfig_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.CellularSdfConfig_destroy(ptr);
+});
+
+/**
+ * Immutable hashed-cell variation shared by coordinated SDF source layers.
+ */
+export class CellularSdfConfig {
+    // Internal ptr reference:
+    #ptr = null;
+
+    // Lifetimes are only to keep dependencies alive.
+    // Since JS won't garbage collect until there are no incoming edges.
+    #selfEdge = [];
+
+    #internalConstructor(symbol, ptr, selfEdge) {
+        if (symbol !== diplomatRuntime.internalConstructor) {
+            console.error("CellularSdfConfig is an Opaque type. You cannot call its constructor.");
+            return;
+        }
+        this.#ptr = ptr;
+        this.#selfEdge = selfEdge;
+
+        // Are we being borrowed? If not, we can register.
+        if (this.#selfEdge.length === 0) {
+            CellularSdfConfig_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Validates every field up front, so a config that constructs here is
+     * never rejected for its own values by a later `cellular_sdf` call.
+     */
+    static create(cellSizeX, cellSizeZ, seed, maxJitterX, maxJitterZ, maxYawDegrees, minScale, maxScale, minYOffset, maxYOffset, presenceNumerator, presenceDenominator, featureSalt) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.CellularSdfConfig_create(diplomatReceive.buffer, cellSizeX, cellSizeZ, seed, maxJitterX, maxJitterZ, maxYawDegrees, minScale, maxScale, minYOffset, maxYOffset, presenceNumerator, presenceDenominator, featureSalt);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new CellularSdfConfig(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/renderer/ChunkMeshResult.d.mts

@@ -0,0 +1,75 @@
+// generated by diplomat-tool
+import type { BlockPos } from "./BlockPos.mjs"
+import type { MeshConfig } from "./MeshConfig.mjs"
+import type { MeshResult } from "./MeshResult.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { ResourcePack } from "./ResourcePack.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { TextureAtlas } from "./TextureAtlas.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Per-chunk mesh results. Wraps {@link crate::meshing::ChunkMeshResult}.
+ */
+export class ChunkMeshResult {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Mesh with the default chunk size (old ABI: `schematic_mesh_by_chunk`).
+     */
+    static create(schematic: Schematic, pack: ResourcePack, config: MeshConfig): ChunkMeshResult;
+
+    /**
+     * Mesh with an explicit chunk size (old ABI: `schematic_mesh_by_chunk_size`).
+     */
+    static createWithSize(schematic: Schematic, pack: ResourcePack, config: MeshConfig, chunkSize: number): ChunkMeshResult;
+
+    /**
+     * Mesh chunks against a pre-built shared atlas, synchronously
+     * (old ABI: `schematic_mesh_chunks_with_atlas`). For progress
+     * reporting use {@link MeshJob::start} instead.
+     */
+    static createWithAtlas(schematic: Schematic, pack: ResourcePack, config: MeshConfig, chunkSize: number, atlas: TextureAtlas): ChunkMeshResult;
+
+    /**
+     * Number of chunk meshes.
+     */
+    chunkCount(): number;
+
+    /**
+     * Coordinate of the `index`-th chunk (old ABI:
+     * `chunkmeshresult_chunk_coordinates` returned all of them flat).
+     */
+    chunkCoordinateAt(index: number): BlockPos;
+
+    /**
+     * The mesh for one chunk coordinate (cloned).
+     */
+    getMesh(cx: number, cy: number, cz: number): MeshResult;
+
+    /**
+     * Total vertex count across all chunk meshes.
+     */
+    totalVertexCount(): number;
+
+    /**
+     * Total triangle count across all chunk meshes.
+     */
+    totalTriangleCount(): number;
+
+    /**
+     * All chunk meshes serialized in the NUCM cache format, base64-encoded.
+     */
+    nucmDataB64(): string;
+
+    /**
+     * NUCM v2 with a shared atlas, base64-encoded.
+     */
+    nucmDataWithAtlasB64(atlas: TextureAtlas): string;
+}