nucleation 0.6.0 → 0.8.0

package/Value.d.mts

@@ -0,0 +1,73 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A typed circuit value (payload-carrying enum; PORTING rule 10).
+ */
+export class Value {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Create an unsigned 32-bit integer value.
+     */
+    static fromU32(v: number): Value;
+
+    /**
+     * Create a signed 32-bit integer value.
+     */
+    static fromI32(v: number): Value;
+
+    /**
+     * Create a 32-bit IEEE 754 float value.
+     */
+    static fromF32(v: number): Value;
+
+    /**
+     * Create a boolean value.
+     */
+    static fromBool(v: boolean): Value;
+
+    /**
+     * Create a string value. Fails if the bytes are not valid UTF-8.
+     */
+    static fromString(s: string): Value;
+
+    /**
+     * The value as u32. Also accepts u64/non-negative signed ints that
+     * fit, and bool (false → 0, true → 1); fails otherwise.
+     */
+    asU32(): number;
+
+    /**
+     * The value as i32. Also accepts i64 values in i32 range; fails for
+     * other types.
+     */
+    asI32(): number;
+
+    /**
+     * The value as f32; fails if this is not an f32 value.
+     */
+    asF32(): number;
+
+    /**
+     * The value as bool; fails if this is not a bool value.
+     */
+    asBool(): boolean;
+
+    /**
+     * The string payload; fails if this is not a string value.
+     */
+    asString(): string;
+
+    /**
+     * The type name (e.g. "u32", "bool", "string").
+     */
+    typeName(): string;
+}

package/Value.d.ts

@@ -1,5 +1,5 @@
 // generated by diplomat-tool
-import type { NucleationError } from "./NucleationError"
+import type { NucleationError } from "./NucleationError.mjs"
 import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
 
 

package/VideoConfig.d.mts

@@ -0,0 +1,15 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Native FFmpeg video output preset.
+ */
+export class VideoConfig {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+}

package/Voxelizer.d.mts

@@ -0,0 +1,58 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Palette } from "./Palette.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 mesh-voxelization entry points (GLB/OBJ → shapes
+ * and textured schematics).
+ */
+export class Voxelizer {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Load a binary glTF (`.glb`, embedded buffers/images) and voxelize
+     * it into a fillable Shape: the model is uniformly scaled so its
+     * largest dimension equals `target_size` voxels, centered on x/z
+     * with its base resting at y = 0. Solidity is a parity test at each
+     * voxel center (robust on closed meshes), plus — when `shell` > 0 —
+     * every voxel whose center is within `shell` blocks of the surface,
+     * which rescues thin walls and hollow vessels (0.7–1.0 closes
+     * single-voxel shells; 0 = pure parity; a *negative* `shell` is
+     * surface-only — a skin |shell| blocks thick with no interior fill,
+     * for open sheets/ribbons that dip or self-overlap). Errors with `Parse` on
+     * malformed/triangle-less GLB and `InvalidArgument` on a
+     * non-positive `target_size`.
+     */
+    static shapeFromGlb(data: Array<number>, targetSize: number, shell: number): Shape;
+
+    /**
+     * Load a Wavefront OBJ (`v`/`vt`/`f` lines; polygon faces are
+     * fan-triangulated, negative indices supported, materials ignored)
+     * and voxelize it into a fillable Shape, fitted and shelled exactly
+     * like `shape_from_glb`. Errors with `Parse` on malformed/triangle-less
+     * OBJ and `InvalidArgument` on invalid UTF-8 or a non-positive
+     * `target_size`.
+     */
+    static shapeFromObj(text: string, targetSize: number, shell: number): Shape;
+
+    /**
+     * Load a binary glTF and voxelize it directly into a textured
+     * schematic named `name`: every solid voxel becomes the `palette`
+     * block closest to its nearest-surface texture color (interior
+     * voxels inherit the nearest surface color; voxels without texture
+     * info snap to mid-gray). `shell` behaves as in `shape_from_glb` —
+     * use ~0.7 for thin-walled models. Errors with `Parse` on malformed GLB and
+     * `InvalidArgument` on invalid UTF-8 or a non-positive
+     * `target_size`.
+     */
+    static schematicFromGlbTextured(data: Array<number>, targetSize: number, shell: number, palette: Palette, name: string): Schematic;
+}

package/Voxelizer.d.ts

@@ -1,8 +1,8 @@
 // generated by diplomat-tool
