@zephytiju/prism-geovision-embed 0.1.0

package/dist/map/MiniMap.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { boundsFor, boundsDiagonalDegrees, graticuleLines, project } from "./projection.js";
+import { heatBlobs } from "./heat.js";
+import { paintFor, withinSideIndices } from "./sideColoring.js";
+import { buildTracks, hasMotion, positionAt } from "./replay.js";
+import { cssTokenColor } from "./tokens.js";
+/**
+ * The simplified STATIC EQUIRECTANGULAR mini-map: an SVG surface over the
+ * snapshot's located entities — normal markers from the overlay layer,
+ * kernel-density blobs from each enabled heat layer, side-color mapping
+ * applied to marker fills/outlines, and (when the replay is scrubbed) the
+ * entities at their interpolated track positions with the static positions
+ * faded underneath. Display-only; pointer capture stays on the slot.
+ */
+export function MiniMap({ file, container, rail, replayFraction, replayWindow, strings, }) {
+    const items = useMemo(() => file.snapshot.entityResults?.items ?? [], [file]);
+    const located = useMemo(() => items.filter((item) => item.lat !== undefined && item.lon !== undefined), [items]);
+    const camera = file.view.camera;
+    const bounds = useMemo(() => boundsFor(located, { lat: camera.lat, lon: camera.lon }), [located, camera]);
+    const diagonal = boundsDiagonalDegrees(bounds);
+    const { rows, columns } = graticuleLines(bounds);
+    const enabled = (kind) => rail.find((layer) => layer.kind === kind && layer.enabled) ?? null;
+    const sideLayer = file.view.layers.find((layer) => layer.kind === "side-color");
+    const sidePaints = useMemo(() => {
+        if (sideLayer?.kind !== "side-color" || enabled("side-color") === null)
+            return new Map();
+        const indices = withinSideIndices(items.map((item) => ({ id: item.id, type: item.type })), sideLayer);
+        const paints = new Map();
+        items.forEach((item) => {
+            paints.set(item.id, paintFor({ type: item.type }, sideLayer, indices.get(item.id) ?? 0));
+        });
+        return paints;
+    }, [sideLayer, items, rail]);
+    const blobs = useMemo(() => {
+        const layer = enabled("heat");
+        const heatLayers = file.view.layers.filter((candidate) => candidate.kind === "heat");
+        const target = heatLayers.find((candidate) => candidate.kind === "heat" && layer !== null) ?? heatLayers[0];
+        if (layer === null || target === undefined || target.kind !== "heat")
+            return [];
+        return heatBlobs(located, target).map((blob) => ({ ...blob, intensity: layer.opacity }));
+    }, [file, located, rail]);
+    const tracks = useMemo(() => buildTracks(located, file.snapshot.timelineEvents, replayWindow), [located, file, replayWindow]);
+    const motion = hasMotion(tracks);
+    const W = 320;
+    const H = 170;
+    const toXY = (point) => {
+        const p = project(point, bounds);
+        return { x: p.x * W, y: p.y * H };
+    };
+    return (_jsxs("svg", { viewBox: `0 0 ${W} ${H}`, style: { width: "100%", height: "100%", display: "block" }, role: "img", "aria-label": strings.mapAria, "data-testid": "geovision-embed-map", children: [_jsx("rect", { x: 0, y: 0, width: W, height: H, fill: "var(--mantine-color-deep-filled, #0b0f16)" }), rows.map((row) => (_jsx("line", { x1: 0, y1: row * H, x2: W, y2: row * H, stroke: "#1c2533", strokeWidth: 0.5 }, `r${String(row)}`))), columns.map((column) => (_jsx("line", { x1: column * W, y1: 0, x2: column * W, y2: H, stroke: "#1c2533", strokeWidth: 0.5 }, `c${String(column)}`))), blobs.map((blob, index) => {
+                const { x, y } = toXY(blob);
+                const radius = 10 + blob.density * 26;
+                return (_jsx("circle", { cx: x, cy: y, r: radius, fill: cssTokenColor(container, "threat"), opacity: blob.density * blob.intensity * 0.55, "data-testid": "geovision-embed-heat-blob" }, `blob-${String(index)}`));
+            }), motion
+                ? located.map((item) => {
+                    const track = tracks.find((candidate) => candidate.entityId === item.id);
+                    if (track === undefined)
+                        return null;
+                    const { x, y } = toXY(positionAt(track, replayFraction, replayWindow));
+                    return (_jsx("circle", { cx: toXY(item).x, cy: toXY(item).y, r: 2, fill: "#4a5a70", opacity: 0.6 }, `ghost-${item.id}`));
+                })
+                : null, located.map((item) => {
+                const track = tracks.find((candidate) => candidate.entityId === item.id);
+                const position = motion && track !== undefined ? positionAt(track, replayFraction, replayWindow) : item;
+                const { x, y } = toXY(position);
+                const paint = sidePaints.get(item.id) ?? null;
+                const selected = file.workspace.selectedEntity === item.id;
+                const fill = cssTokenColor(container, paint?.fillToken ?? "marker");
+                const outline = paint?.outlineToken !== undefined && paint?.outlineToken !== null
+                    ? cssTokenColor(container, paint.outlineToken)
+                    : null;
+                return (_jsxs("g", { "data-testid": "geovision-embed-marker", "data-entity-id": item.id, "data-token": paint?.fillToken ?? "marker", children: [selected ? _jsx("circle", { cx: x, cy: y, r: 7, fill: "none", stroke: cssTokenColor(container, "accent"), strokeWidth: 1.2 }) : null, outline !== null ? (_jsx("circle", { cx: x, cy: y, r: 5.5, fill: "none", stroke: outline, strokeWidth: 1.4 })) : null, _jsx("circle", { cx: x, cy: y, r: 3.4, fill: fill }), _jsx("text", { x: x + 6, y: y + 3, fontSize: 7, fill: "#a7b4c6", fontFamily: "var(--mantine-font-family-monospace, monospace)", children: item.label })] }, item.id));
+            }), _jsx("text", { x: 6, y: H - 6, fontSize: 7, fill: "#5d6b7e", fontFamily: "var(--mantine-font-family-monospace, monospace)", children: `${bounds.minLon.toFixed(1)}° … ${bounds.maxLon.toFixed(1)}° / diag ${diagonal.toFixed(1)}°` })] }));
+}

