nucleation 0.6.0 → 0.8.0

package/GeneratedChunk.d.ts

@@ -0,0 +1,35 @@
+// generated by diplomat-tool
+import type { GeneratedChunkCoverage } from "./GeneratedChunkCoverage.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { WorldChunkView } from "./WorldChunkView.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * One generated chunk plus coverage and source-version metadata.
+ * Call `take_view` once to move its chunk into the existing world-stream API.
+ */
+export class GeneratedChunk {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    cx(): number;
+
+    cz(): number;
+
+    coverage(): GeneratedChunkCoverage;
+
+    sourceId(): string;
+
+    version(): string;
+
+    /**
+     * Consume the generated chunk payload. Metadata access and a second call
+     * return `AlreadyConsumed` afterwards.
+     */
+    takeView(): WorldChunkView;
+}

package/GeneratedChunk.mjs

@@ -0,0 +1,178 @@
+// generated by diplomat-tool
+import { GeneratedChunkCoverage } from "./GeneratedChunkCoverage.mjs"
+import { NucleationError } from "./NucleationError.mjs"
+import { WorldChunkView } from "./WorldChunkView.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const GeneratedChunk_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.GeneratedChunk_destroy(ptr);
+});
+
+/**
+ * One generated chunk plus coverage and source-version metadata.
+ * Call `take_view` once to move its chunk into the existing world-stream API.
+ */
+export class GeneratedChunk {
+    // 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("GeneratedChunk 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) {
+            GeneratedChunk_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    cx() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.GeneratedChunk_cx(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 });
+            }
+            return (new Int32Array(wasm.memory.buffer, diplomatReceive.buffer, 1))[0];
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    cz() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.GeneratedChunk_cz(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 });
+            }
+            return (new Int32Array(wasm.memory.buffer, diplomatReceive.buffer, 1))[0];
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    coverage() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.GeneratedChunk_coverage(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 });
+            }
+            return new GeneratedChunkCoverage(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    sourceId() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.GeneratedChunk_source_id(diplomatReceive.buffer, this.ffiValue, write.buffer);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+            write.free();
+        }
+    }
+
+    version() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.GeneratedChunk_version(diplomatReceive.buffer, this.ffiValue, write.buffer);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+            write.free();
+        }
+    }
+
+    /**
+     * Consume the generated chunk payload. Metadata access and a second call
+     * return `AlreadyConsumed` afterwards.
+     */
+    takeView() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.GeneratedChunk_take_view(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 });
+            }
+            return new WorldChunkView(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/GeneratedChunkCoverage.d.mts

@@ -0,0 +1,25 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Coverage of a generated chunk by its source graph.
+ */
+export class GeneratedChunkCoverage {
+
+    /** @internal */
+    static fromValue(value: GeneratedChunkCoverage | string): GeneratedChunkCoverage;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static Complete : GeneratedChunkCoverage;
+    static Partial : GeneratedChunkCoverage;
+    static Outside : GeneratedChunkCoverage;
+
+
+    constructor(value: GeneratedChunkCoverage | string );
+}

package/GeneratedChunkCoverage.d.ts

@@ -0,0 +1,25 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Coverage of a generated chunk by its source graph.
+ */
+export class GeneratedChunkCoverage {
+
+    /** @internal */
+    static fromValue(value: GeneratedChunkCoverage | string): GeneratedChunkCoverage;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static Complete : GeneratedChunkCoverage;
+    static Partial : GeneratedChunkCoverage;
+    static Outside : GeneratedChunkCoverage;
+
+
+    constructor(value: GeneratedChunkCoverage | string );
+}

package/GeneratedChunkCoverage.mjs

@@ -0,0 +1,75 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * Coverage of a generated chunk by its source graph.
+ */
+export class GeneratedChunkCoverage {
+    #value = undefined;
+
+    static #values = new Map([
+        ["Complete", 0],
+        ["Partial", 1],
+        ["Outside", 2]
+    ]);
+
+    static getAllEntries() {
+        return GeneratedChunkCoverage.#values.entries();
+    }
+
+    #internalConstructor(value) {
+        if (arguments.length > 1 && arguments[0] === diplomatRuntime.internalConstructor) {
+            // We pass in two internalConstructor arguments to create *new*
+            // instances of this type, otherwise the enums are treated as singletons.
+            if (arguments[1] === diplomatRuntime.internalConstructor ) {
+                this.#value = arguments[2];
+                return this;
+            }
+            return GeneratedChunkCoverage.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof GeneratedChunkCoverage) {
+            return value;
+        }
+
+        let intVal = GeneratedChunkCoverage.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return GeneratedChunkCoverage.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a GeneratedChunkCoverage and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new GeneratedChunkCoverage(value);
+    }
+
+    get value(){
+        return [...GeneratedChunkCoverage.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new GeneratedChunkCoverage(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new GeneratedChunkCoverage(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+        new GeneratedChunkCoverage(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 2),
+    ];
+
+    static Complete = GeneratedChunkCoverage.#objectValues[0];
+    static Partial = GeneratedChunkCoverage.#objectValues[1];
+    static Outside = GeneratedChunkCoverage.#objectValues[2];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/GeneratedChunkOverlayMode.d.mts

@@ -0,0 +1,24 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * How a composite layer treats non-air blocks already emitted by earlier layers.
+ */
+export class GeneratedChunkOverlayMode {
+
+    /** @internal */
+    static fromValue(value: GeneratedChunkOverlayMode | string): GeneratedChunkOverlayMode;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static Replace : GeneratedChunkOverlayMode;
+    static KeepExisting : GeneratedChunkOverlayMode;
+
+
+    constructor(value: GeneratedChunkOverlayMode | string );
+}

package/GeneratedChunkOverlayMode.d.ts

@@ -0,0 +1,24 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * How a composite layer treats non-air blocks already emitted by earlier layers.
+ */
+export class GeneratedChunkOverlayMode {
+
+    /** @internal */
+    static fromValue(value: GeneratedChunkOverlayMode | string): GeneratedChunkOverlayMode;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static Replace : GeneratedChunkOverlayMode;
+    static KeepExisting : GeneratedChunkOverlayMode;
+
+
+    constructor(value: GeneratedChunkOverlayMode | string );
+}

package/GeneratedChunkOverlayMode.mjs

@@ -0,0 +1,72 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * How a composite layer treats non-air blocks already emitted by earlier layers.
+ */
+export class GeneratedChunkOverlayMode {
+    #value = undefined;
+
+    static #values = new Map([
+        ["Replace", 0],
+        ["KeepExisting", 1]
+    ]);
+
+    static getAllEntries() {
+        return GeneratedChunkOverlayMode.#values.entries();
+    }
+
+    #internalConstructor(value) {
+        if (arguments.length > 1 && arguments[0] === diplomatRuntime.internalConstructor) {
+            // We pass in two internalConstructor arguments to create *new*
+            // instances of this type, otherwise the enums are treated as singletons.
+            if (arguments[1] === diplomatRuntime.internalConstructor ) {
+                this.#value = arguments[2];
+                return this;
+            }
+            return GeneratedChunkOverlayMode.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof GeneratedChunkOverlayMode) {
+            return value;
+        }
+
+        let intVal = GeneratedChunkOverlayMode.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return GeneratedChunkOverlayMode.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a GeneratedChunkOverlayMode and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new GeneratedChunkOverlayMode(value);
+    }
+
+    get value(){
+        return [...GeneratedChunkOverlayMode.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new GeneratedChunkOverlayMode(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new GeneratedChunkOverlayMode(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+    ];
+
+    static Replace = GeneratedChunkOverlayMode.#objectValues[0];
+    static KeepExisting = GeneratedChunkOverlayMode.#objectValues[1];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/GeneratedWorldStream.d.mts

@@ -0,0 +1,28 @@
+// generated by diplomat-tool
+import type { GeneratedChunk } from "./GeneratedChunk.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A finite, lazy, canonical region-major traversal of a generator.
+ */
+export class GeneratedWorldStream {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Number of chunks not yet requested from the source.
+     */
+    remaining(): bigint;
+
+    /**
+     * Generate and return the next chunk. Returns `NotFound` at end-of-stream,
+     * and `Generation` if the underlying source failed on a valid request.
+     */
+    next(): GeneratedChunk;
+}

package/GeneratedWorldStream.d.ts

@@ -0,0 +1,28 @@
+// generated by diplomat-tool
+import type { GeneratedChunk } from "./GeneratedChunk.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A finite, lazy, canonical region-major traversal of a generator.
+ */
+export class GeneratedWorldStream {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Number of chunks not yet requested from the source.
+     */
+    remaining(): bigint;
+
+    /**
+     * Generate and return the next chunk. Returns `NotFound` at end-of-stream,
+     * and `Generation` if the underlying source failed on a valid request.
+     */
+    next(): GeneratedChunk;
+}

package/GeneratedWorldStream.mjs

@@ -0,0 +1,86 @@
+// generated by diplomat-tool
+import { GeneratedChunk } from "./GeneratedChunk.mjs"
+import { NucleationError } from "./NucleationError.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const GeneratedWorldStream_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.GeneratedWorldStream_destroy(ptr);
+});
+
+/**
+ * A finite, lazy, canonical region-major traversal of a generator.
+ */
+export class GeneratedWorldStream {
+    // 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("GeneratedWorldStream 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) {
+            GeneratedWorldStream_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Number of chunks not yet requested from the source.
+     */
+    remaining() {
+
+        const result = wasm.GeneratedWorldStream_remaining(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Generate and return the next chunk. Returns `NotFound` at end-of-stream,
+     * and `Generation` if the underlying source failed on a valid request.
+     */
+    next() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.GeneratedWorldStream_next(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 });
+            }
+            return new GeneratedChunk(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/Geo.d.mts

@@ -0,0 +1,41 @@
+// 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";
+
+
+
+/**
+ * Namespace for the geodata entry points (no network — data goes in,
+ * blocks come out).
+ */
+export class Geo {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Extrude building footprints into a massed schematic. `buildings_json`
+     * is a JSON array of objects:
+     * `{"polygon": [[x, z], ...], "height": <blocks>, "block": "minecraft:...",
+     * "min_y": <optional base, default 1>}`. Footprints are stamped
+     * tallest-last, so overlaps keep the tallest occupant per column.
+     * `base_block` (empty string = none) lays a ground slab at y=0 under the
+     * whole extent. Errors `Parse` on bad JSON, `InvalidArgument` on non-UTF-8.
+     */
+    static extrudeFootprints(buildingsJson: string, baseBlock: string, name: string): Schematic;
+
+    /**
+     * Raise terrain from a heightmap. `heights_json` is a flat row-major
+     * JSON array of per-column heights (blocks); `width` is columns per row.
+     * `surface_blocks_json` is a JSON array of block names — one entry (the
+     * same surface everywhere) or one per column, row-major and the same
+     * length as `heights`, for elevation/slope banding. Each column's top
+     * `surface_depth` blocks are its surface block, the rest are
+     * `subsurface_block`. Errors `Parse` on bad JSON, `InvalidArgument` on a
+     * non-positive width, empty surface list, or non-UTF-8.
+     */
+    static heightmapTerrain(heightsJson: string, width: number, surfaceBlocksJson: string, subsurfaceBlock: string, surfaceDepth: number, name: string): Schematic;
+}

package/Geo.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/InterpolationSpace.d.mts

@@ -0,0 +1,25 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Color interpolation space for gradient brushes. The old ABI passed this as
+ * `space: c_int` (`1` = Oklab, anything else = RGB).
+ */
+export class InterpolationSpace {
+
+    /** @internal */
+    static fromValue(value: InterpolationSpace | string): InterpolationSpace;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static Rgb : InterpolationSpace;
+    static Oklab : InterpolationSpace;
+
+
+    constructor(value: InterpolationSpace | string );
+}