-import type { NucleationError } from "./NucleationError"
-import type { Palette } from "./Palette"
-import type { Schematic } from "./Schematic"
-import type { Shape } from "./Shape"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Palette } from "./Palette.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { Shape } from "./Shape.mjs"
 import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
 
 

package/WorldChunkView.d.mts

@@ -0,0 +1,75 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A single decoded chunk (or a from-scratch chunk under construction).
+ */
+export class WorldChunkView {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Create an empty chunk view at the given chunk coordinates — the
+     * starting point for generating worlds from scratch. Sections are
+     * created on demand by `set_block`. Serialized with
+     * `status = "minecraft:full"` (Minecraft will not regenerate over it)
+     * and the default data version.
+     */
+    static create(cx: number, cz: number): WorldChunkView;
+
+    /**
+     * The chunk X coordinate (in chunk units).
+     */
+    cx(): number;
+
+    /**
+     * The chunk Z coordinate (in chunk units).
+     */
+    cz(): number;
+
+    /**
+     * Convert the chunk view to a standalone schematic.
+     */
+    toSchematic(): Schematic;
+
+    /**
+     * Build a chunk view at (`cx`, `cz`) from a schematic — every non-air
+     * block whose world (x, z) falls in this chunk is copied in, the rest
+     * ignored. The write-side twin of `to_schematic`: this is how the
+     * schematic building tools become a *world generator*. Fill a schematic
+     * with any shape, SDF, brush, or footprint (intersect it with the
+     * chunk's cuboid to keep memory flat), then hand it here per chunk and
+     * `WorldSink.write_chunk` it. Also the transform step of a world filter:
+     * `to_schematic` a streamed chunk, edit it, rebuild with this.
+     */
+    static fromSchematic(schematic: Schematic, cx: number, cz: number): WorldChunkView;
+
+    /**
+     * Set a block at absolute world coordinates inside this chunk view.
+     * `block_name` must be a valid Minecraft block identifier (e.g.
+     * `minecraft:stone`). Errors with `InvalidArgument` if (x, z) is outside
+     * this chunk's column.
+     */
+    setBlock(x: number, y: number, z: number, blockName: string): void;
+
+    /**
+     * Overwrite the biome of every currently-present section of the chunk
+     * view with `biome_name` (e.g. `minecraft:desert`). Sections are created
+     * lazily by `set_block`, so call this AFTER placing blocks.
+     */
+    setBiome(biomeName: string): void;
+
+    /**
+     * Deduped union of all sections' biome palette entries, in order of
+     * first appearance, written as a JSON array string (`[]` if no section
+     * carries biome data).
+     */
+    biomePaletteJson(): string;
+}

package/WorldChunkView.d.ts

@@ -1,6 +1,6 @@
 // generated by diplomat-tool
-import type { NucleationError } from "./NucleationError"
-import type { Schematic } from "./Schematic"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Schematic } from "./Schematic.mjs"
 import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
 
 

package/WorldGenerator.d.mts

@@ -0,0 +1,75 @@
+// generated by diplomat-tool
+import type { Brush } from "./Brush.mjs"
+import type { CellularSdfConfig } from "./CellularSdfConfig.mjs"
+import type { GeneratedChunk } from "./GeneratedChunk.mjs"
+import type { GeneratedChunkOverlayMode } from "./GeneratedChunkOverlayMode.mjs"
+import type { GeneratedWorldStream } from "./GeneratedWorldStream.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Sdf } from "./Sdf.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * An immutable native chunk source graph.
+ *
+ * Generated bindings expose concrete source constructors rather than host
+ * callbacks, so SDF evaluation and block placement stay entirely in Rust.
+ */
+export class WorldGenerator {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Create an SDF-backed source evaluated at voxel centers over the inclusive
+     * Y range. `source_id` and `version` become chunk provenance/cache metadata.
+     */
+    static sdf(volume: Sdf, material: Brush, minY: number, maxY: number, sourceId: string, version: string): WorldGenerator;
+
+    /**
+     * Create a sparse infinite source by placing a bounded SDF motif once per
+     * deterministically transformed cell. Reuse `config` across layers to keep
+     * terrain, water, vegetation, paths, and structures coordinated.
+     */
+    static cellularSdf(volume: Sdf, material: Brush, minY: number, maxY: number, config: CellularSdfConfig, sourceId: string, version: string): WorldGenerator;
+
+    /**
+     * Create a sparse source from projected building footprints, including
+     * caller-projected OSM-derived data.
+     * `buildings_json` uses the same schema as `Geo.extrude_footprints`:
+     * `[{"polygon":[[x,z],...],"height":40,"min_y":1,
+     * "block":"minecraft:bricks"}]`. `height` is the absolute top Y, matching
+     * `Geo.extrude_footprints`. Fetching and lat/lon projection stay
+     * caller-controlled; this source rasterizes only requested chunks.
+     */
+    static projectedFootprints(buildingsJson: string, baseBlock: string, sourceId: string, version: string): WorldGenerator;
+
+    /**
+     * Create an initially empty ordered source composition.
+     */
+    static composite(sourceId: string, version: string): WorldGenerator;
+
+    /**
+     * Append a source to a composite. Later `Replace` layers win at occupied
+     * voxels; `KeepExisting` layers only fill air. Errors on non-composites.
+     *
+     * Streams already created from this generator keep the layer list they
+     * were built with; only later `generate`/`stream` calls see the addition.
+     */
+    addLayer(source: WorldGenerator, mode: GeneratedChunkOverlayMode): void;
+
+    /**
+     * Generate one random-access chunk.
+     */
+    generate(cx: number, cz: number): GeneratedChunk;
+
+    /**
+     * Traverse an inclusive chunk rectangle lazily in canonical region-major
+     * order. The stream snapshots the generator's sources at creation, so
+     * later `add_layer` calls do not affect a stream already in flight.
+     */
+    stream(minCx: number, minCz: number, maxCx: number, maxCz: number): GeneratedWorldStream;
+}

