worldorbit 4.0.0 → 5.0.0

package/dist/unpkg/core/dist/solver.js

@@ -1,3 +1,4 @@
+import { renderDocumentToScene } from "./scene.js";
 export function createTrajectorySolverSnapshot(trajectory) {
     return {
         trajectoryId: trajectory.id,
@@ -15,6 +16,58 @@ export function createTrajectorySolverSnapshot(trajectory) {
         maneuvers: trajectory.segments.flatMap((segment) => segment.maneuvers.map((maneuver) => mapManeuver(segment.id, maneuver))),
     };
 }
+export function sampleTrajectory(trajectory, document, options = {}) {
+    const scene = renderDocumentToScene(document, {
+        ...options,
+        trajectoryMode: options.trajectoryMode ?? trajectory.renderMode ?? "auto",
+        showTrajectoryWaypoints: options.showTrajectoryWaypoints ?? true,
+        showTrajectoryLabels: options.showTrajectoryLabels ?? true,
+    });
+    const rendered = scene.trajectories.find((entry) => entry.trajectoryId === trajectory.id);
+    return rendered ? mapRenderTrajectoryToSpatial(rendered) : null;
+}
+export function sampleDocumentTrajectories(document, options = {}) {
+    const scene = renderDocumentToScene(document, {
+        ...options,
+        trajectoryMode: options.trajectoryMode ?? "auto",
+        showTrajectoryWaypoints: options.showTrajectoryWaypoints ?? true,
+        showTrajectoryLabels: options.showTrajectoryLabels ?? true,
+    });
+    return scene.trajectories.map(mapRenderTrajectoryToSpatial);
+}
+function mapRenderTrajectoryToSpatial(trajectory) {
+    return {
+        trajectoryId: trajectory.trajectoryId,
+        trajectory: trajectory.trajectory,
+        craftObjectId: trajectory.craftObjectId,
+        mode: trajectory.mode,
+        stroke: trajectory.stroke,
+        strokeWidth: trajectory.strokeWidth,
+        marker: trajectory.marker,
+        labelMode: trajectory.labelMode,
+        showWaypoints: trajectory.showWaypoints,
+        samples: samplePathPoints(trajectory.path).map((point) => ({
+            x: point.x,
+            y: 0,
+            z: point.y,
+        })),
+        waypoints: trajectory.waypoints.map((waypoint) => ({
+            trajectoryId: waypoint.trajectoryId,
+            segmentId: waypoint.segmentId,
+            maneuverId: waypoint.maneuverId,
+            objectId: waypoint.objectId,
+            position: {
+                x: waypoint.x,
+                y: 0,
+                z: waypoint.y,
+            },
+            label: waypoint.label,
+            dateLabel: waypoint.dateLabel,
+            hidden: waypoint.hidden,
+        })),
+        hidden: trajectory.hidden,
+    };
+}
 function mapManeuver(segmentId, maneuver) {
     return {
         segmentId,
@@ -25,3 +78,22 @@ function mapManeuver(segmentId, maneuver) {
         duration: maneuver.duration ?? null,
     };
 }
+function samplePathPoints(path) {
+    const matches = [...path.matchAll(/[MLQ]\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)(?:\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?))?(?:\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?))?/g)];
+    if (matches.length === 0) {
+        return [];
+    }
+    const points = [];
+    for (const match of matches) {
+        const command = match[0][0];
+        if (command === "M" || command === "L") {
+            points.push({ x: Number(match[1]), y: Number(match[2]) });
+            continue;
+        }
+        if (command === "Q") {
+            points.push({ x: Number(match[1]), y: Number(match[2]) });
+            points.push({ x: Number(match[5]), y: Number(match[6]) });
+        }
+    }
+    return points;
+}

package/dist/unpkg/core/dist/spatial-scene.js