package/dist/map/ReplayControl.d.ts

@@ -0,0 +1,20 @@
+import { type ReplayWindow } from "./replay.js";
+import type { GeovisionEmbedStrings } from "../locales/index.js";
+/**
+ * The VIDEO-LIKE replay control: play/pause + a progress scrub over the
+ * snapshot's time-windowed events. Scrob positions are derived state
+ * (display-only) — nothing is published and nothing navigates away. The
+ * play loop advances the fraction on a wall-clock interval, stopping at the
+ * live edge (fraction 1).
+ */
+export declare function ReplayControl({ fraction, playing, disabled, timeWindow, strings, onFraction, onTogglePlay, }: {
+    readonly fraction: number;
+    readonly playing: boolean;
+    /** Static frames disable the control entirely (no pointer capture). */
+    readonly disabled: boolean;
+    readonly timeWindow: ReplayWindow;
+    readonly strings: GeovisionEmbedStrings;
+    readonly onFraction: (fraction: number) => void;
+    readonly onTogglePlay: () => void;
+}): React.ReactElement;
+//# sourceMappingURL=ReplayControl.d.ts.map

package/dist/map/ReplayControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplayControl.d.ts","sourceRoot":"","sources":["../../src/map/ReplayControl.tsx"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAKjE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,UAAU,EACV,OAAO,EACP,UAAU,EACV,YAAY,GACb,EAAE;IACD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,QAAQ,CAAC,YAAY,EAAE,MAAM,IAAI,CAAC;CACnC,GAAG,KAAK,CAAC,YAAY,CA0DrB"}