package/WorldGenerator.d.ts

@@ -0,0 +1,75 @@
+// generated by diplomat-tool
+import type { Brush } from "./Brush.mjs"
+import type { CellularSdfConfig } from "./CellularSdfConfig.mjs"
+import type { GeneratedChunk } from "./GeneratedChunk.mjs"
+import type { GeneratedChunkOverlayMode } from "./GeneratedChunkOverlayMode.mjs"
+import type { GeneratedWorldStream } from "./GeneratedWorldStream.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Sdf } from "./Sdf.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * An immutable native chunk source graph.
+ *
+ * Generated bindings expose concrete source constructors rather than host
+ * callbacks, so SDF evaluation and block placement stay entirely in Rust.
+ */
+export class WorldGenerator {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Create an SDF-backed source evaluated at voxel centers over the inclusive
+     * Y range. `source_id` and `version` become chunk provenance/cache metadata.
+     */
+    static sdf(volume: Sdf, material: Brush, minY: number, maxY: number, sourceId: string, version: string): WorldGenerator;
+
+    /**
+     * Create a sparse infinite source by placing a bounded SDF motif once per
+     * deterministically transformed cell. Reuse `config` across layers to keep
+     * terrain, water, vegetation, paths, and structures coordinated.
+     */
+    static cellularSdf(volume: Sdf, material: Brush, minY: number, maxY: number, config: CellularSdfConfig, sourceId: string, version: string): WorldGenerator;
+
+    /**
+     * Create a sparse source from projected building footprints, including
+     * caller-projected OSM-derived data.
+     * `buildings_json` uses the same schema as `Geo.extrude_footprints`:
+     * `[{"polygon":[[x,z],...],"height":40,"min_y":1,
+     * "block":"minecraft:bricks"}]`. `height` is the absolute top Y, matching
+     * `Geo.extrude_footprints`. Fetching and lat/lon projection stay
+     * caller-controlled; this source rasterizes only requested chunks.
+     */
+    static projectedFootprints(buildingsJson: string, baseBlock: string, sourceId: string, version: string): WorldGenerator;
+
+    /**
+     * Create an initially empty ordered source composition.
+     */
+    static composite(sourceId: string, version: string): WorldGenerator;
+
+    /**
+     * Append a source to a composite. Later `Replace` layers win at occupied
+     * voxels; `KeepExisting` layers only fill air. Errors on non-composites.
+     *
+     * Streams already created from this generator keep the layer list they
+     * were built with; only later `generate`/`stream` calls see the addition.
+     */
+    addLayer(source: WorldGenerator, mode: GeneratedChunkOverlayMode): void;
+
+    /**
+     * Generate one random-access chunk.
+     */
+    generate(cx: number, cz: number): GeneratedChunk;
+
+    /**
+     * Traverse an inclusive chunk rectangle lazily in canonical region-major
+     * order. The stream snapshots the generator's sources at creation, so
+     * later `add_layer` calls do not affect a stream already in flight.
+     */
+    stream(minCx: number, minCz: number, maxCx: number, maxCz: number): GeneratedWorldStream;
+}

