nucleation 0.10.21 → 0.10.23

package/renderer/Nbt.mjs

@@ -0,0 +1,161 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const Nbt_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.Nbt_destroy(ptr);
+});
+
+/**
+ * Namespace type for the free-standing NBT builder helpers (the old
+ * `nbt_text_build` / `nbt_chest_build` / `nbt_sign_build`), following the
+ * static-methods-on-a-dummy-opaque pattern.
+ */
+export class Nbt {
+    // 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("Nbt 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) {
+            Nbt_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Build a Minecraft JSON text-component string.
+     *
+     * `color` may be empty (no color). `bold` and `italic` use `-1` for
+     * unset, `0` for false, nonzero for true.
+     */
+    static textBuild(s, color, bold, italic) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const sSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, s)));
+        const colorSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, color)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Nbt_text_build(diplomatReceive.buffer, sSlice.ptr, colorSlice.ptr, bold, italic, 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();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+            write.free();
+        }
+    }
+
+    /**
+     * Build a chest-NBT SNBT string for use as the `{...}` portion of a block
+     * string.
+     *
+     * `items_json` is a JSON array of `{"id": string, "count"?: int,
+     * "slot"?: int}` entries (may be empty or `[]`); a missing/non-positive
+     * `count` defaults to 1, a missing/negative `slot` auto-assigns
+     * positionally. `name` is an optional plain-text custom name (empty = no
+     * `CustomName`); it is wrapped in a JSON text component automatically
+     * unless it already starts with `{`.
+     */
+    static chestBuild(itemsJson, name) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const itemsJsonSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, itemsJson)));
+        const nameSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, name)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Nbt_chest_build(diplomatReceive.buffer, itemsJsonSlice.ptr, nameSlice.ptr, 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();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+            write.free();
+        }
+    }
+
+    /**
+     * Build a modern (1.20+) sign-NBT SNBT string.
+     *
+     * `front_json` and `back_json` are JSON arrays of up to 4 line strings
+     * (either may be empty or `[]`). Each line may be a plain string
+     * (auto-wrapped via `text_build`) or an already-built JSON component
+     * (starts with `{`). `color` is the dye color string (empty defaults to
+     * `"black"`).
+     */
+    static signBuild(frontJson, backJson, color, glowing, waxed) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const frontJsonSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, frontJson)));
+        const backJsonSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, backJson)));
+        const colorSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, color)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Nbt_sign_build(diplomatReceive.buffer, frontJsonSlice.ptr, backJsonSlice.ptr, colorSlice.ptr, glowing, waxed, 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();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+            write.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/renderer/NucleationError.d.mts

@@ -0,0 +1,53 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Every fallible method in the bridge returns `Result<T, NucleationError>` —
+ * see `stencil/docs/nucleation-error.md` for how these variants were derived from
+ * the three error conventions the old hand-written `ffi` module mixed.
+ */
+export class NucleationError {
+
+    /** @internal */
+    static fromValue(value: NucleationError | string): NucleationError;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static NullArgument : NucleationError;
+    static InvalidArgument : NucleationError;
+    static Parse : NucleationError;
+    static Serialize : NucleationError;
+    static Io : NucleationError;
+    static Lock : NucleationError;
+    static Store : NucleationError;
+    static Mesh : NucleationError;
+    static Render : NucleationError;
+    static Simulation : NucleationError;
+    static AlreadyConsumed : NucleationError;
+    static NotFound : NucleationError;
+    /**
+     * A world-generation source failed while producing a chunk, even though
+     * the request itself was well-formed (see `world_generation`).
+     */
+    static Generation : NucleationError;
+
+
+    /**
+     * Why the last failing bridge call on this thread failed, in words.
+     *
+     * The enum cannot carry a message across the FFI, so a caught error
+     * is a bare variant — `InvalidArgument` — while the layer that
+     * refused already knew it was "19.2M cells over the 8M cap". Modules
+     * that know the story record it; this reads it back, so an exception
+     * handler holding the error value can ask it for the words. Empty
+     * when the last detail-carrying call succeeded.
+     */
+    detail(): string;
+
+    constructor(value: NucleationError | string );
+}

package/renderer/NucleationError.d.ts

@@ -0,0 +1,53 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Every fallible method in the bridge returns `Result<T, NucleationError>` —
+ * see `stencil/docs/nucleation-error.md` for how these variants were derived from
+ * the three error conventions the old hand-written `ffi` module mixed.
+ */
+export class NucleationError {
+
+    /** @internal */
+    static fromValue(value: NucleationError | string): NucleationError;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static NullArgument : NucleationError;
+    static InvalidArgument : NucleationError;
+    static Parse : NucleationError;
+    static Serialize : NucleationError;
+    static Io : NucleationError;
+    static Lock : NucleationError;
+    static Store : NucleationError;
+    static Mesh : NucleationError;
+    static Render : NucleationError;
+    static Simulation : NucleationError;
+    static AlreadyConsumed : NucleationError;
+    static NotFound : NucleationError;
+    /**
+     * A world-generation source failed while producing a chunk, even though
+     * the request itself was well-formed (see `world_generation`).
+     */
+    static Generation : NucleationError;
+
+
+    /**
+     * Why the last failing bridge call on this thread failed, in words.
+     *
+     * The enum cannot carry a message across the FFI, so a caught error
+     * is a bare variant — `InvalidArgument` — while the layer that
+     * refused already knew it was "19.2M cells over the 8M cap". Modules
+     * that know the story record it; this reads it back, so an exception
+     * handler holding the error value can ask it for the words. Empty
+     * when the last detail-carrying call succeeded.
+     */
+    detail(): string;
+
+    constructor(value: NucleationError | string );
+}

package/renderer/NucleationError.mjs

@@ -0,0 +1,136 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * Every fallible method in the bridge returns `Result<T, NucleationError>` —
+ * see `stencil/docs/nucleation-error.md` for how these variants were derived from
+ * the three error conventions the old hand-written `ffi` module mixed.
+ */
+export class NucleationError {
+    #value = undefined;
+
+    static #values = new Map([
+        ["NullArgument", 0],
+        ["InvalidArgument", 1],
+        ["Parse", 2],
+        ["Serialize", 3],
+        ["Io", 4],
+        ["Lock", 5],
+        ["Store", 6],
+        ["Mesh", 7],
+        ["Render", 8],
+        ["Simulation", 9],
+        ["AlreadyConsumed", 10],
+        ["NotFound", 11],
+        ["Generation", 12]
+    ]);
+
+    static getAllEntries() {
+        return NucleationError.#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 NucleationError.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof NucleationError) {
+            return value;
+        }
+
+        let intVal = NucleationError.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return NucleationError.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a NucleationError and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new NucleationError(value);
+    }
+
+    get value(){
+        return [...NucleationError.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 2),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 3),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 4),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 5),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 6),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 7),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 8),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 9),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 10),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 11),
+        new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 12),
+    ];
+
+    static NullArgument = NucleationError.#objectValues[0];
+    static InvalidArgument = NucleationError.#objectValues[1];
+    static Parse = NucleationError.#objectValues[2];
+    static Serialize = NucleationError.#objectValues[3];
+    static Io = NucleationError.#objectValues[4];
+    static Lock = NucleationError.#objectValues[5];
+    static Store = NucleationError.#objectValues[6];
+    static Mesh = NucleationError.#objectValues[7];
+    static Render = NucleationError.#objectValues[8];
+    static Simulation = NucleationError.#objectValues[9];
+    static AlreadyConsumed = NucleationError.#objectValues[10];
+    static NotFound = NucleationError.#objectValues[11];
+    /**
+     * A world-generation source failed while producing a chunk, even though
+     * the request itself was well-formed (see `world_generation`).
+     */
+    static Generation = NucleationError.#objectValues[12];
+
+
+    /**
+     * Why the last failing bridge call on this thread failed, in words.
+     *
+     * The enum cannot carry a message across the FFI, so a caught error
+     * is a bare variant — `InvalidArgument` — while the layer that
+     * refused already knew it was "19.2M cells over the 8M cap". Modules
+     * that know the story record it; this reads it back, so an exception
+     * handler holding the error value can ask it for the words. Empty
+     * when the last detail-carrying call succeeded.
+     */
+    detail() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.NucleationError_detail(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/renderer/OutputCondition.d.mts

@@ -0,0 +1,45 @@
+// generated by diplomat-tool
+import type { Value } from "./Value.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A condition on an output value, for `ExecutionMode::until_condition`
+ * (PORTING rule 10).
+ */
+export class OutputCondition {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Met when the output equals `value`.
+     */
+    static equals(value: Value): OutputCondition;
+
+    /**
+     * Met when the output does not equal `value`.
+     */
+    static notEquals(value: Value): OutputCondition;
+
+    /**
+     * Met when the output is greater than `value`. Numeric only: both
+     * sides must be the same numeric type (u32/i32/f32), else never met.
+     */
+    static greaterThan(value: Value): OutputCondition;
+
+    /**
+     * Met when the output is less than `value`. Numeric only: both sides
+     * must be the same numeric type (u32/i32/f32), else never met.
+     */
+    static lessThan(value: Value): OutputCondition;
+
+    /**
+     * Met when `output & mask` is non-zero (flag checking). Integer
+     * outputs (u32/i32) only; never met for other types.
+     */
+    static bitwiseAnd(mask: number): OutputCondition;
+}

package/renderer/OutputCondition.d.ts

@@ -0,0 +1,45 @@
+// generated by diplomat-tool
+import type { Value } from "./Value.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A condition on an output value, for `ExecutionMode::until_condition`
+ * (PORTING rule 10).
+ */
+export class OutputCondition {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Met when the output equals `value`.
+     */
+    static equals(value: Value): OutputCondition;
+
+    /**
+     * Met when the output does not equal `value`.
+     */
+    static notEquals(value: Value): OutputCondition;
+
+    /**
+     * Met when the output is greater than `value`. Numeric only: both
+     * sides must be the same numeric type (u32/i32/f32), else never met.
+     */
+    static greaterThan(value: Value): OutputCondition;
+
+    /**
+     * Met when the output is less than `value`. Numeric only: both sides
+     * must be the same numeric type (u32/i32/f32), else never met.
+     */
+    static lessThan(value: Value): OutputCondition;
+
+    /**
+     * Met when `output & mask` is non-zero (flag checking). Integer
+     * outputs (u32/i32) only; never met for other types.
+     */
+    static bitwiseAnd(mask: number): OutputCondition;
+}

package/renderer/OutputCondition.mjs

@@ -0,0 +1,129 @@
+// generated by diplomat-tool
+import { Value } from "./Value.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const OutputCondition_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.OutputCondition_destroy(ptr);
+});
+
+/**
+ * A condition on an output value, for `ExecutionMode::until_condition`
+ * (PORTING rule 10).
+ */
+export class OutputCondition {
+    // 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("OutputCondition 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) {
+            OutputCondition_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Met when the output equals `value`.
+     */
+    static equals(value) {
+
+        const result = wasm.OutputCondition_equals(value.ffiValue);
+
+        try {
+            return new OutputCondition(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Met when the output does not equal `value`.
+     */
+    static notEquals(value) {
+
+        const result = wasm.OutputCondition_not_equals(value.ffiValue);
+
+        try {
+            return new OutputCondition(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Met when the output is greater than `value`. Numeric only: both
+     * sides must be the same numeric type (u32/i32/f32), else never met.
+     */
+    static greaterThan(value) {
+
+        const result = wasm.OutputCondition_greater_than(value.ffiValue);
+
+        try {
+            return new OutputCondition(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Met when the output is less than `value`. Numeric only: both sides
+     * must be the same numeric type (u32/i32/f32), else never met.
+     */
+    static lessThan(value) {
+
+        const result = wasm.OutputCondition_less_than(value.ffiValue);
+
+        try {
+            return new OutputCondition(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Met when `output & mask` is non-zero (flag checking). Integer
+     * outputs (u32/i32) only; never met for other types.
+     */
+    static bitwiseAnd(mask) {
+
+        const result = wasm.OutputCondition_bitwise_and(mask);
+
+        try {
+            return new OutputCondition(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}