worldorbit 2.5.15 → 2.5.17

package/packages/core/dist/scene.js

@@ -18,8 +18,10 @@ export function renderDocumentToScene(document, options = {}) {
     const scaleModel = resolveScaleModel(layoutPreset, options.scaleModel);
     const spacingFactor = layoutPresetSpacing(layoutPreset);
     const systemId = document.system?.id ?? null;
-    const objectMap = new Map(document.objects.map((object) => [object.id, object]));
-    const relationships = buildSceneRelationships(document.objects, objectMap);
+    const activeEventId = options.activeEventId ?? null;
+    const effectiveObjects = createEffectiveObjects(document.objects, document.events ?? [], activeEventId);
+    const objectMap = new Map(effectiveObjects.map((object) => [object.id, object]));
+    const relationships = buildSceneRelationships(effectiveObjects, objectMap);
     const positions = new Map();
     const orbitDrafts = [];
     const leaderDrafts = [];
@@ -28,7 +30,7 @@ export function renderDocumentToScene(document, options = {}) {
     const atObjects = [];
     const surfaceChildren = new Map();
     const orbitChildren = new Map();
-    for (const object of document.objects) {
+    for (const object of effectiveObjects) {
         const placement = object.placement;
         if (!placement) {
             rootObjects.push(object);
@@ -129,13 +131,14 @@ export function renderDocumentToScene(document, options = {}) {
     const objects = [...positions.values()].map((position) => createSceneObject(position, scaleModel, relationships));
     const orbitVisuals = orbitDrafts.map((draft) => createOrbitVisual(draft, relationships.groupIds.get(draft.object.id) ?? null));
     const leaders = leaderDrafts.map((draft) => createLeaderLine(draft));
-    const labels = createSceneLabels(objects, height, scaleModel.labelMultiplier);
+    const labels = createSceneLabels(objects, width, height, scaleModel.labelMultiplier);
     const relations = createSceneRelations(document, objects);
-    const layers = createSceneLayers(orbitVisuals, relations, leaders, objects, labels);
-    const groups = createSceneGroups(objects, orbitVisuals, leaders, labels, relationships);
+    const events = createSceneEvents(document.events ?? [], objects, activeEventId);
+    const layers = createSceneLayers(orbitVisuals, relations, events, leaders, objects, labels);
+    const groups = createSceneGroups(objects, orbitVisuals, leaders, labels, relationships, scaleModel.labelMultiplier);
     const semanticGroups = createSceneSemanticGroups(document, objects);
     const viewpoints = createSceneViewpoints(document, projection, frame.preset, relationships, objectMap);
-    const contentBounds = calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels);
+    const contentBounds = calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels, scaleModel.labelMultiplier);
     return {
         width,
         height,
@@ -162,6 +165,8 @@ export function renderDocumentToScene(document, options = {}) {
         groups,
         semanticGroups,
         viewpoints,
+        events,
+        activeEventId,
         objects,
         orbitVisuals,
         relations,
@@ -180,6 +185,37 @@ export function rotatePoint(point, center, rotationDeg) {
         y: center.y + dx * sin + dy * cos,
     };
 }
+function createEffectiveObjects(objects, events, activeEventId) {
+    const cloned = objects.map((object) => structuredClone(object));
+    if (!activeEventId) {
+        return cloned;
+    }
+    const activeEvent = events.find((event) => event.id === activeEventId);
+    if (!activeEvent) {
+        return cloned;
+    }
+    const objectMap = new Map(cloned.map((object) => [object.id, object]));
+    for (const pose of activeEvent.positions) {
+        const object = objectMap.get(pose.objectId);
+        if (!object) {
+            continue;
+        }
+        object.placement = pose.placement ? structuredClone(pose.placement) : null;
+        if (pose.inner) {
+            object.properties.inner = { ...pose.inner };
+        }
+        else {
+            delete object.properties.inner;
+        }
+        if (pose.outer) {
+            object.properties.outer = { ...pose.outer };
+        }
+        else {
+            delete object.properties.outer;
+        }
+    }
+    return cloned;
+}
 function resolveLayoutPreset(document) {
     const rawScale = String(document.system?.properties.scale ?? "balanced").toLowerCase();
     switch (rawScale) {
@@ -339,26 +375,17 @@ function createLeaderLine(draft) {
         hidden: draft.object.properties.hidden === true,
     };
 }
-function createSceneLabels(objects, sceneHeight, labelMultiplier) {
+function createSceneLabels(objects, sceneWidth, sceneHeight, labelMultiplier) {
     const labels = [];
     const occupied = [];
+    const objectMap = new Map(objects.map((object) => [object.objectId, object]));
     const visibleObjects = [...objects]
         .filter((object) => !object.hidden && object.object.renderHints?.renderLabel !== false)
-        .sort((left, right) => left.sortKey - right.sortKey);
+        .sort(compareLabelPlacementOrder);
     for (const object of visibleObjects) {
-        const direction = object.y > sceneHeight * 0.62 ? -1 : 1;
-        const labelHalfWidth = estimateLabelHalfWidth(object, labelMultiplier);
-        let labelY = object.y + direction * (object.radius + 18 * labelMultiplier);
-        let secondaryY = labelY + direction * (16 * labelMultiplier);
-        let bounds = createLabelRect(object.x, labelY, secondaryY, labelHalfWidth, direction);
-        let attempts = 0;
-        while (occupied.some((entry) => rectsOverlap(entry, bounds)) && attempts < 10) {
-            labelY += direction * 14 * labelMultiplier;
-            secondaryY += direction * 14 * labelMultiplier;
-            bounds = createLabelRect(object.x, labelY, secondaryY, labelHalfWidth, direction);
-            attempts += 1;
-        }
-        occupied.push(bounds);
+        const placement = selectLabelPlacement(object, objectMap, occupied, sceneWidth, sceneHeight, labelMultiplier) ??
+            createLabelPlacement(object, defaultVerticalDirection(object, objectMap.get(object.parentId ?? "") ?? null, sceneHeight), 0, labelMultiplier);
+        occupied.push(createLabelRect(object, placement, labelMultiplier));
         labels.push({
             renderId: `${object.renderId}-label`,
             objectId: object.objectId,
@@ -367,17 +394,134 @@ function createSceneLabels(objects, sceneHeight, labelMultiplier) {
             semanticGroupIds: [...object.semanticGroupIds],
             label: object.label,
             secondaryLabel: object.secondaryLabel,
-            x: object.x,
-            y: labelY,
-            secondaryY,
-            textAnchor: "middle",
-            direction: direction < 0 ? "above" : "below",
+            x: placement.x,
+            y: placement.labelY,
+            secondaryY: placement.secondaryY,
+            textAnchor: placement.textAnchor,
+            direction: placement.direction,
             hidden: object.hidden,
         });
     }
     return labels;
 }
-function createSceneLayers(orbitVisuals, relations, leaders, objects, labels) {
+function compareLabelPlacementOrder(left, right) {
+    const priorityDiff = labelPlacementPriority(left) - labelPlacementPriority(right);
+    if (priorityDiff !== 0) {
+        return priorityDiff;
+    }
+    const renderPriorityDiff = (right.object.renderHints?.renderPriority ?? 0) - (left.object.renderHints?.renderPriority ?? 0);
+    if (renderPriorityDiff !== 0) {
+        return renderPriorityDiff;
+    }
+    return left.sortKey - right.sortKey;
+}
+function labelPlacementPriority(object) {
+    switch (object.object.type) {
+        case "star":
+            return 0;
+        case "planet":
+            return 1;
+        case "moon":
+            return 2;
+        case "belt":
+        case "ring":
+            return 3;
+        case "asteroid":
+        case "comet":
+            return 4;
+        case "structure":
+        case "phenomenon":
+            return 5;
+    }
+}
+function selectLabelPlacement(object, objectMap, occupied, sceneWidth, sceneHeight, labelMultiplier) {
+    for (const direction of preferredLabelDirections(object, objectMap, sceneWidth, sceneHeight)) {
+        const maxAttempts = direction === "left" || direction === "right" ? 4 : 6;
+        for (let attempt = 0; attempt <= maxAttempts; attempt += 1) {
+            const placement = createLabelPlacement(object, direction, attempt, labelMultiplier);
+            const rect = createLabelRect(object, placement, labelMultiplier);
+            if (!occupied.some((entry) => rectsOverlap(entry, rect))) {
+                return placement;
+            }
+        }
+    }
+    return null;
+}
+function preferredLabelDirections(object, objectMap, sceneWidth, sceneHeight) {
+    const parent = object.parentId ? objectMap.get(object.parentId) ?? null : null;
+    const vertical = defaultVerticalDirection(object, parent, sceneHeight);
+    const oppositeVertical = vertical === "below" ? "above" : "below";
+    const horizontal = defaultHorizontalDirection(object, parent, sceneWidth);
+    const oppositeHorizontal = horizontal === "right" ? "left" : "right";
+    const preferHorizontal = object.object.type === "structure" ||
+        object.object.type === "phenomenon" ||
+        object.object.placement?.mode === "at" ||
+        object.object.placement?.mode === "surface" ||
+        object.object.placement?.mode === "free";
+    return preferHorizontal
+        ? [horizontal, vertical, oppositeHorizontal, oppositeVertical]
+        : [vertical, horizontal, oppositeVertical, oppositeHorizontal];
+}
+function defaultVerticalDirection(object, parent, sceneHeight) {
+    if (parent && Math.abs(object.y - parent.y) > 6) {
+        return object.y >= parent.y ? "below" : "above";
+    }
+    return object.y > sceneHeight * 0.62 ? "above" : "below";
+}
+function defaultHorizontalDirection(object, parent, sceneWidth) {
+    if (parent && Math.abs(object.x - parent.x) > 6) {
+        return object.x >= parent.x ? "right" : "left";
+    }
+    return object.x >= sceneWidth / 2 ? "right" : "left";
+}
+function createLabelPlacement(object, direction, attempt, labelMultiplier) {
+    const step = 14 * labelMultiplier;
+    switch (direction) {
+        case "above": {
+            const labelY = object.y - (object.radius + 18 * labelMultiplier + attempt * step);
+            return {
+                x: object.x,
+                labelY,
+                secondaryY: labelY - 16 * labelMultiplier,
+                textAnchor: "middle",
+                direction,
+            };
+        }
+        case "below": {
+            const labelY = object.y + object.radius + 18 * labelMultiplier + attempt * step;
+            return {
+                x: object.x,
+                labelY,
+                secondaryY: labelY + 16 * labelMultiplier,
+                textAnchor: "middle",
+                direction,
+            };
+        }
+        case "left": {
+            const x = object.x - (object.visualRadius + 16 * labelMultiplier + attempt * step);
+            const labelY = object.y - 4 * labelMultiplier;
+            return {
+                x,
+                labelY,
+                secondaryY: labelY + 16 * labelMultiplier,
+                textAnchor: "end",
+                direction,
+            };
+        }
+        case "right": {
+            const x = object.x + object.visualRadius + 16 * labelMultiplier + attempt * step;
+            const labelY = object.y - 4 * labelMultiplier;
+            return {
+                x,
+                labelY,
+                secondaryY: labelY + 16 * labelMultiplier,
+                textAnchor: "start",
+                direction,
+            };
+        }
+    }
+}
+function createSceneLayers(orbitVisuals, relations, events, leaders, objects, labels) {
     const backOrbitIds = orbitVisuals
         .filter((visual) => !visual.hidden && Boolean(visual.backArcPath))
         .map((visual) => visual.renderId);
@@ -396,6 +540,10 @@ function createSceneLayers(orbitVisuals, relations, leaders, objects, labels) {
             id: "relations",
             renderIds: relations.filter((relation) => !relation.hidden).map((relation) => relation.renderId),
         },
+        {
+            id: "events",
+            renderIds: events.filter((event) => !event.hidden).map((event) => event.renderId),
+        },
         {
             id: "objects",
             renderIds: objects.filter((object) => !object.hidden).map((object) => object.renderId),
@@ -407,7 +555,7 @@ function createSceneLayers(orbitVisuals, relations, leaders, objects, labels) {
         { id: "metadata", renderIds: ["wo-title", "wo-subtitle", "wo-meta"] },
     ];
 }
-function createSceneGroups(objects, orbitVisuals, leaders, labels, relationships) {
+function createSceneGroups(objects, orbitVisuals, leaders, labels, relationships, labelMultiplier) {
     const groups = new Map();
     const ensureGroup = (groupId) => {
         if (!groupId) {
@@ -456,7 +604,7 @@ function createSceneGroups(objects, orbitVisuals, leaders, labels, relationships
         }
     }
     for (const group of groups.values()) {
-        group.contentBounds = calculateGroupBounds(group, objects, orbitVisuals, leaders, labels);
+        group.contentBounds = calculateGroupBounds(group, objects, orbitVisuals, leaders, labels, labelMultiplier);
     }
     return [...groups.values()].sort((left, right) => left.label.localeCompare(right.label));
 }
@@ -496,6 +644,40 @@ function createSceneRelations(document, objects) {
     })
         .sort((left, right) => left.relation.id.localeCompare(right.relation.id));
 }
+function createSceneEvents(events, objects, activeEventId) {
+    const objectMap = new Map(objects.map((object) => [object.objectId, object]));
+    return events
+        .map((event) => {
+        const objectIds = [...new Set([
+                ...(event.targetObjectId ? [event.targetObjectId] : []),
+                ...event.participantObjectIds,
+            ])];
+        const positions = objectIds
+            .map((objectId) => objectMap.get(objectId))
+            .filter(Boolean);
+        const centroidX = positions.length > 0
+            ? positions.reduce((sum, object) => sum + object.x, 0) / positions.length
+            : 0;
+        const centroidY = positions.length > 0
+            ? positions.reduce((sum, object) => sum + object.y, 0) / positions.length
+            : 0;
+        return {
+            renderId: `${createRenderId(event.id)}-event`,
+            eventId: event.id,
+            event,
+            objectIds,
+            participantIds: [...event.participantObjectIds],
+            targetObjectId: event.targetObjectId,
+            x: centroidX,
+            y: centroidY,
+            hidden: event.hidden ||
+                positions.length === 0 ||
+                positions.every((object) => object.hidden) ||
+                (activeEventId !== null && event.id !== activeEventId),
+        };
+    })
+        .sort((left, right) => left.event.id.localeCompare(right.event.id));
+}
 function createSceneViewpoints(document, projection, preset, relationships, objectMap) {
     const generatedOverview = createGeneratedOverviewViewpoint(document, projection, preset);
     const drafts = new Map();
@@ -552,6 +734,7 @@ function createGeneratedOverviewViewpoint(document, projection, preset) {
         summary: "Fit the whole system with the current atlas defaults.",
         objectId: null,
         selectedObjectId: null,
+        eventIds: [],
         projection,
         preset,
         rotationDeg: 0,
@@ -588,6 +771,9 @@ function applyViewpointField(draft, field, value, document, projection, preset,
                 draft.select = normalizedValue;
             }
             return;
+        case "events":
+            draft.eventIds = splitListValue(normalizedValue);
+            return;
         case "projection":
         case "view":
             draft.projection = parseViewProjection(normalizedValue) ?? projection;
@@ -646,6 +832,7 @@ function finalizeViewpointDraft(draft, projection, preset, objectMap) {
         summary: draft.summary?.trim() || createViewpointSummary(label, objectId, filter),
         objectId,
         selectedObjectId,
+        eventIds: [...new Set(draft.eventIds ?? [])],
         projection: draft.projection ?? projection,
         preset: draft.preset ?? preset,
         rotationDeg: draft.rotationDeg ?? 0,
@@ -720,6 +907,7 @@ function parseViewpointLayers(value) {
             rawLayer === "orbits-back" ||
             rawLayer === "orbits-front" ||
             rawLayer === "relations" ||
+            rawLayer === "events" ||
             rawLayer === "objects" ||
             rawLayer === "labels" ||
             rawLayer === "metadata") {
@@ -790,7 +978,7 @@ function createViewpointSummary(label, objectId, filter) {
     }
     return parts.join(" - ");
 }
-function calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels) {
+function calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels, labelMultiplier) {
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
     let maxX = Number.NEGATIVE_INFINITY;
@@ -820,7 +1008,7 @@ function calculateContentBounds(width, height, objects, orbitVisuals, leaders, l
     for (const label of labels) {
         if (label.hidden)
             continue;
-        includeLabelBounds(label, include);
+        includeLabelBounds(label, include, labelMultiplier);
     }
     if (!Number.isFinite(minX) || !Number.isFinite(minY)) {
         return createBounds(0, 0, width, height);
@@ -862,13 +1050,10 @@ function includeObjectBounds(object, include) {
     include(object.x - object.visualRadius - 24, object.y - object.visualRadius - 16);
     include(object.x + object.visualRadius + 24, object.y + object.visualRadius + 36);
 }
-function includeLabelBounds(label, include) {
-    const labelScale = 1;
-    const labelHalfWidth = estimateLabelHalfWidthFromText(label.label, label.secondaryLabel, labelScale);
-    include(label.x - labelHalfWidth, label.y - 18);
-    include(label.x + labelHalfWidth, label.y + 8);
-    include(label.x - labelHalfWidth, label.secondaryY - 14);
-    include(label.x + labelHalfWidth, label.secondaryY + 8);
+function includeLabelBounds(label, include, labelMultiplier) {
+    const bounds = createLabelRectFromText(label.x, label.y, label.secondaryY, label.textAnchor, label.direction, label.label, label.secondaryLabel, labelMultiplier);
+    include(bounds.left, bounds.top);
+    include(bounds.right, bounds.bottom);
 }
 function placeObject(object, x, y, depth, positions, orbitDrafts, leaderDrafts, context) {
     if (positions.has(object.id)) {
@@ -1286,7 +1471,7 @@ function resolveParentId(object, objectMap) {
             return null;
     }
 }
-function calculateGroupBounds(group, objects, orbitVisuals, leaders, labels) {
+function calculateGroupBounds(group, objects, orbitVisuals, leaders, labels, labelMultiplier) {
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
     let maxX = Number.NEGATIVE_INFINITY;
@@ -1315,7 +1500,7 @@ function calculateGroupBounds(group, objects, orbitVisuals, leaders, labels) {
     }
     for (const label of labels) {
         if (!label.hidden && group.labelIds.includes(label.objectId)) {
-            includeLabelBounds(label, include);
+            includeLabelBounds(label, include, labelMultiplier);
         }
     }
     if (!Number.isFinite(minX) || !Number.isFinite(minY)) {
@@ -1340,12 +1525,29 @@ function resolveGroupRootObjectId(object, objectMap) {
     }
     return current.id;
 }
-function createLabelRect(x, labelY, secondaryY, labelHalfWidth, direction) {
+function createLabelRect(object, placement, labelMultiplier) {
+    return createLabelRectFromText(placement.x, placement.labelY, placement.secondaryY, placement.textAnchor, placement.direction, object.label, object.secondaryLabel, labelMultiplier);
+}
+function createLabelRectFromText(x, labelY, secondaryY, textAnchor, direction, label, secondaryLabel, labelMultiplier) {
+    const labelHalfWidth = estimateLabelHalfWidthFromText(label, secondaryLabel, labelMultiplier);
+    const labelWidth = labelHalfWidth * 2;
+    const topPadding = direction === "above" ? 18 : 12;
+    const bottomPadding = direction === "above" ? 8 : 12;
+    let left = x - labelHalfWidth;
+    let right = x + labelHalfWidth;
+    if (textAnchor === "start") {
+        left = x;
+        right = x + labelWidth;
+    }
+    else if (textAnchor === "end") {
+        left = x - labelWidth;
+        right = x;
+    }
     return {
-        left: x - labelHalfWidth,
-        right: x + labelHalfWidth,
-        top: Math.min(labelY, secondaryY) - (direction < 0 ? 18 : 12),
-        bottom: Math.max(labelY, secondaryY) + (direction < 0 ? 8 : 12),
+        left,
+        right,
+        top: Math.min(labelY, secondaryY) - topPadding,
+        bottom: Math.max(labelY, secondaryY) + bottomPadding,
     };
 }
 function rectsOverlap(left, right) {

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

@@ -60,6 +60,7 @@ export interface WorldOrbitDocument {
     system: WorldOrbitSystem | null;
     groups: WorldOrbitGroup[];
     relations: WorldOrbitRelation[];
+    events: WorldOrbitEvent[];
     objects: WorldOrbitObject[];
 }
 export interface WorldOrbitAtlasDocument {
@@ -70,6 +71,7 @@ export interface WorldOrbitAtlasDocument {
     system: WorldOrbitAtlasSystem | null;
     groups: WorldOrbitGroup[];
     relations: WorldOrbitRelation[];
+    events: WorldOrbitEvent[];
     objects: WorldOrbitObject[];
     diagnostics: WorldOrbitDiagnostic[];
 }
@@ -81,6 +83,7 @@ export interface WorldOrbitDraftDocument {
     system: WorldOrbitAtlasSystem | null;
     groups: WorldOrbitGroup[];
     relations: WorldOrbitRelation[];
+    events: WorldOrbitEvent[];
     objects: WorldOrbitObject[];
     diagnostics: WorldOrbitDiagnostic[];
 }
@@ -132,6 +135,26 @@ export interface WorldOrbitRelation {
     color: string | null;
     hidden: boolean;
 }
+export interface WorldOrbitEvent {
+    id: string;
+    kind: string;
+    label: string;
+    summary: string | null;
+    targetObjectId: string | null;
+    participantObjectIds: string[];
+    timing: string | null;
+    visibility: string | null;
+    tags: string[];
+    color: string | null;
+    hidden: boolean;
+    positions: WorldOrbitEventPose[];
+}
+export interface WorldOrbitEventPose {
+    objectId: string;
+    placement: Placement | null;
+    inner?: UnitValue;
+    outer?: UnitValue;
+}
 export interface WorldOrbitResonance {
     targetObjectId: string;
     ratio: string;
@@ -212,6 +235,7 @@ export interface SceneRenderOptions {
     preset?: RenderPresetName;
     projection?: "document" | ViewProjection;
     scaleModel?: Partial<RenderScaleModel>;
+    activeEventId?: string | null;
 }
 export interface RenderBounds {
     minX: number;
@@ -294,7 +318,18 @@ export interface RenderSceneLabel {
     direction: "above" | "below" | "left" | "right";
     hidden: boolean;
 }
-export type SceneLayerId = "background" | "guides" | "orbits-back" | "orbits-front" | "relations" | "objects" | "labels" | "metadata";
+export interface RenderSceneEvent {
+    renderId: string;
+    eventId: string;
+    event: WorldOrbitEvent;
+    objectIds: string[];
+    participantIds: string[];
+    targetObjectId: string | null;
+    x: number;
+    y: number;
+    hidden: boolean;
+}
+export type SceneLayerId = "background" | "guides" | "orbits-back" | "orbits-front" | "relations" | "events" | "objects" | "labels" | "metadata";
 export interface RenderSceneViewpointFilter {
     query: string | null;
     objectTypes: Array<Exclude<WorldOrbitObjectType, "system">>;
@@ -307,6 +342,7 @@ export interface RenderSceneViewpoint {
     summary: string;
     objectId: string | null;
     selectedObjectId: string | null;
+    eventIds: string[];
     projection: ViewProjection;
     preset: RenderPresetName | null;
     rotationDeg: number;
@@ -368,6 +404,8 @@ export interface RenderScene {
     groups: RenderSceneGroup[];
     semanticGroups: RenderSceneSemanticGroup[];
     viewpoints: RenderSceneViewpoint[];
+    events: RenderSceneEvent[];
+    activeEventId: string | null;
     objects: RenderSceneObject[];
     orbitVisuals: RenderOrbitVisual[];
     relations: RenderSceneRelation[];
@@ -421,6 +459,7 @@ export interface WorldOrbitAtlasViewpoint {
     summary: string;
     focusObjectId: string | null;
     selectedObjectId: string | null;
+    events: string[];
     projection: ViewProjection;
     preset: RenderPresetName | null;
     zoom: number | null;
@@ -448,7 +487,7 @@ export interface WorldOrbitAtlasSystem {
     viewpoints: WorldOrbitAtlasViewpoint[];
     annotations: WorldOrbitAtlasAnnotation[];
 }
-export type AtlasDocumentPathKind = "system" | "defaults" | "metadata" | "group" | "object" | "viewpoint" | "annotation" | "relation";
+export type AtlasDocumentPathKind = "system" | "defaults" | "metadata" | "group" | "event" | "event-pose" | "object" | "viewpoint" | "annotation" | "relation";
 export interface AtlasDocumentPath {
     kind: AtlasDocumentPathKind;
     id?: string;

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

@@ -0,0 +1,2 @@
+import type { WorldOrbitEditor, WorldOrbitEditorOptions } from "./types.js";
+export declare function createWorldOrbitEditor(container: HTMLElement, options?: WorldOrbitEditorOptions): WorldOrbitEditor;