worldorbit 2.5.16 → 2.6.0

package/packages/editor/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { AtlasDocumentPath, AtlasResolvedDiagnostic, WorldOrbitAtlasDocument, WorldOrbitAtlasSystem, WorldOrbitAtlasViewpoint, WorldOrbitObject } from "@worldorbit/core";
+import type { AtlasDocumentPath, AtlasResolvedDiagnostic, WorldOrbitAtlasDocument, WorldOrbitEvent, WorldOrbitAtlasSystem, WorldOrbitAtlasViewpoint, WorldOrbitObject } from "@worldorbit/core";
 export interface WorldOrbitEditorSelection {
     path: AtlasDocumentPath | null;
 }
@@ -37,6 +37,7 @@ export interface WorldOrbitEditor {
     undo(): boolean;
     redo(): boolean;
     addObject(type?: WorldOrbitObject["type"]): string;
+    addEvent(): string;
     addViewpoint(): string;
     addAnnotation(): string;
     addMetadata(key?: string, value?: string): string;
@@ -49,5 +50,6 @@ export interface WorldOrbitEditorFormState {
     selection: WorldOrbitEditorSelection | null;
     system: WorldOrbitAtlasSystem | null;
     viewpoints: WorldOrbitAtlasViewpoint[];
+    events: WorldOrbitEvent[];
     objects: WorldOrbitObject[];
 }

package/packages/viewer/dist/atlas-state.js

@@ -62,14 +62,17 @@ export function searchSceneObjects(scene, query, limit = 12) {
 }
 export function createAtlasStateSnapshot(viewerState, renderOptions, filter, viewpointId) {
     return {
-        version: "2.0",
+        version: "2.5",
         viewpointId,
+        activeEventId: renderOptions.activeEventId ?? null,
         viewerState: { ...viewerState },
         renderOptions: {
             preset: renderOptions.preset,
             projection: renderOptions.projection,
+            camera: renderOptions.camera ? { ...renderOptions.camera } : null,
             layers: renderOptions.layers ? { ...renderOptions.layers } : undefined,
             scaleModel: renderOptions.scaleModel ? { ...renderOptions.scaleModel } : undefined,
+            activeEventId: renderOptions.activeEventId ?? null,
         },
         filter: normalizeViewerFilter(filter),
     };
@@ -80,8 +83,9 @@ export function serializeViewerAtlasState(state) {
 export function deserializeViewerAtlasState(serialized) {
     const raw = JSON.parse(decodeURIComponent(serialized));
     return {
-        version: "2.0",
+        version: raw.version === "2.0" ? "2.0" : "2.5",
         viewpointId: raw.viewpointId ?? null,
+        activeEventId: raw.activeEventId ?? raw.renderOptions?.activeEventId ?? null,
         viewerState: {
             scale: raw.viewerState?.scale ?? 1,
             rotationDeg: raw.viewerState?.rotationDeg ?? 0,
@@ -92,10 +96,12 @@ export function deserializeViewerAtlasState(serialized) {
         renderOptions: {
             preset: raw.renderOptions?.preset,
             projection: raw.renderOptions?.projection,
+            camera: raw.renderOptions?.camera ? { ...raw.renderOptions.camera } : null,
             layers: raw.renderOptions?.layers ? { ...raw.renderOptions.layers } : undefined,
             scaleModel: raw.renderOptions?.scaleModel
                 ? { ...raw.renderOptions.scaleModel }
                 : undefined,
+            activeEventId: raw.activeEventId ?? raw.renderOptions?.activeEventId ?? null,
         },
         filter: normalizeViewerFilter(raw.filter ?? null),
     };
@@ -113,10 +119,12 @@ export function createViewerBookmark(name, label, atlasState) {
             viewerState: { ...atlasState.viewerState },
             renderOptions: {
                 ...atlasState.renderOptions,
+                camera: atlasState.renderOptions.camera ? { ...atlasState.renderOptions.camera } : null,
                 layers: atlasState.renderOptions.layers ? { ...atlasState.renderOptions.layers } : undefined,
                 scaleModel: atlasState.renderOptions.scaleModel
                     ? { ...atlasState.renderOptions.scaleModel }
                     : undefined,
+                activeEventId: atlasState.renderOptions.activeEventId ?? null,
             },
             filter: atlasState.filter ? { ...atlasState.filter } : null,
         },
@@ -134,6 +142,7 @@ export function sceneViewpointToLayerOptions(viewpoint) {
         background: viewpoint.layers.background,
         guides: viewpoint.layers.guides,
         relations: viewpoint.layers.relations,
+        events: viewpoint.layers.events,
         orbits: viewpoint.layers["orbits-front"] === undefined && viewpoint.layers["orbits-back"] === undefined
             ? undefined
             : viewpoint.layers["orbits-front"] !== false || viewpoint.layers["orbits-back"] !== false,

package/packages/viewer/dist/atlas-viewer.js

@@ -326,6 +326,8 @@ export function createAtlasViewer(container, options) {
     }
     function buildInspectorSnapshot() {
         const activeViewer = requireViewer();
+        const scene = activeViewer.getScene();
+        const camera = scene.camera;
         return {
             selection: activeViewer.getSelectionDetails(),
             activeViewpoint: activeViewer.getActiveViewpoint(),
@@ -333,13 +335,23 @@ export function createAtlasViewer(container, options) {
             atlasState: activeViewer.getAtlasState(),
             visibleObjectIds: activeViewer.getVisibleObjects().map((object) => object.objectId),
             scene: {
-                title: activeViewer.getScene().title,
-                projection: activeViewer.getScene().projection,
-                renderPreset: activeViewer.getScene().renderPreset,
-                groupCount: activeViewer.getScene().groups.length,
-                semanticGroupCount: activeViewer.getScene().semanticGroups.length,
-                relationCount: activeViewer.getScene().relations.length,
-                viewpointCount: activeViewer.getScene().viewpoints.length,
+                title: scene.title,
+                projection: scene.projection,
+                renderProjection: scene.renderProjection,
+                camera: camera
+                    ? {
+                        azimuth: camera.azimuth,
+                        elevation: camera.elevation,
+                        roll: camera.roll,
+                        distance: camera.distance,
+                    }
+                    : null,
+                renderPreset: scene.renderPreset,
+                groupCount: scene.groups.length,
+                semanticGroupCount: scene.semanticGroups.length,
+                relationCount: scene.relations.length,
+                eventCount: scene.events.length,
+                viewpointCount: scene.viewpoints.length,
             },
         };
     }

package/packages/viewer/dist/render.js

@@ -39,6 +39,12 @@ 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 eventMarkup = layers.events
+        ? scene.events
+            .filter((event) => !event.hidden)
+            .map((event) => renderSceneEventOverlay(scene, event, visibleObjectIds, theme))
+            .join("")
+        : "";
     const objectMarkup = layers.objects
         ? visibleObjects
             .map((object) => renderSceneObject(object, options.selectedObjectId ?? null, theme))
@@ -86,6 +92,9 @@ export function renderSceneToSvg(scene, options = {}) {
     .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-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; }
     .wo-label { fill: ${theme.ink}; font-family: ${theme.fontFamily}; font-weight: 600; letter-spacing: 0.02em; }
     .wo-label-secondary { fill: ${theme.muted}; font-family: ${theme.fontFamily}; font-weight: 500; }
@@ -120,14 +129,34 @@ export function renderSceneToSvg(scene, options = {}) {
         ${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>` : ""}
+        ${layers.orbits ? `<g data-layer-id="orbits-front">${orbitMarkup.front}</g>` : ""}
+        ${layers.labels ? `<g data-layer-id="labels">${labelMarkup}</g>` : ""}
       </g>
     </g>
   </g>
 </svg>`;
 }
+function renderSceneEventOverlay(scene, event, visibleObjectIds, theme) {
+    const participants = event.objectIds
+        .filter((objectId) => visibleObjectIds.has(objectId))
+        .map((objectId) => scene.objects.find((object) => object.objectId === objectId && !object.hidden))
+        .filter(Boolean);
+    if (participants.length === 0) {
+        return "";
+    }
+    const stroke = event.event.color || theme.accent;
+    const label = event.event.label || event.event.id;
+    const lineMarkup = participants
+        .map((object) => `<line class="wo-event-line" x1="${event.x}" y1="${event.y}" x2="${object.x}" y2="${object.y}" stroke="${escapeAttribute(stroke)}" data-event-id="${escapeAttribute(event.eventId)}" data-object-id="${escapeAttribute(object.objectId)}" />`)
+        .join("");
+    return `<g class="wo-event" data-render-id="${escapeXml(event.renderId)}" data-event-id="${escapeAttribute(event.eventId)}">
+    ${lineMarkup}
+    <circle class="wo-event-node" cx="${event.x}" cy="${event.y}" r="5" fill="${escapeAttribute(stroke)}" />
+    <text class="wo-event-label" x="${event.x}" y="${event.y - 10}" text-anchor="middle" font-size="10">${escapeXml(label)}</text>
+  </g>`;
+}
 export function renderDocumentToSvg(document, options = {}) {
     return renderSceneToSvg(renderDocumentToScene(document, options), options);
 }

package/packages/viewer/dist/theme.js

@@ -2,6 +2,7 @@ const DEFAULT_LAYERS = {
     background: true,
     guides: true,
     relations: true,
+    events: true,
     orbits: true,
     objects: true,
     labels: true,

package/packages/viewer/dist/tooltip.js

@@ -111,6 +111,15 @@ function buildTooltipFields(details) {
             value: `${details.object.resonance.targetObjectId} ${details.object.resonance.ratio}`,
         });
     }
+    if (details.relatedEvents.length > 0) {
+        fields.set("events", {
+            key: "events",
+            label: "Events",
+            value: details.relatedEvents
+                .map((event) => event.event.label || event.event.id)
+                .join(", "),
+        });
+    }
     if (placement?.mode === "at") {
         fields.set("placement", {
             key: "placement",

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

@@ -1,4 +1,4 @@
-import type { CoordinatePoint, RenderOrbitVisual, RenderPresetName, RenderSceneGroup, RenderSceneLabel, RenderScaleModel, RenderScene, RenderSceneObject, RenderSceneViewpoint, SceneRenderOptions, ViewProjection, WorldOrbitObject, WorldOrbitDocument } from "@worldorbit/core";
+import type { CoordinatePoint, RenderOrbitVisual, RenderProjectionFallback, RenderPresetName, RenderSceneEvent, RenderSceneGroup, RenderSceneLabel, RenderScaleModel, RenderScene, RenderSceneObject, RenderSceneViewpoint, SceneRenderOptions, ViewProjection, WorldOrbitObject, WorldOrbitDocument, WorldOrbitViewCamera } from "@worldorbit/core";
 export type WorldOrbitThemeName = "atlas" | "nightglass" | "ember";
 export type WorldOrbitEmbedMode = "static" | "interactive";
 export type TooltipMode = "hover" | "pinned" | "disabled";
@@ -29,6 +29,7 @@ export interface ViewerLayerOptions {
     background?: boolean;
     guides?: boolean;
     relations?: boolean;
+    events?: boolean;
     orbits?: boolean;
     objects?: boolean;
     labels?: boolean;
@@ -79,6 +80,7 @@ export interface ViewerObjectDetails {
     orbit: RenderOrbitVisual | null;
     relatedOrbits: RenderOrbitVisual[];
     relations: RenderScene["relations"];
+    relatedEvents: RenderSceneEvent[];
     parent: RenderSceneObject | null;
     children: RenderSceneObject[];
     ancestors: RenderSceneObject[];
@@ -102,14 +104,17 @@ export interface ViewerTooltipDetails {
     details: ViewerObjectDetails;
 }
 export interface ViewerAtlasState {
-    version: "2.0";
+    version: "2.0" | "2.5";
     viewpointId: string | null;
+    activeEventId?: string | null;
     viewerState: ViewerState;
     renderOptions: {
         preset?: RenderPresetName;
         projection?: "document" | ViewProjection;
+        camera?: WorldOrbitViewCamera | null;
         layers?: ViewerLayerOptions;
         scaleModel?: Partial<RenderScaleModel>;
+        activeEventId?: string | null;
     };
     filter: ViewerFilter | null;
 }
@@ -135,10 +140,13 @@ export interface AtlasInspectorSnapshot {
     scene: {
         title: string;
         projection: ViewProjection;
+        renderProjection: RenderProjectionFallback;
+        camera: WorldOrbitViewCamera | null;
         renderPreset: RenderPresetName | null;
         groupCount: number;
         semanticGroupCount: number;
         relationCount: number;
+        eventCount: number;
         viewpointCount: number;
     };
 }
@@ -189,6 +197,8 @@ export interface WorldOrbitViewer {
     listViewpoints(): RenderSceneViewpoint[];
     getActiveViewpoint(): RenderSceneViewpoint | null;
     goToViewpoint(id: string): boolean;
+    getActiveEventId(): string | null;
+    setActiveEvent(id: string | null): void;
     search(query: string, limit?: number): ViewerSearchResult[];
     getFilter(): ViewerFilter | null;
     setFilter(filter: ViewerFilter | null): void;

package/packages/viewer/dist/viewer.js

@@ -43,6 +43,7 @@ export function createInteractiveViewer(container, options) {
         padding: options.padding,
         preset: options.preset,
         projection: options.projection,
+        camera: options.camera ? { ...options.camera } : null,
         scaleModel: options.scaleModel ? { ...options.scaleModel } : undefined,
         theme: options.theme,
         layers: options.layers,
@@ -333,6 +334,12 @@ export function createInteractiveViewer(container, options) {
             if (currentInput.kind !== "scene" && viewpoint.projection !== scene.projection) {
                 nextRenderOptions.projection = viewpoint.projection;
             }
+            if (viewpoint.camera) {
+                nextRenderOptions.camera = { ...viewpoint.camera };
+            }
+            else if (renderOptions.camera) {
+                nextRenderOptions.camera = null;
+            }
             if (viewpointLayers) {
                 nextRenderOptions.layers = viewpointLayers;
             }
@@ -355,6 +362,12 @@ export function createInteractiveViewer(container, options) {
             emitAtlasStateChange();
             return true;
         },
+        getActiveEventId() {
+            return renderOptions.activeEventId ?? null;
+        },
+        setActiveEvent(id) {
+            api.setRenderOptions({ activeEventId: id });
+        },
         search(query, limit = 12) {
             return searchSceneObjects(scene, query, limit);
         },
@@ -653,6 +666,9 @@ export function createInteractiveViewer(container, options) {
             relations: scene.relations.filter((relation) => !relation.hidden &&
                 (relation.fromObjectId === renderObject.objectId ||
                     relation.toObjectId === renderObject.objectId)),
+            relatedEvents: scene.events.filter((event) => !event.hidden &&
+                (event.targetObjectId === renderObject.objectId ||
+                    event.objectIds.includes(renderObject.objectId))),
             parent: getObjectById(renderObject.parentId),
             children: renderObject.childIds.map((childId) => getObjectById(childId)).filter(Boolean),
             ancestors: renderObject.ancestorIds
@@ -983,18 +999,27 @@ function renderSceneFromInput(input, renderOptions) {
 function cloneRenderOptions(renderOptions) {
     return {
         ...renderOptions,
+        camera: renderOptions.camera ? { ...renderOptions.camera } : null,
         filter: renderOptions.filter ? { ...renderOptions.filter } : undefined,
         scaleModel: renderOptions.scaleModel ? { ...renderOptions.scaleModel } : undefined,
         layers: renderOptions.layers ? { ...renderOptions.layers } : undefined,
         theme: renderOptions.theme && typeof renderOptions.theme === "object"
             ? { ...renderOptions.theme }
             : renderOptions.theme,
+        activeEventId: renderOptions.activeEventId ?? null,
     };
 }
 function mergeRenderOptions(current, next) {
     return {
         ...current,
         ...next,
+        camera: next.camera !== undefined
+            ? next.camera
+                ? { ...next.camera }
+                : null
+            : current.camera
+                ? { ...current.camera }
+                : null,
         filter: next.filter !== undefined
             ? normalizeViewerFilter(next.filter)
             : current.filter
@@ -1027,7 +1052,9 @@ function hasSceneAffectingRenderOptions(options) {
         options.padding !== undefined ||
         options.preset !== undefined ||
         options.projection !== undefined ||
-        options.scaleModel !== undefined);
+        options.camera !== undefined ||
+        options.scaleModel !== undefined ||
+        options.activeEventId !== undefined);
 }
 function resolveSourceRenderOptions(loaded, renderOptions) {
     const atlasDocument = loaded.atlasDocument ?? loaded.draftDocument;