nucleation 0.5.1 → 0.7.0

package/AnimationEffect.d.mts

@@ -0,0 +1,44 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A reusable set of property tracks, modelled after Anime.js object animations.
+ */
+export class AnimationEffect {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    static create(durationMs: number): AnimationEffect;
+
+    static instant(): AnimationEffect;
+
+    static popIn(durationMs: number): AnimationEffect;
+
+    static dropIn(durationMs: number, height: number): AnimationEffect;
+
+    static dropAndPop(durationMs: number, height: number): AnimationEffect;
+
+    static spinIn(durationMs: number, turns: number): AnimationEffect;
+
+    static turntable(durationMs: number): AnimationEffect;
+
+    /**
+     * Add a two-key property tween. Property names follow Anime.js/Three.js:
+     * `x`, `y`, `z`, `rotateX`, `rotateY`, `rotateZ`, `scale`, `opacity`,
+     * `tintR/G/B/A`, and `emissiveR/G/B`.
+     */
+    addTween(propertyName: string, from: number, to: number, easingName: string): void;
+
+    /**
+     * Add a normalised keyframe (`at` in `0..=1`) to a property track.
+     */
+    addKeyframe(propertyName: string, at: number, value: number, easingName: string): void;
+
+    setRepeatForever(): void;
+}

package/AnimationEffect.d.ts

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

package/Autostack.d.mts

@@ -0,0 +1,43 @@
+// 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";
+
+
+
+/**
+ * Free functions in the old ABI hung directly off `schematic_*`; here they get a
+ * namespacing opaque-less home via static methods on a zero-size type is not
+ * supported, so they live as static methods taking `&Schematic` explicitly.
+ */
+export class Autostack {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Detect repeating structures (region coverage). Writes a JSON array string;
+     * each element has `mode`, `vectors`, `coverage`, `region_min`/`region_max`,
+     * `cell_min`/`cell_max`, `label`.
+     */
+    static detectStructures(schematic: Schematic): string;
+
+    /**
+     * Graph-based detection: recovers diagonal lattice periods via the redstone
+     * logic graph. Writes `"[]"` for non-redstone builds. Requires the
+     * `simulation` feature; writes `"[]"` when compiled without it.
+     */
+    static detectStructuresGraph(schematic: Schematic): string;
+
+    /**
+     * Resize a 1D / diagonal structure along its period vector.
+     */
+    static resize1d(schematic: Schematic, vx: number, vy: number, vz: number, units: number): Schematic;
+
+    /**
+     * Resize a 2D structure to `n1`×`n2` cells along the two period vectors.
+     */
+    static resize2d(schematic: Schematic, v1x: number, v1y: number, v1z: number, v2x: number, v2y: number, v2z: number, n1: number, n2: number): Schematic;
+}

package/Autostack.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/BlockPos.d.mts

@@ -0,0 +1,28 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+export type BlockPos_obj = {
+    x: number;
+    y: number;
+    z: number;
+};
+
+
+
+export class BlockPos {
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    /** @internal */
+    static fromFields(structObj : BlockPos_obj) : BlockPos;
+
+    /**
+    * Create `BlockPos` from an object that contains all of `BlockPos`s fields.
+    * Optional fields do not need to be included in the provided object.
+    */
+    constructor(structObj: BlockPos_obj);
+
+}

package/BlockState.d.mts

@@ -0,0 +1,39 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A block state: a block name plus its properties. Port of the old
+ * `BlockStateWrapper` / `blockstate_*` fns.
+ */
+export class BlockState {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Create a block state with the given name and no properties.
+     */
+    static create(name: string): BlockState;
+
+    /**
+     * A copy of this block state with `key=value` set; the original is
+     * unchanged.
+     */
+    withProperty(key: string, value: string): BlockState;
+
+    /**
+     * The block name (e.g. `minecraft:stone`).
+     */
+    name(): string;
+
+    /**
+     * The properties as a JSON object of string→string (the old
+     * `CPropertyArray`).
+     */
+    propertiesJson(): string;
+}

