@jgengine/core 0.9.0 → 0.11.0

package/dist/ui/swingTimer.js

@@ -0,0 +1,38 @@
+/** Threshold above which a timer jump is treated as a fresh swing (period reset). */
+export const SWING_EDGE_EPSILON = 1e-4;
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+const HIDDEN = {
+    visible: false,
+    frac: 0,
+    ready: false,
+    labelKind: "seconds",
+    seconds: 0,
+};
+/**
+ * Pure swing-timer bar state — no hidden state, no clock, no DOM. The caller
+ * threads `prevPeriod`/`prevTimer` back each frame. The period is recovered on
+ * the reset edge (when `swingTimer` jumps up = a new swing began) as
+ * `max(swingTimer, weapon.speed)`, so the fill is correct even without knowing
+ * the weapon's exact cadence. Hidden unless auto-attacking a live, non-object target.
+ */
+export function swingTimerState(player, target, prevPeriod, prevTimer) {
+    const swingTimer = player.swingTimer;
+    if (!player.autoAttack || target === null || target.dead || target.kind === "object") {
+        return { ...HIDDEN, nextPeriod: prevPeriod, nextTimer: swingTimer };
+    }
+    const isResetEdge = swingTimer > prevTimer + SWING_EDGE_EPSILON || prevPeriod <= 0;
+    const period = isResetEdge ? Math.max(swingTimer, player.weapon.speed) : prevPeriod;
+    const frac = period <= 0 ? 1 : clamp01(1 - swingTimer / period);
+    const ready = swingTimer <= 0;
+    return {
+        visible: true,
+        frac,
+        ready,
+        labelKind: ready ? "ready" : "seconds",
+        seconds: Math.max(0, swingTimer),
+        nextPeriod: period,
+        nextTimer: swingTimer,
+    };
+}

package/dist/ui/tooltipModel.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Headless model for HUD tooltips and popovers — the shared description seam games have been
+ * hand-rolling with a bare DOM `title=` attribute. {@link actionTooltip} turns a
+ * {@link ResolvedAction} into structured {@link TooltipContent} (title, cost, cooldown, blocking
+ * notes), and {@link placePopover} is the pure, SSR-safe positioning math the React tooltip uses to
+ * flip and clamp against the viewport. Both are rendering-agnostic.
+ */
+import type { ActionCooldown, ActionCost, ResolvedAction } from "./actionModel.js";
+/** Structured tooltip content — a renderer lays these fields out; the model owns what is shown. */
+export interface TooltipContent {
+    title: string;
+    subtitle?: string;
+    body?: string;
+    /** Hotkey label to echo (e.g. `"Q"`). */
+    hotkey?: string;
+    costs?: readonly ActionCost[];
+    cooldown?: ActionCooldown | null;
+    /** Blocking reasons rendered as a warning footer (why the action is unavailable). */
+    notes?: readonly string[];
+}
+/**
+ * Build {@link TooltipContent} from a {@link ResolvedAction}: title from the label, the group as a
+ * subtitle, the description as the body, and the blocking reasons as warning notes. The single place
+ * an action's tooltip copy is assembled, so every renderer shows the same thing.
+ */
+export declare function actionTooltip(action: ResolvedAction): TooltipContent;
+/** Which side of its anchor a popover opens toward. */
+export type PopoverSide = "top" | "bottom" | "left" | "right";
+/** A positioned rectangle (viewport/anchor space, top-left origin, pixels). */
+export interface UiRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A width/height pair (pixels). */
+export interface UiSize {
+    width: number;
+    height: number;
+}
+/** The resolved popover position — the side it actually opened on and its clamped top-left. */
+export interface PopoverPlacement {
+    side: PopoverSide;
+    left: number;
+    top: number;
+}
+/** Options for {@link placePopover}. */
+export interface PopoverOptions {
+    /** Side to try first (default `"top"`). Flips to the opposite when it would overflow. */
+    preferred?: PopoverSide;
+    /** Gap between the anchor and the popover, in pixels (default 8). */
+    gap?: number;
+    /** Minimum inset from the viewport edges, in pixels (default 8). */
+    margin?: number;
+}
+/**
+ * Position a popover/tooltip of `content` size against its `anchor` rectangle inside `viewport`:
+ * open on the `preferred` side, flip to the opposite when that side lacks room and the opposite has
+ * more, then clamp the top-left so the box stays fully on screen (respecting `margin`). Pure and
+ * deterministic — no DOM reads — so it is SSR-safe and unit-testable, and the React tooltip is a thin
+ * shell over it.
+ */
+export declare function placePopover(anchor: UiRect, content: UiSize, viewport: UiSize, options?: PopoverOptions): PopoverPlacement;