@@ -36,6 +36,7 @@ export function renderDocumentToSpatialScene(document, options = {}) {
     const spatialObjects = scene.objects.map((entry) => createSpatialObject(entry, scene, sceneCenter, objectMap, orbitMap, scaleModel, positionCache, minimumMotionMetric));
     const spatialObjectMap = new Map(spatialObjects.map((object) => [object.objectId, object]));
     const spatialOrbits = scene.orbitVisuals.map((orbit) => createSpatialOrbit(orbit, spatialObjectMap, minimumMotionMetric, scene.activeEventId !== null));
+    const spatialTrajectories = scene.trajectories.map((trajectory) => createSpatialTrajectory(trajectory, spatialObjectMap));
     const focusTargets = spatialObjects.map((object) => ({
         objectId: object.objectId,
         center: { ...object.position },
@@ -65,6 +66,7 @@ export function renderDocumentToSpatialScene(document, options = {}) {
         timeFrozen: scene.activeEventId !== null,
         objects: spatialObjects,
         orbits: spatialOrbits,
+        trajectories: spatialTrajectories,
         focusTargets,
     };
 }
@@ -117,6 +119,41 @@ function createSpatialOrbit(orbit, objectMap, minimumMotionMetric, frozen) {
             createMotionModel(orbit.object, orbit, minimumMotionMetric, frozen),
     };
 }
+function createSpatialTrajectory(trajectory, objectMap) {
+    const samples = samplePathPoints(trajectory.path).map((point) => ({
+        x: point.x,
+        y: 0,
+        z: point.y,
+    }));
+    return {
+        trajectoryId: trajectory.trajectoryId,
+        trajectory: trajectory.trajectory,
+        craftObjectId: trajectory.craftObjectId,
+        mode: trajectory.mode,
+        stroke: trajectory.stroke,
+        strokeWidth: trajectory.strokeWidth,
+        marker: trajectory.marker,
+        labelMode: trajectory.labelMode,
+        showWaypoints: trajectory.showWaypoints,
+        samples,
+        waypoints: trajectory.waypoints.map((waypoint) => {
+            const object = waypoint.objectId ? objectMap.get(waypoint.objectId) ?? null : null;
+            return {
+                trajectoryId: waypoint.trajectoryId,
+                segmentId: waypoint.segmentId,
+                maneuverId: waypoint.maneuverId,
+                objectId: waypoint.objectId,
+                position: object
+                    ? { ...object.position }
+                    : { x: waypoint.x, y: 0, z: waypoint.y },
+                label: waypoint.label,
+                dateLabel: waypoint.dateLabel,
+                hidden: waypoint.hidden,
+            };
+        }),
+        hidden: trajectory.hidden,
+    };
+}
 function resolveSpatialObjectPosition(entry, scene, sceneCenter, objectMap, orbitMap, cache) {
     const cached = cache.get(entry.objectId);
     if (cached) {
@@ -419,3 +456,22 @@ function clampNumber(value, min, max) {
 function degreesToRadians(value) {
     return (value * Math.PI) / 180;
 }
+function samplePathPoints(path) {
+    const matches = [...path.matchAll(/[MLQ]\s*(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)(?:\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?))?(?:\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?))?/g)];
+    if (matches.length === 0) {
+        return [];
+    }
+    const points = [];
+    for (const match of matches) {
+        const command = match[0][0];
+        if (command === "M" || command === "L") {
+            points.push({ x: Number(match[1]), y: Number(match[2]) });
+            continue;
+        }
+        if (command === "Q") {
+            points.push({ x: Number(match[1]), y: Number(match[2]) });
+            points.push({ x: Number(match[5]), y: Number(match[6]) });
+        }
+    }
+    return points;
+}

package/dist/unpkg/core/dist/types.d.ts

@@ -2,7 +2,7 @@ export type WorldOrbitObjectType = "system" | "star" | "planet" | "moon" | "belt
 export type PlacementMode = "orbit" | "at" | "surface" | "free";
 export type Unit = "au" | "km" | "m" | "ly" | "pc" | "kpc" | "re" | "rj" | "sol" | "me" | "mj" | "s" | "min" | "h" | "d" | "y" | "ky" | "my" | "gy" | "K" | "deg";
 export type WorldOrbitDocumentVersion = "1.0";
-export type WorldOrbitAtlasDocumentVersion = "2.0" | "2.1" | "2.5" | "2.6" | "3.0";
+export type WorldOrbitAtlasDocumentVersion = "2.0" | "2.1" | "2.5" | "2.6" | "3.0" | "3.1";
 export type WorldOrbitDraftDocumentVersion = "2.0-draft";
 export type WorldOrbitAnyDocumentVersion = WorldOrbitDocumentVersion | WorldOrbitAtlasDocumentVersion | WorldOrbitDraftDocumentVersion;
 export type ViewProjection = "topdown" | "isometric" | "orthographic" | "perspective";
@@ -201,6 +201,12 @@ export interface WorldOrbitTrajectory {
     tags: string[];
     color: string | null;
     hidden: boolean;
+    renderMode?: TrajectoryRenderMode | null;
+    stroke?: string | null;
+    strokeWidth?: number | null;
+    marker?: string | null;
+    labelMode?: string | null;
+    showWaypoints?: boolean | null;
     segments: WorldOrbitTrajectorySegment[];
 }
 export interface WorldOrbitTrajectorySegment {
@@ -221,9 +227,14 @@ export interface WorldOrbitTrajectorySegment {
     phaseAngle?: UnitValue;
     turnAngle?: UnitValue;
     energy?: UnitValue;
+    waypointLabel?: string | null;
+    waypointDate?: string | null;
+    renderHidden?: boolean | null;
+    sampleDensity?: number | null;
     notes: string[];
     maneuvers: WorldOrbitManeuver[];
 }
+export type TrajectoryRenderMode = "illustrative" | "solver" | "auto";
 export type WorldOrbitTrajectorySegmentKind = "departure" | "transfer" | "flyby" | "capture" | "stationkeeping" | "escape";
 export interface WorldOrbitManeuver {
     id: string;
@@ -330,6 +341,9 @@ export interface SceneRenderOptions {
     scaleModel?: Partial<RenderScaleModel>;
     bodyScaleMode?: BodyScaleMode;
     activeEventId?: string | null;
+    trajectoryMode?: TrajectoryRenderMode;
+    showTrajectoryWaypoints?: boolean;
+    showTrajectoryLabels?: boolean;
 }
 export interface SpatialScaleModel {
     orbitDistanceMultiplier: number;
@@ -435,7 +449,35 @@ export interface RenderSceneEvent {
     y: number;
     hidden: boolean;
 }
-export type SceneLayerId = "background" | "guides" | "orbits-back" | "orbits-front" | "relations" | "events" | "objects" | "labels" | "metadata";
+export interface RenderSceneTrajectoryWaypoint {
+    renderId: string;
+    trajectoryId: string;
+    segmentId: string | null;
+    maneuverId: string | null;
+    objectId: string | null;
+    x: number;
+    y: number;
+    label: string | null;
+    dateLabel: string | null;
+    hidden: boolean;
+}
+export interface RenderSceneTrajectory {
+    renderId: string;
+    trajectoryId: string;
+    trajectory: WorldOrbitTrajectory;
+    craftObjectId: string | null;
+    mode: TrajectoryRenderMode;
+    path: string;
+    stroke: string | null;
+    strokeWidth: number;
+    marker: string | null;
+    labelMode: string | null;
+    showWaypoints: boolean;
+    objectIds: string[];
+    waypoints: RenderSceneTrajectoryWaypoint[];
+    hidden: boolean;
+}
+export type SceneLayerId = "background" | "guides" | "orbits-back" | "orbits-front" | "trajectories" | "relations" | "events" | "objects" | "labels" | "metadata";
 export interface RenderSceneViewpointFilter {
     query: string | null;
     objectTypes: Array<Exclude<WorldOrbitObjectType, "system">>;
@@ -554,6 +596,34 @@ export interface SpatialOrbit {
     hidden: boolean;
     motion: OrbitalMotionModel | null;
 }
+export interface SpatialTrajectorySample {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface SpatialTrajectory {
+    trajectoryId: string;
+    trajectory: WorldOrbitTrajectory;
+    craftObjectId: string | null;
+    mode: TrajectoryRenderMode;
+    stroke: string | null;
+    strokeWidth: number;
+    marker: string | null;
+    labelMode: string | null;
+    showWaypoints: boolean;
+    samples: SpatialTrajectorySample[];
+    waypoints: Array<{
+        trajectoryId: string;
+        segmentId: string | null;
+        maneuverId: string | null;
+        objectId: string | null;
+        position: CoordinatePoint3D;
+        label: string | null;
+        dateLabel: string | null;
+        hidden: boolean;
+    }>;
+    hidden: boolean;
+}
 export interface SpatialFocusTarget {
     objectId: string;
     center: CoordinatePoint3D;
@@ -581,6 +651,7 @@ export interface RenderScene {
     viewpoints: RenderSceneViewpoint[];
     events: RenderSceneEvent[];
     activeEventId: string | null;
+    trajectories: RenderSceneTrajectory[];
     objects: RenderSceneObject[];
     orbitVisuals: RenderOrbitVisual[];
     relations: RenderSceneRelation[];
@@ -608,6 +679,7 @@ export interface SpatialScene {
     timeFrozen: boolean;
     objects: SpatialSceneObject[];
     orbits: SpatialOrbit[];
+    trajectories: SpatialTrajectory[];
     focusTargets: SpatialFocusTarget[];
 }
 export type SceneLayoutPreset = "compact" | "balanced" | "presentation";

package/dist/unpkg/viewer/dist/render.js

@@ -40,6 +40,13 @@ export function renderSceneToSvg(scene, options = {}) {
             .map((relation) => `<line class="wo-relation" x1="${relation.x1}" y1="${relation.y1}" x2="${relation.x2}" y2="${relation.y2}" data-render-id="${escapeXml(relation.renderId)}" data-relation-id="${escapeAttribute(relation.relationId)}" />`)
             .join("")
         : "";
+    const trajectoryMarkup = layers.trajectories
+        ? renderTrajectoryLayer(scene, visibleObjectIds, {
+            showLabels: options.showTrajectoryLabels ?? true,
+            showWaypoints: options.showTrajectoryWaypoints ?? true,
+            includeStructures: layers.structures,
+        })
+        : "";
     const eventMarkup = layers.events
         ? scene.events
             .filter((event) => !event.hidden)
@@ -78,12 +85,15 @@ export function renderSceneToSvg(scene, options = {}) {
       <stop offset="0%" stop-color="${theme.starGlow}" stop-opacity="0.95" />
       <stop offset="100%" stop-color="${theme.starCore}" stop-opacity="0" />
     </radialGradient>
-    <radialGradient id="wo-bg-glow" cx="20%" cy="10%" r="90%">
-      <stop offset="0%" stop-color="${theme.backgroundGlow}" />
-      <stop offset="100%" stop-color="transparent" />
-    </radialGradient>
-    ${imageDefinitions}
-  </defs>
+    <radialGradient id="wo-bg-glow" cx="20%" cy="10%" r="90%">
+      <stop offset="0%" stop-color="${theme.backgroundGlow}" />
+      <stop offset="100%" stop-color="transparent" />
+    </radialGradient>
+    <marker id="wo-trajectory-arrow" markerWidth="12" markerHeight="12" refX="10" refY="6" orient="auto" markerUnits="strokeWidth">
+      <path d="M 0 0 L 12 6 L 0 12 z" fill="${theme.accent}" />
+    </marker>
+    ${imageDefinitions}
+  </defs>
   <style>
     .wo-bg { fill: url(#wo-bg); }
     .wo-bg-glow { fill: url(#wo-bg-glow); }
@@ -91,9 +101,13 @@ export function renderSceneToSvg(scene, options = {}) {
     .wo-orbit { fill: none; stroke: ${theme.orbit}; stroke-width: 1.5; }
     .wo-orbit-back { opacity: 0.38; stroke-dasharray: 8 6; }
     .wo-orbit-front { opacity: 0.9; }
-    .wo-orbit-band { stroke: ${theme.orbitBand}; stroke-linecap: round; }
-    .wo-relation { stroke: ${theme.relation}; stroke-width: 2; stroke-dasharray: 10 6; }
-    .wo-event-line { stroke: ${theme.accent}; stroke-width: 1.6; stroke-dasharray: 5 5; opacity: 0.72; }
+    .wo-orbit-band { stroke: ${theme.orbitBand}; stroke-linecap: round; }
+    .wo-relation { stroke: ${theme.relation}; stroke-width: 2; stroke-dasharray: 10 6; }
+    .wo-trajectory { fill: none; stroke: ${theme.accent}; stroke-width: 2.4; stroke-linecap: round; stroke-linejoin: round; opacity: 0.92; }
+    .wo-trajectory-waypoint { fill: ${theme.spaceFog}; stroke: ${theme.selected}; stroke-width: 1.4; }
+    .wo-trajectory-label { fill: ${theme.accent}; font-family: ${theme.fontFamily}; font-weight: 700; letter-spacing: 0.04em; text-transform: uppercase; }
+    .wo-trajectory-date { fill: ${theme.muted}; font-family: ${theme.fontFamily}; font-weight: 500; }
+    .wo-event-line { stroke: ${theme.accent}; stroke-width: 1.6; stroke-dasharray: 5 5; opacity: 0.72; }
     .wo-event-node { fill: ${theme.accent}; stroke: ${theme.selected}; stroke-width: 1.4; opacity: 0.92; }
     .wo-event-label { fill: ${theme.accent}; font-family: ${theme.fontFamily}; font-weight: 700; letter-spacing: 0.04em; text-transform: uppercase; }
     .wo-leader { stroke: ${theme.leader}; stroke-width: 1.5; stroke-dasharray: 6 5; }
@@ -129,12 +143,13 @@ export function renderSceneToSvg(scene, options = {}) {
       <g data-worldorbit-world-content="true">
         ${layers.orbits ? `<g data-layer-id="orbits-back">${orbitMarkup.back}</g>` : ""}
         ${layers.guides ? `<g data-layer-id="guides">${leaderMarkup}</g>` : ""}
-        ${layers.relations ? `<g data-layer-id="relations">${relationMarkup}</g>` : ""}
-        ${layers.events ? `<g data-layer-id="events">${eventMarkup}</g>` : ""}
-        ${layers.objects ? `<g data-layer-id="objects">${objectMarkup}</g>` : ""}
-        ${layers.orbits ? `<g data-layer-id="orbits-front">${orbitMarkup.front}</g>` : ""}
-        ${layers.labels ? `<g data-layer-id="labels">${labelMarkup}</g>` : ""}
-      </g>
+        ${layers.relations ? `<g data-layer-id="relations">${relationMarkup}</g>` : ""}
+        ${layers.events ? `<g data-layer-id="events">${eventMarkup}</g>` : ""}
+        ${layers.objects ? `<g data-layer-id="objects">${objectMarkup}</g>` : ""}
+        ${layers.orbits ? `<g data-layer-id="orbits-front">${orbitMarkup.front}</g>` : ""}
+        ${layers.trajectories ? `<g data-layer-id="trajectories">${trajectoryMarkup}</g>` : ""}
+        ${layers.labels ? `<g data-layer-id="labels">${labelMarkup}</g>` : ""}
+      </g>
     </g>
   </g>
 </svg>`;
@@ -158,6 +173,47 @@ function renderSceneEventOverlay(scene, event, visibleObjectIds, theme) {
     <text class="wo-event-label" x="${event.x}" y="${event.y - 10}" text-anchor="middle" font-size="10">${escapeXml(label)}</text>
   </g>`;
 }
+function renderTrajectoryLayer(scene, visibleObjectIds, options) {
+    return scene.trajectories
+        .filter((trajectory) => !trajectory.hidden)
+        .filter((trajectory) => trajectory.objectIds.length === 0 || trajectory.objectIds.some((objectId) => visibleObjectIds.has(objectId)))
+        .filter((trajectory) => options.includeStructures ||
+        !trajectory.objectIds.some((objectId) => {
+            const object = scene.objects.find((entry) => entry.objectId === objectId)?.object;
+            return object ? isStructureLike(object) : false;
+        }))
+        .map((trajectory) => {
+        const stroke = trajectory.stroke ?? "#f0b464";
+        const markerEnd = trajectory.marker === "none" ? "" : ` marker-end="url(#wo-trajectory-arrow)"`;
+        const waypointMarkup = trajectory.showWaypoints && options.showWaypoints
+            ? trajectory.waypoints
+                .filter((waypoint) => !waypoint.hidden)
+                .map((waypoint) => renderTrajectoryWaypoint(trajectory, waypoint, options.showLabels))
+                .join("")
+            : "";
+        return `<g class="wo-trajectory-group" data-render-id="${escapeXml(trajectory.renderId)}" data-trajectory-id="${escapeAttribute(trajectory.trajectoryId)}">
+    <path class="wo-trajectory wo-trajectory-${trajectory.mode}" d="${trajectory.path}" stroke="${escapeAttribute(stroke)}" stroke-width="${trajectory.strokeWidth}"${markerEnd} />
+    ${waypointMarkup}
+  </g>`;
+    })
+        .join("");
+}
+function renderTrajectoryWaypoint(trajectory, waypoint, showLabels) {
+    const labelMarkup = showLabels && trajectory.labelMode !== "hidden"
+        ? [
+            waypoint.label
+                ? `<text class="wo-trajectory-label" x="${waypoint.x + 10}" y="${waypoint.y - 10}" font-size="10">${escapeXml(waypoint.label)}</text>`
+                : "",
+            waypoint.dateLabel
+                ? `<text class="wo-trajectory-date" x="${waypoint.x + 10}" y="${waypoint.y + 4}" font-size="9">${escapeXml(waypoint.dateLabel)}</text>`
+                : "",
+        ].join("")
+        : "";
+    return `<g class="wo-trajectory-waypoint-group" data-render-id="${escapeXml(waypoint.renderId)}" data-trajectory-id="${escapeAttribute(waypoint.trajectoryId)}">
+    <circle class="wo-trajectory-waypoint" cx="${waypoint.x}" cy="${waypoint.y}" r="4.5" />
+    ${labelMarkup}
+  </g>`;
+}
 export function renderDocumentToSvg(document, options = {}) {
     return renderSceneToSvg(renderDocumentToScene(document, options), options);
 }

package/dist/unpkg/viewer/dist/theme.js

@@ -4,6 +4,7 @@ const DEFAULT_LAYERS = {
     relations: true,
     events: true,
     orbits: true,
+    trajectories: true,
     objects: true,
     labels: true,
     structures: true,

package/dist/unpkg/viewer/dist/types.d.ts

@@ -43,6 +43,7 @@ export interface ViewerLayerOptions {
     relations?: boolean;
     events?: boolean;
     orbits?: boolean;
+    trajectories?: boolean;
     objects?: boolean;
     labels?: boolean;
     structures?: boolean;
@@ -77,6 +78,9 @@ export interface ViewerRenderOptions extends Omit<SvgRenderOptions, "selectedObj
     viewMode?: WorldOrbitViewMode;
     quality?: WorldOrbit3DQuality;
     style3d?: WorldOrbit3DStyle;
+    trajectoryMode?: "illustrative" | "solver" | "auto";
+    showTrajectoryWaypoints?: boolean;
+    showTrajectoryLabels?: boolean;
 }
 export interface ViewerState {
     scale: number;
@@ -130,6 +134,9 @@ export interface ViewerAtlasState {
         layers?: ViewerLayerOptions;
         scaleModel?: Partial<RenderScaleModel>;
         bodyScaleMode?: SceneRenderOptions["bodyScaleMode"];
+        trajectoryMode?: SceneRenderOptions["trajectoryMode"];
+        showTrajectoryWaypoints?: boolean;
+        showTrajectoryLabels?: boolean;
         activeEventId?: string | null;
         viewMode?: WorldOrbitViewMode;
         quality?: WorldOrbit3DQuality;

package/dist/unpkg/viewer/dist/viewer.js

@@ -1691,6 +1691,33 @@ function fallbackSpatialSceneFromRenderScene(scene) {
             hidden: orbit.hidden,
             motion: null,
         })),
+        trajectories: scene.trajectories.map((trajectory) => ({
+            trajectoryId: trajectory.trajectoryId,
+            trajectory: trajectory.trajectory,
+            craftObjectId: trajectory.craftObjectId,
+            mode: trajectory.mode,
+            stroke: trajectory.stroke,
+            strokeWidth: trajectory.strokeWidth,
+            marker: trajectory.marker,
+            labelMode: trajectory.labelMode,
+            showWaypoints: trajectory.showWaypoints,
+            samples: [],
+            waypoints: trajectory.waypoints.map((waypoint) => ({
+                trajectoryId: waypoint.trajectoryId,
+                segmentId: waypoint.segmentId,
+                maneuverId: waypoint.maneuverId,
+                objectId: waypoint.objectId,
+                position: {
+                    x: waypoint.x - scene.contentBounds.centerX,
+                    y: 0,
+                    z: waypoint.y - scene.contentBounds.centerY,
+                },
+                label: waypoint.label,
+                dateLabel: waypoint.dateLabel,
+                hidden: waypoint.hidden,
+            })),
+            hidden: trajectory.hidden,
+        })),
         focusTargets: scene.objects.map((object) => ({
             objectId: object.objectId,
             center: {