worldorbit 4.0.0 → 5.0.0

package/dist/browser/core/dist/scene.js

@@ -138,7 +138,8 @@ export function renderDocumentToScene(document, options = {}) {
     const labels = createSceneLabels(objects, width, height, scaleModel.labelMultiplier);
     const relations = createSceneRelations(document, objects);
     const events = createSceneEvents(document.events ?? [], objects, activeEventId);
-    const layers = createSceneLayers(orbitVisuals, relations, events, leaders, objects, labels);
+    const trajectories = createSceneTrajectories(document, objects, events, options);
+    const layers = createSceneLayers(orbitVisuals, trajectories, relations, events, leaders, objects, labels);
     const groups = createSceneGroups(objects, orbitVisuals, leaders, labels, relationships, scaleModel.labelMultiplier);
     const semanticGroups = createSceneSemanticGroups(document, objects);
     const viewpoints = createSceneViewpoints(document, schemaProjection, frame.preset, relationships, objectMap);
@@ -179,6 +180,7 @@ export function renderDocumentToScene(document, options = {}) {
         viewpoints,
         events,
         activeEventId,
+        trajectories,
         objects,
         orbitVisuals,
         relations,
@@ -662,7 +664,7 @@ function createLabelPlacement(object, direction, attempt, labelMultiplier) {
         }
     }
 }
