worldorbit 2.5.16 → 2.6.0

package/packages/core/dist/scene.js

@@ -14,12 +14,16 @@ export function renderDocumentToScene(document, options = {}) {
     const height = frame.height;
     const padding = frame.padding;
     const layoutPreset = resolveLayoutPreset(document);
-    const projection = resolveProjection(document, options.projection);
+    const schemaProjection = resolveProjection(document, options.projection);
+    const camera = normalizeViewCamera(options.camera ?? null);
+    const renderProjection = resolveRenderProjection(schemaProjection, camera);
     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 +32,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);
@@ -55,7 +59,7 @@ export function renderDocumentToScene(document, options = {}) {
         surfaceChildren,
         objectMap,
         spacingFactor,
-        projection,
+        projection: renderProjection,
         scaleModel,
     };
     const primaryRoot = rootObjects.find((object) => object.type === "star") ?? rootObjects[0] ?? null;
@@ -70,7 +74,7 @@ export function renderDocumentToScene(document, options = {}) {
             scaleModel.orbitDistanceMultiplier;
         secondaryRoots.forEach((object, index) => {
             const angle = angleForIndex(index, secondaryRoots.length, -Math.PI / 2);
-            const offset = projectPolarOffset(angle, rootRingRadius, projection, 1);
+            const offset = projectPolarOffset(angle, rootRingRadius, renderProjection, 1);
             placeObject(object, centerX + offset.x, centerY + offset.y, 0, positions, orbitDrafts, leaderDrafts, context);
         });
     }