package/dist/map/ReplayControl.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { replayTimeLabel } from "./replay.js";
+/** Fraction advanced per tick (~8.3s for a full sweep at 120ms ticks). */
+const PLAY_STEP = 0.014;
+/**
+ * The VIDEO-LIKE replay control: play/pause + a progress scrub over the
+ * snapshot's time-windowed events. Scrob positions are derived state
+ * (display-only) — nothing is published and nothing navigates away. The
+ * play loop advances the fraction on a wall-clock interval, stopping at the
+ * live edge (fraction 1).
+ */
+export function ReplayControl({ fraction, playing, disabled, timeWindow, strings, onFraction, onTogglePlay, }) {
+    const fractionRef = useRef(fraction);
+    fractionRef.current = fraction;
+    useEffect(() => {
+        if (!playing || disabled)
+            return;
+        const handle = window.setInterval(() => {
+            onFraction(Math.min(1, fractionRef.current + PLAY_STEP)); // parent stops at the edge
+        }, 120);
+        return () => {
+            window.clearInterval(handle);
+        };
+    }, [playing, disabled, onFraction]);
+    return (_jsxs("div", { style: { display: "flex", alignItems: "center", gap: 8, padding: "3px 8px", borderTop: "1px solid var(--mantine-color-border-filled)" }, "data-testid": "geovision-embed-replay", children: [_jsx("button", { type: "button", "data-testid": "geovision-embed-replay-toggle", "aria-label": playing ? strings.replayPause : strings.replayPlay, disabled: disabled, onClick: onTogglePlay, style: {
+                    fontSize: 10,
+                    padding: "1px 8px",
+                    cursor: disabled ? "default" : "pointer",
+                    background: "var(--mantine-color-input-filled)",
+                    color: "var(--mantine-color-text-filled)",
+                    border: "1px solid var(--mantine-color-border-filled)",
+                    borderRadius: 4,
+                }, children: playing ? "❚❚" : "▶" }), _jsx("input", { type: "range", min: 0, max: 1, step: 0.01, value: fraction, disabled: disabled, "aria-label": strings.replayScrub, "data-testid": "geovision-embed-replay-scrub", onChange: (event) => {
+                    onFraction(Number(event.target.value));
+                }, style: { flex: 1, height: 14 } }), _jsx("span", { "data-testid": "geovision-embed-replay-time", style: { fontSize: 9, fontFamily: "var(--mantine-font-family-monospace)", color: "var(--mantine-color-muted-filled)" }, children: `${strings.replayTime} ${replayTimeLabel(fraction, timeWindow)}` })] }));
+}

package/dist/map/heat.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Simplified KERNEL-DENSITY blobs for the embed's SVG mini-map (pure): each
+ * located entity splats a quadratic kernel of the layer's radius (meters →
+ * degrees via the equirectangular approximation) over its neighbours, and
+ * the accumulated density scales a blurred blob's radius/alpha. This is the
+ * compact embed variant of the globe's full heat-grid kernel
+ * (PrismGlobeViewportMicroUI src/model/heat.ts) — same selection semantics,
+ * blob output instead of an offscreen canvas texture.
+ */
+import type { GeovisionHeatLayer } from "@zephytiju/lattice-common-bundle/geovisionView";
+/** One rendered blob. */
+export interface HeatBlob {
+    readonly lat: number;
+    readonly lon: number;
+    /** Relative density 0..1 (normalized over the layer's blobs). */
+    readonly density: number;
+}
+export interface HeatSelectionFilter {
+    readonly entityKinds: readonly string[];
+    readonly tags: readonly string[];
+    readonly eventKinds: readonly string[];
+}
+/** True when the item matches the heat selection (kinds OR tags — stream types are the item `type`). */
+export declare function matchesSelection(entity: {
+    readonly type: string;
+    readonly tags?: readonly string[];
+}, filter: HeatSelectionFilter): boolean;
+/** Kernel weight of `distanceDegrees` under `radiusDegrees` (quadratic falloff). */
+export declare function kernelWeight(distanceDegrees: number, radiusDegrees: number): number;
+/**
+ * Derives the layer's blobs: every located entity matching the selection
+ * accumulates kernel weight from its matching neighbours; density is
+ * normalized to 0..1 against the strongest blob.
+ */
+export declare function heatBlobs(entities: readonly {
+    readonly id: string;
+    readonly type: string;
+    readonly lat?: number;
+    readonly lon?: number;
+}[], layer: GeovisionHeatLayer): readonly HeatBlob[];
+//# sourceMappingURL=heat.d.ts.map

package/dist/map/heat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heat.d.ts","sourceRoot":"","sources":["../../src/map/heat.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AAKzF,yBAAyB;AACzB,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED,wGAAwG;AACxG,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EACpE,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAKT;AAED,oFAAoF;AACpF,wBAAgB,YAAY,CAAC,eAAe,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAInF;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,SAAS;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,EACjH,KAAK,EAAE,kBAAkB,GACxB,SAAS,QAAQ,EAAE,CAyBrB"}

