@zendir/ui 0.2.20 → 0.3.0

package/dist/react/hooks/index.d.ts

@@ -1,21 +1,19 @@
 /**
  * @zendir/ui - React Hooks
  *
- * Hooks for integrating with Zendir SDK and space operations.
+ * Integration hooks for Zendir simulations and UI helpers.
  */
-export { useZendirSession } from './useZendirSession';
-export type { UseZendirSessionOptions, UseZendirSessionResult } from './useZendirSession';
-export { useTelemetry } from './useTelemetry';
-export type { UseTelemetryOptions, UseTelemetryResult } from './useTelemetry';
-export { useSpacecraftPosition } from './useSpacecraftPosition';
-export type { UseSpacecraftPositionOptions, UseSpacecraftPositionResult } from './useSpacecraftPosition';
+export { useZendirSession, isZendirSdkAvailable, preloadZendirSdk } from './useZendirSession';
+export type { UseZendirSessionOptions, UseZendirSessionResult, SessionInfo } from './useZendirSession';
+export { useSimulationScene } from './useSimulationScene';
+export type { CelestialBody, PositionTickDiag, SimulationSceneClient, SimulationSceneObject, StructureDiag, UseSimulationSceneOptions, UseSimulationSceneResult, } from './useSimulationScene';
+export { useGroundTrackHistory } from './useGroundTrackHistory';
+export type { UseGroundTrackHistoryOptions } from './useGroundTrackHistory';
+export { useAccessWindows, createDemoAccessPasses } from './useAccessWindows';
+export type { AccessPass, AccessWindowsState, UseAccessWindowsOptions } from './useAccessWindows';
 export { useCompactMode } from './useCompactMode';
 export type { UseCompactModeOptions, UseCompactModeResult } from './useCompactMode';
-export { useSimulationTime } from './useSimulationTime';
-export type { SimulationTimeState, UseSimulationTimeOptions } from './useSimulationTime';
 export { useSimulationPlayback } from './useSimulationPlayback';
 export type { SimulationPlaybackState, UseSimulationPlaybackOptions, UseSimulationPlaybackResult, } from './useSimulationPlayback';
-export { useAccessWindows, createDemoAccessWindows } from './useAccessWindows';
-export type { AccessWindow, AccessWindowsState, UseAccessWindowsOptions } from './useAccessWindows';
 export { useLiveSelection } from './useLiveSelection';
 export type { UseLiveSelectionOptions, UseLiveSelectionResult } from './useLiveSelection';

package/dist/react/hooks/useAccessWindows.d.ts

@@ -1,6 +1,6 @@
 import { TimerConfig } from '../astro/MissionClock';
 