package/dist/ui/tooltipModel.js

@@ -0,0 +1,82 @@
+/**
+ * Headless model for HUD tooltips and popovers — the shared description seam games have been
+ * hand-rolling with a bare DOM `title=` attribute. {@link actionTooltip} turns a
+ * {@link ResolvedAction} into structured {@link TooltipContent} (title, cost, cooldown, blocking
+ * notes), and {@link placePopover} is the pure, SSR-safe positioning math the React tooltip uses to
+ * flip and clamp against the viewport. Both are rendering-agnostic.
+ */
+/**
+ * Build {@link TooltipContent} from a {@link ResolvedAction}: title from the label, the group as a
+ * subtitle, the description as the body, and the blocking reasons as warning notes. The single place
+ * an action's tooltip copy is assembled, so every renderer shows the same thing.
+ */
+export function actionTooltip(action) {
+    const content = { title: action.label };
+    if (action.group !== undefined)
+        content.subtitle = action.group;
+    if (action.description !== undefined)
+        content.body = action.description;
+    if (action.hotkey !== undefined)
+        content.hotkey = action.hotkey;
+    if (action.costs.length > 0)
+        content.costs = action.costs;
+    if (action.cooldown !== null && !action.cooldown.ready)
+        content.cooldown = action.cooldown;
+    if (action.reasons.length > 0)
+        content.notes = action.reasons.map((reason) => reason.message);
+    return content;
+}
+const OPPOSITE = {
+    top: "bottom",
+    bottom: "top",
+    left: "right",
+    right: "left",
+};
+const clamp = (value, min, max) => Math.max(min, Math.min(max, max < min ? min : value));
+/** @internal Room in pixels between the anchor and the viewport edge on a given side. */
+function roomOn(side, anchor, viewport) {
+    if (side === "top")
+        return anchor.y;
+    if (side === "bottom")
+        return viewport.height - (anchor.y + anchor.height);
+    if (side === "left")
+        return anchor.x;
+    return viewport.width - (anchor.x + anchor.width);
+}
+/** @internal The top-left of `content` placed on `side` of `anchor`, before viewport clamping. */
+function topLeftFor(side, anchor, content, gap) {
+    if (side === "top") {
+        return { left: anchor.x + anchor.width / 2 - content.width / 2, top: anchor.y - gap - content.height };
+    }
+    if (side === "bottom") {
+        return { left: anchor.x + anchor.width / 2 - content.width / 2, top: anchor.y + anchor.height + gap };
+    }
+    if (side === "left") {
+        return { left: anchor.x - gap - content.width, top: anchor.y + anchor.height / 2 - content.height / 2 };
+    }
+    return { left: anchor.x + anchor.width + gap, top: anchor.y + anchor.height / 2 - content.height / 2 };
+}
+/**
+ * Position a popover/tooltip of `content` size against its `anchor` rectangle inside `viewport`:
+ * open on the `preferred` side, flip to the opposite when that side lacks room and the opposite has
+ * more, then clamp the top-left so the box stays fully on screen (respecting `margin`). Pure and
+ * deterministic — no DOM reads — so it is SSR-safe and unit-testable, and the React tooltip is a thin
+ * shell over it.
+ */
+export function placePopover(anchor, content, viewport, options) {
+    const gap = options?.gap ?? 8;
+    const margin = options?.margin ?? 8;
+    const preferred = options?.preferred ?? "top";
+    const needed = preferred === "top" || preferred === "bottom" ? content.height : content.width;
+    let side = preferred;
+    const opposite = OPPOSITE[preferred];
+    if (roomOn(preferred, anchor, viewport) < needed + gap && roomOn(opposite, anchor, viewport) > roomOn(preferred, anchor, viewport)) {
+        side = opposite;
+    }
+    const { left, top } = topLeftFor(side, anchor, content, gap);
+    return {
+        side,
+        left: clamp(left, margin, viewport.width - content.width - margin),
+        top: clamp(top, margin, viewport.height - content.height - margin),
+    };
+}