package/dist/map/heat.js

@@ -0,0 +1,54 @@
+/**
+ * Simplified KERNEL-DENSITY blobs for the embed's SVG mini-map (pure): each
+ * located entity splats a quadratic kernel of the layer's radius (meters →
+ * degrees via the equirectangular approximation) over its neighbours, and
+ * the accumulated density scales a blurred blob's radius/alpha. This is the
+ * compact embed variant of the globe's full heat-grid kernel
+ * (PrismGlobeViewportMicroUI src/model/heat.ts) — same selection semantics,
+ * blob output instead of an offscreen canvas texture.
+ */
+const KM_PER_DEGREE = 111;
+/** True when the item matches the heat selection (kinds OR tags — stream types are the item `type`). */
+export function matchesSelection(entity, filter) {
+    const byKind = filter.entityKinds.length > 0 && filter.entityKinds.includes(entity.type);
+    const entityTags = entity.tags ?? [];
+    const byTag = filter.tags.length > 0 && filter.tags.some((tag) => entityTags.includes(tag));
+    return byKind || byTag;
+}
+/** Kernel weight of `distanceDegrees` under `radiusDegrees` (quadratic falloff). */
+export function kernelWeight(distanceDegrees, radiusDegrees) {
+    if (distanceDegrees >= radiusDegrees || radiusDegrees <= 0)
+        return 0;
+    const ratio = distanceDegrees / radiusDegrees;
+    return (1 - ratio * ratio) ** 2;
+}
+/**
+ * Derives the layer's blobs: every located entity matching the selection
+ * accumulates kernel weight from its matching neighbours; density is
+ * normalized to 0..1 against the strongest blob.
+ */
+export function heatBlobs(entities, layer) {
+    const radiusDegrees = Math.max(0.02, (layer.radius / 1000) / KM_PER_DEGREE);
+    const located = entities.filter((entity) => matchesSelection(entity, layer.selection.filter) &&
+        entity.lat !== undefined &&
+        entity.lon !== undefined);
+    const scored = located.map((entity) => {
+        let weight = kernelWeight(0, radiusDegrees); // self weight
+        for (const other of located) {
+            if (other.id === entity.id)
+                continue;
+            const dLat = other.lat - entity.lat;
+            const dLon = other.lon - entity.lon;
+            weight += kernelWeight(Math.sqrt(dLat * dLat + dLon * dLon), radiusDegrees);
+        }
+        return { lat: entity.lat, lon: entity.lon, weight };
+    });
+    const max = scored.reduce((best, blob) => Math.max(best, blob.weight), 0);
+    if (max <= 0)
+        return [];
+    return scored.map((blob) => ({
+        lat: blob.lat,
+        lon: blob.lon,
+        density: blob.weight / max,
+    }));
+}

package/dist/map/projection.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Static equirectangular mini-map projection (pure math): linear lon/lat →
+ * x/y over a fit-to-content bounds derived from the snapshot's located
+ * entities (plus the saved camera as a fallback anchor). No tiles, no WebGL
+ * — the embed map is a display-only SVG surface.
+ */
+export interface GeoPoint {
+    readonly lat: number;
+    readonly lon: number;
+}
+export interface MapBounds {
+    readonly minLat: number;
+    readonly maxLat: number;
+    readonly minLon: number;
+    readonly maxLon: number;
+}
+export declare function boundsFor(points: readonly GeoPoint[], fallback: GeoPoint): MapBounds;
+/** Projects a lon/lat into the [0..1]² unit square of the bounds (clamped). */
+export declare function project(point: GeoPoint, bounds: MapBounds): {
+    readonly x: number;
+    readonly y: number;
+};
+/** Degree length of the bounds' diagonal (used to scale blob radii). */
+export declare function boundsDiagonalDegrees(bounds: MapBounds): number;
+/** Graticule line fractions for the bounds (roughly 4 lat / 4 lon lines). */
+export declare function graticuleLines(bounds: MapBounds): {
+    readonly rows: readonly number[];
+    readonly columns: readonly number[];
+};
+//# sourceMappingURL=projection.d.ts.map