-function createSceneLayers(orbitVisuals, relations, events, leaders, objects, labels) {
+function createSceneLayers(orbitVisuals, trajectories, relations, events, leaders, objects, labels) {
     const backOrbitIds = orbitVisuals
         .filter((visual) => !visual.hidden && Boolean(visual.backArcPath))
         .map((visual) => visual.renderId);
@@ -677,6 +679,15 @@ function createSceneLayers(orbitVisuals, relations, events, leaders, objects, la
         },
         { id: "orbits-back", renderIds: backOrbitIds },
         { id: "orbits-front", renderIds: frontOrbitIds },
+        {
+            id: "trajectories",
+            renderIds: trajectories
+                .filter((trajectory) => !trajectory.hidden)
+                .flatMap((trajectory) => [
+                trajectory.renderId,
+                ...trajectory.waypoints.filter((waypoint) => !waypoint.hidden).map((waypoint) => waypoint.renderId),
+            ]),
+        },
         {
             id: "relations",
             renderIds: relations.filter((relation) => !relation.hidden).map((relation) => relation.renderId),
@@ -819,6 +830,206 @@ function createSceneEvents(events, objects, activeEventId) {
     })
         .sort((left, right) => left.event.id.localeCompare(right.event.id));
 }
+function createSceneTrajectories(document, objects, events, options) {
+    const objectMap = new Map(objects.map((object) => [object.objectId, object]));
+    return document.trajectories
+        .map((trajectory) => createSceneTrajectory(trajectory, objectMap, events, options))
+        .sort((left, right) => left.trajectoryId.localeCompare(right.trajectoryId));
+}
+function createSceneTrajectory(trajectory, objectMap, events, options) {
+    const craftObject = trajectory.craftObjectId ? objectMap.get(trajectory.craftObjectId) ?? null : null;
+    const mode = resolveTrajectoryMode(trajectory, options);
+    const stroke = trajectory.stroke ?? trajectory.color ?? craftObject?.fillColor ?? null;
+    const strokeWidth = trajectory.strokeWidth ?? 2.4;
+    const showWaypoints = options.showTrajectoryWaypoints ?? trajectory.showWaypoints ?? true;
+    const labelMode = trajectory.labelMode ?? (options.showTrajectoryLabels === false ? "hidden" : "waypoint");
+    const pathParts = [];
+    const waypoints = [];
+    const objectIds = new Set();
+    let lastAnchor = craftObject;
+    if (craftObject) {
+        objectIds.add(craftObject.objectId);
+    }
+    trajectory.segments.forEach((segment, index) => {
+        const geometry = buildTrajectorySegmentGeometry(trajectory, segment, index, mode, objectMap, lastAnchor, showWaypoints);
+        if (geometry.path) {
+            pathParts.push(geometry.path);
+        }
+        geometry.objectIds.forEach((objectId) => objectIds.add(objectId));
+        waypoints.push(...geometry.waypoints);
+        lastAnchor = geometry.lastAnchor ?? lastAnchor;
+    });
+    for (const event of events.filter((entry) => entry.event.trajectoryId === trajectory.id)) {
+        const eventObject = event.targetObjectId
+            ? objectMap.get(event.targetObjectId) ?? null
+            : event.objectIds.map((objectId) => objectMap.get(objectId) ?? null).find(Boolean) ?? null;
+        if (!eventObject) {
+            continue;
+        }
+        waypoints.push({
+            renderId: `${createRenderId(`${trajectory.id}-${event.eventId}`)}-waypoint`,
+            trajectoryId: trajectory.id,
+            segmentId: null,
+            maneuverId: null,
+            objectId: eventObject.objectId,
+            x: eventObject.x,
+            y: eventObject.y,
+            label: event.event.label ?? event.event.id,
+            dateLabel: event.event.epoch ?? null,
+            hidden: trajectory.hidden || event.hidden || !showWaypoints,
+        });
+        objectIds.add(eventObject.objectId);
+    }
+    return {
+        renderId: `${createRenderId(trajectory.id)}-trajectory`,
+        trajectoryId: trajectory.id,
+        trajectory,
+        craftObjectId: trajectory.craftObjectId,
+        mode,
+        path: pathParts.join(" "),
+        stroke,
+        strokeWidth,
+        marker: trajectory.marker ?? "arrow",
+        labelMode,
+        showWaypoints,
+        objectIds: [...objectIds],
+        waypoints,
+        hidden: trajectory.hidden || pathParts.length === 0,
+    };
+}
+function buildTrajectorySegmentGeometry(trajectory, segment, segmentIndex, mode, objectMap, fallbackStart, showWaypoints) {
+    const start = resolveTrajectoryObject(segment.fromObjectId, objectMap) ??
+        fallbackStart;
+    const assist = resolveTrajectoryObject(segment.assist?.objectId ?? segment.aroundObjectId ?? null, objectMap);
+    const end = resolveTrajectoryObject(segment.toObjectId, objectMap) ??
+        resolveTrajectoryObject(segment.aroundObjectId, objectMap) ??
+        assist ??
+        start;
+    if (!start || !end) {
+        return {
+            path: "",
+            objectIds: [],
+            waypoints: [],
+            lastAnchor: fallbackStart,
+        };
+    }
+    const objectIds = [start.objectId, end.objectId];
+    if (assist) {
+        objectIds.push(assist.objectId);
+    }
+    const hidden = trajectory.hidden || segment.renderHidden === true || start.hidden || end.hidden;
+    const waypoints = [];
+    const label = segment.waypointLabel ?? segment.label ?? humanizeIdentifier(segment.id);
+    const dateLabel = segment.waypointDate ?? segment.epoch ?? null;
+    if (showWaypoints) {
+        if (segmentIndex === 0) {
+            waypoints.push(createTrajectoryWaypoint(trajectory.id, segment.id, null, start, start.label, null, hidden));
+        }
+        if (assist && assist.objectId !== start.objectId && assist.objectId !== end.objectId) {
+            waypoints.push(createTrajectoryWaypoint(trajectory.id, segment.id, null, assist, label, dateLabel, hidden));
+        }
+        waypoints.push(createTrajectoryWaypoint(trajectory.id, segment.id, null, end, label, dateLabel, hidden));
+    }
+    const samples = mode === "solver"
+        ? sampleQuadraticPoints(start, resolveTrajectoryControlPoint(start, end, assist, segmentIndex), end, Math.max(10, Math.round((segment.sampleDensity ?? 1) * 14)))
+        : null;
+    const control = resolveTrajectoryControlPoint(start, end, assist, segmentIndex);
+    const path = mode === "solver"
+        ? pointsToPath(samples ?? [start, end])
+        : `M ${formatPathNumber(start.x)} ${formatPathNumber(start.y)} Q ${formatPathNumber(control.x)} ${formatPathNumber(control.y)} ${formatPathNumber(end.x)} ${formatPathNumber(end.y)}`;
+    segment.maneuvers.forEach((maneuver, maneuverIndex) => {
+        if (!showWaypoints) {
+            return;
+        }
+        const point = samplePointOnQuadratic(start, control, end, (maneuverIndex + 1) / (segment.maneuvers.length + 1));
+        waypoints.push({
+            renderId: `${createRenderId(`${trajectory.id}-${segment.id}-${maneuver.id}`)}-waypoint`,
+            trajectoryId: trajectory.id,
+            segmentId: segment.id,
+            maneuverId: maneuver.id,
+            objectId: null,
+            x: point.x,
+            y: point.y,
+            label: maneuver.label ?? maneuver.kind,
+            dateLabel: maneuver.epoch ?? null,
+            hidden,
+        });
+    });
+    return {
+        path,
+        objectIds: [...new Set(objectIds)],
+        waypoints,
+        lastAnchor: end,
+    };
+}
+function createTrajectoryWaypoint(trajectoryId, segmentId, maneuverId, object, label, dateLabel, hidden) {
+    return {
+        renderId: `${createRenderId(`${trajectoryId}-${segmentId ?? object.objectId}-${maneuverId ?? object.objectId}`)}-waypoint`,
+        trajectoryId,
+        segmentId,
+        maneuverId,
+        objectId: object.objectId,
+        x: object.x,
+        y: object.y,
+        label,
+        dateLabel,
+        hidden,
+    };
+}
+function resolveTrajectoryMode(trajectory, options) {
+    const requested = options.trajectoryMode ?? trajectory.renderMode ?? "auto";
+    if (requested !== "auto") {
+        return requested;
+    }
+    const segmentCount = trajectory.segments.filter((segment) => segment.fromObjectId || segment.toObjectId || segment.assist?.objectId || segment.aroundObjectId).length;
+    return segmentCount > 0 ? "solver" : "illustrative";
+}
+function resolveTrajectoryObject(objectId, objectMap) {
+    return objectId ? objectMap.get(objectId) ?? null : null;
+}
+function resolveTrajectoryControlPoint(start, end, assist, segmentIndex) {
+    if (assist) {
+        return {
+            x: assist.x,
+            y: assist.y,
+        };
+    }
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const length = Math.max(Math.hypot(dx, dy), 1);
+    const offset = Math.min(Math.max(length * 0.18, 26), 120) * (segmentIndex % 2 === 0 ? 1 : -1);
+    const normalX = -dy / length;
+    const normalY = dx / length;
+    return {
+        x: (start.x + end.x) / 2 + normalX * offset,
+        y: (start.y + end.y) / 2 + normalY * offset,
+    };
+}
+function sampleQuadraticPoints(start, control, end, count) {
+    const samples = [];
+    for (let index = 0; index <= count; index += 1) {
+        samples.push(samplePointOnQuadratic(start, control, end, index / count));
+    }
+    return samples;
+}
+function samplePointOnQuadratic(start, control, end, t) {
+    const inverse = 1 - t;
+    return {
+        x: inverse * inverse * start.x + 2 * inverse * t * control.x + t * t * end.x,
+        y: inverse * inverse * start.y + 2 * inverse * t * control.y + t * t * end.y,
+    };
+}
+function pointsToPath(points) {
+    if (points.length === 0) {
+        return "";
+    }
+    return points
+        .map((point, index) => `${index === 0 ? "M" : "L"} ${formatPathNumber(point.x)} ${formatPathNumber(point.y)}`)
+        .join(" ");
+}
+function formatPathNumber(value) {
+    return Number.isFinite(value) ? value.toFixed(2) : "0";
+}
 function createSceneViewpoints(document, projection, preset, relationships, objectMap) {
     const generatedOverview = createGeneratedOverviewViewpoint(document, projection, preset);
     const drafts = new Map();
@@ -1099,7 +1310,8 @@ function parseViewpointLayers(value) {
             rawLayer === "events" ||
             rawLayer === "objects" ||
             rawLayer === "labels" ||
-            rawLayer === "metadata") {
+            rawLayer === "metadata" ||
+            rawLayer === "trajectories") {
             next[rawLayer] = enabled;
         }
     }

package/dist/browser/core/dist/solver.d.ts

@@ -1,4 +1,4 @@
-import type { UnitValue, WorldOrbitTrajectory, WorldOrbitTrajectorySegment } from "./types.js";
+import type { SceneRenderOptions, SpatialTrajectory, UnitValue, WorldOrbitDocument, WorldOrbitTrajectory, WorldOrbitTrajectorySegment } from "./types.js";
 export interface SolverSegmentSample {
     segmentId: string;
     kind: WorldOrbitTrajectorySegment["kind"];
@@ -23,4 +23,11 @@ export interface SolverTrajectorySnapshot {
     segments: SolverSegmentSample[];
     maneuvers: SolverManeuverSample[];
 }
+export interface TrajectorySamplingOptions extends Pick<SceneRenderOptions, "width" | "height" | "padding" | "preset" | "projection" | "camera" | "scaleModel" | "bodyScaleMode"> {
+    trajectoryMode?: "illustrative" | "solver" | "auto";
+    showTrajectoryWaypoints?: boolean;
+    showTrajectoryLabels?: boolean;
+}
 export declare function createTrajectorySolverSnapshot(trajectory: WorldOrbitTrajectory): SolverTrajectorySnapshot;
+export declare function sampleTrajectory(trajectory: WorldOrbitTrajectory, document: WorldOrbitDocument, options?: TrajectorySamplingOptions): SpatialTrajectory | null;
+export declare function sampleDocumentTrajectories(document: WorldOrbitDocument, options?: TrajectorySamplingOptions): SpatialTrajectory[];

package/dist/browser/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/browser/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/browser/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";