package/dist/ui.d.ts

@@ -0,0 +1,15 @@
+export { formatDistance } from "./format/distance.js";
+export { formatDelta, formatDuration, formatOrdinal } from "./format/duration.js";
+export { formatSpeed } from "./format/speed.js";
+export { resolveGameLook, type LookPreset } from "./render/lookPreset.js";
+export { STUDIO_STAGE_POST, type GradeConfig, type PostProcessingConfig, type ToneMappingMode, } from "./render/postProcessing.js";
+export { BUILT_IN_SETTING_CATEGORIES, DEFAULT_GRAPHICS_QUALITY, DEFAULT_GRAPHICS_SHADOWS, DEFAULT_MASTER_VOLUME, DEFAULT_UI_SCALE, GRAPHICS_QUALITY_DPR, GRAPHICS_QUALITY_OPTIONS, SETTING_IDS, UI_SCALE_MAX, UI_SCALE_MIN, busVolumeSettingId, createSettingsStore, type GameSettingDef, type GameSettingsConfig, type GraphicsQuality, type SettingCategory, type SettingCategoryDef, type SettingKind, type SettingOption, type SettingValue, type SettingsActionDef, type SettingsStore, type SettingsSurface, type SettingsVariant, } from "./settings/settingsModel.js";
+export { actionByHotkey, actionCooldown, actionCooldownFromFraction, actionCost, moveGridFocus, resolveAction, resolveActionCollection, type ActionCooldown, type ActionCost, type ActionDef, type ActionReason, type FocusDirection, type GridFocusOptions, type ResolvedAction, } from "./ui/actionModel.js";
+export { type GameLayoutMode, type GameViewportLayout, type HudPriority, type Insets, type LayoutCollision, type LayoutCollisionPolicy, type LayoutRect, type LayoutRegion, type MobileHudBehavior, } from "./ui/gameLayout.js";
+export { listHudPanelTypes, registerHudPanelType, resizePanelSize, resolveHudPanelLayout, type EditorUiDocument, type EditorUiPanelLayout, type HudResizeAxes, } from "./ui/hudDocument.js";
+export { HUD_ANCHOR_FRACTIONS, type HudAnchor, type HudLayoutStore, type HudPlacement, type HudSize, } from "./ui/hudLayout.js";
+export { hudScaleForViewport, overflowingPanels, resolveHudFit, type HudPlatform, type HudViewportConfig, } from "./ui/hudScale.js";
+export { orientationGateActive, orientationHintActive, resolveOrientationRequirement, type LayoutOrientation, } from "./ui/orientation.js";
+export { moveSelectionFocus, selectionWindow, summarizeSelection, type EntitySummaryDef, type EntityVital, type SelectionFocusDirection, type SelectionGroup, type SelectionView, type SelectionWindow, type SummarizeSelectionOptions, } from "./ui/selectionModel.js";
+export { swingTimerState, type SwingTargetInput } from "./ui/swingTimer.js";
+export { actionTooltip, placePopover, type PopoverOptions, type PopoverPlacement, type PopoverSide, type TooltipContent, type UiRect, type UiSize, } from "./ui/tooltipModel.js";

package/dist/ui.js

