@zendir/ui 0.5.0 → 0.6.1

package/dist/react/3d/ZenSpace3DTypes.d.ts

@@ -1,8 +1,7 @@
 import { OrbitalElements, GroundStation } from '../types';
-
-export type ViewMode = 'solar-system' | 'earth-orbit' | 'moon' | 'mars' | 'custom';
-export type CameraMode = 'free' | 'follow' | 'orbit' | 'cinematic';
-export type ObjectCategory = 'planet' | 'moon' | 'satellite' | 'debris' | 'station' | 'asteroid' | 'comet' | 'groundStation' | 'constellation';
+export type ViewMode = "solar-system" | "earth-orbit" | "moon" | "mars" | "custom";
+export type CameraMode = "free" | "follow" | "orbit" | "cinematic";
+export type ObjectCategory = "planet" | "moon" | "satellite" | "debris" | "station" | "asteroid" | "comet" | "groundStation" | "constellation";
 export interface SpaceObject {
     /** Unique identifier */
     id: string;
@@ -26,7 +25,7 @@ export interface SpaceObject {
     metadata?: Record<string, unknown>;
 }
 export interface Satellite extends SpaceObject {
-    category: 'satellite';
+    category: "satellite";
     /** Two-Line Element set */
     tle?: TLEData;
     /** Orbital elements */
@@ -36,30 +35,30 @@ export interface Satellite extends SpaceObject {
     /** Launch date */
     launchDate?: string;
     /** Operational status */
-    status?: 'operational' | 'inactive' | 'decaying' | 'unknown';
+    status?: "operational" | "inactive" | "decaying" | "unknown";
     /** Constellation membership */
     constellation?: string;
 }
 export interface Debris extends SpaceObject {
-    category: 'debris';
+    category: "debris";
     /** Radar cross-section (m²) */
     rcs?: number;
     /** Source event (fragmentation, collision, etc.) */
     sourceEvent?: string;
     /** Estimated size category */
-    sizeCategory?: 'small' | 'medium' | 'large';
+    sizeCategory?: "small" | "medium" | "large";
 }
 export interface SpaceStation extends SpaceObject {
-    category: 'station';
+    category: "station";
     /** Station type */
-    stationType?: 'iss' | 'tiangong' | 'commercial' | 'other';
+    stationType?: "iss" | "tiangong" | "commercial" | "other";
     /** Current crew count */
     crewCount?: number;
     /** Docked vehicles */
     dockedVehicles?: string[];
 }
 export interface Asteroid extends SpaceObject {
-    category: 'asteroid';
+    category: "asteroid";
     /** Spectral type */
     spectralType?: string;
     /** Absolute magnitude */
@@ -300,9 +299,9 @@ export interface ManeuverNode {
     /** Delta-V vector (km/s) */
     deltaV: Vector3D;
     /** Maneuver type */
-    type?: 'prograde' | 'retrograde' | 'normal' | 'antinormal' | 'radial' | 'antiradial';
+    type?: "prograde" | "retrograde" | "normal" | "antinormal" | "radial" | "antiradial";
     /** Planned/executed */
-    status?: 'planned' | 'executed';
+    status?: "planned" | "executed";
 }
 export interface CloseApproachData {
     /** Time of closest approach */
@@ -324,7 +323,7 @@ export interface TimeState {
     /** Reference epoch */
     epoch?: Date;
 }
-export type ToolType = 'select' | 'measure' | 'orbit-designer' | 'coverage-analysis' | 'conjunction-warning';
+export type ToolType = "select" | "measure" | "orbit-designer" | "coverage-analysis" | "conjunction-warning";
 export interface ToolState {
     activeTool: ToolType;
     measurementPoints?: Vector3D[];
@@ -485,8 +484,8 @@ export interface ZenSpace3DProps {
         id: string;
         fromId: string;
         toId: string;
-        type: 'uplink' | 'downlink' | 'crosslink' | 'relay';
-        status: 'active' | 'idle' | 'blocked';
+        type: "uplink" | "downlink" | "crosslink" | "relay";
+        status: "active" | "idle" | "blocked";
         color?: string;
         bandwidth?: number;
         latency?: number;
@@ -533,7 +532,7 @@ export interface ZenSpace3DProps {
     /** Canvas height */
     height?: number | string;
     /** Theme override */
-    theme?: 'dark' | 'light' | 'purple-hue';
+    theme?: "dark" | "light" | "purple-hue";
     /** Event callbacks */
     callbacks?: ZenSpace3DCallbacks;
     /** Maximum objects to render (for performance) */
@@ -588,9 +587,9 @@ export interface ZenSpace3DHandle {
     /** Set camera state */
     setCameraState: (state: Partial<CameraState>) => void;
     /** Export screenshot */
-    exportImage: (format?: 'png' | 'jpeg') => string;
+    exportImage: (format?: "png" | "jpeg") => string;
     /** Export 3D scene */
-    exportScene: (format?: 'glb' | 'gltf') => Blob;
+    exportScene: (format?: "glb" | "gltf") => Blob;
     /** Get visible objects */
     getVisibleObjects: () => SpaceObject[];
     /** Find objects by query */
@@ -623,7 +622,7 @@ export interface SceneObject {
     id: string;
     mesh: unknown;
     data: SpaceObject;
-    lod: 'high' | 'medium' | 'low' | 'point';
+    lod: "high" | "medium" | "low" | "point";
     visible: boolean;
     lastUpdate: number;
 }

package/dist/react/3d/ZenSpace3DUtils.d.ts

@@ -1,5 +1,4 @@
 import { Vector3D } from './ZenSpace3DTypes';
-
 /** Earth's mean radius in km. */
 export declare const EARTH_RADIUS_KM = 6371;
 /** Degrees → radians. */

package/dist/react/3d/ZenSpace3DUtils.js

@@ -1,28 +1,41 @@
-const EARTH_RADIUS_KM = 6371;
-const DEG_TO_RAD = Math.PI / 180;
-const RAD_TO_DEG = 180 / Math.PI;
-const SCENE_EARTH_RADIUS = 3e3;
-const KM_TO_SCENE = SCENE_EARTH_RADIUS / EARTH_RADIUS_KM;
+//#region src/react/3d/ZenSpace3DUtils.ts
+/** Earth's mean radius in km. */
+var EARTH_RADIUS_KM = 6371;
+/** Degrees → radians. */
+var DEG_TO_RAD = Math.PI / 180;
+/** Radians → degrees. */
+var RAD_TO_DEG = 180 / Math.PI;
+/** Earth radius in scene units (Three.js render space). */
+var SCENE_EARTH_RADIUS = 3e3;
+/** Conversion factor: 1 km → scene units. */
+var KM_TO_SCENE = SCENE_EARTH_RADIUS / EARTH_RADIUS_KM;
+/**
+* Convert lat/lon/alt to a Cartesian point in scene space.
+*
+* Result is in *render units* (scaled by `KM_TO_SCENE`), suitable for
+* direct use in the Three.js scene graph. For ECI→ECEF on the Cesium
+* backend, use `Cesium.Transforms.computeTemeToPseudoFixedMatrix`.
+*
+* @param lat        Latitude in degrees.
+* @param lon        Longitude in degrees.
+* @param altKm      Altitude above Earth surface in km (default 0).
+* @param earthRadius Scene radius for Earth (default `SCENE_EARTH_RADIUS`).
+*/
 function latLonAltToCartesian(lat, lon, altKm = 0, earthRadius = SCENE_EARTH_RADIUS) {
-  const r = earthRadius + altKm * KM_TO_SCENE;
-  const phi = (90 - lat) * DEG_TO_RAD;
-  const theta = (lon + 180) * DEG_TO_RAD;
-  return {
-    x: -r * Math.sin(phi) * Math.cos(theta),
-    y: r * Math.cos(phi),
-    z: r * Math.sin(phi) * Math.sin(theta)
-  };
+	const r = earthRadius + altKm * KM_TO_SCENE;
+	const phi = (90 - lat) * DEG_TO_RAD;
+	const theta = (lon + 180) * DEG_TO_RAD;
+	return {
+		x: -r * Math.sin(phi) * Math.cos(theta),
+		y: r * Math.cos(phi),
+		z: r * Math.sin(phi) * Math.sin(theta)
+	};
 }
+/** Cubic ease-out curve, used by camera fly-to animations. */
 function easeOutCubic(t) {
-  return 1 - Math.pow(1 - t, 3);
+	return 1 - Math.pow(1 - t, 3);
 }
-export {
-  DEG_TO_RAD,
-  EARTH_RADIUS_KM,
-  KM_TO_SCENE,
-  RAD_TO_DEG,
-  SCENE_EARTH_RADIUS,
-  easeOutCubic,
-  latLonAltToCartesian
-};
-//# sourceMappingURL=ZenSpace3DUtils.js.map
+//#endregion
+export { DEG_TO_RAD, EARTH_RADIUS_KM, KM_TO_SCENE, RAD_TO_DEG, SCENE_EARTH_RADIUS, easeOutCubic, latLonAltToCartesian };
+
+//# sourceMappingURL=ZenSpace3DUtils.js.map

package/dist/react/3d/ZenSpace3DUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"ZenSpace3DUtils.js","sources":["../../../src/react/3d/ZenSpace3DUtils.ts"],"sourcesContent":["/**\n * @zendir/ui - ZenSpace3D rendering math\n *\n * The minimal helper set needed by the live 3D backends:\n *   • Earth + scene scaling constants used by the Three.js path\n *     (`ZenSpace3D.tsx`) and the Cesium capture source\n *     (`CesiumCaptureSource.ts`)\n *   • `latLonAltToCartesian` — lat/lon/alt → render-space Cartesian\n *   • `easeOutCubic` — camera-fly-to easing\n *\n * Higher-level orbital math (TLE/SGP4 propagation, GMST, visibility cones,\n * hex-grid coverage) was removed — those weren't consumed by either\n * backend. The Cesium backend uses Cesium's own `Transforms` for\n * ECI→ECEF, and the Three.js backend draws coverage from explicit\n * `SatelliteCoverage` props rather than computing it locally.\n */\n\nimport type { Vector3D } from './ZenSpace3DTypes';\n\n// ── Constants ─────────────────────────────────────────────────────────────────\n\n/** Earth's mean radius in km. */\nexport const EARTH_RADIUS_KM = 6371;\n\n/** Degrees → radians. */\nexport const DEG_TO_RAD = Math.PI / 180;\n\n/** Radians → degrees. */\nexport const RAD_TO_DEG = 180 / Math.PI;\n\n/** Earth radius in scene units (Three.js render space). */\nexport const SCENE_EARTH_RADIUS = 3000;\n\n/** Conversion factor: 1 km → scene units. */\nexport const KM_TO_SCENE = SCENE_EARTH_RADIUS / EARTH_RADIUS_KM;\n\n// ── Coordinate conversion ─────────────────────────────────────────────────────\n\n/**\n * Convert lat/lon/alt to a Cartesian point in scene space.\n *\n * Result is in *render units* (scaled by `KM_TO_SCENE`), suitable for\n * direct use in the Three.js scene graph. For ECI→ECEF on the Cesium\n * backend, use `Cesium.Transforms.computeTemeToPseudoFixedMatrix`.\n *\n * @param lat        Latitude in degrees.\n * @param lon        Longitude in degrees.\n * @param altKm      Altitude above Earth surface in km (default 0).\n * @param earthRadius Scene radius for Earth (default `SCENE_EARTH_RADIUS`).\n */\nexport function latLonAltToCartesian(\n  lat: number,\n  lon: number,\n  altKm: number = 0,\n  earthRadius: number = SCENE_EARTH_RADIUS,\n): Vector3D {\n  const r = earthRadius + altKm * KM_TO_SCENE;\n  const phi = (90 - lat) * DEG_TO_RAD;\n  const theta = (lon + 180) * DEG_TO_RAD;\n  return {\n    x: -r * Math.sin(phi) * Math.cos(theta),\n    y: r * Math.cos(phi),\n    z: r * Math.sin(phi) * Math.sin(theta),\n  };\n}\n\n// ── Easing ────────────────────────────────────────────────────────────────────\n\n/** Cubic ease-out curve, used by camera fly-to animations. */\nexport function easeOutCubic(t: number): number {\n  return 1 - Math.pow(1 - t, 3);\n}\n"],"names":[],"mappings":"AAsBO,MAAM,kBAAkB;AAGxB,MAAM,aAAa,KAAK,KAAK;AAG7B,MAAM,aAAa,MAAM,KAAK;AAG9B,MAAM,qBAAqB;AAG3B,MAAM,cAAc,qBAAqB;AAgBzC,SAAS,qBACd,KACA,KACA,QAAgB,GAChB,cAAsB,oBACZ;AACV,QAAM,IAAI,cAAc,QAAQ;AAChC,QAAM,OAAO,KAAK,OAAO;AACzB,QAAM,SAAS,MAAM,OAAO;AAC5B,SAAO;AAAA,IACL,GAAG,CAAC,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,IAAI,KAAK;AAAA,IACtC,GAAG,IAAI,KAAK,IAAI,GAAG;AAAA,IACnB,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,IAAI,KAAK;AAAA,EAAA;AAEzC;AAKO,SAAS,aAAa,GAAmB;AAC9C,SAAO,IAAI,KAAK,IAAI,IAAI,GAAG,CAAC;AAC9B;"}
+{"version":3,"file":"ZenSpace3DUtils.js","names":[],"sources":["../../../src/react/3d/ZenSpace3DUtils.ts"],"sourcesContent":["/**\r\n * @zendir/ui - ZenSpace3D rendering math\r\n *\r\n * The minimal helper set needed by the live 3D backends:\r\n *   • Earth + scene scaling constants used by the Three.js path\r\n *     (`ZenSpace3D.tsx`) and the Cesium capture source\r\n *     (`CesiumCaptureSource.ts`)\r\n *   • `latLonAltToCartesian` — lat/lon/alt → render-space Cartesian\r\n *   • `easeOutCubic` — camera-fly-to easing\r\n *\r\n * Higher-level orbital math (TLE/SGP4 propagation, GMST, visibility cones,\r\n * hex-grid coverage) was removed — those weren't consumed by either\r\n * backend. The Cesium backend uses Cesium's own `Transforms` for\r\n * ECI→ECEF, and the Three.js backend draws coverage from explicit\r\n * `SatelliteCoverage` props rather than computing it locally.\r\n */\r\n\r\nimport type { Vector3D } from \"./ZenSpace3DTypes\";\r\n\r\n// ── Constants ─────────────────────────────────────────────────────────────────\r\n\r\n/** Earth's mean radius in km. */\r\nexport const EARTH_RADIUS_KM = 6371;\r\n\r\n/** Degrees → radians. */\r\nexport const DEG_TO_RAD = Math.PI / 180;\r\n\r\n/** Radians → degrees. */\r\nexport const RAD_TO_DEG = 180 / Math.PI;\r\n\r\n/** Earth radius in scene units (Three.js render space). */\r\nexport const SCENE_EARTH_RADIUS = 3000;\r\n\r\n/** Conversion factor: 1 km → scene units. */\r\nexport const KM_TO_SCENE = SCENE_EARTH_RADIUS / EARTH_RADIUS_KM;\r\n\r\n// ── Coordinate conversion ─────────────────────────────────────────────────────\r\n\r\n/**\r\n * Convert lat/lon/alt to a Cartesian point in scene space.\r\n *\r\n * Result is in *render units* (scaled by `KM_TO_SCENE`), suitable for\r\n * direct use in the Three.js scene graph. For ECI→ECEF on the Cesium\r\n * backend, use `Cesium.Transforms.computeTemeToPseudoFixedMatrix`.\r\n *\r\n * @param lat        Latitude in degrees.\r\n * @param lon        Longitude in degrees.\r\n * @param altKm      Altitude above Earth surface in km (default 0).\r\n * @param earthRadius Scene radius for Earth (default `SCENE_EARTH_RADIUS`).\r\n */\r\nexport function latLonAltToCartesian(\r\n  lat: number,\r\n  lon: number,\r\n  altKm: number = 0,\r\n  earthRadius: number = SCENE_EARTH_RADIUS,\r\n): Vector3D {\r\n  const r = earthRadius + altKm * KM_TO_SCENE;\r\n  const phi = (90 - lat) * DEG_TO_RAD;\r\n  const theta = (lon + 180) * DEG_TO_RAD;\r\n  return {\r\n    x: -r * Math.sin(phi) * Math.cos(theta),\r\n    y: r * Math.cos(phi),\r\n    z: r * Math.sin(phi) * Math.sin(theta),\r\n  };\r\n}\r\n\r\n// ── Easing ────────────────────────────────────────────────────────────────────\r\n\r\n/** Cubic ease-out curve, used by camera fly-to animations. */\r\nexport function easeOutCubic(t: number): number {\r\n  return 1 - Math.pow(1 - t, 3);\r\n}\r\n"],"mappings":";;AAsBA,IAAa,kBAAkB;;AAG/B,IAAa,aAAa,KAAK,KAAK;;AAGpC,IAAa,aAAa,MAAM,KAAK;;AAGrC,IAAa,qBAAqB;;AAGlC,IAAa,cAAc,qBAAqB;;;;;;;;;;;;;AAgBhD,SAAgB,qBACd,KACA,KACA,QAAgB,GAChB,cAAsB,oBACZ;CACV,MAAM,IAAI,cAAc,QAAQ;CAChC,MAAM,OAAO,KAAK,OAAO;CACzB,MAAM,SAAS,MAAM,OAAO;CAC5B,OAAO;EACL,GAAG,CAAC,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,IAAI,KAAK;EACtC,GAAG,IAAI,KAAK,IAAI,GAAG;EACnB,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,IAAI,KAAK;CACvC;AACF;;AAKA,SAAgB,aAAa,GAAmB;CAC9C,OAAO,IAAI,KAAK,IAAI,IAAI,GAAG,CAAC;AAC9B"}

package/dist/react/3d/capturePngAnalysis.js

@@ -1,42 +1,48 @@
+//#region src/react/3d/capturePngAnalysis.ts
+/**
+* Lightweight PNG analysis for capture QA (brightness / "all black" detection).
+* Used by tests and optional runtime checks — keep dependency-free (no pngjs).
+*/
+/** ITU-R BT.709 luma from RGB */
 function rgbToLuma(r, g, b) {
-  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+	return .2126 * r + .7152 * g + .0722 * b;
 }
+/**
+* Sample mean luma of PNG bytes by drawing to a small canvas (browser / happy-dom).
+* Returns 0 if decode fails. For very large images, samples a grid (max ~4096 samples).
+*/
 async function meanLuminanceFromPngBytes(png) {
-  var _a;
-  if (typeof createImageBitmap !== "function" || typeof document === "undefined") {
-    return 0;
-  }
-  try {
-    const blob = new Blob([png], { type: "image/png" });
-    const bmp = await createImageBitmap(blob);
-    const w = bmp.width;
-    const h = bmp.height;
-    const canvas = document.createElement("canvas");
-    const step = Math.max(1, Math.floor(Math.sqrt(w * h / 4096)));
-    canvas.width = Math.ceil(w / step);
-    canvas.height = Math.ceil(h / step);
-    const ctx = canvas.getContext("2d");
-    if (!ctx) return 0;
-    ctx.drawImage(bmp, 0, 0, w, h, 0, 0, canvas.width, canvas.height);
-    const { data } = ctx.getImageData(0, 0, canvas.width, canvas.height);
-    let sum = 0;
-    const n = data.length / 4;
-    for (let i = 0; i < data.length; i += 4) {
-      sum += rgbToLuma(data[i], data[i + 1], data[i + 2]);
-    }
-    (_a = bmp.close) == null ? void 0 : _a.call(bmp);
-    return n > 0 ? sum / n : 0;
-  } catch {
-    return 0;
-  }
+	if (typeof createImageBitmap !== "function" || typeof document === "undefined") return 0;
+	try {
+		const blob = new Blob([png], { type: "image/png" });
+		const bmp = await createImageBitmap(blob);
+		const w = bmp.width;
+		const h = bmp.height;
+		const canvas = document.createElement("canvas");
+		const step = Math.max(1, Math.floor(Math.sqrt(w * h / 4096)));
+		canvas.width = Math.ceil(w / step);
+		canvas.height = Math.ceil(h / step);
+		const ctx = canvas.getContext("2d");
+		if (!ctx) return 0;
+		ctx.drawImage(bmp, 0, 0, w, h, 0, 0, canvas.width, canvas.height);
+		const { data } = ctx.getImageData(0, 0, canvas.width, canvas.height);
+		let sum = 0;
+		const n = data.length / 4;
+		for (let i = 0; i < data.length; i += 4) sum += rgbToLuma(data[i], data[i + 1], data[i + 2]);
+		bmp.close?.();
+		return n > 0 ? sum / n : 0;
+	} catch {
+		return 0;
+	}
 }
+/**
+* True if the image is uniformly dark (likely failed render / empty GL buffer).
+* Threshold is mean luma on 0–255 scale (default 5 ≈ pure black).
+*/
 async function isPngMostlyBlack(png, threshold = 5) {
-  const m = await meanLuminanceFromPngBytes(png);
-  return m < threshold;
+	return await meanLuminanceFromPngBytes(png) < threshold;
 }
-export {
-  isPngMostlyBlack,
-  meanLuminanceFromPngBytes,
-  rgbToLuma
-};
-//# sourceMappingURL=capturePngAnalysis.js.map
+//#endregion
+export { isPngMostlyBlack, meanLuminanceFromPngBytes, rgbToLuma };
+
+//# sourceMappingURL=capturePngAnalysis.js.map

package/dist/react/3d/capturePngAnalysis.js.map

@@ -1 +1 @@
-{"version":3,"file":"capturePngAnalysis.js","sources":["../../../src/react/3d/capturePngAnalysis.ts"],"sourcesContent":["/**\r\n * Lightweight PNG analysis for capture QA (brightness / \"all black\" detection).\r\n * Used by tests and optional runtime checks — keep dependency-free (no pngjs).\r\n */\r\n\r\n/** ITU-R BT.709 luma from RGB */\r\nexport function rgbToLuma(r: number, g: number, b: number): number {\r\n  return 0.2126 * r + 0.7152 * g + 0.0722 * b;\r\n}\r\n\r\n/**\r\n * Sample mean luma of PNG bytes by drawing to a small canvas (browser / happy-dom).\r\n * Returns 0 if decode fails. For very large images, samples a grid (max ~4096 samples).\r\n */\r\nexport async function meanLuminanceFromPngBytes(png: Uint8Array): Promise<number> {\r\n  if (typeof createImageBitmap !== 'function' || typeof document === 'undefined') {\r\n    return 0;\r\n  }\r\n  try {\r\n    const blob = new Blob([png as unknown as BlobPart], { type: 'image/png' });\r\n    const bmp = await createImageBitmap(blob);\r\n    const w = bmp.width;\r\n    const h = bmp.height;\r\n    const canvas = document.createElement('canvas');\r\n    const step = Math.max(1, Math.floor(Math.sqrt((w * h) / 4096)));\r\n    canvas.width = Math.ceil(w / step);\r\n    canvas.height = Math.ceil(h / step);\r\n    const ctx = canvas.getContext('2d');\r\n    if (!ctx) return 0;\r\n    ctx.drawImage(bmp, 0, 0, w, h, 0, 0, canvas.width, canvas.height);\r\n    const { data } = ctx.getImageData(0, 0, canvas.width, canvas.height);\r\n    let sum = 0;\r\n    const n = data.length / 4;\r\n    for (let i = 0; i < data.length; i += 4) {\r\n      sum += rgbToLuma(data[i], data[i + 1], data[i + 2]);\r\n    }\r\n    bmp.close?.();\r\n    return n > 0 ? sum / n : 0;\r\n  } catch {\r\n    return 0;\r\n  }\r\n}\r\n\r\n/**\r\n * True if the image is uniformly dark (likely failed render / empty GL buffer).\r\n * Threshold is mean luma on 0–255 scale (default 5 ≈ pure black).\r\n */\r\nexport async function isPngMostlyBlack(png: Uint8Array, threshold = 5): Promise<boolean> {\r\n  const m = await meanLuminanceFromPngBytes(png);\r\n  return m < threshold;\r\n}\r\n"],"names":[],"mappings":"AAMO,SAAS,UAAU,GAAW,GAAW,GAAmB;AACjE,SAAO,SAAS,IAAI,SAAS,IAAI,SAAS;AAC5C;AAMA,eAAsB,0BAA0B,KAAkC;AAR3E;AASL,MAAI,OAAO,sBAAsB,cAAc,OAAO,aAAa,aAAa;AAC9E,WAAO;AAAA,EACT;AACA,MAAI;AACF,UAAM,OAAO,IAAI,KAAK,CAAC,GAA0B,GAAG,EAAE,MAAM,aAAa;AACzE,UAAM,MAAM,MAAM,kBAAkB,IAAI;AACxC,UAAM,IAAI,IAAI;AACd,UAAM,IAAI,IAAI;AACd,UAAM,SAAS,SAAS,cAAc,QAAQ;AAC9C,UAAM,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,KAAM,IAAI,IAAK,IAAI,CAAC,CAAC;AAC9D,WAAO,QAAQ,KAAK,KAAK,IAAI,IAAI;AACjC,WAAO,SAAS,KAAK,KAAK,IAAI,IAAI;AAClC,UAAM,MAAM,OAAO,WAAW,IAAI;AAClC,QAAI,CAAC,IAAK,QAAO;AACjB,QAAI,UAAU,KAAK,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,OAAO,OAAO,OAAO,MAAM;AAChE,UAAM,EAAE,KAAA,IAAS,IAAI,aAAa,GAAG,GAAG,OAAO,OAAO,OAAO,MAAM;AACnE,QAAI,MAAM;AACV,UAAM,IAAI,KAAK,SAAS;AACxB,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,GAAG;AACvC,aAAO,UAAU,KAAK,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC;AAAA,IACpD;AACA,cAAI,UAAJ;AACA,WAAO,IAAI,IAAI,MAAM,IAAI;AAAA,EAC3B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAMA,eAAsB,iBAAiB,KAAiB,YAAY,GAAqB;AACvF,QAAM,IAAI,MAAM,0BAA0B,GAAG;AAC7C,SAAO,IAAI;AACb;"}
+{"version":3,"file":"capturePngAnalysis.js","names":[],"sources":["../../../src/react/3d/capturePngAnalysis.ts"],"sourcesContent":["/**\r\n * Lightweight PNG analysis for capture QA (brightness / \"all black\" detection).\r\n * Used by tests and optional runtime checks — keep dependency-free (no pngjs).\r\n */\r\n\r\n/** ITU-R BT.709 luma from RGB */\r\nexport function rgbToLuma(r: number, g: number, b: number): number {\r\n  return 0.2126 * r + 0.7152 * g + 0.0722 * b;\r\n}\r\n\r\n/**\r\n * Sample mean luma of PNG bytes by drawing to a small canvas (browser / happy-dom).\r\n * Returns 0 if decode fails. For very large images, samples a grid (max ~4096 samples).\r\n */\r\nexport async function meanLuminanceFromPngBytes(\r\n  png: Uint8Array,\r\n): Promise<number> {\r\n  if (\r\n    typeof createImageBitmap !== \"function\" ||\r\n    typeof document === \"undefined\"\r\n  ) {\r\n    return 0;\r\n  }\r\n  try {\r\n    const blob = new Blob([png as unknown as BlobPart], { type: \"image/png\" });\r\n    const bmp = await createImageBitmap(blob);\r\n    const w = bmp.width;\r\n    const h = bmp.height;\r\n    const canvas = document.createElement(\"canvas\");\r\n    const step = Math.max(1, Math.floor(Math.sqrt((w * h) / 4096)));\r\n    canvas.width = Math.ceil(w / step);\r\n    canvas.height = Math.ceil(h / step);\r\n    const ctx = canvas.getContext(\"2d\");\r\n    if (!ctx) return 0;\r\n    ctx.drawImage(bmp, 0, 0, w, h, 0, 0, canvas.width, canvas.height);\r\n    const { data } = ctx.getImageData(0, 0, canvas.width, canvas.height);\r\n    let sum = 0;\r\n    const n = data.length / 4;\r\n    for (let i = 0; i < data.length; i += 4) {\r\n      sum += rgbToLuma(data[i], data[i + 1], data[i + 2]);\r\n    }\r\n    bmp.close?.();\r\n    return n > 0 ? sum / n : 0;\r\n  } catch {\r\n    return 0;\r\n  }\r\n}\r\n\r\n/**\r\n * True if the image is uniformly dark (likely failed render / empty GL buffer).\r\n * Threshold is mean luma on 0–255 scale (default 5 ≈ pure black).\r\n */\r\nexport async function isPngMostlyBlack(\r\n  png: Uint8Array,\r\n  threshold = 5,\r\n): Promise<boolean> {\r\n  const m = await meanLuminanceFromPngBytes(png);\r\n  return m < threshold;\r\n}\r\n"],"mappings":";;;;;;AAMA,SAAgB,UAAU,GAAW,GAAW,GAAmB;CACjE,OAAO,QAAS,IAAI,QAAS,IAAI,QAAS;AAC5C;;;;;AAMA,eAAsB,0BACpB,KACiB;CACjB,IACE,OAAO,sBAAsB,cAC7B,OAAO,aAAa,aAEpB,OAAO;CAET,IAAI;EACF,MAAM,OAAO,IAAI,KAAK,CAAC,GAA0B,GAAG,EAAE,MAAM,YAAY,CAAC;EACzE,MAAM,MAAM,MAAM,kBAAkB,IAAI;EACxC,MAAM,IAAI,IAAI;EACd,MAAM,IAAI,IAAI;EACd,MAAM,SAAS,SAAS,cAAc,QAAQ;EAC9C,MAAM,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,KAAK,KAAM,IAAI,IAAK,IAAI,CAAC,CAAC;EAC9D,OAAO,QAAQ,KAAK,KAAK,IAAI,IAAI;EACjC,OAAO,SAAS,KAAK,KAAK,IAAI,IAAI;EAClC,MAAM,MAAM,OAAO,WAAW,IAAI;EAClC,IAAI,CAAC,KAAK,OAAO;EACjB,IAAI,UAAU,KAAK,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,OAAO,OAAO,OAAO,MAAM;EAChE,MAAM,EAAE,SAAS,IAAI,aAAa,GAAG,GAAG,OAAO,OAAO,OAAO,MAAM;EACnE,IAAI,MAAM;EACV,MAAM,IAAI,KAAK,SAAS;EACxB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,GACpC,OAAO,UAAU,KAAK,IAAI,KAAK,IAAI,IAAI,KAAK,IAAI,EAAE;EAEpD,IAAI,QAAQ;EACZ,OAAO,IAAI,IAAI,MAAM,IAAI;CAC3B,QAAQ;EACN,OAAO;CACT;AACF;;;;;AAMA,eAAsB,iBACpB,KACA,YAAY,GACM;CAElB,OAAO,MADS,0BAA0B,GAAG,IAClC;AACb"}

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

@@ -11,10 +11,10 @@ export type { ZenSpace3DCesiumProps } from './ZenSpace3DCesium';
 export type { ZenSpace3DProps, ZenSpace3DHandle, ViewMode, CameraMode, ObjectCategory, SpaceObject, Satellite, Debris, SpaceStation, Asteroid, TLEData, OrbitPath, ManeuverNode, VisibilityCone, SatelliteCoverage, CoverageRegion, CoverageHexGrid, OverpassInfo, OrbitDesignArc, CoverageCell, TimeState, SelectionState, CameraState, LayerVisibility, ToolType, ToolState, Vector3D, LatLonAlt, SphericalCoords, SceneConfig, SceneObject, ZenSpace3DCallbacks, } from './ZenSpace3DTypes';
 export { latLonAltToCartesian, easeOutCubic, EARTH_RADIUS_KM, DEG_TO_RAD, RAD_TO_DEG, SCENE_EARTH_RADIUS, KM_TO_SCENE, } from './ZenSpace3DUtils';
 export { atmosphereVertexShader, atmosphereFragmentShader, starsVertexShader, starsFragmentShader, coverageVertexShader, coverageFragmentShader, visibilityConeVertexShader, visibilityConeFragmentShader, orbitLineVertexShader, orbitLineFragmentShader, objectGlowVertexShader, objectGlowFragmentShader, selectionRingVertexShader, selectionRingFragmentShader, terminatorVertexShader, terminatorFragmentShader, gridVertexShader, gridFragmentShader, planetRingVertexShader, planetRingFragmentShader, debrisVertexShader, debrisFragmentShader, createAtmosphereUniforms, createStarsUniforms, createVisibilityConeUniforms, } from './ZenSpace3DShaders';
-export { createCesiumCaptureSource, ecefMetersToSdkPosition, eulerXyzToHpr, ecefEulerXyzToHpr, computeDofBlurPx } from './CesiumCaptureSource';
-export type { CesiumCaptureSourceOptions, CesiumCaptureSourceHandle } from './CesiumCaptureSource';
+export { createCesiumCaptureSource, ecefMetersToSdkPosition, eulerXyzToHpr, ecefEulerXyzToHpr, computeDofBlurPx, } from './CesiumCaptureSource';
+export type { CesiumCaptureSourceOptions, CesiumCaptureSourceHandle, } from './CesiumCaptureSource';
 /** PNG brightness helpers for capture QA (e.g. detect all-black frames) */
-export { rgbToLuma, meanLuminanceFromPngBytes, isPngMostlyBlack } from './capturePngAnalysis';
+export { rgbToLuma, meanLuminanceFromPngBytes, isPngMostlyBlack, } from './capturePngAnalysis';
 export { loadThree, isThreeLoaded } from './threeLoader';
 export type { ThreeModule, OrbitControlsType } from './threeLoader';
 export { useSimulationScene } from '../hooks/useSimulationScene';

package/dist/react/3d/index.js

@@ -1,57 +1,9 @@
-import { ZenSpace3D, ZenSpace3D as ZenSpace3D2 } from "./ZenSpace3D.js";
-import { ZenSpace3DCesium } from "./ZenSpace3DCesium.js";
+import useSimulationScene from "../hooks/useSimulationScene.js";
 import { DEG_TO_RAD, EARTH_RADIUS_KM, KM_TO_SCENE, RAD_TO_DEG, SCENE_EARTH_RADIUS, easeOutCubic, latLonAltToCartesian } from "./ZenSpace3DUtils.js";
+import { isThreeLoaded, loadThree } from "./threeLoader.js";
+import { ZenSpace3DCesium } from "./ZenSpace3DCesium.js";
+import { ZenSpace3D } from "./ZenSpace3D.js";
 import { atmosphereFragmentShader, atmosphereVertexShader, coverageFragmentShader, coverageVertexShader, createAtmosphereUniforms, createStarsUniforms, createVisibilityConeUniforms, debrisFragmentShader, debrisVertexShader, gridFragmentShader, gridVertexShader, objectGlowFragmentShader, objectGlowVertexShader, orbitLineFragmentShader, orbitLineVertexShader, planetRingFragmentShader, planetRingVertexShader, selectionRingFragmentShader, selectionRingVertexShader, starsFragmentShader, starsVertexShader, terminatorFragmentShader, terminatorVertexShader, visibilityConeFragmentShader, visibilityConeVertexShader } from "./ZenSpace3DShaders.js";
 import { computeDofBlurPx, createCesiumCaptureSource, ecefEulerXyzToHpr, ecefMetersToSdkPosition, eulerXyzToHpr } from "./CesiumCaptureSource.js";
 import { isPngMostlyBlack, meanLuminanceFromPngBytes, rgbToLuma } from "./capturePngAnalysis.js";
-import { isThreeLoaded, loadThree } from "./threeLoader.js";
-import { useSimulationScene } from "../hooks/useSimulationScene.js";
-export {
-  DEG_TO_RAD,
-  EARTH_RADIUS_KM,
-  KM_TO_SCENE,
-  RAD_TO_DEG,
-  SCENE_EARTH_RADIUS,
-  ZenSpace3D,
-  ZenSpace3DCesium,
-  ZenSpace3D2 as ZenSpace3DDefault,
-  atmosphereFragmentShader,
-  atmosphereVertexShader,
-  computeDofBlurPx,
-  coverageFragmentShader,
-  coverageVertexShader,
-  createAtmosphereUniforms,
-  createCesiumCaptureSource,
-  createStarsUniforms,
-  createVisibilityConeUniforms,
-  debrisFragmentShader,
-  debrisVertexShader,
-  easeOutCubic,
-  ecefEulerXyzToHpr,
-  ecefMetersToSdkPosition,
-  eulerXyzToHpr,
-  gridFragmentShader,
-  gridVertexShader,
-  isPngMostlyBlack,
-  isThreeLoaded,
-  latLonAltToCartesian,
-  loadThree,
-  meanLuminanceFromPngBytes,
-  objectGlowFragmentShader,
-  objectGlowVertexShader,
-  orbitLineFragmentShader,
-  orbitLineVertexShader,
-  planetRingFragmentShader,
-  planetRingVertexShader,
-  rgbToLuma,
-  selectionRingFragmentShader,
-  selectionRingVertexShader,
-  starsFragmentShader,
-  starsVertexShader,
-  terminatorFragmentShader,
-  terminatorVertexShader,
-  useSimulationScene,
-  visibilityConeFragmentShader,
-  visibilityConeVertexShader
-};
-//# sourceMappingURL=index.js.map
+export { DEG_TO_RAD, EARTH_RADIUS_KM, KM_TO_SCENE, RAD_TO_DEG, SCENE_EARTH_RADIUS, ZenSpace3D, ZenSpace3DCesium, ZenSpace3D as ZenSpace3DDefault, atmosphereFragmentShader, atmosphereVertexShader, computeDofBlurPx, coverageFragmentShader, coverageVertexShader, createAtmosphereUniforms, createCesiumCaptureSource, createStarsUniforms, createVisibilityConeUniforms, debrisFragmentShader, debrisVertexShader, easeOutCubic, ecefEulerXyzToHpr, ecefMetersToSdkPosition, eulerXyzToHpr, gridFragmentShader, gridVertexShader, isPngMostlyBlack, isThreeLoaded, latLonAltToCartesian, loadThree, meanLuminanceFromPngBytes, objectGlowFragmentShader, objectGlowVertexShader, orbitLineFragmentShader, orbitLineVertexShader, planetRingFragmentShader, planetRingVertexShader, rgbToLuma, selectionRingFragmentShader, selectionRingVertexShader, starsFragmentShader, starsVertexShader, terminatorFragmentShader, terminatorVertexShader, useSimulationScene, visibilityConeFragmentShader, visibilityConeVertexShader };

package/dist/react/3d/threeLoader.d.ts

@@ -4,7 +4,7 @@
  * Ensures only one instance of Three.js is loaded across all 3D components.
  * This prevents the "Multiple instances of Three.js being imported" warning.
  */
-export type ThreeModule = typeof import('three');
+export type ThreeModule = typeof import("three");
 export type OrbitControlsType = typeof import('three/examples/jsm/controls/OrbitControls.js').OrbitControls;
 interface ThreeLoaderResult {
     THREE: ThreeModule;

package/dist/react/3d/threeLoader.js

@@ -1,22 +1,27 @@
-let loadPromise = null;
+//#region src/react/3d/threeLoader.ts
+var loadPromise = null;
+/**
+* Load Three.js and OrbitControls
+* Returns cached instance if already loaded
+*/
 async function loadThree() {
-  if (loadPromise) {
-    return loadPromise;
-  }
-  loadPromise = (async () => {
-    const [THREE, { OrbitControls }] = await Promise.all([
-      import("three"),
-      import("three/examples/jsm/controls/OrbitControls.js")
-    ]);
-    return { THREE, OrbitControls };
-  })();
-  return loadPromise;
+	if (loadPromise) return loadPromise;
+	loadPromise = (async () => {
+		const [THREE, { OrbitControls }] = await Promise.all([import("three"), import("three/examples/jsm/controls/OrbitControls.js")]);
+		return {
+			THREE,
+			OrbitControls
+		};
+	})();
+	return loadPromise;
 }
+/**
+* Check if Three.js is already loaded
+*/
 function isThreeLoaded() {
-  return loadPromise !== null;
+	return loadPromise !== null;
 }
-export {
-  isThreeLoaded,
-  loadThree
-};
-//# sourceMappingURL=threeLoader.js.map
+//#endregion
+export { isThreeLoaded, loadThree };
+
+//# sourceMappingURL=threeLoader.js.map

package/dist/react/3d/threeLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"threeLoader.js","sources":["../../../src/react/3d/threeLoader.ts"],"sourcesContent":["/**\r\n * Shared Three.js loader\r\n * \r\n * Ensures only one instance of Three.js is loaded across all 3D components.\r\n * This prevents the \"Multiple instances of Three.js being imported\" warning.\r\n */\r\n\r\nexport type ThreeModule = typeof import('three');\r\nexport type OrbitControlsType = typeof import('three/examples/jsm/controls/OrbitControls.js').OrbitControls;\r\n\r\ninterface ThreeLoaderResult {\r\n  THREE: ThreeModule;\r\n  OrbitControls: OrbitControlsType;\r\n}\r\n\r\n// Cached promise to ensure single load\r\nlet loadPromise: Promise<ThreeLoaderResult> | null = null;\r\n\r\n/**\r\n * Load Three.js and OrbitControls\r\n * Returns cached instance if already loaded\r\n */\r\nexport async function loadThree(): Promise<ThreeLoaderResult> {\r\n  if (loadPromise) {\r\n    return loadPromise;\r\n  }\r\n\r\n  loadPromise = (async () => {\r\n    const [THREE, { OrbitControls }] = await Promise.all([\r\n      import('three'),\r\n      import('three/examples/jsm/controls/OrbitControls.js'),\r\n    ]);\r\n    \r\n    return { THREE, OrbitControls };\r\n  })();\r\n\r\n  return loadPromise;\r\n}\r\n\r\n/**\r\n * Check if Three.js is already loaded\r\n */\r\nexport function isThreeLoaded(): boolean {\r\n  return loadPromise !== null;\r\n}\r\n"],"names":[],"mappings":"AAgBA,IAAI,cAAiD;AAMrD,eAAsB,YAAwC;AAC5D,MAAI,aAAa;AACf,WAAO;AAAA,EACT;AAEA,iBAAe,YAAY;AACzB,UAAM,CAAC,OAAO,EAAE,cAAA,CAAe,IAAI,MAAM,QAAQ,IAAI;AAAA,MACnD,OAAO,OAAO;AAAA,MACd,OAAO,8CAA8C;AAAA,IAAA,CACtD;AAED,WAAO,EAAE,OAAO,cAAA;AAAA,EAClB,GAAA;AAEA,SAAO;AACT;AAKO,SAAS,gBAAyB;AACvC,SAAO,gBAAgB;AACzB;"}
+{"version":3,"file":"threeLoader.js","names":[],"sources":["../../../src/react/3d/threeLoader.ts"],"sourcesContent":["/**\r\n * Shared Three.js loader\r\n *\r\n * Ensures only one instance of Three.js is loaded across all 3D components.\r\n * This prevents the \"Multiple instances of Three.js being imported\" warning.\r\n */\r\n\r\nexport type ThreeModule = typeof import(\"three\");\r\nexport type OrbitControlsType =\r\n  typeof import(\"three/examples/jsm/controls/OrbitControls.js\").OrbitControls;\r\n\r\ninterface ThreeLoaderResult {\r\n  THREE: ThreeModule;\r\n  OrbitControls: OrbitControlsType;\r\n}\r\n\r\n// Cached promise to ensure single load\r\nlet loadPromise: Promise<ThreeLoaderResult> | null = null;\r\n\r\n/**\r\n * Load Three.js and OrbitControls\r\n * Returns cached instance if already loaded\r\n */\r\nexport async function loadThree(): Promise<ThreeLoaderResult> {\r\n  if (loadPromise) {\r\n    return loadPromise;\r\n  }\r\n\r\n  loadPromise = (async () => {\r\n    const [THREE, { OrbitControls }] = await Promise.all([\r\n      import(\"three\"),\r\n      import(\"three/examples/jsm/controls/OrbitControls.js\"),\r\n    ]);\r\n\r\n    return { THREE, OrbitControls };\r\n  })();\r\n\r\n  return loadPromise;\r\n}\r\n\r\n/**\r\n * Check if Three.js is already loaded\r\n */\r\nexport function isThreeLoaded(): boolean {\r\n  return loadPromise !== null;\r\n}\r\n"],"mappings":";AAiBA,IAAI,cAAiD;;;;;AAMrD,eAAsB,YAAwC;CAC5D,IAAI,aACF,OAAO;CAGT,eAAe,YAAY;EACzB,MAAM,CAAC,OAAO,EAAE,mBAAmB,MAAM,QAAQ,IAAI,CACnD,OAAO,UACP,OAAO,+CACT,CAAC;EAED,OAAO;GAAE;GAAO;EAAc;CAChC,EAAA,CAAG;CAEH,OAAO;AACT;;;;AAKA,SAAgB,gBAAyB;CACvC,OAAO,gBAAgB;AACzB"}

package/dist/react/astro/ClassificationBanner.d.ts

@@ -1,13 +1,12 @@
 import { default as React } from 'react';
-
-export type ClassificationLevel = 'unclassified' | 'cui' | 'controlled' | 'confidential' | 'secret' | 'top-secret' | 'top-secret-sci';
+export type ClassificationLevel = "unclassified" | "cui" | "controlled" | "confidential" | "secret" | "top-secret" | "top-secret-sci";
 export interface ClassificationBannerProps {
     /** Classification level */
     classification: ClassificationLevel;
     /** Custom label (overrides default text) */
     label?: string;
     /** Position of the banner */
-    position?: 'top' | 'bottom';
+    position?: "top" | "bottom";
     /** Custom className */
     className?: string;
 }