package/dist/map/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../src/map/projection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAKD,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,EAAE,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAoBpF;AAED,+EAA+E;AAC/E,wBAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAG;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAMtG;AAED,wEAAwE;AACxE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAI/D;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,GAAG;IACjD,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC,CASA"}

package/dist/map/projection.js

@@ -0,0 +1,54 @@
+/**
+ * Static equirectangular mini-map projection (pure math): linear lon/lat →
+ * x/y over a fit-to-content bounds derived from the snapshot's located
+ * entities (plus the saved camera as a fallback anchor). No tiles, no WebGL
+ * — the embed map is a display-only SVG surface.
+ */
+/** Geographic padding (degrees) around the content bounds. */
+const PAD_DEGREES = 0.35;
+export function boundsFor(points, fallback) {
+    if (points.length === 0) {
+        return { minLat: fallback.lat - 1, maxLat: fallback.lat + 1, minLon: fallback.lon - 1, maxLon: fallback.lon + 1 };
+    }
+    let minLat = points[0].lat;
+    let maxLat = points[0].lat;
+    let minLon = points[0].lon;
+    let maxLon = points[0].lon;
+    for (const point of points) {
+        minLat = Math.min(minLat, point.lat);
+        maxLat = Math.max(maxLat, point.lat);
+        minLon = Math.min(minLon, point.lon);
+        maxLon = Math.max(maxLon, point.lon);
+    }
+    return {
+        minLat: minLat - PAD_DEGREES,
+        maxLat: maxLat + PAD_DEGREES,
+        minLon: minLon - PAD_DEGREES,
+        maxLon: maxLon + PAD_DEGREES,
+    };
+}
+/** Projects a lon/lat into the [0..1]² unit square of the bounds (clamped). */
+export function project(point, bounds) {
+    const lonSpan = Math.max(1e-6, bounds.maxLon - bounds.minLon);
+    const latSpan = Math.max(1e-6, bounds.maxLat - bounds.minLat);
+    const cx = (Math.min(bounds.maxLon, Math.max(bounds.minLon, point.lon)) - bounds.minLon) / lonSpan;
+    const cy = (bounds.maxLat - Math.min(bounds.maxLat, Math.max(bounds.minLat, point.lat))) / latSpan;
+    return { x: cx, y: cy };
+}
+/** Degree length of the bounds' diagonal (used to scale blob radii). */
+export function boundsDiagonalDegrees(bounds) {
+    const dLat = bounds.maxLat - bounds.minLat;
+    const dLon = bounds.maxLon - bounds.minLon;
+    return Math.sqrt(dLat * dLat + dLon * dLon);
+}
+/** Graticule line fractions for the bounds (roughly 4 lat / 4 lon lines). */
+export function graticuleLines(bounds) {
+    const rows = [];
+    const columns = [];
+    for (let i = 1; i < 5; i += 1) {
+        rows.push(i / 5);
+        columns.push(i / 5);
+    }
+    void bounds;
+    return { rows, columns };
+}

package/dist/map/replay.d.ts

@@ -0,0 +1,52 @@
+/**
+ * VIDEO-LIKE REPLAY math (pure): per-entity movement tracks derived from the
+ * snapshot's time-windowed timeline events, scrubbed by a 0..1 progress
+ * fraction across the window. Display-only — the replay sets nothing global
+ * and publishes nothing.
+ *
+ * TRACK DERIVATION (documented): the file's TimelineEventItem shape carries
+ * no coordinates, so a track's waypoints place the entity at its SNAPSHOT
+ * position plus deterministic micro-offsets (an index-scaled alternating
+ * spiral — no RNG, so every surface derives identical motion from the same
+ * file). Between adjacent waypoints the scrub position interpolates
+ * LINEARLY BY TIME; entities without events stay fixed at their snapshot
+ * position.
+ */
+import type { TimelineEventItem } from "@zephytiju/lattice-common-interfaces";
+import type { GeoPoint } from "./projection.js";
+/** One waypoint of an entity's movement track. */
+export interface ReplayWaypoint {
+    /** Elapsed ms since the window start. */
+    readonly at: number;
+    readonly lat: number;
+    readonly lon: number;
+}
+export interface ReplayTrack {
+    readonly entityId: string;
+    readonly waypoints: readonly ReplayWaypoint[];
+}
+export interface ReplayWindow {
+    readonly startMs: number;
+    readonly endMs: number;
+}
+/**
+ * Builds the movement tracks for the located entities from the window's
+ * events (events for OTHER subjects are ignored; unlocated entities get no
+ * track and stay fixed).
+ */
+export declare function buildTracks(entities: readonly {
+    readonly id: string;
+    readonly lat?: number;
+    readonly lon?: number;
+}[], events: readonly TimelineEventItem[], window: ReplayWindow): readonly ReplayTrack[];
+/**
+ * Position of a track at a scrub fraction (0..1 of the window): piecewise
+ * LINEAR interpolation between the surrounding waypoints BY TIME; clamped at
+ * both ends.
+ */
+export declare function positionAt(track: ReplayTrack, fraction: number, window: ReplayWindow): GeoPoint;
+/** True when the events give any entity a multi-waypoint track. */
+export declare function hasMotion(tracks: readonly ReplayTrack[]): boolean;
+/** UTC hh:mm label for a scrub fraction of the window. */
+export declare function replayTimeLabel(fraction: number, window: ReplayWindow): string;
+//# sourceMappingURL=replay.d.ts.map