@@ -0,0 +1,15 @@
+export { formatDistance } from "./format/distance.js";
+export { formatDelta, formatDuration, formatOrdinal } from "./format/duration.js";
+export { formatSpeed } from "./format/speed.js";
+export { resolveGameLook } from "./render/lookPreset.js";
+export { STUDIO_STAGE_POST, } from "./render/postProcessing.js";
+export { BUILT_IN_SETTING_CATEGORIES, DEFAULT_GRAPHICS_QUALITY, DEFAULT_GRAPHICS_SHADOWS, DEFAULT_MASTER_VOLUME, DEFAULT_UI_SCALE, GRAPHICS_QUALITY_DPR, GRAPHICS_QUALITY_OPTIONS, SETTING_IDS, UI_SCALE_MAX, UI_SCALE_MIN, busVolumeSettingId, createSettingsStore, } from "./settings/settingsModel.js";
+export { actionByHotkey, actionCooldown, actionCooldownFromFraction, actionCost, moveGridFocus, resolveAction, resolveActionCollection, } from "./ui/actionModel.js";
+export {} from "./ui/gameLayout.js";
+export { listHudPanelTypes, registerHudPanelType, resizePanelSize, resolveHudPanelLayout, } from "./ui/hudDocument.js";
+export { HUD_ANCHOR_FRACTIONS, } from "./ui/hudLayout.js";
+export { hudScaleForViewport, overflowingPanels, resolveHudFit, } from "./ui/hudScale.js";
+export { orientationGateActive, orientationHintActive, resolveOrientationRequirement, } from "./ui/orientation.js";
+export { moveSelectionFocus, selectionWindow, summarizeSelection, } from "./ui/selectionModel.js";
+export { swingTimerState } from "./ui/swingTimer.js";
+export { actionTooltip, placePopover, } from "./ui/tooltipModel.js";

package/dist/visibility/bounds.d.ts

@@ -42,11 +42,17 @@ export type BoundsSpec = {
 };
 /** Conservative default: a unit sphere. Objects without explicit bounds cull as a small volume, never a point. */
 export declare const DEFAULT_BOUNDS: BoundsSpec;
+/** @internal */
 export declare function createRenderBounds(): RenderBounds;
-/** Resolve a spec + world position into concrete bounds. Writes into `out` when supplied (no allocation). */
+/** Resolve a spec + world position into concrete bounds. Writes into `out` when supplied (no allocation).
+ * @internal
+ */
 export declare function resolveBounds(spec: BoundsSpec, position: Vec3, out?: RenderBounds): RenderBounds;
+/** @internal */
 export declare function expandRenderBounds(bounds: RenderBounds, margin: number, out?: RenderBounds): RenderBounds;
+/** @internal */
 export declare function aabbIntersects(aMinX: number, aMinY: number, aMinZ: number, aMaxX: number, aMaxY: number, aMaxZ: number, bMinX: number, bMinY: number, bMinZ: number, bMaxX: number, bMaxY: number, bMaxZ: number): boolean;
+/** @internal */
 export declare function boundsIntersect(a: RenderBounds, b: RenderBounds): boolean;
 /**
  * BoundsSystem: caches resolved bounds per object and recomputes only when the caller's
@@ -63,4 +69,5 @@ export interface BoundsCache {
     size(): number;
     recomputes(): number;
 }
+/** @internal */
 export declare function createBoundsCache(): BoundsCache;

package/dist/visibility/bounds.js

@@ -1,5 +1,6 @@
 /** Conservative default: a unit sphere. Objects without explicit bounds cull as a small volume, never a point. */
 export const DEFAULT_BOUNDS = { kind: "sphere", radius: 1 };
