nucleation 0.10.21 → 0.10.23

package/BlockPos.mjs

@@ -108,6 +108,7 @@ export class BlockPos {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("BlockPos._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/Dimensions.mjs

@@ -108,6 +108,7 @@ export class Dimensions {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("Dimensions._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/FieldRange.mjs

@@ -89,6 +89,7 @@ export class FieldRange {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("FieldRange._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/ItemScale.mjs

@@ -111,6 +111,7 @@ export class ItemScale {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("ItemScale._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/MeshBounds.mjs

@@ -153,6 +153,7 @@ export class MeshBounds {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("MeshBounds._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/MeshProgress.mjs

@@ -112,6 +112,7 @@ export class MeshProgress {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("MeshProgress._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/README.md

@@ -53,3 +53,15 @@ embedded scripting are native-only.
 ## License
 
 MIT
+
+### Renderer-only WebAssembly
+
+`import { Schematic } from "nucleation/renderer"` loads the bridge-only WASM build
+for schematic viewing and editing. Simulation, meshing and voxelization remain
+available from the main `nucleation` entry point. Each entry owns a separate WASM
+instance; import only the entry needed by a worker.
+
+Use `renderRegionsJson()` for region bounds and palettes, then
+`regionBlockIndices(name, start, count)` for owned `Uint32Array` windows of at most
+65,536 cells. Indices use x-fastest, then z, then y order. Call `clearContents()`
+when done to release schematic storage immediately.

package/RegionBounds.mjs

@@ -154,6 +154,7 @@ export class RegionBounds {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("RegionBounds._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/Schematic.d.mts

@@ -20,6 +20,13 @@ export class Schematic {
      */
     static create(name: string): Schematic;
 
+    /**
+     * Release all block/entity storage immediately, keeping an empty valid
+     * schematic handle. JS consumers should call this when a parsed world or
+     * editing session is no longer needed instead of waiting for finalizers.
+     */
+    clearContents(): void;
+
     /**
      * Return an independent deep copy. Subsequent block, region, entity,
      * metadata, or transform changes do not affect the original.
@@ -492,6 +499,31 @@ export class Schematic {
      */
     getChunkBlocksJson(offsetX: number, offsetY: number, offsetZ: number, width: number, height: number, length: number): string;
 
+    /**
+     * Non-air blocks inside a bounded box, retaining block-state properties.
+     * Visits only intersecting region cells, not the whole schematic. Bounds
+     * and arithmetic are checked; queries may scan at most 1,048,576 cells
+     * (including region overlaps) and emit at most 32 MiB of JSON. Renderers
+     * should request 16³ sections. Coordinates may be negative.
+     */
+    getChunkNonAirBlocksJson(offsetX: number, offsetY: number, offsetZ: number, width: number, height: number, length: number): string;
+
+    /**
+     * Storage metadata and full block states for palette-index streaming. Region order
+     * is default first, then sorted names (highest precedence first); indices are LOCAL to each region. Bounds
+     * describe allocated storage, never tight bounds. x is fastest, then z, then y.
+     * No block buffer is cloned or serialized here.
+     */
+    renderRegionsJson(): string;
+
+    /**
+     * A bounded window of a region's dense palette indices (including air).
+     * At most 65,536 cells per call; no full-world scan, coordinate tuples, or
+     * intermediate Rust allocation. JS bindings copy the borrowed slice before
+     * returning, so callers may mutate the schematic or grow WASM memory safely.
+     */
+    regionBlockIndices(regionName: string, start: number, count: number): Uint32Array;
+
     /**
      * Split the schematic into chunks (default bottom-up strategy). Writes a
      * JSON array of `{"chunk_x", "chunk_y", "chunk_z", "blocks": [...]}` where

package/Schematic.d.ts

@@ -20,6 +20,13 @@ export class Schematic {
      */
     static create(name: string): Schematic;
 
+    /**
+     * Release all block/entity storage immediately, keeping an empty valid
+     * schematic handle. JS consumers should call this when a parsed world or
+     * editing session is no longer needed instead of waiting for finalizers.
+     */
+    clearContents(): void;
+
     /**
      * Return an independent deep copy. Subsequent block, region, entity,
      * metadata, or transform changes do not affect the original.
@@ -492,6 +499,31 @@ export class Schematic {
      */
     getChunkBlocksJson(offsetX: number, offsetY: number, offsetZ: number, width: number, height: number, length: number): string;
 
+    /**
+     * Non-air blocks inside a bounded box, retaining block-state properties.
+     * Visits only intersecting region cells, not the whole schematic. Bounds
+     * and arithmetic are checked; queries may scan at most 1,048,576 cells
+     * (including region overlaps) and emit at most 32 MiB of JSON. Renderers
+     * should request 16³ sections. Coordinates may be negative.
+     */
+    getChunkNonAirBlocksJson(offsetX: number, offsetY: number, offsetZ: number, width: number, height: number, length: number): string;
+
+    /**
+     * Storage metadata and full block states for palette-index streaming. Region order
+     * is default first, then sorted names (highest precedence first); indices are LOCAL to each region. Bounds
+     * describe allocated storage, never tight bounds. x is fastest, then z, then y.
+     * No block buffer is cloned or serialized here.
+     */
+    renderRegionsJson(): string;
+
+    /**
+     * A bounded window of a region's dense palette indices (including air).
+     * At most 65,536 cells per call; no full-world scan, coordinate tuples, or
+     * intermediate Rust allocation. JS bindings copy the borrowed slice before
+     * returning, so callers may mutate the schematic or grow WASM memory safely.
+     */
+    regionBlockIndices(regionName: string, start: number, count: number): Uint32Array;
+
     /**
      * Split the schematic into chunks (default bottom-up strategy). Writes a
      * JSON array of `{"chunk_x", "chunk_y", "chunk_z", "blocks": [...]}` where

package/Schematic.mjs

@@ -61,6 +61,21 @@ export class Schematic {
         }
     }
 
+    /**
+     * Release all block/entity storage immediately, keeping an empty valid
+     * schematic handle. JS consumers should call this when a parsed world or
+     * editing session is no longer needed instead of waiting for finalizers.
+     */
+    clearContents() {
+    wasm.Schematic_clear_contents(this.ffiValue);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
     /**
      * Return an independent deep copy. Subsequent block, region, entity,
      * metadata, or transform changes do not affect the original.
@@ -1929,6 +1944,91 @@ export class Schematic {
         }
     }
 
+    /**
+     * Non-air blocks inside a bounded box, retaining block-state properties.
+     * Visits only intersecting region cells, not the whole schematic. Bounds
+     * and arithmetic are checked; queries may scan at most 1,048,576 cells
+     * (including region overlaps) and emit at most 32 MiB of JSON. Renderers
+     * should request 16³ sections. Coordinates may be negative.
+     */
+    getChunkNonAirBlocksJson(offsetX, offsetY, offsetZ, width, height, length) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Schematic_get_chunk_non_air_blocks_json(diplomatReceive.buffer, this.ffiValue, offsetX, offsetY, offsetZ, width, height, length, 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();
+        }
+    }
+
+    /**
+     * Storage metadata and full block states for palette-index streaming. Region order
+     * is default first, then sorted names (highest precedence first); indices are LOCAL to each region. Bounds
+     * describe allocated storage, never tight bounds. x is fastest, then z, then y.
+     * No block buffer is cloned or serialized here.
+     */
+    renderRegionsJson() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.Schematic_render_regions_json(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * A bounded window of a region's dense palette indices (including air).
+     * At most 65,536 cells per call; no full-world scan, coordinate tuples, or
+     * intermediate Rust allocation. JS bindings copy the borrowed slice before
+     * returning, so callers may mutate the schematic or grow WASM memory safely.
+     */
+    regionBlockIndices(regionName, start, count) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const regionNameSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, regionName)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 9, 4, true);
+
+        // This lifetime edge depends on lifetimes 'a
+        let aEdges = [this];
+
+
+        const result = wasm.Schematic_region_block_indices(diplomatReceive.buffer, this.ffiValue, regionNameSlice.ptr, start, count);
+
+        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 diplomatRuntime.DiplomatSlicePrimitive(wasm, diplomatReceive.buffer, "u32", aEdges).getValue().slice();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
     /**
      * Split the schematic into chunks (default bottom-up strategy). Writes a
      * JSON array of `{"chunk_x", "chunk_y", "chunk_z", "blocks": [...]}` where

package/SdfBounds.mjs

@@ -133,6 +133,7 @@ export class SdfBounds {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("SdfBounds._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/SdfNormal.mjs

@@ -100,6 +100,7 @@ export class SdfNormal {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("SdfNormal._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/TextureInfo.mjs

@@ -125,6 +125,7 @@ export class TextureInfo {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("TextureInfo._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/diplomat-runtime.mjs

@@ -8,11 +8,13 @@ export const internalConstructor = Symbol("constructor");
 export const exposeConstructor = Symbol("exposeConstructor");
 
 export function readString8(wasm, ptr, len) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     const buf = new Uint8Array(wasm.memory.buffer, ptr, len);
     return (new TextDecoder("utf-8")).decode(buf)
 }
 
 export function readString16(wasm, ptr, len) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     const buf = new Uint16Array(wasm.memory.buffer, ptr, len);
     return String.fromCharCode.apply(null, buf)
 }
@@ -48,6 +50,7 @@ export function withDiplomatWrite(wasm, callback) {
  * @returns {number} The underlying pointer.
  */
 export function ptrRead(wasm, ptr) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     return (new Uint32Array(wasm.memory.buffer, ptr, 1))[0];
 }
 
@@ -55,6 +58,7 @@ export function ptrRead(wasm, ptr) {
  * Get the flag of a result type.
  */
 export function resultFlag(wasm, ptr, offset) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     return (new Uint8Array(wasm.memory.buffer, ptr + offset, 1))[0];
 }
 
@@ -62,6 +66,7 @@ export function resultFlag(wasm, ptr, offset) {
  * Get the discriminant of a Rust enum.
 */
 export function enumDiscriminant(wasm, ptr) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     return (new Int32Array(wasm.memory.buffer, ptr, 1))[0]
 }
 
@@ -83,7 +88,7 @@ export function maybePaddingFields(needsPaddingFields, paddingCount) {
 * (which is a `TypedArray` variant like `Uint8Array` or `Int16Array`)
 */
 export function writeToArrayBuffer(arrayBuffer, offset, value, typedArrayKind) {
-    let buffer = new typedArrayKind(arrayBuffer, offset);
+    let buffer = new typedArrayKind(arrayBuffer, offset < 0 ? offset >>> 0 : offset);
     buffer[0] = value;
 }
 
@@ -223,7 +228,7 @@ export class DiplomatBuf {
         }
     }
 
-    const ptr = wasm.diplomat_alloc(utf8Length, 1);
+    const ptr = wasm.diplomat_alloc(utf8Length, 1) >>> 0;
 
     const result = (new TextEncoder()).encodeInto(string, new Uint8Array(wasm.memory.buffer, ptr, utf8Length));
     console.assert(string.length === result.read && utf8Length === result.written, "UTF-8 write error");
@@ -233,7 +238,7 @@ export class DiplomatBuf {
 
     static str16 = (wasm, string) => {
     const byteLength = string.length * 2;
-    const ptr = wasm.diplomat_alloc(byteLength, 2);
+    const ptr = wasm.diplomat_alloc(byteLength, 2) >>> 0;
 
     const destination = new Uint16Array(wasm.memory.buffer, ptr, string.length);
     for (let i = 0; i < string.length; i++) {
@@ -244,7 +249,7 @@ export class DiplomatBuf {
     }
 
     static sliceWrapper = (wasm, buf) => {
-        const ptr = wasm.diplomat_alloc(8, 4);
+        const ptr = wasm.diplomat_alloc(8, 4) >>> 0;
         let dst = new Uint32Array(wasm.memory.buffer, ptr, 2);
 
         dst[0] = buf.ptr;
@@ -262,7 +267,7 @@ export class DiplomatBuf {
             4;
 
     const byteLength = list.length * elementSize;
-    const ptr = wasm.diplomat_alloc(byteLength, elementSize);
+    const ptr = wasm.diplomat_alloc(byteLength, elementSize) >>> 0;
 
     /**
      * Create an array view of the buffer. This gives us the `set` method which correctly handles untyped values
@@ -288,15 +293,15 @@ export class DiplomatBuf {
 
         const byteLength = strings.length * 4 * 2;
 
-        const ptr = wasm.diplomat_alloc(byteLength, 4);
+        const ptr = wasm.diplomat_alloc(byteLength, 4) >>> 0;
 
-        const destination = new Uint32Array(wasm.memory.buffer, ptr, byteLength);
 
         const stringsAlloc = [];
 
         for (let i = 0; i < strings.length; i++) {
             stringsAlloc.push(encodeStr(wasm, strings[i]));
 
+            const destination = new Uint32Array(wasm.memory.buffer, ptr, strings.length * 2);
             destination[2 * i] = stringsAlloc[i].ptr;
             destination[(2 * i) + 1] = stringsAlloc[i].size;
         }
@@ -310,7 +315,7 @@ export class DiplomatBuf {
     }
 
     static struct = (wasm, size, align) => {
-        const ptr = wasm.diplomat_alloc(size, align);
+        const ptr = wasm.diplomat_alloc(size, align) >>> 0;
 
         return new DiplomatBuf(ptr, size, () => {
             wasm.diplomat_free(ptr, size, align);
@@ -325,7 +330,7 @@ export class DiplomatBuf {
     free;
 
     constructor(ptr, size, free) {
-        this.ptr = ptr;
+        this.ptr = ptr >>> 0;
         this.size = size;
         this.free = free;
         this.leak = () => { };
@@ -357,7 +362,7 @@ export class DiplomatWriteBuf {
 
     constructor(wasm) {
         this.#wasm = wasm;
-        this.#buffer = this.#wasm.diplomat_buffer_write_create(0);
+        this.#buffer = this.#wasm.diplomat_buffer_write_create(0) >>> 0;
 
         this.leak = () => { };
     }
@@ -409,7 +414,7 @@ export class DiplomatSlice {
     constructor(wasm, buffer, bufferType, lifetimeEdges) {
         this.#wasm = wasm;
 
-        const [ptr, size] = new Uint32Array(this.#wasm.memory.buffer, buffer, 2);
+        const [ptr, size] = new Uint32Array(this.#wasm.memory.buffer, buffer >>> 0, 2);
 
         this.#buffer = new bufferType(this.#wasm.memory.buffer, ptr, size);
         this.#bufferType = bufferType;
@@ -432,7 +437,7 @@ export class DiplomatSlice {
 
 export class DiplomatSlicePrimitive extends DiplomatSlice {
     constructor(wasm, buffer, sliceType, lifetimeEdges) {
-        const [ptr, size] = new Uint32Array(wasm.memory.buffer, buffer, 2);
+        const [ptr, size] = new Uint32Array(wasm.memory.buffer, buffer >>> 0, 2);
 
         let arrayType;
         switch (sliceType) {
@@ -552,7 +557,7 @@ export class DiplomatReceiveBuf {
 
         this.#hasResult = hasResult;
 
-        this.#buffer = this.#wasm.diplomat_alloc(this.#size, this.#align);
+        this.#buffer = this.#wasm.diplomat_alloc(this.#size, this.#align) >>> 0;
 
         this.leak = () => { };
     }
@@ -736,7 +741,7 @@ export class FunctionParamAllocator {
 
         this.#capacity = capacity;
         // FunctionParamAllocator is global, so this will be freed when the webpage closes:
-        this.#ptr = wasm.diplomat_alloc(this.#capacity, 1);
+        this.#ptr = wasm.diplomat_alloc(this.#capacity, 1) >>> 0;
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nucleation",
-  "version": "0.10.21",
+  "version": "0.10.23",
   "description": "A high-performance Minecraft schematic parser and utility library",
   "type": "module",
   "main": "index.mjs",
@@ -12,6 +12,10 @@
     "./design": {
       "types": "./veneer/design.d.ts",
       "default": "./veneer/design.mjs"
+    },
+    "./renderer": {
+      "types": "./renderer/index.d.ts",
+      "default": "./renderer/index.mjs"
     }
   },
   "files": [
@@ -20,7 +24,8 @@
     "*.d.mts",
     "veneer/",
     "nucleation.wasm",
-    "diplomat.config.mjs"
+    "diplomat.config.mjs",
+    "renderer/"
   ],
   "engines": {
     "node": ">=18"

package/renderer/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, start: number, end: 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/renderer/AnimationEffect.d.ts

@@ -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, start: number, end: 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;
+}