nucleation 0.2.18 → 0.3.1

package/ExecutionMode.mjs

@@ -0,0 +1,127 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import { OutputCondition } from "./OutputCondition.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const ExecutionMode_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.ExecutionMode_destroy(ptr);
+});
+
+/**
+ * How long to run the circuit for one `execute` call (PORTING rule 10).
+ */
+export class ExecutionMode {
+    // 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("ExecutionMode 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) {
+            ExecutionMode_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Run for exactly `ticks` ticks.
+     */
+    static fixedTicks(ticks) {
+
+        const result = wasm.ExecutionMode_fixed_ticks(ticks);
+
+        try {
+            return new ExecutionMode(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Run until the output named `output_name` meets `condition`,
+     * checking every `check_interval` ticks, giving up after `max_ticks`
+     * ticks (the result's `condition_met` reports which happened).
+     */
+    static untilCondition(outputName, condition, maxTicks, checkInterval) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const outputNameSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, outputName)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.ExecutionMode_until_condition(diplomatReceive.buffer, outputNameSlice.ptr, condition.ffiValue, maxTicks, checkInterval);
+
+        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 ExecutionMode(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Run until any output changes from its initial reading, checking
+     * every `check_interval` ticks, giving up after `max_ticks` ticks.
+     */
+    static untilChange(maxTicks, checkInterval) {
+
+        const result = wasm.ExecutionMode_until_change(maxTicks, checkInterval);
+
+        try {
+            return new ExecutionMode(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Run (one tick at a time) until all outputs have been unchanged for
+     * `stable_ticks` consecutive ticks, giving up after `max_ticks`
+     * ticks (the result's `condition_met` reports stability).
+     */
+    static untilStable(stableTicks, maxTicks) {
+
+        const result = wasm.ExecutionMode_until_stable(stableTicks, maxTicks);
+
+        try {
+            return new ExecutionMode(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/Fingerprint.d.ts

@@ -0,0 +1,44 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError"
+import type { Schematic } from "./Schematic"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Namespace type for the fingerprint free functions (PORTING rule 12).
+ */
+export class Fingerprint {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * The fingerprint of a schematic for the given preset, as a hex string.
+     * Errors with `InvalidArgument` on an unknown preset.
+     */
+    static compute(schematic: Schematic, preset: string): string;
+
+    /**
+     * The structural signature (JSON) of a schematic for the given preset.
+     */
+    static signatureJson(schematic: Schematic, preset: string): string;
+
+    /**
+     * Translation-invariant fuzzy distance between two builds' footprints.
+     */
+    static footprintDistance(a: Schematic, b: Schematic, preset: string): number;
+
+    /**
+     * The schematic's translation/scale-invariant FFT shape footprint as a
+     * JSON array of floats.
+     */
+    static footprintJson(schematic: Schematic, preset: string): string;
+
+    /**
+     * Whether two schematics share the same fingerprint for the given preset.
+     */
+    static isDuplicate(a: Schematic, b: Schematic, preset: string): boolean;
+}

package/Fingerprint.mjs

@@ -0,0 +1,197 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import { Schematic } from "./Schematic.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const Fingerprint_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.Fingerprint_destroy(ptr);
+});
+
+/**
+ * Namespace type for the fingerprint free functions (PORTING rule 12).
+ */
+export class Fingerprint {
+    // 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("Fingerprint 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) {
+            Fingerprint_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * The fingerprint of a schematic for the given preset, as a hex string.
+     * Errors with `InvalidArgument` on an unknown preset.
+     */
+    static compute(schematic, preset) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const presetSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, preset)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Fingerprint_compute(diplomatReceive.buffer, schematic.ffiValue, presetSlice.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();
+        }
+    }
+
+    /**
+     * The structural signature (JSON) of a schematic for the given preset.
+     */
+    static signatureJson(schematic, preset) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const presetSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, preset)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Fingerprint_signature_json(diplomatReceive.buffer, schematic.ffiValue, presetSlice.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();
+        }
+    }
+
+    /**
+     * Translation-invariant fuzzy distance between two builds' footprints.
+     */
+    static footprintDistance(a, b, preset) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const presetSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, preset)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Fingerprint_footprint_distance(diplomatReceive.buffer, a.ffiValue, b.ffiValue, presetSlice.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 Float32Array(wasm.memory.buffer, diplomatReceive.buffer, 1))[0];
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * The schematic's translation/scale-invariant FFT shape footprint as a
+     * JSON array of floats.
+     */
+    static footprintJson(schematic, preset) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const presetSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, preset)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Fingerprint_footprint_json(diplomatReceive.buffer, schematic.ffiValue, presetSlice.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();
+        }
+    }
+
+    /**
+     * Whether two schematics share the same fingerprint for the given preset.
+     */
+    static isDuplicate(a, b, preset) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const presetSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, preset)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 1, true);
+
+
+        const result = wasm.Fingerprint_is_duplicate(diplomatReceive.buffer, a.ffiValue, b.ffiValue, presetSlice.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 Uint8Array(wasm.memory.buffer, diplomatReceive.buffer, 1))[0] === 1;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/InterpolationSpace.d.ts

@@ -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 );
+}