+/** @internal */
 export function createRenderBounds() {
     return {
         centerX: 0,
@@ -27,7 +28,9 @@ function fillBounds(out, cx, cy, cz, hx, hy, hz) {
     out.radius = Math.sqrt(hx * hx + hy * hy + hz * hz);
     return out;
 }
-/** Resolve a spec + world position into concrete bounds. Writes into `out` when supplied (no allocation). */
+/** Resolve a spec + world position into concrete bounds. Writes into `out` when supplied (no allocation).
+ * @internal
+ */
 export function resolveBounds(spec, position, out = createRenderBounds()) {
     if (spec.kind === "point") {
         return fillBounds(out, position[0], position[1], position[2], 0, 0, 0);
@@ -49,6 +52,7 @@ export function resolveBounds(spec, position, out = createRenderBounds()) {
             return fillBounds(out, cx, cy, cz, spec.halfWidth, spec.halfHeight ?? 0, spec.halfDepth);
     }
 }
+/** @internal */
 export function expandRenderBounds(bounds, margin, out = createRenderBounds()) {
     out.centerX = bounds.centerX;
     out.centerY = bounds.centerY;
@@ -62,14 +66,17 @@ export function expandRenderBounds(bounds, margin, out = createRenderBounds()) {
     out.maxZ = bounds.maxZ + margin;
     return out;
 }
+/** @internal */
 export function aabbIntersects(aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ, bMinX, bMinY, bMinZ, bMaxX, bMaxY, bMaxZ) {
     return (aMinX <= bMaxX && aMaxX >= bMinX &&
         aMinY <= bMaxY && aMaxY >= bMinY &&
         aMinZ <= bMaxZ && aMaxZ >= bMinZ);
 }
+/** @internal */
 export function boundsIntersect(a, b) {
     return aabbIntersects(a.minX, a.minY, a.minZ, a.maxX, a.maxY, a.maxZ, b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ);
 }
+/** @internal */
 export function createBoundsCache() {
     const entries = new Map();
     let recomputes = 0;

package/dist/visibility/frustum.d.ts

@@ -36,12 +36,21 @@ export interface Frustum {
     maxY: number;
     maxZ: number;
 }
+/** @internal */
 export declare function createFrustum(): Frustum;
+/** @internal */
 export declare function updateFrustum(out: Frustum, view: CameraView): Frustum;
-/** Conservative AABB-vs-frustum: never a false negative (may keep a corner-case that is truly outside). */
+/** Conservative AABB-vs-frustum: never a false negative (may keep a corner-case that is truly outside).
+ * @internal
+ */
 export declare function aabbInFrustum(f: Frustum, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): boolean;
+/** @internal */
 export declare function sphereInFrustum(f: Frustum, cx: number, cy: number, cz: number, radius: number): boolean;
-/** Sphere broad-phase reject, then the tight AABB test. Both conservative. */
+/** Sphere broad-phase reject, then the tight AABB test. Both conservative.
+ * @internal
+ */
 export declare function boundsInFrustum(f: Frustum, b: RenderBounds): boolean;
-/** Push every plane outward by `margin` (unit normals ⇒ d += margin) to form a preload/hysteresis region. */
+/** Push every plane outward by `margin` (unit normals ⇒ d += margin) to form a preload/hysteresis region.
+ * @internal
+ */
 export declare function dilateFrustum(src: Frustum, margin: number, out: Frustum): Frustum;

package/dist/visibility/frustum.js

@@ -1,5 +1,6 @@
 const WORLD_UP = [0, 1, 0];
 const ALT_UP = [1, 0, 0];
+/** @internal */
 export function createFrustum() {
     return {
         planes: new Float64Array(24),
@@ -43,6 +44,7 @@ function planeFromCorners(planes, slot, corners, a, b, c, centroidX, centroidY,
     planes[slot * 4 + 2] = nz;
     planes[slot * 4 + 3] = d;
 }
+/** @internal */
 export function updateFrustum(out, view) {
     const { position, target } = view;
     let fx = target[0] - position[0];
@@ -137,7 +139,9 @@ export function updateFrustum(out, view) {
     planeFromCorners(planes, 5, corners, 2, 3, 6, cX, cY, cZ); // bottom
     return out;
 }
-/** Conservative AABB-vs-frustum: never a false negative (may keep a corner-case that is truly outside). */
+/** Conservative AABB-vs-frustum: never a false negative (may keep a corner-case that is truly outside).
+ * @internal
+ */
 export function aabbInFrustum(f, minX, minY, minZ, maxX, maxY, maxZ) {
     const planes = f.planes;
     for (let i = 0; i < 6; i += 1) {
@@ -150,6 +154,7 @@ export function aabbInFrustum(f, minX, minY, minZ, maxX, maxY, maxZ) {
     }
     return true;
 }
+/** @internal */
 export function sphereInFrustum(f, cx, cy, cz, radius) {
     const planes = f.planes;
     for (let i = 0; i < 6; i += 1) {
@@ -159,13 +164,17 @@ export function sphereInFrustum(f, cx, cy, cz, radius) {
     }
     return true;
 }
-/** Sphere broad-phase reject, then the tight AABB test. Both conservative. */
+/** Sphere broad-phase reject, then the tight AABB test. Both conservative.
+ * @internal
+ */
 export function boundsInFrustum(f, b) {
     if (!sphereInFrustum(f, b.centerX, b.centerY, b.centerZ, b.radius))
         return false;
     return aabbInFrustum(f, b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ);
 }
-/** Push every plane outward by `margin` (unit normals ⇒ d += margin) to form a preload/hysteresis region. */
+/** Push every plane outward by `margin` (unit normals ⇒ d += margin) to form a preload/hysteresis region.
+ * @internal
+ */
 export function dilateFrustum(src, margin, out) {
     const sp = src.planes;
     const op = out.planes;

package/dist/visibility/spatialIndex.js

@@ -33,10 +33,10 @@ export function createSpatialIndex(options = {}) {
                     const key = packCell(x, y, z);
                     let bucket = cells.get(key);
                     if (bucket === undefined) {
-                        bucket = new Set();
+                        bucket = { x, y, z, ids: new Set() };
                         cells.set(key, bucket);
                     }
-                    bucket.add(id);
+                    bucket.ids.add(id);
                 }
             }
         }
@@ -49,8 +49,8 @@ export function createSpatialIndex(options = {}) {
                     const bucket = cells.get(key);
                     if (bucket === undefined)
                         continue;
-                    bucket.delete(id);
-                    if (bucket.size === 0)
+                    bucket.ids.delete(id);
+                    if (bucket.ids.size === 0)
                         cells.delete(key);
                 }
             }
@@ -69,17 +69,20 @@ export function createSpatialIndex(options = {}) {
         addToCells(id, range);
         entries.set(id, { range, dynamic });
     }
-    function collectCell(key, out) {
-        const bucket = cells.get(key);
-        if (bucket === undefined)
-            return;
-        for (const id of bucket) {
+    function collectBucket(bucket, out) {
+        for (const id of bucket.ids) {
             if (stamps.get(id) === queryStamp)
                 continue;
             stamps.set(id, queryStamp);
             out.push(id);
         }
     }
+    function collectCell(key, out) {
+        const bucket = cells.get(key);
+        if (bucket === undefined)
+            return;
+        collectBucket(bucket, out);
+    }
     function collectOversized(out) {
         for (const id of oversized) {
             if (stamps.get(id) === queryStamp)
@@ -93,12 +96,25 @@ export function createSpatialIndex(options = {}) {
         out.length = 0;
         const x0 = cellOf(minX, size), y0 = cellOf(minY, size), z0 = cellOf(minZ, size);
         const x1 = cellOf(maxX, size), y1 = cellOf(maxY, size), z1 = cellOf(maxZ, size);
-        for (let x = x0; x <= x1; x += 1) {
-            for (let y = y0; y <= y1; y += 1) {
-                for (let z = z0; z <= z1; z += 1) {
-                    if (cellFilter !== undefined && !cellFilter(x, y, z))
-                        continue;
-                    collectCell(packCell(x, y, z), out);
+        const rangeCellCount = (x1 - x0 + 1) * (y1 - y0 + 1) * (z1 - z0 + 1);
+        if (rangeCellCount > cells.size) {
+            for (const bucket of cells.values()) {
+                if (bucket.x < x0 || bucket.x > x1 || bucket.y < y0 || bucket.y > y1 || bucket.z < z0 || bucket.z > z1) {
+                    continue;
+                }
+                if (cellFilter !== undefined && !cellFilter(bucket.x, bucket.y, bucket.z))
+                    continue;
+                collectBucket(bucket, out);
+            }
+        }
+        else {
+            for (let x = x0; x <= x1; x += 1) {
+                for (let y = y0; y <= y1; y += 1) {
+                    for (let z = z0; z <= z1; z += 1) {
+                        if (cellFilter !== undefined && !cellFilter(x, y, z))
+                            continue;
+                        collectCell(packCell(x, y, z), out);
+                    }
                 }
             }
         }
@@ -172,13 +188,11 @@ export function createSpatialIndex(options = {}) {
         cells() {
             const result = [];
             for (const [key, bucket] of cells) {
-                const parts = key.split(":");
-                const x = Number(parts[0]), y = Number(parts[1]), z = Number(parts[2]);
                 result.push({
                     key,
-                    count: bucket.size,
-                    minX: x * size, minY: y * size, minZ: z * size,
-                    maxX: (x + 1) * size, maxY: (y + 1) * size, maxZ: (z + 1) * size,
+                    count: bucket.ids.size,
+                    minX: bucket.x * size, minY: bucket.y * size, minZ: bucket.z * size,
+                    maxX: (bucket.x + 1) * size, maxY: (bucket.y + 1) * size, maxZ: (bucket.z + 1) * size,
                 });
             }
             return result;