@jgengine/core 0.7.0 → 0.9.0

package/dist/world/placementController.d.ts

@@ -6,12 +6,24 @@ export interface PlacementHit {
     point: PlacementVec3;
     normal: PlacementVec3;
 }
+/** A fixed buildable slot the placement controller snaps to instead of grid/free positioning. */
+export interface PlacementSlot {
+    id: string;
+    center: PlacementVec3;
+    /** Capture radius around `center`. Defaults to `config.slotRadius`, then `1.5`. */
+    radius?: number;
+    /** `false` hides the slot from hover resolution without releasing it. Default `true`. */
+    enabled?: boolean;
+}
 export interface PlacementControllerConfig {
     footprint: Footprint;
     rules?: PlacementRules;
     snapMode?: SnapMode;
     grid?: number;
     quarterTurns?: number;
+    slots?: readonly PlacementSlot[];
+    /** Fallback capture radius for slots that don't set their own. Default `1.5`. */
+    slotRadius?: number;
 }
 export interface PlacementPreview {
     center: Vec2;
@@ -20,9 +32,11 @@ export interface PlacementPreview {
     footprint: Footprint;
     aabb: Aabb;
     valid: boolean;
-    reason?: "out-of-bounds" | "overlap";
+    reason?: "out-of-bounds" | "overlap" | "no-slot";
     snapMode: SnapMode;
     normal: PlacementVec3;
+    /** Id of the resolved slot, when the controller is in slot mode and a slot matched. */
+    slotId?: string;
 }
 export interface PlacementCommit {
     center: Vec2;
@@ -31,6 +45,8 @@ export interface PlacementCommit {
     quarterTurns: number;
     footprint: Footprint;
     aabb: Aabb;
+    /** Id of the slot this commit occupied, when the controller is in slot mode. */
+    slotId?: string;
 }
 export interface PlacementController {
     hover(hit: PlacementHit): PlacementPreview;
@@ -41,6 +57,11 @@ export interface PlacementController {
     setFootprint(footprint: Footprint): void;
     setRules(rules: PlacementRules): void;
     setGrid(grid: number): void;
+    setSlots(slots: readonly PlacementSlot[]): void;
+    /** Id of the currently hovered slot, or `null` when idle, out of slot mode, or unmatched. */
+    hoveredSlotId(): string | null;
+    /** Frees a previously committed slot so it can match again. */
+    releaseSlot(id: string): void;
     commit(): PlacementCommit | null;
     reset(): void;
 }

package/dist/world/placementController.js

@@ -1,6 +1,10 @@
 import { footprintAabb, snapToGrid } from "./geometry.js";
 import { validatePlacement } from "./placement.js";
 const SNAP_ORDER = ["grid", "free", "surface"];
+const DEFAULT_SLOT_RADIUS = 1.5;
+function distanceVec3(a, b) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+}
 export function quarterTurnsToRotationY(quarterTurns) {
     const turns = ((quarterTurns % 4) + 4) % 4;
     return turns === 0 ? 0 : -turns * (Math.PI / 2);
@@ -11,6 +15,9 @@ export function createPlacementController(config) {
     let snapMode = config.snapMode ?? "grid";
     let grid = config.grid ?? rules.snap ?? 1;
     let quarterTurns = ((config.quarterTurns ?? 0) % 4 + 4) % 4;
+    let slots = config.slots;
+    const slotRadius = config.slotRadius ?? DEFAULT_SLOT_RADIUS;
+    const occupiedSlots = new Set();
     let lastHit = null;
     let preview = null;
     function snapCenter(raw) {
@@ -18,7 +25,40 @@ export function createPlacementController(config) {
             return snapToGrid(raw, grid);
         return raw;
     }
+    function nearestSlot(hit) {
+        let best = null;
+        let bestDistance = Number.POSITIVE_INFINITY;
+        for (const slot of slots ?? []) {
+            if (slot.enabled === false || occupiedSlots.has(slot.id))
+                continue;
+            const distance = distanceVec3(hit.point, slot.center);
+            if (distance <= (slot.radius ?? slotRadius) && distance < bestDistance) {
+                best = slot;
+                bestDistance = distance;
+            }
+        }
+        return best;
+    }
+    function computeSlotPreview(hit) {
+        const slot = nearestSlot(hit);
+        const center = slot === null ? [hit.point[0], hit.point[2]] : [slot.center[0], slot.center[2]];
+        const next = {
+            center,
+            y: slot === null ? hit.point[1] : slot.center[1],
+            quarterTurns,
+            footprint,
+            aabb: footprintAabb(center, footprint, quarterTurns),
+            valid: slot !== null,
+            snapMode,
+            normal: hit.normal,
+            ...(slot === null ? { reason: "no-slot" } : { slotId: slot.id }),
+        };
+        preview = next;
+        return next;
+    }
     function compute(hit) {
+        if (slots !== undefined)
+            return computeSlotPreview(hit);
         const raw = [hit.point[0], hit.point[2]];
         const center = snapCenter(raw);
         const rulesWithoutSnap = snapMode === "grid" ? { ...rules, snap: undefined } : rules;
@@ -76,9 +116,24 @@ export function createPlacementController(config) {
             if (lastHit !== null)
                 compute(lastHit);
         },
+        setSlots(next) {
+            slots = next;
+            if (lastHit !== null)
+                compute(lastHit);
+        },
+        hoveredSlotId() {
+            return preview?.slotId ?? null;
+        },
+        releaseSlot(id) {
+            occupiedSlots.delete(id);
+            if (lastHit !== null)
+                compute(lastHit);
+        },
         commit() {
             if (preview === null || !preview.valid)
                 return null;
+            if (preview.slotId !== undefined)
+                occupiedSlots.add(preview.slotId);
             return {
                 center: preview.center,
                 y: preview.y,
@@ -86,6 +141,7 @@ export function createPlacementController(config) {
                 quarterTurns,
                 footprint: preview.footprint,
                 aabb: preview.aabb,
+                ...(preview.slotId !== undefined ? { slotId: preview.slotId } : {}),
             };
         },
         reset() {

package/dist/world/terrain.d.ts

@@ -1,4 +1,4 @@
-import type { TerrainEnvironmentDescriptor, WorldBounds } from "./features.js";
+import type { EnvironmentWorldFeature, TerrainEnvironmentConfig, TerrainEnvironmentDescriptor, TerrainIslandDescriptor, TerrainMaterial, WorldBounds, WorldFeature } from "./features.js";
 export type TerrainNormal = readonly [number, number, number];
 export interface TerrainField {
     sampleHeight(x: number, z: number): number;
@@ -46,7 +46,68 @@ export interface ArenaFieldConfig {
 }
 export declare const ARENA_WATER_LEVEL = -0.9;
 export declare function arenaField(config?: ArenaFieldConfig): TerrainField;
+export declare function groundFieldFor(world?: WorldFeature): TerrainField;
+/** Ground height between islands when no base terrain exists — deep enough to read as a fall into the void, finite so physics stays sane. */
+export declare const ISLAND_VOID_HEIGHT = -256;
+/**
+ * Composes a base terrain and any number of bounded islands into one world field: inside an island's
+ * rect the island's own field (sampled in island-local coordinates) wins, elsewhere the base terrain
+ * answers, and with no base the gap is `ISLAND_VOID_HEIGHT` void. Later islands win overlaps.
+ */
+export declare function composeIslandFields(base: TerrainField | null, islands: readonly TerrainIslandDescriptor[], voidHeight?: number): TerrainField;
+/** The full ground field for an environment world: base `terrain` composed with any `islands`. */
+export declare function resolveEnvironmentField(feature: EnvironmentWorldFeature): TerrainField;
+export interface TerrainSlopeSample {
+    /** Unit XZ direction pointing downhill; `[0, 0]` on level ground. */
+    downhill: readonly [number, number];
+    /** Rise over run (tan of the slope angle); `0` on level ground. */
+    steepness: number;
+}
+/** Local slope from the field's normal — the input for gravity-roll, ski acceleration, and slide checks (#284.6). */
+export declare function sampleSlope(field: TerrainField, x: number, z: number): TerrainSlopeSample;
+/**
+ * Downhill force/acceleration from the local slope: direction × sin(slope angle) × `scale`.
+ * Add it to any integrator's XZ velocity each tick (`scale` ≈ gravity for a free-rolling body).
+ */
+export declare function slopeForce(field: TerrainField, x: number, z: number, scale?: number): readonly [number, number];
+export interface TerrainPalette {
+    low: string;
+    high: string;
+    waterline: string;
+}
+export declare const DEFAULT_TERRAIN_MATERIAL: TerrainMaterial;
+export declare const TERRAIN_MATERIAL_PALETTES: Record<TerrainMaterial, TerrainPalette>;
+export declare function resolveTerrainPalette(descriptor?: Pick<TerrainEnvironmentConfig, "material" | "colors">): TerrainPalette;
+/**
+ * Per-position palette sampler over the descriptor's base `material`/`colors` plus its
+ * `materialRegions` — the multi-biome coloring seam. Regions paint fully inside `radius`
+ * and blend back to the surrounding palette across `falloff`; later regions win overlaps.
+ */
+export declare function createTerrainPaletteSampler(descriptor: Pick<TerrainEnvironmentConfig, "material" | "colors" | "materialRegions">): (x: number, z: number) => TerrainPalette;
+export interface HeightMapFieldConfig {
+    columns: number;
+    rows: number;
+    samples: ArrayLike<number>;
+    bounds?: WorldBounds;
+    heightScale?: number;
+    baseHeight?: number;
+    waterLevel?: number;
+}
+export declare function heightMapField(config: HeightMapFieldConfig): TerrainField;
 export declare function resolveTerrainField(descriptor?: TerrainEnvironmentDescriptor): TerrainField;
+/** Returns `position` with `y` replaced by the field's ground height (plus `offset`) at its `x`/`z`. */
+export declare function snapToGround(field: TerrainField, position: readonly [number, number, number], offset?: number): [number, number, number];
+export interface GroundSnapTarget {
+    position: readonly [number, number, number];
+}
+export interface GroundSnapEntityStore {
+    get(id: string): GroundSnapTarget | null;
+    setPose(id: string, pose: {
+        position?: readonly [number, number, number];
+    }): boolean;
+}
+/** Ground-snaps an already-spawned entity in place; returns false when `id` is unknown. */
+export declare function snapEntityToGround(entities: GroundSnapEntityStore, id: string, field: TerrainField, offset?: number): boolean;
 export declare const DEFAULT_MAX_WALK_SLOPE = 0.6;
 export declare function resolveGroundStep(field: TerrainField, x: number, z: number, stepX: number, stepZ: number, maxSlope?: number): {
     stepX: number;

package/dist/world/terrain.js

@@ -148,20 +148,264 @@ export function arenaField(config = {}) {
     };
     return fieldFromHeight(sampleHeight, { bounds: config.bounds, waterLevel: ARENA_WATER_LEVEL });
 }
+export function groundFieldFor(world) {
+    if (world !== undefined && world.kind === "environment")
+        return resolveEnvironmentField(world);
+    return flatField();
+}
+/** Ground height between islands when no base terrain exists — deep enough to read as a fall into the void, finite so physics stays sane. */
+export const ISLAND_VOID_HEIGHT = -256;
+function islandContains(descriptor, x, z) {
+    return (Math.abs(x - descriptor.origin[0]) <= descriptor.bounds.w / 2 &&
+        Math.abs(z - descriptor.origin[1]) <= descriptor.bounds.d / 2);
+}
+/**
+ * Composes a base terrain and any number of bounded islands into one world field: inside an island's
+ * rect the island's own field (sampled in island-local coordinates) wins, elsewhere the base terrain
+ * answers, and with no base the gap is `ISLAND_VOID_HEIGHT` void. Later islands win overlaps.
+ */
+export function composeIslandFields(base, islands, voidHeight = ISLAND_VOID_HEIGHT) {
+    if (islands.length === 0)
+        return base ?? flatField();
+    const resolved = islands.map((descriptor) => ({
+        descriptor,
+        field: resolveTerrainField({ ...descriptor, kind: "terrain" }),
+    }));
+    function islandAt(x, z) {
+        for (let index = resolved.length - 1; index >= 0; index -= 1) {
+            if (islandContains(resolved[index].descriptor, x, z))
+                return resolved[index];
+        }
+        return null;
+    }
+    const sampleHeight = (x, z) => {
+        const island = islandAt(x, z);
+        if (island !== null) {
+            return island.field.sampleHeight(x - island.descriptor.origin[0], z - island.descriptor.origin[1]);
+        }
+        return base !== null ? base.sampleHeight(x, z) : voidHeight;
+    };
+    return {
+        sampleHeight,
+        sampleNormal(x, z) {
+            const island = islandAt(x, z);
+            if (island !== null) {
+                return island.field.sampleNormal(x - island.descriptor.origin[0], z - island.descriptor.origin[1]);
+            }
+            return base !== null ? base.sampleNormal(x, z) : [0, 1, 0];
+        },
+        ...(base?.bounds === undefined ? {} : { bounds: base.bounds }),
+        ...(base?.waterLevel === undefined ? {} : { waterLevel: base.waterLevel }),
+    };
+}
+/** The full ground field for an environment world: base `terrain` composed with any `islands`. */
+export function resolveEnvironmentField(feature) {
+    const base = feature.terrain === undefined ? null : resolveTerrainField(feature.terrain);
+    if (feature.islands === undefined || feature.islands.length === 0)
+        return base ?? flatField();
+    return composeIslandFields(base, feature.islands);
+}
+/** Local slope from the field's normal — the input for gravity-roll, ski acceleration, and slide checks (#284.6). */
+export function sampleSlope(field, x, z) {
+    const [nx, ny, nz] = field.sampleNormal(x, z);
+    const horizontal = Math.hypot(nx, nz);
+    if (horizontal < 1e-9)
+        return { downhill: [0, 0], steepness: 0 };
+    return {
+        downhill: [nx / horizontal, nz / horizontal],
+        steepness: horizontal / Math.max(ny, 1e-9),
+    };
+}
+/**
+ * Downhill force/acceleration from the local slope: direction × sin(slope angle) × `scale`.
+ * Add it to any integrator's XZ velocity each tick (`scale` ≈ gravity for a free-rolling body).
+ */
+export function slopeForce(field, x, z, scale = 9.8) {
+    const [nx, , nz] = field.sampleNormal(x, z);
+    if (Math.hypot(nx, nz) < 1e-9)
+        return [0, 0];
+    return [nx * scale, nz * scale];
+}
+export const DEFAULT_TERRAIN_MATERIAL = "grass";
+export const TERRAIN_MATERIAL_PALETTES = {
+    grass: { low: "#30402c", high: "#7f8b50", waterline: "#1d4c6e" },
+    sand: { low: "#9c8354", high: "#e0c98a", waterline: "#2f6f8f" },
+    snow: { low: "#c7d3dc", high: "#ffffff", waterline: "#3a6ea5" },
+    rock: { low: "#3a3a3d", high: "#8a8a8d", waterline: "#1d4c6e" },
+    ash: { low: "#2b2622", high: "#5c534a", waterline: "#3a3630" },
+    highland: { low: "#414f33", high: "#a3a86b", waterline: "#365f63" },
+    slate: { low: "#2f3540", high: "#7d8896", waterline: "#26404f" },
+};
+export function resolveTerrainPalette(descriptor = {}) {
+    const material = descriptor.material ?? DEFAULT_TERRAIN_MATERIAL;
+    const preset = TERRAIN_MATERIAL_PALETTES[material];
+    if (preset === undefined) {
+        throw new Error(`Unknown terrain material "${material}". Valid materials: ${Object.keys(TERRAIN_MATERIAL_PALETTES).join(", ")}. Use colors: { low, high, waterline } for a custom look.`);
+    }
+    const colors = descriptor.colors ?? {};
+    return {
+        low: colors.low ?? preset.low,
+        high: colors.high ?? preset.high,
+        waterline: colors.waterline ?? preset.waterline,
+    };
+}
+function hexToRgb(hex) {
+    const value = Number.parseInt(hex.slice(1), 16);
+    return [(value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff];
+}
+function rgbToHex(r, g, b) {
+    const value = ((Math.round(r) & 0xff) << 16) | ((Math.round(g) & 0xff) << 8) | (Math.round(b) & 0xff);
+    return `#${value.toString(16).padStart(6, "0")}`;
+}
+function mixHex(from, to, t) {
+    if (t <= 0)
+        return from;
+    if (t >= 1)
+        return to;
+    const [fr, fg, fb] = hexToRgb(from);
+    const [tr, tg, tb] = hexToRgb(to);
+    return rgbToHex(lerp(fr, tr, t), lerp(fg, tg, t), lerp(fb, tb, t));
+}
+function mixPalette(from, to, t) {
+    if (t <= 0)
+        return from;
+    if (t >= 1)
+        return to;
+    return {
+        low: mixHex(from.low, to.low, t),
+        high: mixHex(from.high, to.high, t),
+        waterline: mixHex(from.waterline, to.waterline, t),
+    };
+}
+/**
+ * Per-position palette sampler over the descriptor's base `material`/`colors` plus its
+ * `materialRegions` — the multi-biome coloring seam. Regions paint fully inside `radius`
+ * and blend back to the surrounding palette across `falloff`; later regions win overlaps.
+ */
+export function createTerrainPaletteSampler(descriptor) {
+    const base = resolveTerrainPalette(descriptor);
+    const regions = (descriptor.materialRegions ?? []).map((region) => ({
+        center: region.center,
+        radius: region.radius,
+        falloff: region.falloff ?? region.radius * 0.5,
+        palette: resolveTerrainPalette(region),
+    }));
+    if (regions.length === 0)
+        return () => base;
+    return (x, z) => {
+        let palette = base;
+        for (const region of regions) {
+            const distance = Math.hypot(x - region.center[0], z - region.center[1]);
+            if (distance <= region.radius) {
+                palette = region.palette;
+            }
+            else if (distance <= region.radius + region.falloff) {
+                const t = smoothstep(region.radius, region.radius + region.falloff, distance);
+                palette = mixPalette(region.palette, palette, t);
+            }
+        }
+        return palette;
+    };
+}
+function withFlattenMasks(sampleHeight, masks) {
+    const resolved = masks.map((mask) => ({
+        center: mask.center,
+        radius: mask.radius,
+        target: mask.height ?? sampleHeight(mask.center[0], mask.center[1]),
+        falloff: mask.falloff ?? mask.radius * 0.5,
+    }));
+    return (x, z) => {
+        const base = sampleHeight(x, z);
+        let height = base;
+        for (const mask of resolved) {
+            const distance = Math.hypot(x - mask.center[0], z - mask.center[1]);
+            if (distance <= mask.radius) {
+                height = mask.target;
+            }
+            else if (distance <= mask.radius + mask.falloff) {
+                const t = smoothstep(mask.radius, mask.radius + mask.falloff, distance);
+                height = lerp(mask.target, base, t);
+            }
+        }
+        return height;
+    };
+}
+export function heightMapField(config) {
+    const { columns, rows, samples } = config;
+    if (columns <= 0 || rows <= 0)
+        throw new Error("heightMapField: columns/rows must be positive");
+    if (samples.length < columns * rows) {
+        throw new Error(`heightMapField: samples length ${samples.length} < columns*rows ${columns * rows}`);
+    }
+    const bounds = config.bounds ?? { w: columns, d: rows };
+    const heightScale = config.heightScale ?? 1;
+    const baseHeight = config.baseHeight ?? 0;
+    const halfW = bounds.w / 2;
+    const halfD = bounds.d / 2;
+    const sampleAt = (col, row) => {
+        const c = Math.max(0, Math.min(columns - 1, col));
+        const r = Math.max(0, Math.min(rows - 1, row));
+        return samples[r * columns + c];
+    };
+    return fieldFromHeight((x, z) => {
+        const u = columns <= 1 ? 0 : ((x + halfW) / bounds.w) * (columns - 1);
+        const v = rows <= 1 ? 0 : ((z + halfD) / bounds.d) * (rows - 1);
+        const c0 = Math.floor(u);
+        const r0 = Math.floor(v);
+        const fu = u - c0;
+        const fv = v - r0;
+        const h00 = sampleAt(c0, r0);
+        const h10 = sampleAt(c0 + 1, r0);
+        const h01 = sampleAt(c0, r0 + 1);
+        const h11 = sampleAt(c0 + 1, r0 + 1);
+        const top = lerp(h00, h10, fu);
+        const bottom = lerp(h01, h11, fu);
+        return baseHeight + heightScale * lerp(top, bottom, fv);
+    }, {
+        bounds,
+        ...(config.waterLevel === undefined ? {} : { waterLevel: config.waterLevel }),
+    });
+}
 export function resolveTerrainField(descriptor) {
     if (descriptor === undefined)
         return flatField();
-    return noiseField({
-        seed: descriptor.seed,
-        amplitude: descriptor.height,
-        frequency: descriptor.frequency,
-        octaves: descriptor.octaves,
-        ridged: descriptor.ridged,
-        baseHeight: descriptor.baseHeight,
-        waterLevel: descriptor.waterLevel,
-        bounds: descriptor.bounds,
+    if (descriptor.heightField === undefined && descriptor.heightMap !== undefined) {
+        throw new Error(`terrain heightMap "${descriptor.heightMap}" is not auto-loaded. Decode elevation samples into heightMapField({ columns, rows, samples }) and pass heightField: field.sampleHeight (or omit heightMap and set heightField directly).`);
+    }
+    const base = descriptor.heightField !== undefined
+        ? fieldFromHeight(descriptor.heightField, {
+            bounds: descriptor.bounds,
+            ...(descriptor.waterLevel === undefined ? {} : { waterLevel: descriptor.waterLevel }),
+        })
+        : noiseField({
+            seed: descriptor.seed,
+            amplitude: descriptor.height,
+            frequency: descriptor.frequency,
+            octaves: descriptor.octaves,
+            ridged: descriptor.ridged,
+            baseHeight: descriptor.baseHeight,
+            waterLevel: descriptor.waterLevel,
+            bounds: descriptor.bounds,
+        });
+    if (descriptor.flatten === undefined || descriptor.flatten.length === 0)
+        return base;
+    return fieldFromHeight(withFlattenMasks(base.sampleHeight, descriptor.flatten), {
+        bounds: base.bounds,
+        waterLevel: base.waterLevel,
     });
 }
+/** Returns `position` with `y` replaced by the field's ground height (plus `offset`) at its `x`/`z`. */
+export function snapToGround(field, position, offset = 0) {
+    const [x, , z] = position;
+    return [x, field.sampleHeight(x, z) + offset, z];
+}
+/** Ground-snaps an already-spawned entity in place; returns false when `id` is unknown. */
+export function snapEntityToGround(entities, id, field, offset = 0) {
+    const entity = entities.get(id);
+    if (entity === null)
+        return false;
+    return entities.setPose(id, { position: snapToGround(field, entity.position, offset) });
+}
 export const DEFAULT_MAX_WALK_SLOPE = 0.6;
 export function resolveGroundStep(field, x, z, stepX, stepZ, maxSlope = DEFAULT_MAX_WALK_SLOPE) {
     const baseHeight = field.sampleHeight(x, z);

package/dist/world/voxelField.d.ts

@@ -0,0 +1,54 @@
+export type VoxelCoord = readonly [number, number, number];
+export type VoxelFace = "px" | "nx" | "py" | "ny" | "pz" | "nz";
+export interface VoxelFieldConfig {
+    chunkSize?: number;
+}
+export interface VoxelCell<T extends string = string> {
+    x: number;
+    y: number;
+    z: number;
+    type: T;
+}
+export interface VoxelHit<T extends string = string> {
+    x: number;
+    y: number;
+    z: number;
+    type: T;
+    face: VoxelFace;
+    adjacent: VoxelCoord;
+    distance: number;
+}
+export interface VoxelBounds {
+    min: VoxelCoord;
+    max: VoxelCoord;
+}
+export interface VoxelFieldSummary<T extends string = string> {
+    blocks: number;
+    types: Record<T, number>;
+    bounds: VoxelBounds | null;
+}
+export interface VoxelField<T extends string = string> {
+    set(x: number, y: number, z: number, type: T): boolean;
+    remove(x: number, y: number, z: number): boolean;
+    get(x: number, y: number, z: number): T | null;
+    has(x: number, y: number, z: number): boolean;
+    fill(min: VoxelCoord, max: VoxelCoord, type: T): number;
+    clear(): void;
+    count(): number;
+    cells(): IterableIterator<VoxelCell<T>>;
+    bounds(): VoxelBounds | null;
+    neighbors(x: number, y: number, z: number): VoxelCell<T>[];
+    exposedFaces(x: number, y: number, z: number): readonly VoxelFace[];
+    raycast(origin: VoxelCoord, direction: VoxelCoord, maxDistance: number): VoxelHit<T> | null;
+    chunkOf(x: number, y: number, z: number): {
+        cx: number;
+        cy: number;
+        cz: number;
+    };
+    chunkVersion(cx: number, cy: number, cz: number): number;
+    subscribe(listener: () => void): () => void;
+    summary(): VoxelFieldSummary<T>;
+}
+export declare const VOXEL_FACES: readonly VoxelFace[];
+export declare const VOXEL_FACE_NORMALS: Record<VoxelFace, VoxelCoord>;
+export declare function createVoxelField<T extends string = string>(config?: VoxelFieldConfig): VoxelField<T>;