@jgengine/core 0.7.0 → 0.9.0

package/dist/runtime/gameRuntime.js

@@ -13,6 +13,7 @@ export function createGameRuntime(definition) {
                 server: input.serverRow,
                 players: input.playersByUserId,
                 chunks: input.chunksByKey,
+                revision: input.revision,
             });
             if (loop?.onInit && !initialized) {
                 initialized = true;
@@ -34,18 +35,18 @@ export function createGameRuntime(definition) {
             if (!loop?.onTick)
                 return snapshot;
             let current = snapshot;
-            for (const userId of Object.keys(current.players)) {
-                const ctx = {
-                    get snapshot() {
-                        return current;
-                    },
-                    player: { userId, isNew: false },
-                    setSnapshot(next) {
-                        current = next;
-                    },
-                };
-                loop.onTick(ctx, dtSeconds);
-            }
+            const ctx = {
+                get snapshot() {
+                    return current;
+                },
+                get playerIds() {
+                    return Object.keys(current.players);
+                },
+                setSnapshot(next) {
+                    current = next;
+                },
+            };
+            loop.onTick(ctx, dtSeconds);
             return current;
         },
         joinPlayer(snapshot, userId, isNew) {

package/dist/runtime/hostPersistence.d.ts

@@ -62,6 +62,27 @@ export declare function drainPendingLeaderboardIncrements(session: Record<string
     increments: LeaderboardIncrement[];
     session: Record<string, unknown>;
 };
+export declare const LEADERBOARD_TOP_LIMIT = 100;
+export declare function clampLimit(value: number | undefined, fallback: number, max: number): number;
+export type LeaderboardRow = {
+    gameId: string;
+    stat: string;
+    scope: LeaderboardScope;
+    serverId?: string;
+    userId: string;
+    value: number;
+    updatedAt: number;
+};
+export declare function leaderboardRowKey(row: Omit<LeaderboardRow, "value" | "updatedAt">): string;
+export declare function applyLeaderboardRows(rows: Map<string, LeaderboardRow>, gameId: string, entries: LeaderboardIncrement[], now: number): void;
+export declare function topLeaderboardRows(rows: Iterable<LeaderboardRow>, args: {
+    gameId: string;
+    stat: string;
+    scope: LeaderboardScope;
+    serverId?: string;
+    limit?: number;
+}): LeaderboardEntry[];
+export declare function profileLeaderboardStats(rows: Iterable<LeaderboardRow>, gameId: string, userId: string): Record<string, number>;
 export declare const FEED_RING_LIMIT = 20;
 export declare function trimFeedEntries<T>(entries: T[], limit?: number): T[];
 export declare function shouldAutoSave(save: SaveConfig, dirtyAt: number | undefined, lastSavedAt: number | undefined, now: number): boolean;
@@ -77,7 +98,13 @@ export type ServerListing = {
     tags?: string[];
     updatedAt: number;
 };
-export declare function toServerListing(record: GameServerRecord): ServerListing;
+export type ToServerListingOptions = {
+    includeJoinCode?: boolean;
+};
+export declare function toServerListing(record: GameServerRecord, options?: ToServerListingOptions): ServerListing;
+export declare const OPEN_SERVER_LISTING_LIMIT = 20;
+export declare const OPEN_SERVER_LISTING_MAX = 100;
+export declare function toOpenServerListings(listings: Iterable<ServerListing>, limit?: number): ServerListing[];
 export type HostPersistence = {
     savePlan?: (plan: ServerPersistPlan) => Promise<void>;
     resetScenario?: (reset: NormalizedScenarioReset) => Promise<void>;
@@ -91,6 +118,7 @@ export type HostPersistence = {
     saveProfile: (record: PlayerProfileRecord) => Promise<void>;
     loadChunks: (serverId: string) => Promise<WorldChunkRecord[]>;
     saveChunks: (serverId: string, chunks: WorldChunkRecord[]) => Promise<void>;
+    deleteChunks: (serverId: string, chunkKeys: string[]) => Promise<void>;
     loadFeed: (args: {
         serverId: string;
         action: string;
@@ -118,6 +146,7 @@ export type ServerPersistPlan = {
     server: GameServerRecord;
     profiles: PlayerProfileRecord[];
     chunks: WorldChunkRecord[];
+    deletedChunks: string[];
     leaderboard: LeaderboardIncrement[];
 };
 export declare function planServerPersist(server: GameServerRecord, snapshot: GameRuntimeSnapshot, save: SaveConfig, now: number): ServerPersistPlan;

package/dist/runtime/hostPersistence.js

@@ -20,6 +20,56 @@ export function drainPendingLeaderboardIncrements(session) {
     delete rest[LEADERBOARD_PENDING_KEY];
     return { increments: raw.filter(isLeaderboardIncrement), session: rest };
 }
+export const LEADERBOARD_TOP_LIMIT = 100;
+export function clampLimit(value, fallback, max) {
+    const candidate = value ?? fallback;
+    if (!Number.isFinite(candidate))
+        return fallback;
+    return Math.min(Math.max(Math.floor(candidate), 1), max);
+}
+export function leaderboardRowKey(row) {
+    return [row.gameId, row.scope, row.stat, row.serverId ?? "", row.userId].join("|");
+}
+export function applyLeaderboardRows(rows, gameId, entries, now) {
+    for (const entry of entries) {
+        const key = leaderboardRowKey({ ...entry, gameId });
+        const existing = rows.get(key);
+        if (existing) {
+            rows.set(key, { ...existing, value: existing.value + entry.by, updatedAt: now });
+        }
+        else {
+            rows.set(key, {
+                gameId,
+                stat: entry.stat,
+                scope: entry.scope,
+                serverId: entry.serverId,
+                userId: entry.userId,
+                value: entry.by,
+                updatedAt: now,
+            });
+        }
+    }
+}
+export function topLeaderboardRows(rows, args) {
+    const limit = clampLimit(args.limit, LEADERBOARD_TOP_LIMIT, LEADERBOARD_TOP_LIMIT);
+    return [...rows]
+        .filter((row) => row.gameId === args.gameId &&
+        row.stat === args.stat &&
+        row.scope === args.scope &&
+        (args.serverId === undefined || row.serverId === args.serverId))
+        .sort((a, b) => b.value - a.value)
+        .slice(0, limit)
+        .map((row) => ({ userId: row.userId, value: row.value }));
+}
+export function profileLeaderboardStats(rows, gameId, userId) {
+    const profile = {};
+    for (const row of rows) {
+        if (row.gameId === gameId && row.userId === userId && row.scope === "profile") {
+            profile[row.stat] = row.value;
+        }
+    }
+    return profile;
+}
 export const FEED_RING_LIMIT = 20;
 export function trimFeedEntries(entries, limit = FEED_RING_LIMIT) {
     if (entries.length <= limit)
@@ -35,7 +85,7 @@ export function shouldAutoSave(save, dirtyAt, lastSavedAt, now) {
     const anchor = lastSavedAt ?? 0;
     return now - anchor >= intervalMs;
 }
-export function toServerListing(record) {
+export function toServerListing(record, options = {}) {
     return {
         serverId: record.serverId,
         status: record.status,
@@ -44,11 +94,21 @@ export function toServerListing(record) {
         mode: record.mode,
         label: record.label,
         visibility: record.visibility,
-        joinCode: record.joinCode,
+        ...(options.includeJoinCode === true && record.joinCode !== undefined
+            ? { joinCode: record.joinCode }
+            : {}),
         tags: record.tags,
         updatedAt: record.updatedAt,
     };
 }
+export const OPEN_SERVER_LISTING_LIMIT = 20;
+export const OPEN_SERVER_LISTING_MAX = 100;
+export function toOpenServerListings(listings, limit = OPEN_SERVER_LISTING_LIMIT) {
+    return [...listings]
+        .filter((listing) => listing.status === "running")
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+        .slice(0, clampLimit(limit, OPEN_SERVER_LISTING_LIMIT, OPEN_SERVER_LISTING_MAX));
+}
 export function buildHydratePlayers(server, profiles) {
     const players = {};
     for (const userId of server.memberUserIds) {
@@ -96,12 +156,16 @@ export function planServerPersist(server, snapshot, save, now) {
         }
     }
     const chunks = [];
+    const deletedChunks = [];
     if (isSaveEnabled(save) && saveScopeIncludesChunks(save.scope)) {
         for (const chunkKey of snapshot.dirty.chunks) {
             const chunk = snapshot.chunks[chunkKey];
-            if (!chunk)
-                continue;
-            chunks.push({ serverId: server.serverId, chunkKey, snapshot: chunk, updatedAt: now });
+            if (chunk) {
+                chunks.push({ serverId: server.serverId, chunkKey, snapshot: chunk, updatedAt: now });
+            }
+            else {
+                deletedChunks.push(chunkKey);
+            }
         }
     }
     return {
@@ -116,6 +180,7 @@ export function planServerPersist(server, snapshot, save, now) {
         },
         profiles,
         chunks,
+        deletedChunks,
         leaderboard,
     };
 }

package/dist/runtime/inputSnapshot.d.ts

@@ -0,0 +1,12 @@
+import type { PointerAxisState } from "../input/pointerAxis.js";
+export interface InputSnapshot {
+    /** Replaces the held-action set for this frame. Called by the shell before `onTick` each frame; does not bump `ctx.version()` or notify `ctx.subscribe` listeners — per-frame publishes would storm subscribers. */
+    publish(held: readonly string[]): void;
+    /** Replaces the normalized pointer-position state for this frame (#293). Same no-notify contract as `publish`. */
+    publishPointer(state: PointerAxisState | null): void;
+    isDown(action: string): boolean;
+    held(): readonly string[];
+    /** Pointer position over the play surface, `[-1, 1]` per axis with `+y` down, published by the shell each frame; `null` until the first pointer move. */
+    pointer(): PointerAxisState | null;
+}
+export declare function createInputSnapshot(): InputSnapshot;

package/dist/runtime/inputSnapshot.js

@@ -0,0 +1,17 @@
+export function createInputSnapshot() {
+    let heldSet = new Set();
+    let heldList = [];
+    let pointerState = null;
+    return {
+        publish(held) {
+            heldList = held;
+            heldSet = new Set(held);
+        },
+        publishPointer(state) {
+            pointerState = state;
+        },
+        isDown: (action) => heldSet.has(action),
+        held: () => heldList,
+        pointer: () => pointerState,
+    };
+}

package/dist/runtime/motionIntents.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Seam for game code to reach the motion the shell's FrameDriver
+ * otherwise owns privately (#162.4). Game code calls `impulse`,
+ * `pushHorizontal`, `setVerticalVelocity`, and/or `setY` from `onTick` or
+ * commands; the shell calls `takePending()` once per frame, before
+ * integrating gravity, to drain what accumulated. `setY` wins over physics
+ * for that frame; impulses add to the velocity the driver is about to
+ * integrate; a later `setVerticalVelocity` replaces that velocity outright.
+ * Horizontal pushes compose with the walk controller (#282.4): they add to
+ * its horizontal velocity and decay naturally as it re-blends toward input —
+ * knockback, dashes, explosion shoves without raw `setPose` offsets.
+ *
+ * Intentionally not `ctx.version()`/`ctx.subscribe` wired: these fire at
+ * most once per frame and would otherwise storm subscribers with per-frame
+ * churn (same rationale as `InputSnapshot.publish`).
+ */
+export interface MotionIntents {
+    impulse(velocityY: number): void;
+    /** Adds a horizontal velocity kick (world units/s) that the walk controller integrates and decays. */
+    pushHorizontal(velocityX: number, velocityZ: number): void;
+    setVerticalVelocity(velocityY: number): void;
+    setY(y: number): void;
+    takePending(): MotionIntentBatch | null;
+}
+export interface MotionIntentBatch {
+    impulses: readonly number[];
+    horizontalImpulses: readonly (readonly [number, number])[];
+    verticalVelocity: number | null;
+    y: number | null;
+}
+export declare function createMotionIntents(): MotionIntents;
+/** Fold a batch's horizontal pushes into a controller's velocity pair — shared by the walk and voxel drivers. */
+export declare function applyHorizontalImpulses(velocityX: number, velocityZ: number, batch: MotionIntentBatch | null): readonly [number, number];

package/dist/runtime/motionIntents.js

@@ -0,0 +1,43 @@
+export function createMotionIntents() {
+    let impulses = [];
+    let horizontalImpulses = [];
+    let verticalVelocity = null;
+    let y = null;
+    return {
+        impulse(velocityY) {
+            impulses.push(velocityY);
+        },
+        pushHorizontal(velocityX, velocityZ) {
+            horizontalImpulses.push([velocityX, velocityZ]);
+        },
+        setVerticalVelocity(velocityY) {
+            verticalVelocity = velocityY;
+        },
+        setY(nextY) {
+            y = nextY;
+        },
+        takePending() {
+            if (impulses.length === 0 && horizontalImpulses.length === 0 && verticalVelocity === null && y === null) {
+                return null;
+            }
+            const batch = { impulses, horizontalImpulses, verticalVelocity, y };
+            impulses = [];
+            horizontalImpulses = [];
+            verticalVelocity = null;
+            y = null;
+            return batch;
+        },
+    };
+}
+/** Fold a batch's horizontal pushes into a controller's velocity pair — shared by the walk and voxel drivers. */
+export function applyHorizontalImpulses(velocityX, velocityZ, batch) {
+    if (batch === null || batch.horizontalImpulses.length === 0)
+        return [velocityX, velocityZ];
+    let x = velocityX;
+    let z = velocityZ;
+    for (const [ix, iz] of batch.horizontalImpulses) {
+        x += ix;
+        z += iz;
+    }
+    return [x, z];
+}

package/dist/runtime/snapshot.d.ts

@@ -77,6 +77,7 @@ export declare function createRuntimeSnapshot(args: {
     server?: RuntimeServerRow;
     players?: Record<string, RuntimePlayerRow>;
     chunks?: Record<string, RuntimeChunkRow>;
+    revision?: number;
 }): GameRuntimeSnapshot;
 export declare function markServerDirty(snapshot: GameRuntimeSnapshot): GameRuntimeSnapshot;
 export declare function markPlayerDirty(snapshot: GameRuntimeSnapshot, userId: string): GameRuntimeSnapshot;

package/dist/runtime/snapshot.js

@@ -24,7 +24,7 @@ export function createRuntimeSnapshot(args) {
         server: args.server ?? createEmptyServerRow(),
         players: args.players ?? {},
         chunks: args.chunks ?? {},
-        revision: 0,
+        revision: args.revision ?? 0,
         dirty: {
             server: false,
             players: [],

package/dist/runtime/transport.d.ts

@@ -1,3 +1,5 @@
+import type { ChatSync } from "../multiplayer/chatContract.js";
+import type { PlayerPose } from "../multiplayer/poseSyncGate.js";
 import type { PresenceTransport } from "../multiplayer/presenceContract.js";
 export type JoinServerResult = {
     serverId: string;
@@ -58,3 +60,33 @@ export type GameBackend<TPresenceRow = unknown, TPresenceLocation = unknown, TGa
     feeds?: GameRuntimeFeeds;
     presence?: PresenceTransport<TPresenceRow, TPresenceLocation, TGameId>;
 };
+export type PresencePoseRow = {
+    userId: string;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotationY: number;
+    rotationPitch: number;
+    lastSeenAt: number;
+};
+export type PresenceSync = {
+    subscribe: (serverId: string, onChange: (rows: PresencePoseRow[]) => void) => FeedUnsubscribe;
+    syncPose: (serverId: string, pose: PlayerPose) => void;
+};
+export type LiveGameBackend<TPresenceRow = unknown, TPresenceLocation = unknown, TGameId extends string = string> = GameBackend<TPresenceRow, TPresenceLocation, TGameId> & {
+    presenceSync: PresenceSync;
+    pushFeedEntry: (args: {
+        serverId: string;
+        action: string;
+        entry: unknown;
+    }) => Promise<void>;
+    chatSyncFor?: (serverId: string) => ChatSync;
+};
+export type MultiplayerSession = {
+    gameId: string;
+    userId: string;
+    backend: LiveGameBackend;
+    feedActions: string[];
+};

package/dist/runtime/visibility.d.ts

@@ -0,0 +1,74 @@
+/** Stable identifier for a visibility-tracked object or camera. */
+export type VisibilityId = string | number;
+/** World-space point; `z` is optional for 2D adapters. */
+export interface VisibilityPoint {
+    x: number;
+    y: number;
+    z?: number;
+}
+/** Sphere bounds used for visibility/streaming distance checks. */
+export interface VisibilityBounds {
+    center: VisibilityPoint;
+    radius: number;
+}
+/** A camera's position and reach, as seen by the visibility system. */
+export interface CameraVisibilityContext {
+    id: VisibilityId;
+    position: VisibilityPoint;
+    /** Approximate visible radius in world units. Adapters may derive this from a frustum. */
+    visibleRadius: number;
+    /** Extra distance used to request assets before an object becomes visible. */
+    preloadMargin?: number;
+    /** Cameras such as editor thumbnails can opt out of influencing streaming. */
+    influencesStreaming?: boolean;
+}
+/** Per-object escape hatches that bypass or tune the default visibility policy. */
+export interface VisibilityOverrides {
+    alwaysVisible?: boolean;
+    neverUnload?: boolean;
+    cullingDisabled?: boolean;
+    streamingDisabled?: boolean;
+    minRenderDistance?: number;
+    maxRenderDistance?: number;
+    preloadMargin?: number;
+}
+/** An entity/asset tracked by `VisibilitySystem.evaluate`. */
+export interface VisibilityObject {
+    id: VisibilityId;
+    bounds: VisibilityBounds;
+    overrides?: VisibilityOverrides;
+}
+/** Baseline policy settings a `VisibilitySystem` is constructed with. */
+export interface VisibilityDefaults {
+    enabled: boolean;
+    streamingEnabled: boolean;
+    minRenderDistance: number;
+    maxRenderDistance: number;
+    preloadMargin: number;
+    unloadGraceMs: number;
+    hysteresis: number;
+}
+/** Default `VisibilityDefaults` a `VisibilitySystem` falls back to when unspecified. */
+export declare const DEFAULT_VISIBILITY_SETTINGS: Readonly<VisibilityDefaults>;
+/** Result of evaluating one object against the active cameras this tick. */
+export interface VisibilityDecision {
+    render: boolean;
+    load: boolean;
+    unload: boolean;
+    reason: "always-visible" | "culling-disabled" | "visible" | "preload" | "distance-culled" | "outside-view" | "grace-period" | "streaming-disabled";
+}
+/**
+ * Engine-level visibility and asset-residency policy.
+ *
+ * Render culling and asset streaming are intentionally separate. This class never
+ * destroys entities or throttles simulation; adapters decide how to apply results.
+ */
+export declare class VisibilitySystem {
+    #private;
+    readonly settings: VisibilityDefaults;
+    constructor(settings?: Partial<VisibilityDefaults>);
+    evaluate(object: VisibilityObject, cameras: readonly CameraVisibilityContext[], now?: number): VisibilityDecision;
+    setLoaded(id: VisibilityId, loaded: boolean, now?: number): void;
+    forget(id: VisibilityId): void;
+    clear(): void;
+}

package/dist/runtime/visibility.js

@@ -0,0 +1,127 @@
+/** Default `VisibilityDefaults` a `VisibilitySystem` falls back to when unspecified. */
+export const DEFAULT_VISIBILITY_SETTINGS = Object.freeze({
+    enabled: true,
+    streamingEnabled: true,
+    minRenderDistance: 0,
+    maxRenderDistance: Number.POSITIVE_INFINITY,
+    preloadMargin: 24,
+    unloadGraceMs: 5_000,
+    hysteresis: 8,
+});
+function squaredDistance(a, b) {
+    const dx = a.x - b.x;
+    const dy = a.y - b.y;
+    const dz = (a.z ?? 0) - (b.z ?? 0);
+    return dx * dx + dy * dy + dz * dz;
+}
+function intersectsRadius(camera, bounds, extraMargin) {
+    const radius = Math.max(0, camera.visibleRadius + extraMargin + bounds.radius);
+    return squaredDistance(camera.position, bounds.center) <= radius * radius;
+}
+/**
+ * Engine-level visibility and asset-residency policy.
+ *
+ * Render culling and asset streaming are intentionally separate. This class never
+ * destroys entities or throttles simulation; adapters decide how to apply results.
+ */
+export class VisibilitySystem {
+    settings;
+    #states = new Map();
+    constructor(settings = {}) {
+        this.settings = { ...DEFAULT_VISIBILITY_SETTINGS, ...settings };
+    }
+    evaluate(object, cameras, now = Date.now()) {
+        const overrides = object.overrides ?? {};
+        const state = this.#states.get(object.id) ?? { loaded: false, lastNeededAt: now };
+        if (overrides.alwaysVisible) {
+            this.#markNeeded(object.id, state, now);
+            return { render: true, load: true, unload: false, reason: "always-visible" };
+        }
+        if (!this.settings.enabled || overrides.cullingDisabled) {
+            this.#markNeeded(object.id, state, now);
+            return { render: true, load: true, unload: false, reason: "culling-disabled" };
+        }
+        const minDistance = Math.max(0, overrides.minRenderDistance ?? this.settings.minRenderDistance);
+        const maxDistance = Math.max(minDistance, overrides.maxRenderDistance ?? this.settings.maxRenderDistance);
+        const minDistanceSq = minDistance * minDistance;
+        const maxDistanceWithRadius = maxDistance + object.bounds.radius;
+        const maxDistanceSq = maxDistanceWithRadius * maxDistanceWithRadius;
+        let insideDistance = false;
+        let visible = false;
+        let preload = false;
+        for (const camera of cameras) {
+            const distanceSq = squaredDistance(camera.position, object.bounds.center);
+            if (distanceSq < minDistanceSq || distanceSq > maxDistanceSq)
+                continue;
+            insideDistance = true;
+            if (intersectsRadius(camera, object.bounds, this.settings.hysteresis)) {
+                visible = true;
+            }
+            if (camera.influencesStreaming !== false) {
+                const margin = overrides.preloadMargin ?? camera.preloadMargin ?? this.settings.preloadMargin;
+                if (intersectsRadius(camera, object.bounds, margin + this.settings.hysteresis)) {
+                    preload = true;
+                }
+            }
+        }
+        if (visible) {
+            this.#markNeeded(object.id, state, now);
+            return { render: true, load: true, unload: false, reason: "visible" };
+        }
+        if (overrides.streamingDisabled || !this.settings.streamingEnabled) {
+            state.loaded = true;
+            this.#states.set(object.id, state);
+            return {
+                render: false,
+                load: true,
+                unload: false,
+                reason: "streaming-disabled",
+            };
+        }
+        if (preload) {
+            this.#markNeeded(object.id, state, now);
+            return { render: false, load: true, unload: false, reason: "preload" };
+        }
+        if (overrides.neverUnload) {
+            state.loaded = true;
+            this.#states.set(object.id, state);
+            return {
+                render: false,
+                load: true,
+                unload: false,
+                reason: insideDistance ? "outside-view" : "distance-culled",
+            };
+        }
+        const graceActive = state.loaded && now - state.lastNeededAt < this.settings.unloadGraceMs;
+        if (graceActive) {
+            this.#states.set(object.id, state);
+            return { render: false, load: true, unload: false, reason: "grace-period" };
+        }
+        state.loaded = false;
+        this.#states.set(object.id, state);
+        return {
+            render: false,
+            load: false,
+            unload: true,
+            reason: insideDistance ? "outside-view" : "distance-culled",
+        };
+    }
+    setLoaded(id, loaded, now = Date.now()) {
+        const previous = this.#states.get(id);
+        this.#states.set(id, {
+            loaded,
+            lastNeededAt: loaded ? now : previous?.lastNeededAt ?? now,
+        });
+    }
+    forget(id) {
+        this.#states.delete(id);
+    }
+    clear() {
+        this.#states.clear();
+    }
+    #markNeeded(id, state, now) {
+        state.loaded = true;
+        state.lastNeededAt = now;
+        this.#states.set(id, state);
+    }
+}

package/dist/scene/colliders.d.ts

@@ -0,0 +1,44 @@
+import type { EntityPosition } from "./entityStore.js";
+export type ColliderPurpose = "physical" | "damage";
+export type ColliderShape = {
+    kind: "sphere";
+    radius: number;
+    offset?: EntityPosition;
+} | {
+    kind: "aabb";
+    halfExtents: EntityPosition;
+    offset?: EntityPosition;
+};
+export interface ColliderDef {
+    name: string;
+    purpose: ColliderPurpose;
+    shape: ColliderShape;
+    /** Defaults true for `purpose: "damage"`, false for `purpose: "physical"`. */
+    damageEligible?: boolean;
+    /** Defaults true — a blocking collider stops a ray at first impact. */
+    blocks?: boolean;
+}
+export interface EntityColliderSet {
+    /** Single physical collision body (push / obstruction). */
+    body?: ColliderDef;
+    /** Named damage hitboxes (zero or more). */
+    hitboxes?: readonly ColliderDef[];
+}
+export interface ResolvedCollider {
+    name: string;
+    purpose: ColliderPurpose;
+    shape: ColliderShape;
+    damageEligible: boolean;
+    blocks: boolean;
+}
+export declare const DEFAULT_ENTITY_HIT_RADIUS = 0.5;
+export declare const DEFAULT_OBJECT_HALF_EXTENTS: EntityPosition;
+export declare function defaultEntityColliders(): EntityColliderSet;
+export declare function defaultObjectColliders(halfExtents?: EntityPosition): EntityColliderSet;
+export declare function resolveColliders(set: EntityColliderSet | null | undefined): ResolvedCollider[];
+export declare function worldOffset(local: EntityPosition | undefined, position: EntityPosition, rotationY: number): EntityPosition;
+export declare function colliderWorldCenter(collider: ResolvedCollider, position: EntityPosition, rotationY: number): EntityPosition;
+export declare function colliderBounds(collider: ResolvedCollider, position: EntityPosition, rotationY: number): {
+    min: EntityPosition;
+    max: EntityPosition;
+};