nucleation 0.3.0 → 0.3.2

package/Brush.d.ts

@@ -1,6 +1,7 @@
 // generated by diplomat-tool
 import type { InterpolationSpace } from "./InterpolationSpace"
 import type { NucleationError } from "./NucleationError"
+import type { Palette } from "./Palette"
 import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
 
 
@@ -50,6 +51,14 @@ export class Brush {
      */
     static pointGradient(positions: Array<number>, colors: Array<number>, falloff: number, space: InterpolationSpace): Brush;
 
+    /**
+     * Use `palette` for this brush's color→block snapping instead of the
+     * default all-blocks palette. No-op for `solid` brushes, which place
+     * a fixed block state. Set it before filling; the palette is shared,
+     * not copied.
+     */
+    setPalette(palette: Palette): void;
+
     /**
      * Gradient along a parametric curve: `stops` holds the curve parameters in
      * `[0, 1]` and `colors` the matching flat RGB triples

package/Brush.mjs

@@ -1,6 +1,7 @@
 // generated by diplomat-tool
 import { InterpolationSpace } from "./InterpolationSpace.mjs"
 import { NucleationError } from "./NucleationError.mjs"
+import { Palette } from "./Palette.mjs"
 import wasm from "./diplomat-wasm.mjs";
 import * as diplomatRuntime from "./diplomat-runtime.mjs";
 
@@ -166,6 +167,22 @@ export class Brush {
         }
     }
 
+    /**
+     * Use `palette` for this brush's color→block snapping instead of the
+     * default all-blocks palette. No-op for `solid` brushes, which place
+     * a fixed block state. Set it before filling; the palette is shared,
+     * not copied.
+     */
+    setPalette(palette) {
+    wasm.Brush_set_palette(this.ffiValue, palette.ffiValue);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
     /**
      * Gradient along a parametric curve: `stops` holds the curve parameters in
      * `[0, 1]` and `colors` the matching flat RGB triples

package/Palette.d.ts

@@ -0,0 +1,106 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A set of colored blocks that color/gradient brushes snap their computed
+ * colors to (nearest neighbor in Oklab space). Wraps an Arc'd
+ * {@link crate::building::BlockPalette}; sharing one palette across many
+ * brushes is cheap.
+ */
+export class Palette {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Every block blockpedia knows a color for (the default palette
+     * brushes use when none is set).
+     */
+    static all(): Palette;
+
+    /**
+     * Only solid blocks: no transparency, gravity, tile entities, or
+     * support requirements.
+     */
+    static solid(): Palette;
+
+    /**
+     * Conservative structural set (full building blocks).
+     */
+    static structural(): Palette;
+
+    /**
+     * Decorative set: allows stairs/slabs but no tile entities.
+     */
+    static decorative(): Palette;
+
+    /**
+     * The 16 concrete colors (excludes concrete powder).
+     */
+    static concrete(): Palette;
+
+    /**
+     * The 16 wool colors.
+     */
+    static wool(): Palette;
+
+    /**
+     * Terracotta colors (excludes glazed variants).
+     */
+    static terracotta(): Palette;
+
+    /**
+     * Grayscale-leaning blocks (stones, basalt, deepslate, ...).
+     */
+    static grayscale(): Palette;
+
+    /**
+     * The planks family — a natural light→dark wood ramp.
+     */
+    static wood(): Palette;
+
+    /**
+     * A copy of this palette ordered by perceptual lightness (Oklab L,
+     * dark → light). Combined with `block_ids_json`, gives a
+     * ready-to-index ramp: `ids[i]` for intensity `i / (len - 1)`.
+     */
+    sortedByLightness(): Palette;
+
+    /**
+     * JSON array of exactly `steps` block ids sampling the color
+     * gradient from (`r1`,`g1`,`b1`) to (`r2`,`g2`,`b2`) in Oklab
+     * space, each step snapped to this palette's closest block. Built
+     * for value→block lookups (heatmaps, fractals): index the returned
+     * list by `intensity * (steps - 1)`. Entries may repeat on coarse
+     * palettes; errors with `NotFound` on an empty palette.
+     */
+    gradientIdsJson(r1: number, g1: number, b1: number, r2: number, g2: number, b2: number, steps: number): string;
+
+    /**
+     * Custom palette from a JSON array of block ids, e.g.
+     * `["minecraft:stone", "minecraft:oak_planks"]`. Ids blockpedia has
+     * no color for are silently skipped — check `len` afterwards.
+     */
+    static fromBlockIds(idsJson: string): Palette;
+
+    /**
+     * Number of blocks in the palette.
+     */
+    len(): number;
+
+    /**
+     * The palette's block ids as a JSON array string.
+     */
+    blockIdsJson(): string;
+
+    /**
+     * The palette block whose color is closest (Oklab distance) to the
+     * given RGB. Errors with `NotFound` on an empty palette.
+     */
+    closestBlock(r: number, g: number, b: number): string;
+}

package/Palette.mjs

@@ -0,0 +1,334 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const Palette_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.Palette_destroy(ptr);
+});
+
+/**
+ * A set of colored blocks that color/gradient brushes snap their computed
+ * colors to (nearest neighbor in Oklab space). Wraps an Arc'd
+ * {@link crate::building::BlockPalette}; sharing one palette across many
+ * brushes is cheap.
+ */
+export class Palette {
+    // 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("Palette 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) {
+            Palette_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Every block blockpedia knows a color for (the default palette
+     * brushes use when none is set).
+     */
+    static all() {
+
+        const result = wasm.Palette_all();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Only solid blocks: no transparency, gravity, tile entities, or
+     * support requirements.
+     */
+    static solid() {
+
+        const result = wasm.Palette_solid();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Conservative structural set (full building blocks).
+     */
+    static structural() {
+
+        const result = wasm.Palette_structural();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Decorative set: allows stairs/slabs but no tile entities.
+     */
+    static decorative() {
+
+        const result = wasm.Palette_decorative();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * The 16 concrete colors (excludes concrete powder).
+     */
+    static concrete() {
+
+        const result = wasm.Palette_concrete();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * The 16 wool colors.
+     */
+    static wool() {
+
+        const result = wasm.Palette_wool();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Terracotta colors (excludes glazed variants).
+     */
+    static terracotta() {
+
+        const result = wasm.Palette_terracotta();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Grayscale-leaning blocks (stones, basalt, deepslate, ...).
+     */
+    static grayscale() {
+
+        const result = wasm.Palette_grayscale();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * The planks family — a natural light→dark wood ramp.
+     */
+    static wood() {
+
+        const result = wasm.Palette_wood();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * A copy of this palette ordered by perceptual lightness (Oklab L,
+     * dark → light). Combined with `block_ids_json`, gives a
+     * ready-to-index ramp: `ids[i]` for intensity `i / (len - 1)`.
+     */
+    sortedByLightness() {
+
+        const result = wasm.Palette_sorted_by_lightness(this.ffiValue);
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * JSON array of exactly `steps` block ids sampling the color
+     * gradient from (`r1`,`g1`,`b1`) to (`r2`,`g2`,`b2`) in Oklab
+     * space, each step snapped to this palette's closest block. Built
+     * for value→block lookups (heatmaps, fractals): index the returned
+     * list by `intensity * (steps - 1)`. Entries may repeat on coarse
+     * palettes; errors with `NotFound` on an empty palette.
+     */
+    gradientIdsJson(r1, g1, b1, r2, g2, b2, steps) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Palette_gradient_ids_json(diplomatReceive.buffer, this.ffiValue, r1, g1, b1, r2, g2, b2, steps, 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();
+        }
+    }
+
+    /**
+     * Custom palette from a JSON array of block ids, e.g.
+     * `["minecraft:stone", "minecraft:oak_planks"]`. Ids blockpedia has
+     * no color for are silently skipped — check `len` afterwards.
+     */
+    static fromBlockIds(idsJson) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const idsJsonSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, idsJson)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Palette_from_block_ids(diplomatReceive.buffer, idsJsonSlice.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 Palette(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Number of blocks in the palette.
+     */
+    len() {
+
+        const result = wasm.Palette_len(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * The palette's block ids as a JSON array string.
+     */
+    blockIdsJson() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.Palette_block_ids_json(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * The palette block whose color is closest (Oklab distance) to the
+     * given RGB. Errors with `NotFound` on an empty palette.
+     */
+    closestBlock(r, g, b) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Palette_closest_block(diplomatReceive.buffer, this.ffiValue, r, g, b, 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();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/PaletteBuilder.d.ts

@@ -0,0 +1,76 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError"
+import type { Palette } from "./Palette"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Filter-driven palette construction (wraps
+ * {@link crate::building::PaletteBuilder}, which fronts blockpedia's
+ * `BlockFilter`). Call flag methods, then `build` — the builder is
+ * consumed; further calls error with `AlreadyConsumed`.
+ */
+export class PaletteBuilder {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * A builder matching every colored block (no filters yet).
+     */
+    static create(): PaletteBuilder;
+
+    /**
+     * Exclude gravity-affected blocks (sand, gravel, ...).
+     */
+    excludeFalling(): void;
+
+    /**
+     * Exclude blocks with block entities (chests, furnaces, ...).
+     */
+    excludeTileEntities(): void;
+
+    /**
+     * Keep only full cube blocks (no stairs, slabs, fences, ...).
+     */
+    fullBlocksOnly(): void;
+
+    /**
+     * Exclude blocks that need supporting blocks (torches, rails, ...).
+     */
+    excludeNeedsSupport(): void;
+
+    /**
+     * Exclude transparent/translucent blocks (glass, leaves, ...).
+     */
+    excludeTransparent(): void;
+
+    /**
+     * Exclude light-emitting blocks (glowstone, lanterns, ...).
+     */
+    excludeLightSources(): void;
+
+    /**
+     * Keep only blocks obtainable in survival.
+     */
+    survivalOnly(): void;
+
+    /**
+     * Exclude blocks whose id contains `keyword`.
+     */
+    excludeKeyword(keyword: string): void;
+
+    /**
+     * Keep only blocks whose id contains `keyword` (repeatable; matches
+     * any of the included keywords).
+     */
+    includeKeyword(keyword: string): void;
+
+    /**
+     * Build the palette; consumes the builder.
+     */
+    build(): Palette;
+}

package/PaletteBuilder.mjs

@@ -0,0 +1,297 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import { Palette } from "./Palette.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const PaletteBuilder_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.PaletteBuilder_destroy(ptr);
+});
+
+/**
+ * Filter-driven palette construction (wraps
+ * {@link crate::building::PaletteBuilder}, which fronts blockpedia's
+ * `BlockFilter`). Call flag methods, then `build` — the builder is
+ * consumed; further calls error with `AlreadyConsumed`.
+ */
+export class PaletteBuilder {
+    // 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("PaletteBuilder 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) {
+            PaletteBuilder_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * A builder matching every colored block (no filters yet).
+     */
+    static create() {
+
+        const result = wasm.PaletteBuilder_create();
+
+        try {
+            return new PaletteBuilder(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Exclude gravity-affected blocks (sand, gravel, ...).
+     */
+    excludeFalling() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_exclude_falling(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();
+        }
+    }
+
+    /**
+     * Exclude blocks with block entities (chests, furnaces, ...).
+     */
+    excludeTileEntities() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_exclude_tile_entities(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();
+        }
+    }
+
+    /**
+     * Keep only full cube blocks (no stairs, slabs, fences, ...).
+     */
+    fullBlocksOnly() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_full_blocks_only(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();
+        }
+    }
+
+    /**
+     * Exclude blocks that need supporting blocks (torches, rails, ...).
+     */
+    excludeNeedsSupport() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_exclude_needs_support(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();
+        }
+    }
+
+    /**
+     * Exclude transparent/translucent blocks (glass, leaves, ...).
+     */
+    excludeTransparent() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_exclude_transparent(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();
+        }
+    }
+
+    /**
+     * Exclude light-emitting blocks (glowstone, lanterns, ...).
+     */
+    excludeLightSources() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_exclude_light_sources(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();
+        }
+    }
+
+    /**
+     * Keep only blocks obtainable in survival.
+     */
+    survivalOnly() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_survival_only(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();
+        }
+    }
+
+    /**
+     * Exclude blocks whose id contains `keyword`.
+     */
+    excludeKeyword(keyword) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const keywordSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, keyword)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_exclude_keyword(diplomatReceive.buffer, this.ffiValue, keywordSlice.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();
+        }
+    }
+
+    /**
+     * Keep only blocks whose id contains `keyword` (repeatable; matches
+     * any of the included keywords).
+     */
+    includeKeyword(keyword) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const keywordSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, keyword)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_include_keyword(diplomatReceive.buffer, this.ffiValue, keywordSlice.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();
+        }
+    }
+
+    /**
+     * Build the palette; consumes the builder.
+     */
+    build() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.PaletteBuilder_build(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 Palette(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/index.d.ts

@@ -22,6 +22,10 @@ export { Brush } from "./Brush"
 
 export { BuildingTool } from "./BuildingTool"
 
+export { Palette } from "./Palette"
+
+export { PaletteBuilder } from "./PaletteBuilder"
+
 export { Shape } from "./Shape"
 
 export { DefinitionRegion } from "./DefinitionRegion"

package/index.mjs

@@ -20,6 +20,10 @@ export { Brush } from "./Brush.mjs"
 
 export { BuildingTool } from "./BuildingTool.mjs"
 
+export { Palette } from "./Palette.mjs"
+
+export { PaletteBuilder } from "./PaletteBuilder.mjs"
+
 export { Shape } from "./Shape.mjs"
 
 export { DefinitionRegion } from "./DefinitionRegion.mjs"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nucleation",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "A high-performance Minecraft schematic parser and utility library",
   "type": "module",
   "main": "index.mjs",