package/dist/map/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../src/map/replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,kDAAkD;AAClD,MAAM,WAAW,cAAc;IAC7B,yCAAyC;IACzC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAC;CAC/C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AASD;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,SAAS;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,EAC1F,MAAM,EAAE,SAAS,iBAAiB,EAAE,EACpC,MAAM,EAAE,YAAY,GACnB,SAAS,WAAW,EAAE,CAsBxB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,QAAQ,CAsB/F;AAED,mEAAmE;AACnE,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,OAAO,CAEjE;AAED,0DAA0D;AAC1D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAO9E"}

package/dist/map/replay.js

@@ -0,0 +1,91 @@
+/**
+ * VIDEO-LIKE REPLAY math (pure): per-entity movement tracks derived from the
+ * snapshot's time-windowed timeline events, scrubbed by a 0..1 progress
+ * fraction across the window. Display-only — the replay sets nothing global
+ * and publishes nothing.
+ *
+ * TRACK DERIVATION (documented): the file's TimelineEventItem shape carries
+ * no coordinates, so a track's waypoints place the entity at its SNAPSHOT
+ * position plus deterministic micro-offsets (an index-scaled alternating
+ * spiral — no RNG, so every surface derives identical motion from the same
+ * file). Between adjacent waypoints the scrub position interpolates
+ * LINEARLY BY TIME; entities without events stay fixed at their snapshot
+ * position.
+ */
+/** Deterministic micro-offset (degrees) for waypoint index i (1-based steps). */
+function offsetFor(index) {
+    const magnitude = 0.045 * Math.sqrt(index);
+    const angle = index * 2.399963; // golden-angle spiral, radians
+    return { dLat: magnitude * Math.sin(angle), dLon: magnitude * Math.cos(angle) };
+}
+/**
+ * Builds the movement tracks for the located entities from the window's
+ * events (events for OTHER subjects are ignored; unlocated entities get no
+ * track and stay fixed).
+ */
+export function buildTracks(entities, events, window) {
+    const tracks = [];
+    for (const entity of entities) {
+        if (entity.lat === undefined || entity.lon === undefined)
+            continue;
+        const baseLat = entity.lat;
+        const baseLon = entity.lon;
+        const own = events
+            .filter((event) => event.subjectId === entity.id)
+            .slice()
+            .sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+        const waypoints = [
+            { at: 0, lat: baseLat, lon: baseLon }, // window start: snapshot position
+        ];
+        own.forEach((event, index) => {
+            const at = Date.parse(event.at) - window.startMs;
+            if (!Number.isFinite(at) || at <= 0)
+                return;
+            const { dLat, dLon } = offsetFor(index + 1);
+            waypoints.push({ at, lat: baseLat + dLat, lon: baseLon + dLon });
+        });
+        tracks.push({ entityId: entity.id, waypoints });
+    }
+    return tracks;
+}
+/**
+ * Position of a track at a scrub fraction (0..1 of the window): piecewise
+ * LINEAR interpolation between the surrounding waypoints BY TIME; clamped at
+ * both ends.
+ */
+export function positionAt(track, fraction, window) {
+    const clamped = Math.min(1, Math.max(0, fraction));
+    const elapsed = clamped * (window.endMs - window.startMs);
+    const points = track.waypoints;
+    const first = points[0];
+    if (points.length === 1 || elapsed <= first.at) {
+        return { lat: first.lat, lon: first.lon };
+    }
+    for (let i = 1; i < points.length; i += 1) {
+        const previous = points[i - 1];
+        const current = points[i];
+        if (elapsed <= current.at) {
+            const span = current.at - previous.at;
+            const t = span <= 0 ? 1 : (elapsed - previous.at) / span;
+            return {
+                lat: previous.lat + (current.lat - previous.lat) * t,
+                lon: previous.lon + (current.lon - previous.lon) * t,
+            };
+        }
+    }
+    const last = points[points.length - 1];
+    return { lat: last.lat, lon: last.lon };
+}
+/** True when the events give any entity a multi-waypoint track. */
+export function hasMotion(tracks) {
+    return tracks.some((track) => track.waypoints.length > 1);
+}
+/** UTC hh:mm label for a scrub fraction of the window. */
+export function replayTimeLabel(fraction, window) {
+    const clamped = Math.min(1, Math.max(0, fraction));
+    const ms = window.startMs + clamped * (window.endMs - window.startMs);
+    const date = new Date(ms);
+    const hh = String(date.getUTCHours()).padStart(2, "0");
+    const mm = String(date.getUTCMinutes()).padStart(2, "0");
+    return `${hh}:${mm}Z`;
+}