package/InterpolationSpace.mjs

@@ -0,0 +1,73 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * Color interpolation space for gradient brushes. The old ABI passed this as
+ * `space: c_int` (`1` = Oklab, anything else = RGB).
+ */
+export class InterpolationSpace {
+    #value = undefined;
+
+    static #values = new Map([
+        ["Rgb", 0],
+        ["Oklab", 1]
+    ]);
+
+    static getAllEntries() {
+        return InterpolationSpace.#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 InterpolationSpace.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof InterpolationSpace) {
+            return value;
+        }
+
+        let intVal = InterpolationSpace.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return InterpolationSpace.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a InterpolationSpace and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new InterpolationSpace(value);
+    }
+
+    get value(){
+        return [...InterpolationSpace.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new InterpolationSpace(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new InterpolationSpace(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+    ];
+
+    static Rgb = InterpolationSpace.#objectValues[0];
+    static Oklab = InterpolationSpace.#objectValues[1];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/IoLayout.d.ts

@@ -0,0 +1,26 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * An immutable IO layout. Wraps
+ * {@link crate::simulation::typed_executor::IoLayout}.
+ */
+export class IoLayout {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Input names as a JSON array string.
+     */
+    inputNamesJson(): string;
+
+    /**
+     * Output names as a JSON array string.
+     */
+    outputNamesJson(): string;
+}

package/IoLayout.mjs

@@ -0,0 +1,81 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const IoLayout_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.IoLayout_destroy(ptr);
+});
+
+/**
+ * An immutable IO layout. Wraps
+ * {@link crate::simulation::typed_executor::IoLayout}.
+ */
+export class IoLayout {
+    // 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("IoLayout 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) {
+            IoLayout_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Input names as a JSON array string.
+     */
+    inputNamesJson() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.IoLayout_input_names_json(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * Output names as a JSON array string.
+     */
+    outputNamesJson() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.IoLayout_output_names_json(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/IoLayoutBuilder.d.ts

@@ -0,0 +1,73 @@
+// generated by diplomat-tool
+import type { IoLayout } from "./IoLayout"
+import type { IoType } from "./IoType"
+import type { LayoutFunction } from "./LayoutFunction"
+import type { NucleationError } from "./NucleationError"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Builder for an {@link IoLayout}. `build` consumes it (PORTING rule 11).
+ */
+export class IoLayoutBuilder {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Create an empty layout builder.
+     */
+    static create(): IoLayoutBuilder;
+
+    /**
+     * Add an input. `positions` is flat `[x,y,z, x,y,z, ...]`.
+     */
+    addInput(name: string, ioType: IoType, layout: LayoutFunction, positions: Array<number>): void;
+
+    /**
+     * Add an output. `positions` is flat `[x,y,z, x,y,z, ...]`.
+     */
+    addOutput(name: string, ioType: IoType, layout: LayoutFunction, positions: Array<number>): void;
+
+    /**
+     * Add an input with automatic layout inference.
+     */
+    addInputAuto(name: string, ioType: IoType, positions: Array<number>): void;
+
+    /**
+     * Add an output with automatic layout inference.
+     */
+    addOutputAuto(name: string, ioType: IoType, positions: Array<number>): void;
+
+    /**
+     * Add an input from a region given as flat block positions (sorted by
+     * the default YXZ strategy, matching the old region semantics).
+     */
+    addInputFromRegion(name: string, ioType: IoType, layout: LayoutFunction, regionPositions: Array<number>): void;
+
+    /**
+     * Add an input from a region (flat positions) with automatic layout
+     * inference.
+     */
+    addInputFromRegionAuto(name: string, ioType: IoType, regionPositions: Array<number>): void;
+
+    /**
+     * Add an output from a region given as flat block positions.
+     */
+    addOutputFromRegion(name: string, ioType: IoType, layout: LayoutFunction, regionPositions: Array<number>): void;
+
+    /**
+     * Add an output from a region (flat positions) with automatic layout
+     * inference.
+     */
+    addOutputFromRegionAuto(name: string, ioType: IoType, regionPositions: Array<number>): void;
+
+    /**
+     * Build the {@link IoLayout}. Consumes the builder (a second call returns
+     * `AlreadyConsumed`).
+     */
+    build(): IoLayout;
+}