package/BlockState.d.ts

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

package/Blocks.d.mts

@@ -0,0 +1,91 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Namespace for read-only queries over the built-in block table
+ * (Java 26.2 blocks + official semantics extracted from the vanilla
+ * jars: definition kinds, base-block links, block tags, model
+ * geometry). All list results are JSON array strings sorted by id;
+ * block/tag/kind arguments accept both `minecraft:`-prefixed and
+ * short forms (`minecraft:oak_stairs` / `oak_stairs`).
+ */
+export class Blocks {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Full facts for one block as a JSON object:
+     * `{id, kind, base_block, tags: [...], full_cube, transparent,
+     * color: [r, g, b] | null, properties: {name: [values...]},
+     * default_state: {name: value}}`. `kind` is the official
+     * definition kind (`minecraft:stair`, plain full blocks are
+     * `minecraft:block`); `base_block` is the block this one is a
+     * shape variant of (or `null`); `color` is the texture-derived
+     * average RGB. Errors with `NotFound` for unknown ids.
+     */
+    static getJson(id: string): string;
+
+    /**
+     * All known block ids as a sorted JSON array string.
+     */
+    static idsJson(): string;
+
+    /**
+     * Ids of every block carrying the vanilla block tag, as a sorted
+     * Blocks whose measured texture color is within `max_distance`
+     * (Oklab; ~0.05 = same color family, ~0.15 = generous) of the given
+     * RGB, as a JSON array of `{"id", "color": [r,g,b], "distance"}`
+     * sorted nearest-first. Blocks without color data never match.
+     */
+    static byColorJson(r: number, g: number, b: number, maxDistance: number): string;
+
+    /**
+     * JSON array string (`[]` for unknown tags). Accepts
+     * `minecraft:wool` and short `wool` forms, including nested paths
+     * like `mineable/pickaxe`.
+     */
+    static byTagJson(tag: string): string;
+
+    /**
+     * Ids of every block of the given official definition kind
+     * (`minecraft:stair`, `minecraft:slab`, `minecraft:door`, ...), as
+     * a sorted JSON array string (`[]` for unknown kinds).
+     */
+    static byKindJson(kind: string): string;
+
+    /**
+     * The base block followed by all its shape variants — blocks whose
+     * `base_block` is `base_id` (stairs, slabs, walls, fences of the
+     * base) — as a JSON array string. The base itself is always first;
+     * variants follow sorted by id. Errors with `NotFound` for unknown
+     * base ids.
+     */
+    static variantsOfJson(baseId: string): string;
+
+    /**
+     * All known vanilla block tag names as a sorted JSON array string
+     * (`minecraft:`-prefixed, e.g. `minecraft:wool`).
+     */
+    static tagsJson(): string;
+
+    /**
+     * Every property-value combination of the block as a JSON array of
+     * `{prop: value}` objects (a single `{}` entry for property-less
+     * blocks). Errors with `NotFound` for unknown ids and with
+     * `InvalidArgument` if the combination count exceeds 4096 (guard
+     * against pathological output; the current data tops out at 1350
+     * for `minecraft:note_block`).
+     */
+    static statesJson(id: string): string;
+
+    /**
+     * Total number of blocks in the table.
+     */
+    static count(): number;
+}

package/Blocks.d.ts

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

package/Brush.d.mts