package/dist/map/sideColoring.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Side-color application for the embed's SVG mini-map (pure): the file's
+ * side-color layer paints markers per side — each party's matcher
+ * (nationality / org / tags) is evaluated against the entity dimensions the
+ * snapshot carries. The format's EntityResultItem declares only
+ * id/type/label/lat/lon, so TAG matchers apply to the item's stream `type`
+ * (the kinds≡tags convention the recorded behavior already uses for heat
+ * selections); nationality/org matchers evaluate the same-named fields when
+ * a richer snapshot carries them. Style variants: solid (base), stripe
+ * (alternate base/secondary by within-side index), accent (base fill +
+ * secondary outline).
+ */
+import type { GeovisionSideColorLayer } from "@zephytiju/lattice-common-bundle/geovisionView";
+/** Entity dimensions the matchers see (item type + optional enrichment). */
+export interface SideColorEntity {
+    readonly type: string;
+    readonly nationality?: string;
+    readonly org?: string;
+    readonly tags?: readonly string[];
+}
+/** The resolved paint of one entity under a side-color layer. */
+export interface SideColorPaint {
+    readonly sideId: string;
+    readonly baseToken: string;
+    readonly fillToken: string;
+    readonly outlineToken: string | null;
+    readonly style: "solid" | "stripe" | "accent";
+}
+/**
+ * Resolves the paint for one entity: the FIRST side whose parties match
+ * wins; unmatched entities keep the host palette (null). The within-side
+ * index drives stripe alternation across the file's entity order.
+ */
+export declare function paintFor(entity: SideColorEntity, layer: GeovisionSideColorLayer, withinSideIndex: number): SideColorPaint | null;
+/** Within-side indices for the entity list (order of first-seen members). */
+export declare function withinSideIndices(entities: readonly (SideColorEntity & {
+    readonly id: string;
+})[], layer: GeovisionSideColorLayer): ReadonlyMap<string, number>;
+//# sourceMappingURL=sideColoring.d.ts.map

package/dist/map/sideColoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sideColoring.d.ts","sourceRoot":"","sources":["../../src/map/sideColoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gDAAgD,CAAC;AAE9F,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,iEAAiE;AACjE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;CAC/C;AAkBD;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,uBAAuB,EAC9B,eAAe,EAAE,MAAM,GACtB,cAAc,GAAG,IAAI,CAkBvB;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,CAAC,eAAe,GAAG;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,EAChE,KAAK,EAAE,uBAAuB,GAC7B,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAc7B"}

package/dist/map/sideColoring.js