@@ -129,39 +133,49 @@ 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 viewpoints = createSceneViewpoints(document, schemaProjection, frame.preset, relationships, objectMap);
+    const contentBounds = calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels, scaleModel.labelMultiplier);
     return {
         width,
         height,
         padding,
         renderPreset: frame.preset,
-        projection,
+        projection: schemaProjection,
+        renderProjection,
+        camera,
         scaleModel,
         title: String(document.system?.title ?? document.system?.properties.title ?? document.system?.id ?? "WorldOrbit") ||
             "WorldOrbit",
-        subtitle: `${capitalizeLabel(projection)} view - ${capitalizeLabel(layoutPreset)} layout`,
+        subtitle: buildSceneSubtitle(schemaProjection, renderProjection, layoutPreset, camera),
         systemId,
-        viewMode: projection,
+        viewMode: schemaProjection,
         layoutPreset,
         metadata: {
             format: document.format,
             version: document.version,
-            view: projection,
+            view: schemaProjection,
+            renderProjection,
             scale: String(document.system?.properties.scale ?? layoutPreset),
             units: String(document.system?.properties.units ?? "mixed"),
             preset: frame.preset ?? "custom",
+            ...(camera?.azimuth !== null ? { "camera.azimuth": String(camera?.azimuth) } : {}),
+            ...(camera?.elevation !== null ? { "camera.elevation": String(camera?.elevation) } : {}),
+            ...(camera?.roll !== null ? { "camera.roll": String(camera?.roll) } : {}),
+            ...(camera?.distance !== null ? { "camera.distance": String(camera?.distance) } : {}),
         },
         contentBounds,
         layers,
         groups,
         semanticGroups,
         viewpoints,
+        events,
+        activeEventId,
         objects,
         orbitVisuals,
         relations,
@@ -180,6 +194,56 @@ 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]));
+    const referencedIds = new Set([
+        ...(activeEvent.targetObjectId ? [activeEvent.targetObjectId] : []),
+        ...activeEvent.participantObjectIds,
+        ...activeEvent.positions.map((pose) => pose.objectId),
+    ]);
+    for (const objectId of referencedIds) {
+        const object = objectMap.get(objectId);
+        if (!object) {
+            continue;
+        }
+        if (activeEvent.epoch) {
+            object.epoch = activeEvent.epoch;
+        }
+        if (activeEvent.referencePlane) {
+            object.referencePlane = activeEvent.referencePlane;
+        }
+    }
+    for (const pose of activeEvent.positions) {
+        const object = objectMap.get(pose.objectId);
+        if (!object) {
+            continue;
+        }
+        if (pose.placement) {
+            object.placement = structuredClone(pose.placement);
+        }
+        if (pose.inner) {
+            object.properties.inner = { ...pose.inner };
+        }
+        if (pose.outer) {
+            object.properties.outer = { ...pose.outer };
+        }
+        if (pose.epoch) {
+            object.epoch = pose.epoch;
+        }
+        if (pose.referencePlane) {
+            object.referencePlane = pose.referencePlane;
+        }
+    }
+    return cloned;
+}
 function resolveLayoutPreset(document) {
     const rawScale = String(document.system?.properties.scale ?? "balanced").toLowerCase();
     switch (rawScale) {
@@ -216,12 +280,69 @@ function scenePresetDefaults(preset) {
     }
 }
 function resolveProjection(document, projection) {
-    if (projection === "topdown" || projection === "isometric") {
+    if (projection === "topdown" ||
+        projection === "isometric" ||
+        projection === "orthographic" ||
+        projection === "perspective") {
         return projection;
     }
-    return String(document.system?.properties.view ?? "topdown").toLowerCase() === "isometric"
-        ? "isometric"
-        : "topdown";
+    const documentView = String(document.system?.properties.view ?? "topdown").toLowerCase();
+    return parseViewProjection(documentView) ?? "topdown";
+}
+function resolveRenderProjection(projection, camera) {
+    switch (projection) {
+        case "topdown":
+            return "topdown";
+        case "isometric":
+            return "isometric";
+        case "orthographic":
+            return camera && (camera.azimuth !== null || camera.elevation !== null || camera.roll !== null)
+                ? "isometric"
+                : "topdown";
+        case "perspective":
+            return "isometric";
+    }
+}
+function normalizeViewCamera(camera) {
+    if (!camera) {
+        return null;
+    }
+    const normalized = {
+        azimuth: normalizeFiniteCameraValue(camera.azimuth),
+        elevation: normalizeFiniteCameraValue(camera.elevation),
+        roll: normalizeFiniteCameraValue(camera.roll),
+        distance: normalizePositiveCameraDistance(camera.distance),
+    };
+    return normalized.azimuth !== null ||
+        normalized.elevation !== null ||
+        normalized.roll !== null ||
+        normalized.distance !== null
+        ? normalized
+        : null;
+}
+function normalizeFiniteCameraValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function normalizePositiveCameraDistance(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function buildSceneSubtitle(projection, renderProjection, layoutPreset, camera) {
+    const parts = [`${capitalizeLabel(projection)} view`, `${capitalizeLabel(layoutPreset)} layout`];
+    if (projection !== renderProjection) {
+        parts.push(`2D ${renderProjection} fallback`);
+    }
+    if (camera) {
+        const cameraParts = [
+            camera.azimuth !== null ? `az ${camera.azimuth}` : null,
+            camera.elevation !== null ? `el ${camera.elevation}` : null,
+            camera.roll !== null ? `roll ${camera.roll}` : null,
+            camera.distance !== null ? `dist ${camera.distance}` : null,
+        ].filter(Boolean);
+        if (cameraParts.length > 0) {
+            parts.push(`camera ${cameraParts.join(" / ")}`);
+        }
+    }
+    return parts.join(" - ");
 }
 function resolveScaleModel(layoutPreset, overrides) {
     const defaults = defaultScaleModel(layoutPreset);
@@ -339,26 +460,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 +479,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 +625,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 +640,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 +689,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 +729,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();
@@ -546,13 +813,18 @@ function createSceneViewpoints(document, projection, preset, relationships, obje
 function createGeneratedOverviewViewpoint(document, projection, preset) {
     const title = document.system?.title ?? document.system?.properties.title;
     const label = title ? `${String(title)} Overview` : "Overview";
+    const camera = normalizeViewCamera(null);
+    const renderProjection = resolveRenderProjection(projection, camera);
     return {
         id: "overview",
         label,
         summary: "Fit the whole system with the current atlas defaults.",
         objectId: null,
         selectedObjectId: null,
+        eventIds: [],
         projection,
+        renderProjection,
+        camera,
         preset,
         rotationDeg: 0,
         scale: null,
@@ -588,6 +860,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;
@@ -599,6 +874,30 @@ function applyViewpointField(draft, field, value, document, projection, preset,
         case "angle":
             draft.rotationDeg = parseFiniteNumber(normalizedValue) ?? draft.rotationDeg ?? 0;
             return;
+        case "camera.azimuth":
+            draft.camera = {
+                ...(draft.camera ?? createEmptyViewCamera()),
+                azimuth: parseFiniteNumber(normalizedValue),
+            };
+            return;
+        case "camera.elevation":
+            draft.camera = {
+                ...(draft.camera ?? createEmptyViewCamera()),
+                elevation: parseFiniteNumber(normalizedValue),
+            };
+            return;
+        case "camera.roll":
+            draft.camera = {
+                ...(draft.camera ?? createEmptyViewCamera()),
+                roll: parseFiniteNumber(normalizedValue),
+            };
+            return;
+        case "camera.distance":
+            draft.camera = {
+                ...(draft.camera ?? createEmptyViewCamera()),
+                distance: parsePositiveNumber(normalizedValue),
+            };
+            return;
         case "zoom":
         case "scale":
             draft.scale = parsePositiveNumber(normalizedValue);
@@ -640,13 +939,19 @@ function finalizeViewpointDraft(draft, projection, preset, objectMap) {
         : objectId;
     const filter = normalizeViewpointFilter(draft.filter);
     const label = draft.label?.trim() || humanizeIdentifier(draft.id);
+    const resolvedProjection = draft.projection ?? projection;
+    const camera = normalizeViewCamera(draft.camera ?? null);
+    const renderProjection = resolveRenderProjection(resolvedProjection, camera);
     return {
         id: draft.id,
         label,
         summary: draft.summary?.trim() || createViewpointSummary(label, objectId, filter),
         objectId,
         selectedObjectId,
-        projection: draft.projection ?? projection,
+        eventIds: [...new Set(draft.eventIds ?? [])],
+        projection: resolvedProjection,
+        renderProjection,
+        camera,
         preset: draft.preset ?? preset,
         rotationDeg: draft.rotationDeg ?? 0,
         scale: draft.scale ?? null,
@@ -663,6 +968,14 @@ function createEmptyViewpointFilter() {
         groupIds: [],
     };
 }
+function createEmptyViewCamera() {
+    return {
+        azimuth: null,
+        elevation: null,
+        roll: null,
+        distance: null,
+    };
+}
 function normalizeViewpointFilter(filter) {
     if (!filter) {
         return null;
@@ -681,11 +994,18 @@ function normalizeViewpointFilter(filter) {
         : null;
 }
 function parseViewProjection(value) {
-    return value.toLowerCase() === "isometric"
-        ? "isometric"
-        : value.toLowerCase() === "topdown"
-            ? "topdown"
-            : null;
+    switch (value.toLowerCase()) {
+        case "topdown":
+            return "topdown";
+        case "isometric":
+            return "isometric";
+        case "orthographic":
+            return "orthographic";
+        case "perspective":
+            return "perspective";
+        default:
+            return null;
+    }
 }
 function parseRenderPreset(value) {
     const normalized = value.toLowerCase();
@@ -720,6 +1040,7 @@ function parseViewpointLayers(value) {
             rawLayer === "orbits-back" ||
             rawLayer === "orbits-front" ||
             rawLayer === "relations" ||
+            rawLayer === "events" ||
             rawLayer === "objects" ||
             rawLayer === "labels" ||
             rawLayer === "metadata") {
@@ -742,6 +1063,7 @@ function parseViewpointObjectTypes(value) {
 function parseViewpointGroups(value, document, relationships, objectMap) {
     return splitListValue(value).map((entry) => {
         if (document.schemaVersion === "2.1" ||
+            document.schemaVersion === "2.5" ||
             document.groups.some((group) => group.id === entry)) {
             return entry;
         }
@@ -790,7 +1112,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 +1142,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 +1184,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 +1605,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 +1634,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 +1659,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) {