@jgengine/core 0.6.0 → 0.8.0

package/dist/scene/objectQuery.d.ts

@@ -0,0 +1,18 @@
+import type { EntityPosition } from "./entityStore.js";
+import type { SceneObject } from "./objectStore.js";
+export interface ObjectRaycastInput {
+    origin: EntityPosition;
+    direction: EntityPosition;
+    maxDistance: number;
+    halfExtents?: EntityPosition;
+    filter?: (object: SceneObject) => boolean;
+}
+export interface ObjectRaycastHit {
+    instanceId: string;
+    catalogId: string;
+    distance: number;
+    point: EntityPosition;
+    normal: EntityPosition;
+}
+export declare function raycastObjects(objects: readonly SceneObject[], input: ObjectRaycastInput): ObjectRaycastHit | null;
+export declare function raycastObjectsAll(objects: readonly SceneObject[], input: ObjectRaycastInput): ObjectRaycastHit[];

package/dist/scene/objectQuery.js

@@ -0,0 +1,108 @@
+const DEFAULT_HALF_EXTENTS = [0.5, 0.5, 0.5];
+function normalize(direction) {
+    const length = Math.hypot(direction[0], direction[1], direction[2]);
+    if (length === 0)
+        return [0, 0, 0];
+    return [direction[0] / length, direction[1] / length, direction[2] / length];
+}
+function intersectAabb(origin, direction, min, max, maxDistance) {
+    let tMin = 0;
+    let tMax = maxDistance;
+    let normalAxis = -1;
+    let normalSign = 0;
+    for (let axis = 0; axis < 3; axis += 1) {
+        const originAxis = origin[axis];
+        const dirAxis = direction[axis];
+        const minAxis = min[axis];
+        const maxAxis = max[axis];
+        if (Math.abs(dirAxis) < 1e-12) {
+            if (originAxis < minAxis || originAxis > maxAxis)
+                return null;
+            continue;
+        }
+        const invD = 1 / dirAxis;
+        const t1 = (minAxis - originAxis) * invD;
+        const t2 = (maxAxis - originAxis) * invD;
+        const minIsNear = t1 <= t2;
+        const tNearAxis = minIsNear ? t1 : t2;
+        const tFarAxis = minIsNear ? t2 : t1;
+        const nearFaceSign = minIsNear ? -1 : 1;
+        if (tNearAxis > tMin) {
+            tMin = tNearAxis;
+            normalAxis = axis;
+            normalSign = nearFaceSign;
+        }
+        tMax = Math.min(tMax, tFarAxis);
+        if (tMin > tMax)
+            return null;
+    }
+    if (tMin > maxDistance || tMin < 0)
+        return null;
+    const normal = normalAxis === 0
+        ? [normalSign, 0, 0]
+        : normalAxis === 1
+            ? [0, normalSign, 0]
+            : normalAxis === 2
+                ? [0, 0, normalSign]
+                : [0, 1, 0];
+    return { distance: tMin, normal };
+}
+function hitFor(object, origin, direction, halfExtents, maxDistance) {
+    const min = [
+        object.position[0] - halfExtents[0],
+        object.position[1] - halfExtents[1],
+        object.position[2] - halfExtents[2],
+    ];
+    const max = [
+        object.position[0] + halfExtents[0],
+        object.position[1] + halfExtents[1],
+        object.position[2] + halfExtents[2],
+    ];
+    const hit = intersectAabb(origin, direction, min, max, maxDistance);
+    if (hit === null)
+        return null;
+    return {
+        instanceId: object.instanceId,
+        catalogId: object.catalogId,
+        distance: hit.distance,
+        point: [
+            origin[0] + direction[0] * hit.distance,
+            origin[1] + direction[1] * hit.distance,
+            origin[2] + direction[2] * hit.distance,
+        ],
+        normal: hit.normal,
+    };
+}
+export function raycastObjects(objects, input) {
+    const direction = normalize(input.direction);
+    if (direction[0] === 0 && direction[1] === 0 && direction[2] === 0)
+        return null;
+    const halfExtents = input.halfExtents ?? DEFAULT_HALF_EXTENTS;
+    let nearest = null;
+    for (const object of objects) {
+        if (input.filter !== undefined && !input.filter(object))
+            continue;
+        const hit = hitFor(object, input.origin, direction, halfExtents, input.maxDistance);
+        if (hit === null)
+            continue;
+        if (nearest === null || hit.distance < nearest.distance)
+            nearest = hit;
+    }
+    return nearest;
+}
+export function raycastObjectsAll(objects, input) {
+    const direction = normalize(input.direction);
+    if (direction[0] === 0 && direction[1] === 0 && direction[2] === 0)
+        return [];
+    const halfExtents = input.halfExtents ?? DEFAULT_HALF_EXTENTS;
+    const hits = [];
+    for (const object of objects) {
+        if (input.filter !== undefined && !input.filter(object))
+            continue;
+        const hit = hitFor(object, input.origin, direction, halfExtents, input.maxDistance);
+        if (hit !== null)
+            hits.push(hit);
+    }
+    hits.sort((a, b) => a.distance - b.distance);
+    return hits;
+}