@@ -0,0 +1,69 @@
+/**
+ * Side-color application for the embed's SVG mini-map (pure): the file's
+ * side-color layer paints markers per side — each party's matcher
+ * (nationality / org / tags) is evaluated against the entity dimensions the
+ * snapshot carries. The format's EntityResultItem declares only
+ * id/type/label/lat/lon, so TAG matchers apply to the item's stream `type`
+ * (the kinds≡tags convention the recorded behavior already uses for heat
+ * selections); nationality/org matchers evaluate the same-named fields when
+ * a richer snapshot carries them. Style variants: solid (base), stripe
+ * (alternate base/secondary by within-side index), accent (base fill +
+ * secondary outline).
+ */
+function partyMatches(party, entity) {
+    const { nationality, org, tags } = party.match;
+    if (nationality !== undefined && entity.nationality === nationality)
+        return true;
+    if (org !== undefined && entity.org === org)
+        return true;
+    if (tags !== undefined && tags.length > 0) {
+        // Kinds≡tags: the item's stream type counts as a tag (see module header).
+        if (tags.includes(entity.type))
+            return true;
+        const entityTags = entity.tags ?? [];
+        if (tags.some((tag) => entityTags.includes(tag)))
+            return true;
+    }
+    return false;
+}
+/**
+ * Resolves the paint for one entity: the FIRST side whose parties match
+ * wins; unmatched entities keep the host palette (null). The within-side
+ * index drives stripe alternation across the file's entity order.
+ */
+export function paintFor(entity, layer, withinSideIndex) {
+    for (const side of layer.sides) {
+        const party = side.parties.find((candidate) => partyMatches(candidate, entity));
+        if (party === undefined)
+            continue;
+        const fillToken = party.style === "stripe" && withinSideIndex % 2 === 1
+            ? party.secondaryToken ?? side.baseToken
+            : side.baseToken;
+        const outlineToken = party.style === "accent" ? party.secondaryToken ?? null : null;
+        return {
+            sideId: side.id,
+            baseToken: side.baseToken,
+            fillToken,
+            outlineToken,
+            style: party.style,
+        };
+    }
+    return null;
+}
+/** Within-side indices for the entity list (order of first-seen members). */
+export function withinSideIndices(entities, layer) {
+    const counters = new Map();
+    const result = new Map();
+    for (const entity of entities) {
+        for (const side of layer.sides) {
+            const party = side.parties.find((candidate) => partyMatches(candidate, entity));
+            if (party === undefined)
+                continue;
+            const count = counters.get(side.id) ?? 0;
+            counters.set(side.id, count + 1);
+            result.set(entity.id, count);
+            break;
+        }
+    }
+    return result;
+}

package/dist/map/tokens.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Semantic-token → CSS color resolution for the SVG mini-map: marker/blob
+ * colors resolve the HOST theme's Mantine tokens (--mantine-color-<token>-filled)
+ * through the embed container's computed style — the embed ships no palette
+ * of its own. Falls back to a small neutral ramp when a token is unresolvable
+ * (e.g. a bare test container), so the map stays legible everywhere.
+ */
+/** Reads the token's color from the container's computed style (no cache — theme swaps must apply). */
+export declare function cssTokenColor(container: HTMLElement | null, token: string): string;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/map/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/map/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAWH,uGAAuG;AACvG,wBAAgB,aAAa,CAAC,SAAS,EAAE,WAAW,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAOlF"}

package/dist/map/tokens.js

@@ -0,0 +1,25 @@
+/**
+ * Semantic-token → CSS color resolution for the SVG mini-map: marker/blob
+ * colors resolve the HOST theme's Mantine tokens (--mantine-color-<token>-filled)
+ * through the embed container's computed style — the embed ships no palette
+ * of its own. Falls back to a small neutral ramp when a token is unresolvable
+ * (e.g. a bare test container), so the map stays legible everywhere.
+ */
+const FALLBACKS = {
+    threat: "#ff6b6b",
+    warn: "#ffa94d",
+    accent: "#62B3FF",
+    signal: "#c0a8ff",
+    ok: "#69db7c",
+    marker: "#8fa3bf",
+};
+/** Reads the token's color from the container's computed style (no cache — theme swaps must apply). */
+export function cssTokenColor(container, token) {
+    if (container !== null) {
+        const value = getComputedStyle(container).getPropertyValue(`--mantine-color-${token}-filled`);
+        const trimmed = value.trim();
+        if (trimmed.length > 0)
+            return trimmed;
+    }
+    return FALLBACKS[token] ?? "#8fa3bf";
+}