@@ -0,0 +1,99 @@
+// generated by diplomat-tool
+import type { Field3 } from "./Field3.mjs"
+import type { InterpolationSpace } from "./InterpolationSpace.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Palette } from "./Palette.mjs"
+import type { Sdf } from "./Sdf.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Decides which block goes at each point of a filled shape. Wraps `BrushEnum`.
+ */
+export class Brush {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Every point becomes `block_name` (a block-state string).
+     */
+    static solid(blockName: string): Brush;
+
+    /**
+     * Nearest-block-to-RGB-color brush.
+     */
+    static color(r: number, g: number, b: number): Brush;
+
+    /**
+     * Linear color gradient between two anchored points.
+     */
+    static linearGradient(x1: number, y1: number, z1: number, r1: number, g1: number, b1: number, x2: number, y2: number, z2: number, r2: number, g2: number, b2: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Base color shaded by surface normal against light direction
+     * (`lx`, `ly`, `lz`).
+     */
+    static shaded(r: number, g: number, b: number, lx: number, ly: number, lz: number): Brush;
+
+    /**
+     * Bilinear gradient over the patch `origin + s*u + t*v` with corner colors
+     * c00/c10/c01/c11.
+     */
+    static bilinearGradient(ox: number, oy: number, oz: number, ux: number, uy: number, uz: number, vx: number, vy: number, vz: number, r00: number, g00: number, b00: number, r10: number, g10: number, b10: number, r01: number, g01: number, b01: number, r11: number, g11: number, b11: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Inverse-distance-weighted gradient between colored anchor points.
+     * `positions` is flat `[x0, y0, z0, x1, …]` and `colors` is flat
+     * `[r0, g0, b0, r1, …]`; both must describe the same non-zero number of
+     * points (`positions.len() == colors.len()`, a multiple of 3).
+     */
+    static pointGradient(positions: Array<number>, colors: Array<number>, falloff: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Spotlight-lit base color (`r`, `g`, `b`): Lambert shading toward a
+     * cone light at (`px`, `py`, `pz`) aimed along (`dx`, `dy`, `dz`).
+     * Full intensity inside 0.7 × `cone_angle_deg`, smoothstep falloff
+     * to zero at the cone edge; surfaces facing away or outside the cone
+     * drop to a 4% ambient floor.
+     */
+    static spotlight(px: number, py: number, pz: number, dx: number, dy: number, dz: number, coneAngleDeg: number, r: number, g: number, b: number): 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
+     * (`colors.len() == stops.len() * 3`, `stops` non-empty).
+     */
+    static curveGradient(stops: Array<number>, colors: Array<number>, space: InterpolationSpace): Brush;
+
+    /**
+     * Compatibility path that colors voxels by evaluating an SDF graph as
+     * a scalar field. Prefer `field3` for new code.
+     * `stops` are in `[0, 1]`; `colors` are flat RGB triples. The sampled
+     * value is remapped from `[lo, hi]` before reading the gradient.
+     */
+    static fieldSdf(field: Sdf, stops: Array<number>, colors: Array<number>, lo: number, hi: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Color every voxel by evaluating a geometry-neutral scalar field at
+     * its center. The field is cloned into the brush, so both wrappers
+     * may be independently destroyed after construction.
+     */
+    static field3(field: Field3, stops: Array<number>, colors: Array<number>, lo: number, hi: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Legacy JSON-first field brush. Prefer `field3` for new code.
+     */
+    static field(fieldJson: string, stops: Array<number>, colors: Array<number>, lo: number, hi: number, space: InterpolationSpace): Brush;
+}

package/Brush.d.ts

@@ -1,7 +1,9 @@
 // generated by diplomat-tool
-import type { InterpolationSpace } from "./InterpolationSpace"
-import type { NucleationError } from "./NucleationError"
-import type { Palette } from "./Palette"
+import type { Field3 } from "./Field3.mjs"
+import type { InterpolationSpace } from "./InterpolationSpace.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Palette } from "./Palette.mjs"
+import type { Sdf } from "./Sdf.mjs"
 import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
 
 
@@ -76,15 +78,22 @@ export class Brush {
     static curveGradient(stops: Array<number>, colors: Array<number>, space: InterpolationSpace): Brush;
 
     /**
-     * A field brush: color every voxel by evaluating a scalar field at its
-     * center, remapping `[lo, hi]` to `[0, 1]`, and reading a multi-stop
-     * gradient (`stops` in `[0, 1]`, `colors` as flat RGB triples). The
-     * field is any SDF JSON — the same language that builds geometry — so a
-     * `cells` node paints a Voronoi mosaic (`mode: value`) or cracks
-     * (`mode: f2MinusF1`), an fbm field a marble, a coordinate expression a
-     * stripe. Call `set_palette` to choose the block set. Errors with
-     * `Parse` on bad field JSON and `InvalidArgument` on a stops/colors
-     * length mismatch.
+     * Compatibility path that colors voxels by evaluating an SDF graph as
+     * a scalar field. Prefer `field3` for new code.
+     * `stops` are in `[0, 1]`; `colors` are flat RGB triples. The sampled
+     * value is remapped from `[lo, hi]` before reading the gradient.
+     */
+    static fieldSdf(field: Sdf, stops: Array<number>, colors: Array<number>, lo: number, hi: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Color every voxel by evaluating a geometry-neutral scalar field at
+     * its center. The field is cloned into the brush, so both wrappers
+     * may be independently destroyed after construction.
+     */
+    static field3(field: Field3, stops: Array<number>, colors: Array<number>, lo: number, hi: number, space: InterpolationSpace): Brush;
+
+    /**
+     * Legacy JSON-first field brush. Prefer `field3` for new code.
      */
     static field(fieldJson: string, stops: Array<number>, colors: Array<number>, lo: number, hi: number, space: InterpolationSpace): Brush;
 }

package/Brush.mjs

@@ -1,7 +1,9 @@
 // generated by diplomat-tool
+import { Field3 } from "./Field3.mjs"
 import { InterpolationSpace } from "./InterpolationSpace.mjs"
 import { NucleationError } from "./NucleationError.mjs"
 import { Palette } from "./Palette.mjs"
+import { Sdf } from "./Sdf.mjs"
 import wasm from "./diplomat-wasm.mjs";
 import * as diplomatRuntime from "./diplomat-runtime.mjs";
 
@@ -235,15 +237,70 @@ export class Brush {
     }
 
     /**
-     * A field brush: color every voxel by evaluating a scalar field at its
-     * center, remapping `[lo, hi]` to `[0, 1]`, and reading a multi-stop
-     * gradient (`stops` in `[0, 1]`, `colors` as flat RGB triples). The
-     * field is any SDF JSON — the same language that builds geometry — so a
-     * `cells` node paints a Voronoi mosaic (`mode: value`) or cracks
-     * (`mode: f2MinusF1`), an fbm field a marble, a coordinate expression a
-     * stripe. Call `set_palette` to choose the block set. Errors with
-     * `Parse` on bad field JSON and `InvalidArgument` on a stops/colors
-     * length mismatch.
+     * Compatibility path that colors voxels by evaluating an SDF graph as
+     * a scalar field. Prefer `field3` for new code.
+     * `stops` are in `[0, 1]`; `colors` are flat RGB triples. The sampled
+     * value is remapped from `[lo, hi]` before reading the gradient.
+     */
+    static fieldSdf(field, stops, colors, lo, hi, space) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const stopsSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.slice(wasm, stops, "f32")));
+        const colorsSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.slice(wasm, colors, "u8")));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Brush_field_sdf(diplomatReceive.buffer, field.ffiValue, stopsSlice.ptr, colorsSlice.ptr, lo, hi, space.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 Brush(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Color every voxel by evaluating a geometry-neutral scalar field at
+     * its center. The field is cloned into the brush, so both wrappers
+     * may be independently destroyed after construction.
+     */
+    static field3(field, stops, colors, lo, hi, space) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const stopsSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.slice(wasm, stops, "f32")));
+        const colorsSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.slice(wasm, colors, "u8")));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Brush_field3(diplomatReceive.buffer, field.ffiValue, stopsSlice.ptr, colorsSlice.ptr, lo, hi, space.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 Brush(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Legacy JSON-first field brush. Prefer `field3` for new code.
      */
     static field(fieldJson, stops, colors, lo, hi, space) {
         let functionCleanupArena = new diplomatRuntime.CleanupArena();

package/BuildAnimation.d.mts

@@ -0,0 +1,142 @@
+// generated by diplomat-tool
+import type { AnimationEffect } from "./AnimationEffect.mjs"
+import type { Brush } from "./Brush.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { Shape } from "./Shape.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A schematic wrapper that records construction calls as animation targets.
+ */
+export class BuildAnimation {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    static create(name: string): BuildAnimation;
+
+    /**
+     * Clone an existing schematic into one animation group. Entity-only
+     * schematics are supported; overlapping block/entity integer positions
+     * are rejected rather than silently dropping a model.
+     */
+    static fromSchematic(schematic: Schematic): BuildAnimation;
+
+    /**
+     * Apply one effect to every existing animation group.
+     */
+    animateAll(effect: AnimationEffect): void;
+
+    setDefaultEffect(effect: AnimationEffect): void;
+
+    /**
+     * Apply an effect to exactly the next recorded operation or explicit group.
+     * The returned borrowed builder enables fluent calls in every generated binding.
+     */
+    withEffect(effect: AnimationEffect): BuildAnimation;
+
+    setStepMs(stepMs: number): void;
+
+    setStaggerTotalMs(totalMs: number): void;
+
+    clearStagger(): void;
+
+    /**
+     * Shift every construction group's start time. Negative offsets let a
+     * repeating staggered effect cross the beginning of a loop capture.
+     */
+    setStaggerOffsetMs(offsetMs: number): void;
+
+    /**
+     * Capture exactly one loop period, excluding the duplicate endpoint.
+     * The rounded frame count evenly partitions the complete period.
+     */
+    setLoopPeriodMs(periodMs: number): void;
+
+    clearLoopPeriod(): void;
+
+    beginGroup(): void;
+
+    beginKeyedGroup(key: number): void;
+
+    endGroup(): number;
+
+    setBlock(x: number, y: number, z: number, block: string): number;
+
+    createRegion(name: string, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
+
+    setBlockInRegion(region: string, x: number, y: number, z: number, block: string): number;
+
+    translate(x: number, y: number, z: number, durationMs: number): void;
+
+    translateRegion(region: string, x: number, y: number, z: number, durationMs: number): void;
+
+    translateAll(x: number, y: number, z: number, durationMs: number): void;
+
+    rotateX(degrees: number, durationMs: number): void;
+
+    rotateY(degrees: number, durationMs: number): void;
+
+    rotateZ(degrees: number, durationMs: number): void;
+
+    rotateRegionX(region: string, degrees: number, durationMs: number): void;
+
+    rotateRegionY(region: string, degrees: number, durationMs: number): void;
+
+    rotateRegionZ(region: string, degrees: number, durationMs: number): void;
+
+    rotateAllX(degrees: number, durationMs: number): void;
+
+    rotateAllY(degrees: number, durationMs: number): void;
+
+    rotateAllZ(degrees: number, durationMs: number): void;
+
+    flipX(durationMs: number): void;
+
+    flipY(durationMs: number): void;
+
+    flipZ(durationMs: number): void;
+
+    flipRegionX(region: string, durationMs: number): void;
+
+    flipRegionY(region: string, durationMs: number): void;
+
+    flipRegionZ(region: string, durationMs: number): void;
+
+    flipAllX(durationMs: number): void;
+
+    flipAllY(durationMs: number): void;
+
+    flipAllZ(durationMs: number): void;
+
+    stampRegion(source: Schematic, region: string, x: number, y: number, z: number, exclusions: string, durationMs: number): void;
+
+    stampBox(source: Schematic, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, x: number, y: number, z: number, exclusions: string, durationMs: number): void;
+
+    setOperationGizmos(enabled: boolean): void;
+
+    operationsJson(): string;
+
+    frameJson(timeMs: number): string;
+
+    /**
+     * Fill a parametric shape and record its voxels as ordered groups in
+     * the same transactional construction operation.
+     */
+    fillAlongParameter(shape: Shape, brush: Brush, groupCount: number): number;
+
+    addArmorStand(x: number, y: number, z: number, yaw: number, armorMaterial: string): number;
+
+    animateCamera(effect: AnimationEffect, offsetMs: number): void;
+
+    frameCount(fps: number, holdMs: number): number;
+
+    groupCount(): number;
+
+    durationMs(): number;
+}

package/BuildAnimation.d.ts

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