package/dist/scene/objectStore.d.ts

@@ -1,15 +1,22 @@
 import type { EntityPosition } from "./entityStore.js";
+export interface ObjectVisual {
+    scale?: number | readonly [number, number, number];
+    color?: string;
+    opacity?: number;
+}
 export interface SceneObject {
     instanceId: string;
     catalogId: string;
     position: EntityPosition;
     rotationY: number;
     parentSpace?: string;
+    visual?: ObjectVisual;
 }
 export interface PlaceOptions {
     instanceId?: string;
     parentSpace?: string;
     rotation?: number;
+    visual?: ObjectVisual;
 }
 export interface ObjectListFilter {
     parentSpace?: string;
@@ -19,10 +26,14 @@ export interface ObjectStore {
     remove(instanceId: string): boolean;
     move(instanceId: string, x: number, y: number, z: number): boolean;
     rotate(instanceId: string, rotationY: number): boolean;
+    setVisual(instanceId: string, visual: ObjectVisual | undefined): boolean;
     get(instanceId: string): SceneObject | null;
     list(filter?: ObjectListFilter): readonly SceneObject[];
+    at(x: number, y: number, z: number, tolerance?: number): SceneObject[];
+    inBox(min: EntityPosition, max: EntityPosition): readonly SceneObject[];
     clear(): void;
     subscribe(listener: () => void): () => void;
     snapshot(): readonly SceneObject[];
 }
 export declare function createObjectStore(): ObjectStore;
+export declare function objectVisualScale(visual: ObjectVisual | undefined): readonly [number, number, number];

package/dist/scene/objectStore.js

@@ -1,6 +1,17 @@
 import { createObservableKeyedStore } from "../store/observableKeyedStore.js";
+const CELL_SIZE = 1;
+function cellIndexOf(value) {
+    return Math.floor(value / CELL_SIZE);
+}
+function cellKey(cx, cy, cz) {
+    return `${cx}:${cy}:${cz}`;
+}
+function cellKeyOf(position) {
+    return cellKey(cellIndexOf(position[0]), cellIndexOf(position[1]), cellIndexOf(position[2]));
+}
 export function createObjectStore() {
     const store = createObservableKeyedStore();
+    const cellIndex = new Map();
     let nextCounter = 1;
     function generateId() {
         let id = `object-${nextCounter}`;
@@ -11,31 +22,58 @@ export function createObjectStore() {
         nextCounter += 1;
         return id;
     }
+    function indexAdd(instanceId, position) {
+        const key = cellKeyOf(position);
+        let bucket = cellIndex.get(key);
+        if (bucket === undefined) {
+            bucket = new Set();
+            cellIndex.set(key, bucket);
+        }
+        bucket.add(instanceId);
+    }
+    function indexRemove(instanceId, position) {
+        const key = cellKeyOf(position);
+        const bucket = cellIndex.get(key);
+        if (bucket === undefined)
+            return;
+        bucket.delete(instanceId);
+        if (bucket.size === 0)
+            cellIndex.delete(key);
+    }
     return {
         place(catalogId, x, y, z, options = {}) {
             if (options.instanceId !== undefined && store.has(options.instanceId)) {
                 throw new Error(`Scene object id "${options.instanceId}" is already placed.`);
             }
             const instanceId = options.instanceId ?? generateId();
+            const position = [x, y, z];
             store.set(instanceId, {
                 instanceId,
                 catalogId,
-                position: [x, y, z],
+                position,
                 rotationY: options.rotation ?? 0,
                 ...(options.parentSpace !== undefined ? { parentSpace: options.parentSpace } : {}),
+                ...(options.visual !== undefined ? { visual: options.visual } : {}),
             });
+            indexAdd(instanceId, position);
             return instanceId;
         },
         remove(instanceId) {
-            const existed = store.has(instanceId);
+            const current = store.get(instanceId);
+            if (!current)
+                return false;
             store.delete(instanceId);
-            return existed;
+            indexRemove(instanceId, current.position);
+            return true;
         },
         move(instanceId, x, y, z) {
             const current = store.get(instanceId);
             if (!current)
                 return false;
-            store.set(instanceId, { ...current, position: [x, y, z] });
+            const position = [x, y, z];
+            store.set(instanceId, { ...current, position });
+            indexRemove(instanceId, current.position);
+            indexAdd(instanceId, position);
             return true;
         },
         rotate(instanceId, rotationY) {
@@ -45,6 +83,20 @@ export function createObjectStore() {
             store.set(instanceId, { ...current, rotationY });
             return true;
         },
+        setVisual(instanceId, visual) {
+            const current = store.get(instanceId);
+            if (!current)
+                return false;
+            store.set(instanceId, {
+                instanceId: current.instanceId,
+                catalogId: current.catalogId,
+                position: current.position,
+                rotationY: current.rotationY,
+                ...(current.parentSpace !== undefined ? { parentSpace: current.parentSpace } : {}),
+                ...(visual !== undefined ? { visual } : {}),
+            });
+            return true;
+        },
         get(instanceId) {
             return store.get(instanceId) ?? null;
         },
@@ -54,10 +106,57 @@ export function createObjectStore() {
                 return all;
             return all.filter((object) => object.parentSpace === filter.parentSpace);
         },
+        at(x, y, z, tolerance = 0) {
+            const minCx = cellIndexOf(x - tolerance);
+            const maxCx = cellIndexOf(x + tolerance);
+            const minCy = cellIndexOf(y - tolerance);
+            const maxCy = cellIndexOf(y + tolerance);
+            const minCz = cellIndexOf(z - tolerance);
+            const maxCz = cellIndexOf(z + tolerance);
+            const results = [];
+            for (let cx = minCx; cx <= maxCx; cx += 1) {
+                for (let cy = minCy; cy <= maxCy; cy += 1) {
+                    for (let cz = minCz; cz <= maxCz; cz += 1) {
+                        const bucket = cellIndex.get(cellKey(cx, cy, cz));
+                        if (bucket === undefined)
+                            continue;
+                        for (const instanceId of bucket) {
+                            const object = store.get(instanceId);
+                            if (object === undefined)
+                                continue;
+                            const dx = object.position[0] - x;
+                            const dy = object.position[1] - y;
+                            const dz = object.position[2] - z;
+                            if (Math.hypot(dx, dy, dz) <= tolerance)
+                                results.push(object);
+                        }
+                    }
+                }
+            }
+            return results;
+        },
+        inBox(min, max) {
+            const hits = [];
+            for (const bucket of cellIndex.values()) {
+                for (const instanceId of bucket) {
+                    const object = store.get(instanceId);
+                    if (object === undefined)
+                        continue;
+                    const [x, y, z] = object.position;
+                    if (x >= min[0] && x <= max[0] &&
+                        y >= min[1] && y <= max[1] &&
+                        z >= min[2] && z <= max[2]) {
+                        hits.push(object);
+                    }
+                }
+            }
+            return hits;
+        },
         clear() {
             for (const object of store.arraySnapshot()) {
                 store.delete(object.instanceId);
             }
+            cellIndex.clear();
         },
         subscribe(listener) {
             return store.subscribe(listener);
@@ -67,3 +166,9 @@ export function createObjectStore() {
         },
     };
 }
+export function objectVisualScale(visual) {
+    const scale = visual?.scale;
+    if (scale === undefined)
+        return [1, 1, 1];
+    return typeof scale === "number" ? [scale, scale, scale] : scale;
+}

package/dist/scene/paintLayer.d.ts

@@ -0,0 +1,15 @@
+export interface PaintStroke {
+    u: number;
+    v: number;
+    radius: number;
+    color: string;
+}
+export interface PaintLayer {
+    paint(instanceId: string, stroke: PaintStroke): void;
+    strokes(instanceId: string): readonly PaintStroke[];
+    paintedIds(): readonly string[];
+    clear(instanceId?: string): void;
+    version(instanceId: string): number;
+    subscribe(listener: () => void): () => void;
+}
+export declare function createPaintLayer(): PaintLayer;

package/dist/scene/paintLayer.js

@@ -0,0 +1,53 @@
+export function createPaintLayer() {
+    const strokesByInstance = new Map();
+    const versionByInstance = new Map();
+    const listeners = new Set();
+    function bumpVersion(instanceId) {
+        versionByInstance.set(instanceId, (versionByInstance.get(instanceId) ?? 0) + 1);
+    }
+    function notify() {
+        for (const listener of listeners)
+            listener();
+    }
+    return {
+        paint(instanceId, stroke) {
+            const list = strokesByInstance.get(instanceId);
+            if (list === undefined)
+                strokesByInstance.set(instanceId, [stroke]);
+            else
+                list.push(stroke);
+            bumpVersion(instanceId);
+            notify();
+        },
+        strokes(instanceId) {
+            return strokesByInstance.get(instanceId) ?? [];
+        },
+        paintedIds() {
+            return Array.from(strokesByInstance.keys());
+        },
+        clear(instanceId) {
+            if (instanceId === undefined) {
+                if (strokesByInstance.size === 0)
+                    return;
+                for (const id of strokesByInstance.keys())
+                    bumpVersion(id);
+                strokesByInstance.clear();
+                notify();
+                return;
+            }
+            if (!strokesByInstance.delete(instanceId))
+                return;
+            bumpVersion(instanceId);
+            notify();
+        },
+        version(instanceId) {
+            return versionByInstance.get(instanceId) ?? 0;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/scene/possession.d.ts

@@ -0,0 +1,30 @@
+import type { SceneEntity } from "./entityStore.js";
+export interface PossessionSwappedEvent {
+    userId: string;
+    entityId: string;
+    previousEntityId: string;
+}
+export interface PossessionEntities {
+    get(id: string): SceneEntity | null;
+    update(id: string, patch: {
+        role?: SceneEntity["role"];
+    }): boolean;
+}
+export interface PossessionEvents {
+    emit(name: "possession.swapped", payload: PossessionSwappedEvent): void;
+}
+export interface PossessionDeps {
+    entities: PossessionEntities;
+    events?: PossessionEvents;
+}
+export interface Possession {
+    own(userId: string, entityId: string): void;
+    disown(userId: string, entityId: string): void;
+    owns(userId: string, entityId: string): boolean;
+    listOwned(userId: string): readonly string[];
+    active(userId: string): string;
+    possess(userId: string, entityId: string): {
+        reason: string;
+    } | null;
+}
+export declare function createPossession(deps: PossessionDeps): Possession;

package/dist/scene/possession.js

@@ -0,0 +1,51 @@
+export function createPossession(deps) {
+    const owned = new Map();
+    const activeByUser = new Map();
+    function ownedSet(userId) {
+        let set = owned.get(userId);
+        if (set === undefined) {
+            set = new Set([userId]);
+            owned.set(userId, set);
+        }
+        return set;
+    }
+    return {
+        own(userId, entityId) {
+            ownedSet(userId).add(entityId);
+        },
+        disown(userId, entityId) {
+            if (entityId === userId)
+                return;
+            ownedSet(userId).delete(entityId);
+            if (activeByUser.get(userId) === entityId)
+                activeByUser.delete(userId);
+        },
+        owns(userId, entityId) {
+            return ownedSet(userId).has(entityId);
+        },
+        listOwned(userId) {
+            return Array.from(ownedSet(userId));
+        },
+        active(userId) {
+            return activeByUser.get(userId) ?? userId;
+        },
+        possess(userId, entityId) {
+            if (!ownedSet(userId).has(entityId)) {
+                return { reason: `entity "${entityId}" is not owned by "${userId}"` };
+            }
+            if (deps.entities.get(entityId) === null) {
+                return { reason: `entity "${entityId}" is not spawned` };
+            }
+            const previousEntityId = activeByUser.get(userId) ?? userId;
+            if (previousEntityId === entityId)
+                return null;
+            activeByUser.set(userId, entityId);
+            if (deps.entities.get(previousEntityId) !== null) {
+                deps.entities.update(previousEntityId, { role: "npc" });
+            }
+            deps.entities.update(entityId, { role: "player" });
+            deps.events?.emit("possession.swapped", { userId, entityId, previousEntityId });
+            return null;
+        },
+    };
+}

package/dist/scene/roster.d.ts

@@ -0,0 +1,25 @@
+export interface RosterEntry {
+    id: string;
+    catalogId: string;
+    capturedAt: number;
+    equipped: boolean;
+}
+export interface RosterCaptureOptions {
+    id?: string;
+    capturedAt?: number;
+}
+export interface Roster {
+    capture(userId: string, catalogId: string, options?: RosterCaptureOptions): RosterEntry;
+    release(userId: string, entryId: string): boolean;
+    has(userId: string, entryId: string): boolean;
+    get(userId: string, entryId: string): RosterEntry | null;
+    list(userId: string): readonly RosterEntry[];
+    equippedList(userId: string): readonly RosterEntry[];
+    setEquipped(userId: string, entryId: string, equipped: boolean): RosterEntry | null;
+    snapshot(userId: string): readonly RosterEntry[];
+    hydrate(userId: string, entries: readonly RosterEntry[]): void;
+}
+export interface RosterDeps {
+    now?: () => number;
+}
+export declare function createRoster(deps?: RosterDeps): Roster;

package/dist/scene/roster.js

@@ -0,0 +1,57 @@
+export function createRoster(deps = {}) {
+    const now = deps.now ?? Date.now;
+    const rosters = new Map();
+    let counter = 0;
+    function requireEntries(userId) {
+        let entries = rosters.get(userId);
+        if (entries === undefined) {
+            entries = new Map();
+            rosters.set(userId, entries);
+        }
+        return entries;
+    }
+    return {
+        capture(userId, catalogId, options = {}) {
+            counter += 1;
+            const id = options.id ?? `roster_${counter}`;
+            const entry = {
+                id,
+                catalogId,
+                capturedAt: options.capturedAt ?? now(),
+                equipped: false,
+            };
+            requireEntries(userId).set(id, entry);
+            return entry;
+        },
+        release(userId, entryId) {
+            return rosters.get(userId)?.delete(entryId) ?? false;
+        },
+        has(userId, entryId) {
+            return rosters.get(userId)?.has(entryId) ?? false;
+        },
+        get(userId, entryId) {
+            return rosters.get(userId)?.get(entryId) ?? null;
+        },
+        list(userId) {
+            return Array.from(rosters.get(userId)?.values() ?? []);
+        },
+        equippedList(userId) {
+            return Array.from(rosters.get(userId)?.values() ?? []).filter((entry) => entry.equipped);
+        },
+        setEquipped(userId, entryId, equipped) {
+            const entries = rosters.get(userId);
+            const entry = entries?.get(entryId);
+            if (entries === undefined || entry === undefined)
+                return null;
+            const next = { ...entry, equipped };
+            entries.set(entryId, next);
+            return next;
+        },
+        snapshot(userId) {
+            return Array.from(rosters.get(userId)?.values() ?? []);
+        },
+        hydrate(userId, entries) {
+            rosters.set(userId, new Map(entries.map((entry) => [entry.id, entry])));
+        },
+    };
+}

package/dist/scene/selection.d.ts

@@ -0,0 +1,30 @@
+export interface ScreenRect {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export interface ScreenPoint {
+    id: string;
+    x: number;
+    y: number;
+}
+/** Normalize two drag corners (in any order) into a rectangle. */
+export declare function screenRect(ax: number, ay: number, bx: number, by: number): ScreenRect;
+export declare function rectContainsPoint(rect: ScreenRect, x: number, y: number): boolean;
+/** Ids of the projected candidates whose screen point falls inside the marquee. */
+export declare function selectWithinRect(candidates: readonly ScreenPoint[], rect: ScreenRect): string[];
+/** True when the drag is large enough to be a marquee rather than a click. */
+export declare function isMarquee(rect: ScreenRect, thresholdPx?: number): boolean;
+export interface SelectionSet {
+    add(id: string): void;
+    remove(id: string): void;
+    toggle(id: string): void;
+    has(id: string): boolean;
+    replace(ids: Iterable<string>): void;
+    clear(): void;
+    list(): string[];
+    size(): number;
+}
+/** An ordered, deduplicated set of selected instance ids for RTS unit-command routing. */
+export declare function createSelectionSet(initial?: Iterable<string>): SelectionSet;

package/dist/scene/selection.js

@@ -0,0 +1,38 @@
+/** Normalize two drag corners (in any order) into a rectangle. */
+export function screenRect(ax, ay, bx, by) {
+    return {
+        minX: Math.min(ax, bx),
+        minY: Math.min(ay, by),
+        maxX: Math.max(ax, bx),
+        maxY: Math.max(ay, by),
+    };
+}
+export function rectContainsPoint(rect, x, y) {
+    return x >= rect.minX && x <= rect.maxX && y >= rect.minY && y <= rect.maxY;
+}
+/** Ids of the projected candidates whose screen point falls inside the marquee. */
+export function selectWithinRect(candidates, rect) {
+    return candidates.filter((candidate) => rectContainsPoint(rect, candidate.x, candidate.y)).map((c) => c.id);
+}
+/** True when the drag is large enough to be a marquee rather than a click. */
+export function isMarquee(rect, thresholdPx = 4) {
+    return rect.maxX - rect.minX >= thresholdPx || rect.maxY - rect.minY >= thresholdPx;
+}
+/** An ordered, deduplicated set of selected instance ids for RTS unit-command routing. */
+export function createSelectionSet(initial) {
+    const ids = new Set(initial);
+    return {
+        add: (id) => void ids.add(id),
+        remove: (id) => void ids.delete(id),
+        toggle: (id) => (ids.has(id) ? ids.delete(id) : ids.add(id)),
+        has: (id) => ids.has(id),
+        replace(next) {
+            ids.clear();
+            for (const id of next)
+                ids.add(id);
+        },
+        clear: () => ids.clear(),
+        list: () => Array.from(ids),
+        size: () => ids.size,
+    };
+}

package/dist/scene/spatial.d.ts

@@ -18,10 +18,22 @@ export interface MoveTowardOptions {
     stopDistance?: number;
     dt: number;
 }
+export interface SpatialGridOptions {
+    /** Cell edge over the x/z plane; tune to ≈ the typical query radius so a query touches a handful of cells. */
+    cellSize: number;
+}
 export interface SpatialApiOptions {
     resolvePosition: (instanceId: string) => EntityPosition | undefined;
     candidates: () => string[];
     occluder?: (from: EntityPosition, to: EntityPosition) => boolean;
+    /**
+     * Opt-in broadphase acceleration for `inRadius`/`queryArc` over large candidate sets. When set,
+     * a uniform x/z cell index is built lazily from `candidates()` + `resolvePosition()` on first use
+     * and reused across calls until `invalidate()` is called — so many queries against one tick's
+     * frozen positions pay for one rebuild, not one linear scan each. Results are exactly the linear
+     * scan's results (same filtering; see `SpatialApi.invalidate` for the staleness contract).
+     */
+    grid?: SpatialGridOptions;
 }
 export interface SpatialApi {
     distance(aInstanceId: string, bInstanceId: string): number | null;
@@ -29,6 +41,15 @@ export interface SpatialApi {
     hasLineOfSight(fromInstanceId: string, toInstanceId: string): boolean;
     queryArc(options: QueryArcOptions): string[];
     moveToward(instanceId: string, target: EntityPosition | string, options: MoveTowardOptions): EntityPosition | null;
+    /**
+     * Marks the `grid` broadphase index stale so the next `inRadius`/`queryArc` call rebuilds it from
+     * `candidates()` and `resolvePosition()`. Call this after moving, spawning, or despawning a
+     * candidate; a candidate absent from the index at query time is never skipped (it falls back to
+     * an exact check), but a candidate that *moved* since the last rebuild can be missed until you
+     * invalidate — so treat "invalidate after any position change" as the contract, not an
+     * optimization. A no-op when no `grid` config was supplied. Safe to call every tick.
+     */
+    invalidate(): void;
 }
 export declare function distanceBetween(a: EntityPosition, b: EntityPosition): number;
 export declare function createSpatialApi(options: SpatialApiOptions): SpatialApi;