package/WorldGenerator.mjs

@@ -0,0 +1,255 @@
+// generated by diplomat-tool
+import { Brush } from "./Brush.mjs"
+import { CellularSdfConfig } from "./CellularSdfConfig.mjs"
+import { GeneratedChunk } from "./GeneratedChunk.mjs"
+import { GeneratedChunkOverlayMode } from "./GeneratedChunkOverlayMode.mjs"
+import { GeneratedWorldStream } from "./GeneratedWorldStream.mjs"
+import { NucleationError } from "./NucleationError.mjs"
+import { Sdf } from "./Sdf.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const WorldGenerator_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.WorldGenerator_destroy(ptr);
+});
+
+/**
+ * An immutable native chunk source graph.
+ *
+ * Generated bindings expose concrete source constructors rather than host
+ * callbacks, so SDF evaluation and block placement stay entirely in Rust.
+ */
+export class WorldGenerator {
+    // 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("WorldGenerator 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) {
+            WorldGenerator_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Create an SDF-backed source evaluated at voxel centers over the inclusive
+     * Y range. `source_id` and `version` become chunk provenance/cache metadata.
+     */
+    static sdf(volume, material, minY, maxY, sourceId, version) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const sourceIdSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, sourceId)));
+        const versionSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, version)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.WorldGenerator_sdf(diplomatReceive.buffer, volume.ffiValue, material.ffiValue, minY, maxY, sourceIdSlice.ptr, versionSlice.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 WorldGenerator(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Create a sparse infinite source by placing a bounded SDF motif once per
+     * deterministically transformed cell. Reuse `config` across layers to keep
+     * terrain, water, vegetation, paths, and structures coordinated.
+     */
+    static cellularSdf(volume, material, minY, maxY, config, sourceId, version) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const sourceIdSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, sourceId)));
+        const versionSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, version)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.WorldGenerator_cellular_sdf(diplomatReceive.buffer, volume.ffiValue, material.ffiValue, minY, maxY, config.ffiValue, sourceIdSlice.ptr, versionSlice.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 WorldGenerator(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Create a sparse source from projected building footprints, including
+     * caller-projected OSM-derived data.
+     * `buildings_json` uses the same schema as `Geo.extrude_footprints`:
+     * `[{"polygon":[[x,z],...],"height":40,"min_y":1,
+     * "block":"minecraft:bricks"}]`. `height` is the absolute top Y, matching
+     * `Geo.extrude_footprints`. Fetching and lat/lon projection stay
+     * caller-controlled; this source rasterizes only requested chunks.
+     */
+    static projectedFootprints(buildingsJson, baseBlock, sourceId, version) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const buildingsJsonSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, buildingsJson)));
+        const baseBlockSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, baseBlock)));
+        const sourceIdSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, sourceId)));
+        const versionSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, version)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.WorldGenerator_projected_footprints(diplomatReceive.buffer, buildingsJsonSlice.ptr, baseBlockSlice.ptr, sourceIdSlice.ptr, versionSlice.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 WorldGenerator(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Create an initially empty ordered source composition.
+     */
+    static composite(sourceId, version) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const sourceIdSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, sourceId)));
+        const versionSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, version)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.WorldGenerator_composite(diplomatReceive.buffer, sourceIdSlice.ptr, versionSlice.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 WorldGenerator(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Append a source to a composite. Later `Replace` layers win at occupied
+     * voxels; `KeepExisting` layers only fill air. Errors on non-composites.
+     *
+     * Streams already created from this generator keep the layer list they
+     * were built with; only later `generate`/`stream` calls see the addition.
+     */
+    addLayer(source, mode) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.WorldGenerator_add_layer(diplomatReceive.buffer, this.ffiValue, source.ffiValue, mode.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();
+        }
+    }
+
+    /**
+     * Generate one random-access chunk.
+     */
+    generate(cx, cz) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.WorldGenerator_generate(diplomatReceive.buffer, this.ffiValue, cx, cz);
+
+        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 GeneratedChunk(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Traverse an inclusive chunk rectangle lazily in canonical region-major
+     * order. The stream snapshots the generator's sources at creation, so
+     * later `add_layer` calls do not affect a stream already in flight.
+     */
+    stream(minCx, minCz, maxCx, maxCz) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.WorldGenerator_stream(diplomatReceive.buffer, this.ffiValue, minCx, minCz, maxCx, maxCz);
+
+        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 GeneratedWorldStream(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}