@jgengine/core 0.7.0 → 0.9.0

package/dist/scene/spatial.js

@@ -14,11 +14,121 @@ function forwardXZ(aim) {
     }
     return [Math.sin(aim.yaw), Math.cos(aim.yaw)];
 }
+function cellCoord(value, cellSize) {
+    return Math.floor(value / cellSize);
+}
+const CELL_KEY_OFFSET = 0x8000;
+function packCell(cx, cz) {
+    return ((cx + CELL_KEY_OFFSET) << 16) | ((cz + CELL_KEY_OFFSET) & 0xffff);
+}
+const DEFAULT_CELL_SIZE = 8;
 export function createSpatialApi(options) {
-    const { resolvePosition, candidates, occluder } = options;
+    const { resolvePosition, candidates, occluder, getVersion } = options;
+    const gridConfig = options.grid === false ? undefined : (options.grid ?? { cellSize: DEFAULT_CELL_SIZE });
+    const cellSize = gridConfig?.cellSize;
+    let gridIndex = null;
+    let gridDirty = true;
+    let lastVersion;
     function resolveTarget(target) {
         return typeof target === "string" ? resolvePosition(target) : target;
     }
+    function takeBucket(index) {
+        if (index.poolCursor < index.bucketPool.length) {
+            const bucket = index.bucketPool[index.poolCursor];
+            index.poolCursor += 1;
+            bucket.length = 0;
+            return bucket;
+        }
+        const bucket = [];
+        index.bucketPool.push(bucket);
+        index.poolCursor += 1;
+        return bucket;
+    }
+    function ensureGrid() {
+        if (cellSize === undefined)
+            return null;
+        const version = getVersion?.();
+        if (version !== undefined && version !== lastVersion) {
+            gridDirty = true;
+            lastVersion = version;
+        }
+        if (!gridDirty && gridIndex !== null)
+            return gridIndex;
+        const previous = gridIndex;
+        const cells = previous?.cells ?? new Map();
+        cells.clear();
+        const indexed = previous?.indexed ?? new Set();
+        indexed.clear();
+        const index = {
+            cells,
+            indexed,
+            bucketPool: previous?.bucketPool ?? [],
+            poolCursor: 0,
+        };
+        for (const instanceId of candidates()) {
+            const position = resolvePosition(instanceId);
+            if (position === undefined)
+                continue;
+            indexed.add(instanceId);
+            const key = packCell(cellCoord(position[0], cellSize), cellCoord(position[2], cellSize));
+            let bucket = cells.get(key);
+            if (bucket === undefined) {
+                bucket = takeBucket(index);
+                cells.set(key, bucket);
+            }
+            bucket.push(instanceId);
+        }
+        gridIndex = index;
+        gridDirty = false;
+        return index;
+    }
+    function collectNear(index, centerX, centerZ, radius, out) {
+        const size = cellSize;
+        const cxMin = cellCoord(centerX - radius, size);
+        const cxMax = cellCoord(centerX + radius, size);
+        const czMin = cellCoord(centerZ - radius, size);
+        const czMax = cellCoord(centerZ + radius, size);
+        out.length = 0;
+        const seen = collectNearSeen;
+        seen.clear();
+        for (let cz = czMin; cz <= czMax; cz += 1) {
+            for (let cx = cxMin; cx <= cxMax; cx += 1) {
+                const bucket = index.cells.get(packCell(cx, cz));
+                if (bucket === undefined)
+                    continue;
+                for (const id of bucket) {
+                    if (seen.has(id))
+                        continue;
+                    seen.add(id);
+                    out.push(id);
+                }
+            }
+        }
+    }
+    const collectNearSeen = new Set();
+    const nearScratch = [];
+    const resultScratch = [];
+    function appendUnindexed(index, out) {
+        for (const instanceId of candidates()) {
+            if (index.indexed.has(instanceId))
+                continue;
+            out.push(instanceId);
+        }
+    }
+    function filterInRadius(ids, centerId, centerPosition, radius, filter) {
+        resultScratch.length = 0;
+        for (const instanceId of ids) {
+            if (instanceId === centerId)
+                continue;
+            if (filter !== undefined && !filter(instanceId))
+                continue;
+            const position = resolvePosition(instanceId);
+            if (position !== undefined && distanceBetween(centerPosition, position) <= radius) {
+                resultScratch.push(instanceId);
+            }
+        }
+        return resultScratch.slice();
+    }
     return {
         distance(aInstanceId, bInstanceId) {
             const a = resolvePosition(aInstanceId);
@@ -32,14 +142,13 @@ export function createSpatialApi(options) {
             const centerPosition = resolveTarget(center);
             if (centerPosition === undefined)
                 return [];
-            return candidates().filter((instanceId) => {
-                if (instanceId === centerId)
-                    return false;
-                if (filter !== undefined && !filter(instanceId))
-                    return false;
-                const position = resolvePosition(instanceId);
-                return position !== undefined && distanceBetween(centerPosition, position) <= radius;
-            });
+            const index = ensureGrid();
+            if (index === null) {
+                return filterInRadius(candidates(), centerId, centerPosition, radius, filter);
+            }
+            collectNear(index, centerPosition[0], centerPosition[2], radius, nearScratch);
+            appendUnindexed(index, nearScratch);
+            return filterInRadius(nearScratch, centerId, centerPosition, radius, filter);
         },
         hasLineOfSight(fromInstanceId, toInstanceId) {
             const from = resolvePosition(fromInstanceId);
@@ -58,22 +167,36 @@ export function createSpatialApi(options) {
             if (forward === null)
                 return [];
             const minDot = Math.cos((halfAngleDeg * Math.PI) / 180);
-            return candidates().filter((instanceId) => {
+            const index = ensureGrid();
+            const ids = index === null
+                ? candidates()
+                : (collectNear(index, origin[0], origin[2], radius, nearScratch),
+                    appendUnindexed(index, nearScratch),
+                    nearScratch);
+            resultScratch.length = 0;
+            for (const instanceId of ids) {
                 if (instanceId === from)
-                    return false;
+                    continue;
                 const position = resolvePosition(instanceId);
                 if (position === undefined)
-                    return false;
+                    continue;
                 const dx = position[0] - origin[0];
                 const dz = position[2] - origin[2];
                 const planarDistance = Math.sqrt(dx * dx + dz * dz);
                 if (planarDistance > radius)
-                    return false;
-                if (planarDistance === 0)
-                    return true;
+                    continue;
+                if (planarDistance === 0) {
+                    resultScratch.push(instanceId);
+                    continue;
+                }
                 const dot = (forward[0] * dx + forward[1] * dz) / planarDistance;
-                return dot >= minDot;
-            });
+                if (dot >= minDot)
+                    resultScratch.push(instanceId);
+            }
+            return resultScratch.slice();
+        },
+        invalidate() {
+            gridDirty = true;
         },
         moveToward(instanceId, target, { speed, stopDistance = 0, dt }) {
             const current = resolvePosition(instanceId);

package/dist/sensor/concealment.d.ts

@@ -0,0 +1,21 @@
+export type ColorHex = string;
+export declare function colorDistance(a: ColorHex, b: ColorHex): number;
+export declare function concealmentScore(entityColors: readonly ColorHex[], backgroundColors: readonly ColorHex[]): number;
+export interface ConcealmentTarget {
+    id: string;
+    entityColors: readonly ColorHex[];
+    backgroundColors: readonly ColorHex[];
+}
+export interface ConcealmentSample {
+    id: string;
+    score: number;
+    concealed: boolean;
+    dwellSeconds: number;
+}
+export interface ConcealmentSensor {
+    tick(targets: readonly ConcealmentTarget[], dt: number): ConcealmentSample[];
+    reset(id?: string): void;
+}
+export declare function createConcealmentSensor(config?: {
+    threshold?: number;
+}): ConcealmentSensor;

package/dist/sensor/concealment.js

@@ -0,0 +1,63 @@
+function parseHex(hex) {
+    const match = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim());
+    if (match === null)
+        return [0, 0, 0];
+    const value = parseInt(match[1], 16);
+    return [(value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff];
+}
+function redmean(a, b) {
+    const rmean = (a[0] + b[0]) / 2;
+    const dr = a[0] - b[0];
+    const dg = a[1] - b[1];
+    const db = a[2] - b[2];
+    return Math.sqrt((2 + rmean / 256) * dr * dr + 4 * dg * dg + (2 + (255 - rmean) / 256) * db * db);
+}
+const REDMEAN_MAX = redmean([0, 0, 0], [255, 255, 255]);
+export function colorDistance(a, b) {
+    const distance = redmean(parseHex(a), parseHex(b));
+    return REDMEAN_MAX === 0 ? 0 : Math.min(1, distance / REDMEAN_MAX);
+}
+export function concealmentScore(entityColors, backgroundColors) {
+    if (entityColors.length === 0 || backgroundColors.length === 0)
+        return 0;
+    let total = 0;
+    for (const entityColor of entityColors) {
+        let nearest = Number.POSITIVE_INFINITY;
+        for (const backgroundColor of backgroundColors) {
+            const distance = colorDistance(entityColor, backgroundColor);
+            if (distance < nearest)
+                nearest = distance;
+        }
+        total += nearest;
+    }
+    return 1 - total / entityColors.length;
+}
+export function createConcealmentSensor(config) {
+    const threshold = config?.threshold ?? 0.7;
+    const dwell = new Map();
+    return {
+        tick(targets, dt) {
+            const seen = new Set();
+            const samples = [];
+            for (const target of targets) {
+                seen.add(target.id);
+                const score = concealmentScore(target.entityColors, target.backgroundColors);
+                const concealed = score >= threshold;
+                const nextDwell = concealed ? (dwell.get(target.id) ?? 0) + dt : 0;
+                dwell.set(target.id, nextDwell);
+                samples.push({ id: target.id, score, concealed, dwellSeconds: nextDwell });
+            }
+            for (const id of dwell.keys()) {
+                if (!seen.has(id))
+                    dwell.delete(id);
+            }
+            return samples;
+        },
+        reset(id) {
+            if (id === undefined)
+                dwell.clear();
+            else
+                dwell.delete(id);
+        },
+    };
+}

package/dist/sensor/freezeMonitor.d.ts

@@ -0,0 +1,17 @@
+export interface FreezeSubject {
+    id: string;
+    groundSpeed: number;
+}
+export interface FreezeViolation {
+    id: string;
+    speed: number;
+    movedSeconds: number;
+}
+export interface FreezeMonitor {
+    tick(subjects: readonly FreezeSubject[], frozenIds: ReadonlySet<string>, dt: number): FreezeViolation[];
+    reset(id?: string): void;
+}
+export declare function createFreezeMonitor(config?: {
+    toleranceSpeed?: number;
+    graceSeconds?: number;
+}): FreezeMonitor;

package/dist/sensor/freezeMonitor.js

@@ -0,0 +1,35 @@
+export function createFreezeMonitor(config) {
+    const toleranceSpeed = config?.toleranceSpeed ?? 0.05;
+    const graceSeconds = config?.graceSeconds ?? 0;
+    const moved = new Map();
+    return {
+        tick(subjects, frozenIds, dt) {
+            const seen = new Set();
+            const violations = [];
+            for (const subject of subjects) {
+                seen.add(subject.id);
+                const shouldHoldStill = frozenIds.has(subject.id) && subject.groundSpeed > toleranceSpeed;
+                if (!shouldHoldStill) {
+                    moved.delete(subject.id);
+                    continue;
+                }
+                const movedSeconds = (moved.get(subject.id) ?? 0) + dt;
+                moved.set(subject.id, movedSeconds);
+                if (movedSeconds > graceSeconds) {
+                    violations.push({ id: subject.id, speed: subject.groundSpeed, movedSeconds });
+                }
+            }
+            for (const id of moved.keys()) {
+                if (!seen.has(id))
+                    moved.delete(id);
+            }
+            return violations;
+        },
+        reset(id) {
+            if (id === undefined)
+                moved.clear();
+            else
+                moved.delete(id);
+        },
+    };
+}

package/dist/sensor/recordingBuffer.d.ts

@@ -9,10 +9,16 @@ export interface RecordingBufferOptions {
     /** Hard cap on frame count, oldest evicted first. Default unlimited. */
     maxFrames?: number;
 }
+export interface RecordingPair<T> {
+    before: RecordingFrame<T> | null;
+    after: RecordingFrame<T> | null;
+}
 export interface RecordingBuffer<T> {
     append(t: number, data: T): void;
     /** Nearest frame at or before `t`, or null if the buffer is empty or `t` precedes every frame. */
     seek(t: number): RecordingFrame<T> | null;
+    /** The frames bracketing `t` for interpolated playback: `before` is `seek(t)`, `after` is the next recorded frame (null past the end). */
+    seekPair(t: number): RecordingPair<T>;
     /** Frames with `fromT <= t <= toT`, in recorded order. */
     range(fromT: number, toT: number): RecordingFrame<T>[];
     clear(): void;

package/dist/sensor/recordingBuffer.js

@@ -45,6 +45,13 @@ export function createRecordingBuffer(options = {}) {
             const index = floorIndex(t);
             return index === -1 ? null : frames[index];
         },
+        seekPair(t) {
+            const index = floorIndex(t);
+            return {
+                before: index === -1 ? null : frames[index],
+                after: frames[index + 1] ?? null,
+            };
+        },
         range(fromT, toT) {
             return frames.filter((frame) => frame.t >= fromT && frame.t <= toT);
         },

package/dist/sensor/replayLoop.d.ts

@@ -0,0 +1,39 @@
+import type { RecordingBuffer } from "./recordingBuffer.js";
+export interface ReplayLoopOptions<T> {
+    /** Blend between the two frames straddling the seek time; omit to hold the earlier frame. */
+    interpolate?: (before: T, after: T, alpha: number) => T;
+    /** Returns `null` for this long at the start of every loop pass — a spawn-grace gap so a looping ghost blinks out instead of teleporting. Default `0`. */
+    spawnGraceSeconds?: number;
+}
+/**
+ * Replays a finished `RecordingBuffer` on a loop — modulo-time seek, frame interpolation, and
+ * spawn grace, the pieces every ghost-lap/echo feature hand-rolled (#286.4). `sample(t)` is a pure
+ * function of absolute time; `null` means "the ghost isn't on track right now".
+ */
+export interface ReplayLoop<T> {
+    duration(): number;
+    sample(t: number): T | null;
+}
+export declare function createReplayLoop<T>(buffer: RecordingBuffer<T>, options?: ReplayLoopOptions<T>): ReplayLoop<T>;
+export interface ReplayEntityDeps {
+    has(id: string): boolean;
+    spawn(id: string): void;
+    setPose(id: string, pose: {
+        position: readonly [number, number, number];
+        rotationY?: number;
+        dt?: number;
+    }): unknown;
+    despawn(id: string): unknown;
+}
+export interface RecordedPoseLike {
+    position: readonly [number, number, number];
+    rotationY?: number;
+}
+/** Linear pose blend for `ReplayLoopOptions.interpolate` — position lerp plus shortest-arc yaw. */
+export declare function interpolateRecordedPose<T extends RecordedPoseLike>(before: T, after: T, alpha: number): T;
+/**
+ * Reconcile a replayed pose against an entity store: spawns the ghost on the first non-null sample,
+ * poses it while samples flow, despawns it through grace gaps or after the recording empties.
+ * `deps` matches `ctx.scene.entity` structurally — pass `{ has: (id) => ctx.scene.entity.get(id) !== null, spawn, setPose, despawn }`.
+ */
+export declare function syncReplayEntity(deps: ReplayEntityDeps, id: string, pose: RecordedPoseLike | null, dt?: number): void;

package/dist/sensor/replayLoop.js

@@ -0,0 +1,64 @@
+export function createReplayLoop(buffer, options = {}) {
+    const grace = Math.max(0, options.spawnGraceSeconds ?? 0);
+    const interpolate = options.interpolate;
+    return {
+        duration: () => buffer.duration(),
+        sample(t) {
+            const frames = buffer.frames();
+            if (frames.length === 0)
+                return null;
+            const first = frames[0];
+            const duration = buffer.duration();
+            if (duration <= 0)
+                return first.data;
+            const local = ((t % duration) + duration) % duration;
+            if (local < grace)
+                return null;
+            const seekT = first.t + local;
+            const pair = buffer.seekPair(seekT);
+            if (pair.before === null)
+                return pair.after?.data ?? null;
+            if (pair.after === null || interpolate === undefined)
+                return pair.before.data;
+            const span = pair.after.t - pair.before.t;
+            const alpha = span <= 1e-9 ? 0 : (seekT - pair.before.t) / span;
+            return interpolate(pair.before.data, pair.after.data, alpha);
+        },
+    };
+}
+/** Linear pose blend for `ReplayLoopOptions.interpolate` — position lerp plus shortest-arc yaw. */
+export function interpolateRecordedPose(before, after, alpha) {
+    let yawDelta = (after.rotationY ?? 0) - (before.rotationY ?? 0);
+    while (yawDelta > Math.PI)
+        yawDelta -= Math.PI * 2;
+    while (yawDelta < -Math.PI)
+        yawDelta += Math.PI * 2;
+    return {
+        ...before,
+        position: [
+            before.position[0] + (after.position[0] - before.position[0]) * alpha,
+            before.position[1] + (after.position[1] - before.position[1]) * alpha,
+            before.position[2] + (after.position[2] - before.position[2]) * alpha,
+        ],
+        ...(before.rotationY === undefined ? {} : { rotationY: (before.rotationY ?? 0) + yawDelta * alpha }),
+    };
+}
+/**
+ * Reconcile a replayed pose against an entity store: spawns the ghost on the first non-null sample,
+ * poses it while samples flow, despawns it through grace gaps or after the recording empties.
+ * `deps` matches `ctx.scene.entity` structurally — pass `{ has: (id) => ctx.scene.entity.get(id) !== null, spawn, setPose, despawn }`.
+ */
+export function syncReplayEntity(deps, id, pose, dt) {
+    if (pose === null) {
+        if (deps.has(id))
+            deps.despawn(id);
+        return;
+    }
+    if (!deps.has(id))
+        deps.spawn(id);
+    deps.setPose(id, {
+        position: pose.position,
+        ...(pose.rotationY === undefined ? {} : { rotationY: pose.rotationY }),
+        ...(dt === undefined ? {} : { dt }),
+    });
+}

package/dist/sensor/visionCone.d.ts

@@ -0,0 +1,31 @@
+export type VisionPoint = readonly [number, number];
+/** Structurally matches `world/walls` `WallSegment` — pass those straight in as occluders. */
+export interface VisionWall {
+    from: VisionPoint;
+    to: VisionPoint;
+}
+export interface VisionConeConfig {
+    range: number;
+    /** Full cone opening angle in radians (matches `TelegraphShape`'s cone `angle`). */
+    angle: number;
+}
+/** 2D segment intersection on the XZ plane (collinear overlaps count) — the LoS building block `revealQuery`/`frustumSensor` never shipped (#286.5). */
+export declare function segmentsIntersect(a1: VisionPoint, a2: VisionPoint, b1: VisionPoint, b2: VisionPoint): boolean;
+/** True when no wall segment crosses the sight line. */
+export declare function hasWallLineOfSight(from: VisionPoint, to: VisionPoint, walls: readonly VisionWall[]): boolean;
+/** Angle + range test only — no occlusion. `heading` is engine yaw (radians, `atan2(dx, dz)`). */
+export declare function pointInCone(origin: VisionPoint, heading: number, config: VisionConeConfig, point: VisionPoint): boolean;
+export interface VisionTarget<TId extends string = string> {
+    id: TId;
+    at: VisionPoint;
+}
+/**
+ * The guard-sight primitive every stealth game hand-rolled: an angle+range cone on the XZ plane
+ * whose sight lines are blocked by 2D wall segments (`world/walls` segments fit structurally).
+ * Pure math — feed entity positions and heading each tick.
+ */
+export interface VisionCone {
+    canSee(origin: VisionPoint, heading: number, target: VisionPoint): boolean;
+    visibleTargets<TId extends string>(origin: VisionPoint, heading: number, targets: readonly VisionTarget<TId>[]): TId[];
+}
+export declare function createVisionCone(config: VisionConeConfig, walls?: readonly VisionWall[]): VisionCone;

package/dist/sensor/visionCone.js

@@ -0,0 +1,72 @@
+function orientation(ax, az, bx, bz, cx, cz) {
+    const value = (bz - az) * (cx - bx) - (bx - ax) * (cz - bz);
+    if (value > 1e-9)
+        return 1;
+    if (value < -1e-9)
+        return -1;
+    return 0;
+}
+function onSegment(ax, az, bx, bz, cx, cz) {
+    return (Math.min(ax, bx) - 1e-9 <= cx &&
+        cx <= Math.max(ax, bx) + 1e-9 &&
+        Math.min(az, bz) - 1e-9 <= cz &&
+        cz <= Math.max(az, bz) + 1e-9);
+}
+/** 2D segment intersection on the XZ plane (collinear overlaps count) — the LoS building block `revealQuery`/`frustumSensor` never shipped (#286.5). */
+export function segmentsIntersect(a1, a2, b1, b2) {
+    const o1 = orientation(a1[0], a1[1], a2[0], a2[1], b1[0], b1[1]);
+    const o2 = orientation(a1[0], a1[1], a2[0], a2[1], b2[0], b2[1]);
+    const o3 = orientation(b1[0], b1[1], b2[0], b2[1], a1[0], a1[1]);
+    const o4 = orientation(b1[0], b1[1], b2[0], b2[1], a2[0], a2[1]);
+    if (o1 !== o2 && o3 !== o4)
+        return true;
+    if (o1 === 0 && onSegment(a1[0], a1[1], a2[0], a2[1], b1[0], b1[1]))
+        return true;
+    if (o2 === 0 && onSegment(a1[0], a1[1], a2[0], a2[1], b2[0], b2[1]))
+        return true;
+    if (o3 === 0 && onSegment(b1[0], b1[1], b2[0], b2[1], a1[0], a1[1]))
+        return true;
+    if (o4 === 0 && onSegment(b1[0], b1[1], b2[0], b2[1], a2[0], a2[1]))
+        return true;
+    return false;
+}
+/** True when no wall segment crosses the sight line. */
+export function hasWallLineOfSight(from, to, walls) {
+    for (const wall of walls) {
+        if (segmentsIntersect(from, to, wall.from, wall.to))
+            return false;
+    }
+    return true;
+}
+/** Angle + range test only — no occlusion. `heading` is engine yaw (radians, `atan2(dx, dz)`). */
+export function pointInCone(origin, heading, config, point) {
+    const dx = point[0] - origin[0];
+    const dz = point[1] - origin[1];
+    const distance = Math.hypot(dx, dz);
+    if (distance > config.range)
+        return false;
+    if (distance < 1e-9)
+        return true;
+    let delta = Math.atan2(dx, dz) - heading;
+    while (delta > Math.PI)
+        delta -= Math.PI * 2;
+    while (delta < -Math.PI)
+        delta += Math.PI * 2;
+    return Math.abs(delta) <= config.angle / 2;
+}
+export function createVisionCone(config, walls = []) {
+    function canSee(origin, heading, target) {
+        return pointInCone(origin, heading, config, target) && hasWallLineOfSight(origin, target, walls);
+    }
+    return {
+        canSee,
+        visibleTargets(origin, heading, targets) {
+            const seen = [];
+            for (const target of targets) {
+                if (canSee(origin, heading, target.at))
+                    seen.push(target.id);
+            }
+            return seen;
+        },
+    };
+}

package/dist/session/extraction.d.ts

@@ -38,11 +38,11 @@ export interface RaidPlayerSnapshot {
     remaining: number;
 }
 export interface RaidSession {
-    beginExtract(userId: string, extractId: string, team?: string): ContestedEvent | null;
+    beginExtract(userId: string, extractId: string, position: RingPoint, team?: string): ContestedEvent | null;
     tickExtract(userId: string, dt: number, occupants?: Record<string, number>): ContestedEvent[];
     damage(userId: string, reason?: string): ContestedEvent | null;
     cancelExtract(userId: string): void;
-    resolveExtraction(userId: string, containers: readonly ContainerSnapshot[]): ExtractionResult;
+    resolveExtraction(userId: string, containers: readonly ContainerSnapshot[]): ExtractionResult | null;
     resolveDeath(userId: string, containers: readonly ContainerSnapshot[], now: number, rng?: () => number): DeathResult;
     claimDeliveries(now: number): readonly DeliveryEntry[];
     pendingDeliveries(userId?: string): readonly DeliveryEntry[];

package/dist/session/extraction.js

@@ -1,5 +1,10 @@
 import { createDeliveryQueue, insureLost, partitionOnDeath, resolveConsolation, } from "../inventory/storageTier.js";
 import { createContestedChannel, } from "./contestedChannel.js";
+function inExtractZone(point, position) {
+    const dx = position[0] - point.center[0];
+    const dz = position[1] - point.center[1];
+    return dx * dx + dz * dz <= point.radius * point.radius;
+}
 function mergeAll(containers) {
     const totals = new Map();
     for (const container of containers) {
@@ -24,12 +29,14 @@ export function createRaidSession(config) {
         return statuses.get(userId) ?? "in-raid";
     }
     return {
-        beginExtract(userId, extractId, team) {
+        beginExtract(userId, extractId, position, team) {
             const point = points.get(extractId);
             if (point === undefined)
                 return null;
             if (statusOf(userId) === "extracted" || statusOf(userId) === "dead")
                 return null;
+            if (!inExtractZone(point, position))
+                return null;
             const channel = createContestedChannel({
                 duration: point.holdSeconds,
                 interruptOnDamage: point.interruptOnDamage ?? true,
@@ -65,7 +72,11 @@ export function createRaidSession(config) {
         },
         resolveExtraction(userId, containers) {
             const attempt = attempts.get(userId);
-            const extractId = attempt?.extractId ?? "";
+            if (attempt === undefined)
+                return null;
+            if (attempt.channel.phase() !== "complete" && statusOf(userId) !== "extracted")
+                return null;
+            const extractId = attempt.extractId;
             attempts.delete(userId);
             statuses.set(userId, "extracted");
             return { userId, extractId, banked: mergeAll(containers) };

package/dist/session/roles.d.ts

@@ -0,0 +1,6 @@
+export interface RoleSpec {
+    id: string;
+    count?: number;
+    ratio?: number;
+}
+export declare function assignRoles(userIds: readonly string[], roles: readonly RoleSpec[], rng?: () => number): Record<string, string>;

package/dist/session/roles.js

@@ -0,0 +1,32 @@
+import { shuffleWithRng } from "../cards/cardPile.js";
+export function assignRoles(userIds, roles, rng = Math.random) {
+    if (roles.length === 0)
+        throw new Error("assignRoles needs at least one role");
+    const shuffled = shuffleWithRng(userIds, rng);
+    const assignment = {};
+    let index = 0;
+    const countRoles = roles.filter((role) => role.count !== undefined);
+    const ratioRoles = roles.filter((role) => role.count === undefined && role.ratio !== undefined);
+    const fillRole = roles.find((role) => role.count === undefined && role.ratio === undefined);
+    const fallbackRole = fillRole ?? roles[roles.length - 1];
+    for (const role of countRoles) {
+        const take = Math.max(0, Math.min(role.count, shuffled.length - index));
+        for (let i = 0; i < take; i += 1) {
+            assignment[shuffled[index]] = role.id;
+            index += 1;
+        }
+    }
+    for (const role of ratioRoles) {
+        const wanted = Math.round(role.ratio * shuffled.length);
+        const take = Math.max(0, Math.min(wanted, shuffled.length - index));
+        for (let i = 0; i < take; i += 1) {
+            assignment[shuffled[index]] = role.id;
+            index += 1;
+        }
+    }
+    while (index < shuffled.length) {
+        assignment[shuffled[index]] = fallbackRole.id;
+        index += 1;
+    }
+    return assignment;
+}