-export interface AccessWindow {
+export interface AccessPass {
     /** Start time (AOS) */
     startTime: Date;
     /** End time (LOS) */
@@ -18,11 +18,11 @@ export interface AccessWindow {
 }
 export interface AccessWindowsState {
     /** Currently active pass (if any) */
-    currentPass: AccessWindow | null;
+    currentPass: AccessPass | null;
     /** Next upcoming pass */
-    nextPass: AccessWindow | null;
+    nextPass: AccessPass | null;
     /** All upcoming passes */
-    upcomingPasses: AccessWindow[];
+    upcomingPasses: AccessPass[];
     /** Whether currently in a pass */
     isInPass: boolean;
     /** Current elevation (degrees, if in pass) */
@@ -39,28 +39,24 @@ export interface AccessWindowsState {
     losTimer: TimerConfig | null;
     /** Timer config for TCA (for MissionClock) */
     tcaTimer: TimerConfig | null;
-    /** Whether connected to SDK */
-    isConnected: boolean;
-    /** Whether SDK is available */
-    isSdkAvailable: boolean;
-    /** Error message if any */
-    error: string | null;
 }
 export interface UseAccessWindowsOptions {
-    /** Spacecraft ID to track */
-    spacecraftId?: string;
-    /** Ground station ID (or 'all' for all stations) */
-    groundStationId?: string;
     /** Update interval in milliseconds (default: 1000) */
     updateInterval?: number;
-    /** Number of passes to fetch (default: 5) */
-    passCount?: number;
-    /** Manual access windows (for demo/testing) */
-    manualWindows?: AccessWindow[];
+    /**
+     * Access windows to track. Provide pre-computed passes (from your own
+     * orbital propagator, SGP4, demo data, etc.). Pass `[]` or omit to
+     * yield an empty/idle state.
+     */
+    windows?: AccessPass[];
+    /**
+     * @deprecated Use `windows`. Old alias kept for one minor for migration.
+     */
+    manualWindows?: AccessPass[];
 }
 export declare function useAccessWindows(options?: UseAccessWindowsOptions): AccessWindowsState;
 /**
  * Generate demo access windows for testing
  */
-export declare function createDemoAccessWindows(count?: number): AccessWindow[];
+export declare function createDemoAccessPasses(count?: number): AccessPass[];
 export default useAccessWindows;

package/dist/react/hooks/useGroundTrackHistory.d.ts

@@ -0,0 +1,34 @@
+import { Satellite } from '../3d/ZenSpace3DTypes';
+import { SatelliteTrack } from '../charts/GroundTrackMap';
+
+export interface UseGroundTrackHistoryOptions {
+    /**
+     * How long to retain ground-track history. Default 90 minutes (≈ one
+     * full LEO orbit). Older points fall off the front of the buffer.
+     */
+    historyMinutes?: number;
+    /**
+     * Hard cap on points per satellite. Default 600. Protects against
+     * runaway history when the upstream data source ticks faster than
+     * expected. The shorter of `historyMinutes` and `maxPoints` wins.
+     */
+    maxPoints?: number;
+    /**
+     * Optional default colour to assign to each track. The hook does not
+     * synthesise palette assignments — pass per-id via `colorBySatelliteId`
+     * if you want per-satellite colours.
+     */
+    color?: string;
+    /** Map of satellite-id → colour string. */
+    colorBySatelliteId?: Record<string, string>;
+}
+/**
+ * Build per-satellite ground-track history from a live ECI position feed.
+ *
+ * @param satellites   Live satellite array (ECI km positions). Pass
+ *                     `useSimulationScene().satellites` directly.
+ * @param options      History length and palette options.
+ * @returns            `SatelliteTrack[]` ready for `<GroundTrackMap />`.
+ */
+export declare function useGroundTrackHistory(satellites: Satellite[], options?: UseGroundTrackHistoryOptions): SatelliteTrack[];
+export default useGroundTrackHistory;

package/dist/react/hooks/useSimulationScene.d.ts

@@ -0,0 +1,141 @@
+import { GroundStation } from '../types';
+import { Satellite } from '../3d/ZenSpace3DTypes';
+
+/**
+ * Minimal client interface this hook depends on. Compatible with the
+ * `zendir-ts` `ZendirClient` surface but typed structurally so the hook
+ * can be used with any compatible client (e.g. a test fake).
+ */
+export interface SimulationSceneClient {
+    getSimulationStructure(simulationId: string, containerId?: string, opts?: {
+        signal?: AbortSignal;
+        retry?: unknown;
+    }): Promise<Record<string, unknown>>;
+    getProperties(objectId: string, properties: string | string[], containerId?: string, opts?: {
+        signal?: AbortSignal;
+        retry?: unknown;
+    }): Promise<unknown>;
+    getAllProperties(objectId: string, containerId?: string, opts?: {
+        signal?: AbortSignal;
+        retry?: unknown;
+    }): Promise<Record<string, unknown>>;
+}
+export interface UseSimulationSceneOptions {
+    /** ZendirClient (or any compatible client). Pass `null` to defer. */
+    client: SimulationSceneClient | null;
+    /** Container ID hosting the simulation. */
+    containerId: string;
+    /** Simulation ID to introspect. */
+    simulationId: string;
+    /** Polling interval in ms for spacecraft positions. Default: 2000. */
+    pollIntervalMs?: number;
+    /** Pause polling without unmounting. Default: true. */
+    enabled?: boolean;
+}
+export interface SimulationSceneObject {
+    id: string;
+    name: string;
+    kind: 'spacecraft' | 'groundStation' | 'celestialBody';
+}
+/**
+ * Lightweight diagnostic snapshot of the raw `getSimulationStructure`
+ * response — useful for debugging parsing mismatches in the UI without
+ * shipping the full raw blob.
+ */
+export interface StructureDiag {
+    /** Every top-level key the engine returned (e.g. "Objects","objects","Time"). */
+    topLevelKeys: string[];
+    /** Length of the `Objects` / `objects` array in the raw response (-1 if absent). */
+    rawObjectCount: number;
+    /** Length of the `Systems` / `systems` array in the raw response (-1 if absent). */
+    rawSystemCount: number;
+}
+/**
+ * Per-tick diagnostic — answers "did the position fetch succeed and what came back?".
+ * Surfaced in the debug UI so a failed-but-silent tick (parser miss, engine
+ * returning a different property name, all-zero positions, etc.) is visible.
+ */
+export interface PositionTickDiag {
+    /** Wall-clock instant of the most recent tick attempt. */
+    attemptedAt: Date;
+    /** Number of spacecraft IDs the tick requested positions for. */
+    requested: number;
+    /** Number of position responses that parsed successfully. */
+    parsedOk: number;
+    /** Number of position responses that arrived but couldn't be parsed. */
+    parseFailed: number;
+    /** Number of position responses rejected by the SDK (network / 4xx / 5xx). */
+    requestFailed: number;
+    /**
+     * The exact property names this tick asked the engine for. `null` means
+     * the schema probe failed and the tick fell back to `getAllProperties`.
+     * Surfaced so the debug UI can show which schema variant is in use.
+     */
+    requestedProps: string[] | null;
+    /** All keys present on the first satellite's response (helps spot wrong property names). */
+    firstResponseKeys: string[];
+    /** Compact JSON of the first satellite's raw response (capped to 200 chars). */
+    firstResponseSample: string;
+}
+export interface UseSimulationSceneResult {
+    /** Spacecraft with live ECI position/velocity (km, km/s). */
+    satellites: Satellite[];
+    /** Static ground stations (lat/lon). */
+    groundStations: GroundStation[];
+    /**
+     * Celestial bodies (planets, moons, sun) with live ECI positions in km.
+     * The simulation's central body is filtered out — Cesium renders it
+     * natively as the focal globe. Pass directly to
+     * `<ZenSpace3D customObjects={scene.celestialBodies} />`.
+     */
+    celestialBodies: CelestialBody[];
+    /** Objects discovered from `getSimulationStructure` (for diagnostics/UI lists). */
+    objects: SimulationSceneObject[];
+    /** True until the first structure fetch resolves. */
+    isLoading: boolean;
+    /**
+     * Set when the structure-fetch fails (polling stops). Per-tick
+     * polling errors do NOT surface here — they retry silently to keep
+     * the UI from flapping during transient network blips.
+     */
+    error: string | null;
+    /** Re-run structure fetch and a position tick. */
+    refresh: () => Promise<void>;
+    /**
+     * UTC `Date` representing wall-clock at the most recent successful
+     * tick. Pass straight into `<ZenSpace3D referenceTime={...} />` so
+     * ECI/J2000 positions rotate to ECEF at "now".
+     */
+    referenceDate: Date;
+    /**
+     * Diagnostic snapshot of the raw structure response — null until the
+     * first fetch resolves. Use in debug panels to verify key casing and
+     * array lengths returned by the engine.
+     */
+    structureDiag: StructureDiag | null;
+    /**
+     * Diagnostic for the most recent position-polling tick — null until
+     * the first tick has run. Use in debug panels to verify that
+     * `getProperties` is actually returning parsable position vectors.
+     */
+    positionTickDiag: PositionTickDiag | null;
+}
+export declare function useSimulationScene(options: UseSimulationSceneOptions): UseSimulationSceneResult;
+export default useSimulationScene;
+/**
+ * Celestial body with the position polled from the engine's `Position`
+ * property (in km, ECI), suitable to feed straight into
+ * `<ZenSpace3D customObjects={...} />`. The simulation's central body
+ * (e.g. Earth in Earth-centric sims) is filtered out — Cesium renders
+ * the focal globe natively, so emitting it as a marker would collide.
+ */
+export interface CelestialBody {
+    id: string;
+    name: string;
+    /** ECI position in km. */
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}

package/dist/react/hooks/useSimulationScene.js

@@ -0,0 +1,401 @@
+import { useState, useRef, useCallback, useEffect } from "react";
+const PLACEHOLDER_SCENECRAFT_POSITION = { x: 6771, y: 0, z: 0 };
+const TICK_RETRY = {
+  maxRetries: 2,
+  initialDelayMs: 500,
+  maxDelayMs: 1500
+};
+const DEFAULT_POLL_MS = 2e3;
+const M_TO_KM = 1 / 1e3;
+function useSimulationScene(options) {
+  const {
+    client,
+    containerId,
+    simulationId,
+    pollIntervalMs = DEFAULT_POLL_MS,
+    enabled = true
+  } = options;
+  const [satellites, setSatellites] = useState([]);
+  const [groundStations, setGroundStations] = useState([]);
+  const [celestialBodies, setCelestialBodies] = useState([]);
+  const [objects, setObjects] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [referenceDate, setReferenceDate] = useState(() => /* @__PURE__ */ new Date());
+  const [structureDiag, setStructureDiag] = useState(null);
+  const [positionTickDiag, setPositionTickDiag] = useState(null);
+  const spacecraftIdsRef = useRef([]);
+  const celestialBodyIdsRef = useRef([]);
+  const celestialBodyNamesRef = useRef([]);
+  const intervalRef = useRef(null);
+  const abortRef = useRef(null);
+  const tickInFlightRef = useRef(false);
+  const positionPropsRef = useRef(null);
+  const tickPositions = useCallback(
+    async (signal) => {
+      if (!client) return;
+      const ids = spacecraftIdsRef.current;
+      if (ids.length === 0) return;
+      if (tickInFlightRef.current) return;
+      tickInFlightRef.current = true;
+      try {
+        const propsToFetch = positionPropsRef.current;
+        const useFallbackAll = !propsToFetch || propsToFetch.length === 0;
+        const updates = await Promise.allSettled(
+          ids.map(
+            (id) => useFallbackAll ? (
+              // `retry: TICK_RETRY` overrides the SDK's engineWarmup default
+              // for this one call. See the TICK_RETRY definition above for
+              // the rationale (avoid a stuck tick stalling the viewer).
+              client.getAllProperties(id, containerId, { signal, retry: TICK_RETRY })
+            ) : client.getProperties(id, propsToFetch, containerId, {
+              signal,
+              retry: TICK_RETRY
+            })
+          )
+        );
+        if (signal.aborted) return;
+        let parsedOk = 0;
+        let parseFailed = 0;
+        let requestFailed = 0;
+        let firstResponseKeys = [];
+        let firstResponseSample = "";
+        for (let i = 0; i < ids.length; i++) {
+          const result = updates[i];
+          if (result.status !== "fulfilled") {
+            requestFailed += 1;
+            continue;
+          }
+          if (i === 0) {
+            const v = result.value;
+            if (v && typeof v === "object") firstResponseKeys = Object.keys(v);
+            try {
+              const json = JSON.stringify(v);
+              firstResponseSample = json.length > 200 ? `${json.slice(0, 200)}…` : json;
+            } catch {
+              firstResponseSample = String(v);
+            }
+          }
+          if (parsePositionVelocity(result.value)) parsedOk += 1;
+          else parseFailed += 1;
+        }
+        setPositionTickDiag({
+          attemptedAt: /* @__PURE__ */ new Date(),
+          requested: ids.length,
+          parsedOk,
+          parseFailed,
+          requestFailed,
+          requestedProps: useFallbackAll ? null : propsToFetch,
+          firstResponseKeys,
+          firstResponseSample
+        });
+        setSatellites((prev) => {
+          if (prev.length === 0) return prev;
+          const next = prev.slice();
+          for (let i = 0; i < ids.length; i++) {
+            const result = updates[i];
+            if (result.status !== "fulfilled") continue;
+            const idx = next.findIndex((sc) => sc.id === ids[i]);
+            if (idx < 0) continue;
+            const parsed = parsePositionVelocity(result.value);
+            if (!parsed) continue;
+            next[idx] = { ...next[idx], position: parsed.position, velocity: parsed.velocity };
+          }
+          return next;
+        });
+        const celIds = celestialBodyIdsRef.current;
+        if (celIds.length > 0) {
+          const celResults = await Promise.allSettled(
+            celIds.map(
+              (id) => client.getProperties(id, ["Position", "IsCentralBody"], containerId, {
+                signal,
+                retry: TICK_RETRY
+              })
+            )
+          );
+          if (signal.aborted) return;
+          const next = [];
+          for (let i = 0; i < celIds.length; i++) {
+            const result = celResults[i];
+            if (result.status !== "fulfilled") continue;
+            const raw = result.value;
+            const obj = raw && typeof raw === "object" ? raw : null;
+            if (!obj) continue;
+            if (obj.IsCentralBody === true) continue;
+            const posVec = parseVec3(obj.Position);
+            if (!posVec) continue;
+            const positionKm = scaleVec(posVec, M_TO_KM);
+            const id = celIds[i];
+            const name = celestialBodyNamesRef.current[i] ?? `CelestialBody ${shortId(id)}`;
+            next.push({ id, name, position: positionKm });
+          }
+          setCelestialBodies(next);
+        }
+      } catch {
+      } finally {
+        tickInFlightRef.current = false;
+        if (!signal.aborted) {
+          setReferenceDate(/* @__PURE__ */ new Date());
+        }
+      }
+    },
+    [client, containerId]
+  );
+  const loadStructure = useCallback(
+    async (signal) => {
+      if (!client) return;
+      setIsLoading(true);
+      setError(null);
+      try {
+        const structure = await client.getSimulationStructure(simulationId, containerId, { signal });
+        if (signal.aborted) return;
+        setStructureDiag({
+          topLevelKeys: Object.keys(structure),
+          rawObjectCount: Array.isArray(structure.Objects) ? structure.Objects.length : Array.isArray(structure.objects) ? structure.objects.length : -1,
+          rawSystemCount: Array.isArray(structure.Systems) ? structure.Systems.length : Array.isArray(structure.systems) ? structure.systems.length : -1
+        });
+        const buckets = bucketStructure(structure);
+        spacecraftIdsRef.current = buckets.spacecraft.map((s) => s.id);
+        celestialBodyIdsRef.current = buckets.celestialBodyIds;
+        celestialBodyNamesRef.current = buckets.celestialBodyNames;
+        setSatellites(buckets.spacecraft);
+        setObjects(buckets.objects);
+        if (buckets.spacecraft.length > 0) {
+          try {
+            const probeId = buckets.spacecraft[0].id;
+            const all = await client.getAllProperties(probeId, containerId, { signal });
+            if (signal.aborted) return;
+            positionPropsRef.current = detectPositionPropertyNames(all);
+          } catch {
+            positionPropsRef.current = null;
+          }
+        } else {
+          positionPropsRef.current = null;
+        }
+        const stationResults = await Promise.allSettled(
+          buckets.groundStationIds.map(
+            (id) => client.getAllProperties(id, containerId, { signal })
+          )
+        );
+        if (signal.aborted) return;
+        const stations = [];
+        for (let i = 0; i < buckets.groundStationIds.length; i++) {
+          const result = stationResults[i];
+          const id = buckets.groundStationIds[i];
+          const fallbackName = buckets.groundStationNames[i] ?? shortId(id);
+          if (result.status !== "fulfilled") {
+            stations.push({ id, name: fallbackName, latitude: 0, longitude: 0 });
+            continue;
+          }
+          stations.push(toGroundStation(id, fallbackName, result.value));
+        }
+        setGroundStations(stations);
+        setIsLoading(false);
+        if (spacecraftIdsRef.current.length > 0) {
+          await tickPositions(signal);
+        }
+      } catch (err) {
+        if (signal.aborted) return;
+        setError(err instanceof Error ? err.message : "Failed to load simulation structure");
+        setIsLoading(false);
+      }
+    },
+    [client, containerId, simulationId, tickPositions]
+  );
+  useEffect(() => {
+    if (!client || !containerId || !simulationId) {
+      setIsLoading(false);
+      return;
+    }
+    const controller = new AbortController();
+    abortRef.current = controller;
+    void loadStructure(controller.signal);
+    return () => {
+      controller.abort();
+      if (abortRef.current === controller) abortRef.current = null;
+    };
+  }, [client, containerId, simulationId, loadStructure]);
+  useEffect(() => {
+    if (!enabled || !client || error) {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+      return;
+    }
+    const interval = setInterval(() => {
+      const controller = new AbortController();
+      void tickPositions(controller.signal).catch(() => void 0);
+    }, pollIntervalMs);
+    intervalRef.current = interval;
+    return () => {
+      clearInterval(interval);
+      if (intervalRef.current === interval) intervalRef.current = null;
+    };
+  }, [client, enabled, error, pollIntervalMs, tickPositions]);
+  const refresh = useCallback(async () => {
+    const controller = new AbortController();
+    await loadStructure(controller.signal);
+  }, [loadStructure]);
+  return {
+    satellites,
+    groundStations,
+    celestialBodies,
+    objects,
+    isLoading,
+    error,
+    refresh,
+    referenceDate,
+    structureDiag,
+    positionTickDiag
+  };
+}
+function firstStringField(obj, keys) {
+  for (const key of keys) {
+    const v = obj[key];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+function bucketStructure(structure) {
+  const out = {
+    spacecraft: [],
+    groundStationIds: [],
+    groundStationNames: [],
+    celestialBodyIds: [],
+    celestialBodyNames: [],
+    objects: []
+  };
+  const topObjects = pickArray(structure, ["Objects", "objects"]);
+  for (const obj of topObjects) walkObject(obj, out);
+  const topSystems = pickArray(structure, ["Systems", "systems"]);
+  for (const sys of topSystems) walkObject(sys, out);
+  return out;
+}
+function pickArray(obj, keys) {
+  for (const key of keys) {
+    const v = obj[key];
+    if (Array.isArray(v) && v.length > 0) return v;
+  }
+  for (const key of keys) {
+    const v = obj[key];
+    if (Array.isArray(v)) return v;
+  }
+  return [];
+}
+function walkObject(node, out) {
+  if (!node || typeof node !== "object") return;
+  const obj = node;
+  const id = firstStringField(obj, ["ID", "id", "Id"]);
+  const type = firstStringField(obj, ["Type", "type"]);
+  const name = firstStringField(obj, ["Name", "name"]);
+  if (id && type) {
+    if (type === "Spacecraft" || type.endsWith(".Spacecraft")) {
+      upsertObjectSummary(out, {
+        id,
+        name: name ?? `Spacecraft ${shortId(id)}`,
+        kind: "spacecraft"
+      });
+      out.spacecraft.push({
+        id,
+        name: name ?? `Spacecraft ${shortId(id)}`,
+        category: "satellite",
+        position: { ...PLACEHOLDER_SCENECRAFT_POSITION },
+        visualRadius: 50
+      });
+    } else if (type === "GroundStation" || type.endsWith(".GroundStation")) {
+      upsertObjectSummary(out, {
+        id,
+        name: name ?? `GroundStation ${shortId(id)}`,
+        kind: "groundStation"
+      });
+      out.groundStationIds.push(id);
+      out.groundStationNames.push(name);
+    } else if (type === "CelestialBody" || type.endsWith(".CelestialBody")) {
+      upsertObjectSummary(out, {
+        id,
+        name: name ?? `CelestialBody ${shortId(id)}`,
+        kind: "celestialBody"
+      });
+      out.celestialBodyIds.push(id);
+      out.celestialBodyNames.push(name);
+    }
+  }
+  const children = pickArray(obj, ["Children", "children"]);
+  for (const child of children) walkObject(child, out);
+}
+function upsertObjectSummary(out, next) {
+  const idx = out.objects.findIndex((o) => o.id === next.id);
+  if (idx >= 0) {
+    out.objects[idx] = next;
+    return;
+  }
+  out.objects.push(next);
+}
+function detectPositionPropertyNames(props) {
+  const positionCandidates = ["Position_BN_N", "Position", "r_BN_N", "r_N"];
+  for (const name of positionCandidates) {
+    if (name in props && parseVec3(props[name]) !== null) {
+      return [name];
+    }
+  }
+  return [];
+}
+function parsePositionVelocity(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const position = parseVec3(obj.Position_BN_N) ?? parseVec3(obj.Position) ?? parseVec3(obj.position);
+  if (!position) return null;
+  if (position.x === 0 && position.y === 0 && position.z === 0) return null;
+  const velocity = parseVec3(obj.Velocity_BN_N) ?? parseVec3(obj.Velocity) ?? parseVec3(obj.velocity);
+  return {
+    position: scaleVec(position, M_TO_KM),
+    velocity: velocity ? scaleVec(velocity, M_TO_KM) : void 0
+  };
+}
+function parseVec3(raw) {
+  if (Array.isArray(raw) && raw.length >= 3) {
+    const [x, y, z] = raw;
+    if (typeof x === "number" && typeof y === "number" && typeof z === "number") {
+      return { x, y, z };
+    }
+  }
+  if (raw && typeof raw === "object") {
+    const obj = raw;
+    const x = obj.X ?? obj.x;
+    const y = obj.Y ?? obj.y;
+    const z = obj.Z ?? obj.z;
+    if (typeof x === "number" && typeof y === "number" && typeof z === "number") {
+      return { x, y, z };
+    }
+  }
+  return null;
+}
+function scaleVec(v, k) {
+  return { x: v.x * k, y: v.y * k, z: v.z * k };
+}
+function toGroundStation(id, fallbackName, props) {
+  const name = firstStringField(props, ["Name"]) ?? fallbackName;
+  const latitude = pickNumber(props, ["Latitude", "latitude"]) ?? 0;
+  const longitude = pickNumber(props, ["Longitude", "longitude"]) ?? 0;
+  const elevation = pickNumber(props, ["Altitude", "altitude", "Elevation"]);
+  const minElevation = pickNumber(props, ["MinElevation", "MinimumElevation"]);
+  const station = { id, name, latitude, longitude };
+  if (elevation !== void 0) station.elevation = elevation;
+  if (minElevation !== void 0) station.minElevation = minElevation;
+  return station;
+}
+function pickNumber(obj, keys) {
+  for (const key of keys) {
+    const v = obj[key];
+    if (typeof v === "number" && Number.isFinite(v)) return v;
+  }
+  return void 0;
+}
+function shortId(id) {
+  return id.length > 8 ? id.slice(0, 8) : id;
+}
+export {
+  useSimulationScene
+};
+//# sourceMappingURL=useSimulationScene.js.map