worldorbit 2.6.0 → 3.0.1

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

@@ -0,0 +1,1901 @@
+const AU_IN_KM = 149_597_870.7;
+const EARTH_RADIUS_IN_KM = 6_371;
+const JUPITER_RADIUS_IN_KM = 71_492;
+const SOLAR_RADIUS_IN_KM = 695_700;
+const LY_IN_AU = 63_241.077;
+const PC_IN_AU = 206_264.806;
+const KPC_IN_AU = 206_264_806;
+const ISO_FLATTENING = 0.68;
+const MIN_ISO_MINOR_SCALE = 0.2;
+const ARC_SAMPLE_COUNT = 28;
+export function renderDocumentToScene(document, options = {}) {
+    const frame = resolveSceneFrame(options);
+    const width = frame.width;
+    const height = frame.height;
+    const padding = frame.padding;
+    const layoutPreset = resolveLayoutPreset(document);
+    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 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 = [];
+    const rootObjects = [];
+    const freeObjects = [];
+    const atObjects = [];
+    const surfaceChildren = new Map();
+    const orbitChildren = new Map();
+    for (const object of effectiveObjects) {
+        const placement = object.placement;
+        if (!placement) {
+            rootObjects.push(object);
+            continue;
+        }
+        if (placement.mode === "orbit") {
+            pushGrouped(orbitChildren, placement.target, object);
+            continue;
+        }
+        if (placement.mode === "surface") {
+            pushGrouped(surfaceChildren, placement.target, object);
+            continue;
+        }
+        if (placement.mode === "at") {
+            atObjects.push(object);
+            continue;
+        }
+        freeObjects.push(object);
+    }
+    const centerX = freeObjects.length > 0 ? width * 0.42 : width / 2;
+    const centerY = height / 2;
+    const context = {
+        orbitChildren,
+        surfaceChildren,
+        objectMap,
+        spacingFactor,
+        projection: renderProjection,
+        scaleModel,
+    };
+    const primaryRoot = rootObjects.find((object) => object.type === "star") ?? rootObjects[0] ?? null;
+    if (primaryRoot) {
+        placeObject(primaryRoot, centerX, centerY, 0, positions, orbitDrafts, leaderDrafts, context);
+    }
+    const secondaryRoots = rootObjects.filter((object) => object.id !== primaryRoot?.id);
+    if (secondaryRoots.length > 0) {
+        const rootRingRadius = Math.min(width, height) *
+            0.28 *
+            spacingFactor *
+            scaleModel.orbitDistanceMultiplier;
+        secondaryRoots.forEach((object, index) => {
+            const angle = angleForIndex(index, secondaryRoots.length, -Math.PI / 2);
+            const offset = projectPolarOffset(angle, rootRingRadius, renderProjection, 1);
+            placeObject(object, centerX + offset.x, centerY + offset.y, 0, positions, orbitDrafts, leaderDrafts, context);
+        });
+    }
+    freeObjects.forEach((object, index) => {
+        const x = width -
+            padding -
+            140 -
+            freePlacementOffsetPx(object.placement?.mode === "free" ? object.placement.distance : undefined, scaleModel);
+        const rowStep = Math.max(76, ((height - padding * 2 - 180) / Math.max(1, freeObjects.length)) * spacingFactor) * scaleModel.freePlacementMultiplier;
+        const y = padding + 92 + index * rowStep;
+        positions.set(object.id, {
+            object,
+            x,
+            y,
+            radius: visualRadiusFor(object, 0, scaleModel),
+            sortKey: computeSortKey(x, y, 0),
+        });
+        leaderDrafts.push({
+            object,
+            groupId: relationships.groupIds.get(object.id) ?? null,
+            x1: x - 60,
+            y1: y,
+            x2: x - 18,
+            y2: y,
+            mode: "free",
+        });
+        placeOrbitingChildren(object, positions, orbitDrafts, leaderDrafts, context, 1);
+    });
+    atObjects.forEach((object, index) => {
+        if (positions.has(object.id) || !object.placement || object.placement.mode !== "at") {
+            return;
+        }
+        const resolved = resolveAtPosition(object.placement.reference, positions, objectMap, index, atObjects.length, width, height, padding, context);
+        positions.set(object.id, {
+            object,
+            x: resolved.x,
+            y: resolved.y,
+            radius: visualRadiusFor(object, 2, scaleModel),
+            sortKey: computeSortKey(resolved.x, resolved.y, 2),
+            anchorX: resolved.anchorX,
+            anchorY: resolved.anchorY,
+        });
+        if (resolved.anchorX !== undefined && resolved.anchorY !== undefined) {
+            leaderDrafts.push({
+                object,
+                groupId: relationships.groupIds.get(object.id) ?? null,
+                x1: resolved.anchorX,
+                y1: resolved.anchorY,
+                x2: resolved.x,
+                y2: resolved.y,
+                mode: "at",
+            });
+        }
+        placeOrbitingChildren(object, positions, orbitDrafts, leaderDrafts, context, 2);
+    });
+    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, 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 groups = createSceneGroups(objects, orbitVisuals, leaders, labels, relationships, scaleModel.labelMultiplier);
+    const semanticGroups = createSceneSemanticGroups(document, objects);
+    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: schemaProjection,
+        renderProjection,
+        camera,
+        scaleModel,
+        title: String(document.system?.title ?? document.system?.properties.title ?? document.system?.id ?? "WorldOrbit") ||
+            "WorldOrbit",
+        subtitle: buildSceneSubtitle(schemaProjection, renderProjection, layoutPreset, camera),
+        systemId,
+        viewMode: schemaProjection,
+        layoutPreset,
+        metadata: {
+            format: document.format,
+            version: document.version,
+            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,
+        leaders,
+        labels,
+    };
+}
+export function rotatePoint(point, center, rotationDeg) {
+    const radians = degreesToRadians(rotationDeg);
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    const dx = point.x - center.x;
+    const dy = point.y - center.y;
+    return {
+        x: center.x + dx * cos - dy * sin,
+        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) {
+        case "compressed":
+        case "compact":
+            return "compact";
+        case "expanded":
+        case "presentation":
+            return "presentation";
+        default:
+            return "balanced";
+    }
+}
+function resolveSceneFrame(options) {
+    const defaults = scenePresetDefaults(options.preset);
+    return {
+        width: options.width ?? defaults.width,
+        height: options.height ?? defaults.height,
+        padding: options.padding ?? defaults.padding,
+        preset: options.preset ?? null,
+    };
+}
+function scenePresetDefaults(preset) {
+    switch (preset) {
+        case "presentation":
+            return { width: 1440, height: 900, padding: 88 };
+        case "atlas-card":
+            return { width: 960, height: 560, padding: 56 };
+        case "markdown":
+            return { width: 920, height: 540, padding: 48 };
+        case "diagram":
+        default:
+            return { width: 1200, height: 780, padding: 72 };
+    }
+}
+function resolveProjection(document, projection) {
+    if (projection === "topdown" ||
+        projection === "isometric" ||
+        projection === "orthographic" ||
+        projection === "perspective") {
+        return projection;
+    }
+    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);
+    return {
+        ...defaults,
+        ...overrides,
+    };
+}
+function defaultScaleModel(layoutPreset) {
+    switch (layoutPreset) {
+        case "compact":
+            return {
+                orbitDistanceMultiplier: 0.84,
+                bodyRadiusMultiplier: 0.92,
+                labelMultiplier: 0.9,
+                freePlacementMultiplier: 0.9,
+                ringThicknessMultiplier: 0.92,
+                minBodyRadius: 4,
+                maxBodyRadius: 36,
+            };
+        case "presentation":
+            return {
+                orbitDistanceMultiplier: 1.2,
+                bodyRadiusMultiplier: 1.18,
+                labelMultiplier: 1.08,
+                freePlacementMultiplier: 1.05,
+                ringThicknessMultiplier: 1.16,
+                minBodyRadius: 5,
+                maxBodyRadius: 48,
+            };
+        default:
+            return {
+                orbitDistanceMultiplier: 1,
+                bodyRadiusMultiplier: 1,
+                labelMultiplier: 1,
+                freePlacementMultiplier: 1,
+                ringThicknessMultiplier: 1,
+                minBodyRadius: 4,
+                maxBodyRadius: 40,
+            };
+    }
+}
+function layoutPresetSpacing(layoutPreset) {
+    switch (layoutPreset) {
+        case "compact":
+            return 0.84;
+        case "presentation":
+            return 1.2;
+        default:
+            return 1;
+    }
+}
+function createSceneObject(position, scaleModel, relationships) {
+    const { object, x, y, radius, sortKey, anchorX, anchorY } = position;
+    const renderPriority = object.renderHints?.renderPriority ?? 0;
+    return {
+        renderId: createRenderId(object.id),
+        objectId: object.id,
+        object,
+        parentId: relationships.parentIds.get(object.id) ?? null,
+        ancestorIds: relationships.ancestorIds.get(object.id) ?? [],
+        childIds: relationships.childIds.get(object.id) ?? [],
+        groupId: relationships.groupIds.get(object.id) ?? null,
+        semanticGroupIds: [...(object.groups ?? [])],
+        x,
+        y,
+        radius,
+        visualRadius: visualExtentForObject(object, radius, scaleModel),
+        sortKey: sortKey + renderPriority * 0.001,
+        anchorX,
+        anchorY,
+        label: object.id,
+        secondaryLabel: object.type === "structure" ? String(object.properties.kind ?? object.type) : object.type,
+        fillColor: customColorFor(object.properties.color),
+        imageHref: typeof object.properties.image === "string" && object.properties.image.trim()
+            ? object.properties.image
+            : undefined,
+        hidden: object.properties.hidden === true,
+    };
+}
+function createOrbitVisual(draft, groupId) {
+    return {
+        renderId: `${createRenderId(draft.object.id)}-orbit`,
+        objectId: draft.object.id,
+        object: draft.object,
+        parentId: draft.parentId,
+        groupId,
+        semanticGroupIds: [...(draft.object.groups ?? [])],
+        kind: draft.kind,
+        cx: draft.cx,
+        cy: draft.cy,
+        radius: draft.radius,
+        rx: draft.rx,
+        ry: draft.ry,
+        rotationDeg: draft.rotationDeg,
+        band: draft.band,
+        bandThickness: draft.bandThickness,
+        frontArcPath: draft.frontArcPath,
+        backArcPath: draft.backArcPath,
+        hidden: draft.object.properties.hidden === true || draft.object.renderHints?.renderOrbit === false,
+    };
+}
+function createLeaderLine(draft) {
+    return {
+        renderId: `${createRenderId(draft.object.id)}-leader-${draft.mode}`,
+        objectId: draft.object.id,
+        object: draft.object,
+        groupId: draft.groupId,
+        semanticGroupIds: [...(draft.object.groups ?? [])],
+        x1: draft.x1,
+        y1: draft.y1,
+        x2: draft.x2,
+        y2: draft.y2,
+        mode: draft.mode,
+        hidden: draft.object.properties.hidden === true,
+    };
+}
+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(compareLabelPlacementOrder);
+    for (const object of visibleObjects) {
+        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,
+            object: object.object,
+            groupId: object.groupId,
+            semanticGroupIds: [...object.semanticGroupIds],
+            label: object.label,
+            secondaryLabel: object.secondaryLabel,
+            x: placement.x,
+            y: placement.labelY,
+            secondaryY: placement.secondaryY,
+            textAnchor: placement.textAnchor,
+            direction: placement.direction,
+            hidden: object.hidden,
+        });
+    }
+    return 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);
+    const frontOrbitIds = orbitVisuals
+        .filter((visual) => !visual.hidden)
+        .map((visual) => visual.renderId);
+    return [
+        { id: "background", renderIds: ["wo-bg", "wo-bg-glow", "wo-grid"] },
+        {
+            id: "guides",
+            renderIds: leaders.filter((leader) => !leader.hidden).map((leader) => leader.renderId),
+        },
+        { id: "orbits-back", renderIds: backOrbitIds },
+        { id: "orbits-front", renderIds: frontOrbitIds },
+        {
+            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),
+        },
+        {
+            id: "labels",
+            renderIds: labels.filter((label) => !label.hidden).map((label) => label.renderId),
+        },
+        { id: "metadata", renderIds: ["wo-title", "wo-subtitle", "wo-meta"] },
+    ];
+}
+function createSceneGroups(objects, orbitVisuals, leaders, labels, relationships, labelMultiplier) {
+    const groups = new Map();
+    const ensureGroup = (groupId) => {
+        if (!groupId) {
+            return null;
+        }
+        const existing = groups.get(groupId);
+        if (existing) {
+            return existing;
+        }
+        const rootObjectId = relationships.groupRoots.get(groupId) ?? null;
+        const created = {
+            renderId: groupId,
+            rootObjectId,
+            label: rootObjectId ?? groupId,
+            objectIds: [],
+            orbitIds: [],
+            labelIds: [],
+            leaderIds: [],
+            contentBounds: createBounds(0, 0, 0, 0),
+        };
+        groups.set(groupId, created);
+        return created;
+    };
+    for (const object of objects) {
+        const group = ensureGroup(object.groupId);
+        if (group && !object.hidden) {
+            group.objectIds.push(object.objectId);
+        }
+    }
+    for (const orbit of orbitVisuals) {
+        const group = ensureGroup(orbit.groupId);
+        if (group && !orbit.hidden) {
+            group.orbitIds.push(orbit.objectId);
+        }
+    }
+    for (const leader of leaders) {
+        const group = ensureGroup(leader.groupId);
+        if (group && !leader.hidden) {
+            group.leaderIds.push(leader.objectId);
+        }
+    }
+    for (const label of labels) {
+        const group = ensureGroup(label.groupId);
+        if (group && !label.hidden) {
+            group.labelIds.push(label.objectId);
+        }
+    }
+    for (const group of groups.values()) {
+        group.contentBounds = calculateGroupBounds(group, objects, orbitVisuals, leaders, labels, labelMultiplier);
+    }
+    return [...groups.values()].sort((left, right) => left.label.localeCompare(right.label));
+}
+function createSceneSemanticGroups(document, objects) {
+    return [...document.groups]
+        .map((group) => ({
+        id: group.id,
+        label: group.label,
+        summary: group.summary,
+        color: group.color,
+        tags: [...group.tags],
+        hidden: group.hidden,
+        objectIds: objects
+            .filter((object) => !object.hidden && object.semanticGroupIds.includes(group.id))
+            .map((object) => object.objectId),
+    }))
+        .sort((left, right) => left.label.localeCompare(right.label));
+}
+function createSceneRelations(document, objects) {
+    const objectMap = new Map(objects.map((object) => [object.objectId, object]));
+    return document.relations
+        .map((relation) => {
+        const from = objectMap.get(relation.from);
+        const to = objectMap.get(relation.to);
+        return {
+            renderId: `${createRenderId(relation.id)}-relation`,
+            relationId: relation.id,
+            relation,
+            fromObjectId: relation.from,
+            toObjectId: relation.to,
+            x1: from?.x ?? 0,
+            y1: from?.y ?? 0,
+            x2: to?.x ?? 0,
+            y2: to?.y ?? 0,
+            hidden: relation.hidden || !from || !to || from.hidden || to.hidden,
+        };
+    })
+        .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();
+    for (const [key, value] of Object.entries(document.system?.info ?? {})) {
+        if (!key.startsWith("viewpoint.")) {
+            continue;
+        }
+        const [prefix, rawId, ...fieldParts] = key.split(".");
+        if (prefix !== "viewpoint" || !rawId || fieldParts.length === 0) {
+            continue;
+        }
+        const id = normalizeViewpointId(rawId);
+        if (!id) {
+            continue;
+        }
+        const field = fieldParts.join(".").toLowerCase();
+        const draft = drafts.get(id) ?? { id };
+        applyViewpointField(draft, field, value, document, projection, preset, relationships, objectMap);
+        drafts.set(id, draft);
+    }
+    const viewpoints = [...drafts.values()]
+        .map((draft) => finalizeViewpointDraft(draft, projection, preset, objectMap))
+        .filter(Boolean);
+    const overviewIndex = viewpoints.findIndex((viewpoint) => viewpoint.id === generatedOverview.id);
+    if (overviewIndex >= 0) {
+        viewpoints.splice(overviewIndex, 1, {
+            ...generatedOverview,
+            ...viewpoints[overviewIndex],
+            layers: {
+                ...generatedOverview.layers,
+                ...viewpoints[overviewIndex].layers,
+            },
+            filter: viewpoints[overviewIndex].filter ?? generatedOverview.filter,
+            generated: false,
+        });
+    }
+    else {
+        viewpoints.unshift(generatedOverview);
+    }
+    return viewpoints.sort((left, right) => {
+        if (left.id === "overview")
+            return -1;
+        if (right.id === "overview")
+            return 1;
+        return left.label.localeCompare(right.label);
+    });
+}
+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,
+        layers: {},
+        filter: null,
+        generated: true,
+    };
+}
+function applyViewpointField(draft, field, value, document, projection, preset, relationships, objectMap) {
+    const normalizedValue = value.trim();
+    switch (field) {
+        case "label":
+        case "title":
+            if (normalizedValue) {
+                draft.label = normalizedValue;
+            }
+            return;
+        case "summary":
+        case "description":
+            if (normalizedValue) {
+                draft.summary = normalizedValue;
+            }
+            return;
+        case "focus":
+        case "object":
+            if (normalizedValue) {
+                draft.focus = normalizedValue;
+            }
+            return;
+        case "select":
+        case "selection":
+            if (normalizedValue) {
+                draft.select = normalizedValue;
+            }
+            return;
+        case "events":
+            draft.eventIds = splitListValue(normalizedValue);
+            return;
+        case "projection":
+        case "view":
+            draft.projection = parseViewProjection(normalizedValue) ?? projection;
+            return;
+        case "preset":
+            draft.preset = parseRenderPreset(normalizedValue) ?? preset;
+            return;
+        case "rotation":
+        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);
+            return;
+        case "layers":
+            draft.layers = parseViewpointLayers(normalizedValue);
+            return;
+        case "query":
+            draft.filter = {
+                ...(draft.filter ?? createEmptyViewpointFilter()),
+                query: normalizedValue || null,
+            };
+            return;
+        case "types":
+        case "objecttypes":
+            draft.filter = {
+                ...(draft.filter ?? createEmptyViewpointFilter()),
+                objectTypes: parseViewpointObjectTypes(normalizedValue),
+            };
+            return;
+        case "tags":
+            draft.filter = {
+                ...(draft.filter ?? createEmptyViewpointFilter()),
+                tags: splitListValue(normalizedValue),
+            };
+            return;
+        case "groups":
+            draft.filter = {
+                ...(draft.filter ?? createEmptyViewpointFilter()),
+                groupIds: parseViewpointGroups(normalizedValue, document, relationships, objectMap),
+            };
+            return;
+    }
+}
+function finalizeViewpointDraft(draft, projection, preset, objectMap) {
+    const objectId = draft.focus && objectMap.has(draft.focus) ? draft.focus : null;
+    const selectedObjectId = draft.select && objectMap.has(draft.select)
+        ? draft.select
+        : 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,
+        eventIds: [...new Set(draft.eventIds ?? [])],
+        projection: resolvedProjection,
+        renderProjection,
+        camera,
+        preset: draft.preset ?? preset,
+        rotationDeg: draft.rotationDeg ?? 0,
+        scale: draft.scale ?? null,
+        layers: draft.layers ?? {},
+        filter,
+        generated: false,
+    };
+}
+function createEmptyViewpointFilter() {
+    return {
+        query: null,
+        objectTypes: [],
+        tags: [],
+        groupIds: [],
+    };
+}
+function createEmptyViewCamera() {
+    return {
+        azimuth: null,
+        elevation: null,
+        roll: null,
+        distance: null,
+    };
+}
+function normalizeViewpointFilter(filter) {
+    if (!filter) {
+        return null;
+    }
+    const normalized = {
+        query: filter.query?.trim() || null,
+        objectTypes: [...new Set(filter.objectTypes)],
+        tags: [...new Set(filter.tags)],
+        groupIds: [...new Set(filter.groupIds)],
+    };
+    return normalized.query ||
+        normalized.objectTypes.length > 0 ||
+        normalized.tags.length > 0 ||
+        normalized.groupIds.length > 0
+        ? normalized
+        : null;
+}
+function parseViewProjection(value) {
+    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();
+    if (normalized === "diagram" ||
+        normalized === "presentation" ||
+        normalized === "atlas-card" ||
+        normalized === "markdown") {
+        return normalized;
+    }
+    return null;
+}
+function parseFiniteNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function parsePositiveNumber(value) {
+    const parsed = parseFiniteNumber(value);
+    return parsed !== null && parsed > 0 ? parsed : null;
+}
+function parseViewpointLayers(value) {
+    const next = {};
+    for (const token of splitListValue(value)) {
+        const enabled = !token.startsWith("-") && !token.startsWith("!");
+        const rawLayer = token.replace(/^[-!]+/, "").toLowerCase();
+        if (rawLayer === "orbits") {
+            next["orbits-back"] = enabled;
+            next["orbits-front"] = enabled;
+            continue;
+        }
+        if (rawLayer === "background" ||
+            rawLayer === "guides" ||
+            rawLayer === "orbits-back" ||
+            rawLayer === "orbits-front" ||
+            rawLayer === "relations" ||
+            rawLayer === "events" ||
+            rawLayer === "objects" ||
+            rawLayer === "labels" ||
+            rawLayer === "metadata") {
+            next[rawLayer] = enabled;
+        }
+    }
+    return next;
+}
+function parseViewpointObjectTypes(value) {
+    return splitListValue(value).filter((entry) => entry === "star" ||
+        entry === "planet" ||
+        entry === "moon" ||
+        entry === "belt" ||
+        entry === "asteroid" ||
+        entry === "comet" ||
+        entry === "ring" ||
+        entry === "structure" ||
+        entry === "phenomenon");
+}
+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;
+        }
+        if (entry.startsWith("wo-") && entry.endsWith("-group")) {
+            return entry;
+        }
+        if (relationships.groupIds.has(entry)) {
+            return relationships.groupIds.get(entry) ?? createGroupId(entry);
+        }
+        return objectMap.has(entry) ? createGroupId(entry) : createGroupId(entry);
+    });
+}
+function splitListValue(value) {
+    return value
+        .split(/[\s,]+/)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function normalizeViewpointId(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function humanizeIdentifier(value) {
+    return value
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+        .join(" ");
+}
+function createViewpointSummary(label, objectId, filter) {
+    const parts = [label];
+    if (objectId) {
+        parts.push(`focus ${objectId}`);
+    }
+    if (filter?.objectTypes.length) {
+        parts.push(filter.objectTypes.join("/"));
+    }
+    if (filter?.tags.length) {
+        parts.push(`tags ${filter.tags.join(", ")}`);
+    }
+    if (filter?.query) {
+        parts.push(`query "${filter.query}"`);
+    }
+    return parts.join(" - ");
+}
+function calculateContentBounds(width, height, objects, orbitVisuals, leaders, labels, labelMultiplier) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    const include = (x, y) => {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    };
+    for (const orbit of orbitVisuals) {
+        if (orbit.hidden)
+            continue;
+        includeOrbitBounds(orbit, include);
+    }
+    for (const leader of leaders) {
+        if (leader.hidden)
+            continue;
+        include(leader.x1, leader.y1);
+        include(leader.x2, leader.y2);
+    }
+    for (const object of objects) {
+        if (object.hidden)
+            continue;
+        includeObjectBounds(object, include);
+    }
+    for (const label of labels) {
+        if (label.hidden)
+            continue;
+        includeLabelBounds(label, include, labelMultiplier);
+    }
+    if (!Number.isFinite(minX) || !Number.isFinite(minY)) {
+        return createBounds(0, 0, width, height);
+    }
+    return createBounds(minX, minY, maxX, maxY);
+}
+function includeOrbitBounds(orbit, include) {
+    const strokePadding = orbit.bandThickness !== undefined
+        ? orbit.bandThickness / 2 + 4
+        : orbit.band
+            ? 10
+            : 3;
+    if (orbit.kind === "circle" && orbit.radius !== undefined) {
+        include(orbit.cx - orbit.radius - strokePadding, orbit.cy - orbit.radius - strokePadding);
+        include(orbit.cx + orbit.radius + strokePadding, orbit.cy + orbit.radius + strokePadding);
+        return;
+    }
+    const rx = orbit.rx ?? orbit.radius ?? 0;
+    const ry = orbit.ry ?? orbit.radius ?? 0;
+    const points = sampleEllipseArcPoints(orbit.cx, orbit.cy, rx, ry, orbit.rotationDeg, 0, Math.PI * 2, ARC_SAMPLE_COUNT * 2);
+    for (const point of points) {
+        include(point.x - strokePadding, point.y - strokePadding);
+        include(point.x + strokePadding, point.y + strokePadding);
+    }
+}
+function createBounds(minX, minY, maxX, maxY) {
+    return {
+        minX,
+        minY,
+        maxX,
+        maxY,
+        width: maxX - minX,
+        height: maxY - minY,
+        centerX: minX + (maxX - minX) / 2,
+        centerY: minY + (maxY - minY) / 2,
+    };
+}
+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, 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)) {
+        return;
+    }
+    positions.set(object.id, {
+        object,
+        x,
+        y,
+        radius: visualRadiusFor(object, depth, context.scaleModel),
+        sortKey: computeSortKey(x, y, depth),
+    });
+    placeOrbitingChildren(object, positions, orbitDrafts, leaderDrafts, context, depth + 1);
+}
+function placeOrbitingChildren(object, positions, orbitDrafts, leaderDrafts, context, depth) {
+    const parent = positions.get(object.id);
+    if (!parent) {
+        return;
+    }
+    const orbiting = [...(context.orbitChildren.get(object.id) ?? [])].sort(compareOrbiting);
+    const orbitMetricContext = computeOrbitMetricContext(orbiting, parent.radius, context.spacingFactor, context.scaleModel);
+    const orbitRadiiPx = resolveOrbitRadiiPx(orbiting, orbitMetricContext);
+    orbiting.forEach((child, index) => {
+        const orbitGeometry = resolveOrbitGeometry(child, index, orbiting.length, parent, orbitMetricContext, orbitRadiiPx[index] ?? orbitMetricContext.innerPx, context);
+        orbitDrafts.push({
+            object: child,
+            parentId: object.id,
+            kind: orbitGeometry.kind,
+            cx: orbitGeometry.cx,
+            cy: orbitGeometry.cy,
+            radius: orbitGeometry.radius,
+            rx: orbitGeometry.rx,
+            ry: orbitGeometry.ry,
+            rotationDeg: orbitGeometry.rotationDeg,
+            band: orbitGeometry.band,
+            bandThickness: orbitGeometry.bandThickness,
+            frontArcPath: orbitGeometry.frontArcPath,
+            backArcPath: orbitGeometry.backArcPath,
+        });
+        placeObject(child, orbitGeometry.objectX, orbitGeometry.objectY, depth, positions, orbitDrafts, leaderDrafts, context);
+    });
+    const surfaceObjects = [...(context.surfaceChildren.get(object.id) ?? [])];
+    surfaceObjects.forEach((child, index) => {
+        const angle = angleForIndex(index, surfaceObjects.length, -Math.PI / 3);
+        const leaderDistance = 28 * context.spacingFactor;
+        const anchorOffset = projectPolarOffset(angle, parent.radius, context.projection, context.projection === "isometric" ? 0.9 : 1);
+        const bodyOffset = projectPolarOffset(angle, parent.radius + leaderDistance, context.projection, context.projection === "isometric" ? 0.9 : 1);
+        const anchorX = parent.x + anchorOffset.x;
+        const anchorY = parent.y + anchorOffset.y;
+        const x = parent.x + bodyOffset.x;
+        const y = parent.y + bodyOffset.y;
+        positions.set(child.id, {
+            object: child,
+            x,
+            y,
+            radius: visualRadiusFor(child, depth + 1, context.scaleModel),
+            sortKey: computeSortKey(x, y, depth + 1),
+            anchorX,
+            anchorY,
+        });
+        leaderDrafts.push({
+            object: child,
+            groupId: context.objectMap.has(child.id) ? createGroupId(resolveGroupRootObjectId(child, context.objectMap)) : null,
+            x1: anchorX,
+            y1: anchorY,
+            x2: x,
+            y2: y,
+            mode: "surface",
+        });
+        placeOrbitingChildren(child, positions, orbitDrafts, leaderDrafts, context, depth + 1);
+    });
+}
+function compareOrbiting(left, right) {
+    const leftMetric = orbitMetric(left);
+    const rightMetric = orbitMetric(right);
+    if (leftMetric !== null && rightMetric !== null && leftMetric !== rightMetric) {
+        return leftMetric - rightMetric;
+    }
+    if (leftMetric !== null && rightMetric === null)
+        return -1;
+    if (leftMetric === null && rightMetric !== null)
+        return 1;
+    return left.id.localeCompare(right.id);
+}
+function computeOrbitMetricContext(objects, parentRadius, spacingFactor, scaleModel) {
+    const metrics = objects.map((object) => orbitMetric(object));
+    const presentMetrics = metrics.filter((value) => value !== null);
+    const innerPx = parentRadius + 56 * spacingFactor * scaleModel.orbitDistanceMultiplier;
+    const stepPx = (objects.length > 2 ? 54 : 64) * spacingFactor * scaleModel.orbitDistanceMultiplier;
+    if (presentMetrics.length === 0) {
+        return {
+            metrics,
+            minMetric: 0,
+            maxMetric: 0,
+            metricSpread: 0,
+            innerPx,
+            stepPx,
+            pixelSpread: Math.max(stepPx * Math.max(objects.length - 1, 1), stepPx),
+            minimumGapPx: stepPx * 0.42,
+        };
+    }
+    const minMetric = Math.min(...presentMetrics);
+    const maxMetric = Math.max(...presentMetrics);
+    const metricSpread = maxMetric - minMetric;
+    return {
+        metrics,
+        minMetric,
+        maxMetric,
+        metricSpread,
+        innerPx,
+        stepPx,
+        pixelSpread: Math.max(stepPx * Math.max(objects.length - 1, 1), stepPx),
+        minimumGapPx: stepPx * 0.42,
+    };
+}
+function resolveOrbitGeometry(object, index, count, parent, metricContext, orbitRadiusPx, context) {
+    const placement = object.placement;
+    const band = object.type === "belt" || object.type === "ring";
+    if (!placement || placement.mode !== "orbit") {
+        const fallbackRadius = metricContext.innerPx + index * metricContext.stepPx;
+        return {
+            kind: "circle",
+            cx: parent.x,
+            cy: parent.y,
+            radius: fallbackRadius,
+            rotationDeg: 0,
+            band,
+            bandThickness: band
+                ? 12 * context.scaleModel.ringThicknessMultiplier
+                : undefined,
+            objectX: parent.x,
+            objectY: parent.y - fallbackRadius,
+        };
+    }
+    const eccentricity = clampNumber(typeof placement.eccentricity === "number" ? placement.eccentricity : 0, 0, 0.92);
+    const semiMajor = orbitRadiusPx;
+    const baseMinor = Math.max(semiMajor * Math.sqrt(1 - eccentricity * eccentricity), semiMajor * 0.18);
+    const inclinationDeg = unitValueToDegrees(placement.inclination) ?? 0;
+    const inclinationScale = context.projection === "isometric"
+        ? Math.max(MIN_ISO_MINOR_SCALE, Math.cos(degreesToRadians(inclinationDeg))) *
+            ISO_FLATTENING
+        : 1;
+    const semiMinor = Math.max(baseMinor * inclinationScale, semiMajor * 0.14);
+    const rotationDeg = unitValueToDegrees(placement.angle) ?? 0;
+    const focusOffset = semiMajor * eccentricity;
+    const centerOffset = rotateOffset(-focusOffset, 0, rotationDeg);
+    const cx = parent.x + centerOffset.x;
+    const cy = parent.y + centerOffset.y;
+    const phase = resolveOrbitPhase(placement.phase, index, count);
+    const objectPoint = ellipsePoint(cx, cy, semiMajor, semiMinor, rotationDeg, phase);
+    const useCircle = context.projection === "topdown" &&
+        eccentricity <= 0.0001 &&
+        Math.abs(rotationDeg) <= 0.0001;
+    const bandThickness = band
+        ? resolveBandThickness(object, semiMajor, metricContext, context.scaleModel)
+        : undefined;
+    return {
+        kind: useCircle ? "circle" : "ellipse",
+        cx: useCircle ? parent.x : cx,
+        cy: useCircle ? parent.y : cy,
+        radius: useCircle ? semiMajor : undefined,
+        rx: useCircle ? undefined : semiMajor,
+        ry: useCircle ? undefined : semiMinor,
+        rotationDeg,
+        band,
+        bandThickness,
+        frontArcPath: context.projection === "isometric" || band
+            ? buildEllipseArcPath(cx, cy, semiMajor, semiMinor, rotationDeg, 0, Math.PI)
+            : undefined,
+        backArcPath: context.projection === "isometric" || band
+            ? buildEllipseArcPath(cx, cy, semiMajor, semiMinor, rotationDeg, Math.PI, Math.PI * 2)
+            : undefined,
+        objectX: objectPoint.x,
+        objectY: objectPoint.y,
+    };
+}
+function resolveOrbitRadiusPx(metric, metricContext) {
+    return metricContext.innerPx + metricContext.stepPx * log2(Math.max(metric, 0) + 1);
+}
+function resolveOrbitRadiiPx(objects, metricContext) {
+    const radii = [];
+    objects.forEach((object, index) => {
+        const metric = orbitMetric(object);
+        const fallbackRadius = metricContext.innerPx + index * metricContext.stepPx;
+        const baseRadius = metric === null
+            ? fallbackRadius
+            : resolveOrbitRadiusPx(metric, metricContext);
+        const minimumRadius = index === 0
+            ? metricContext.innerPx
+            : (radii[index - 1] ?? metricContext.innerPx) + metricContext.minimumGapPx;
+        radii.push(Math.max(baseRadius, minimumRadius));
+    });
+    return radii;
+}
+function orbitMetric(object) {
+    if (!object.placement || object.placement.mode !== "orbit") {
+        return null;
+    }
+    return toDistanceMetric(object.placement.semiMajor ?? object.placement.distance ?? null);
+}
+function log2(value) {
+    return Math.log(value) / Math.log(2);
+}
+function resolveOrbitPhase(phase, index, count) {
+    const degreeValue = phase ? unitValueToDegrees(phase) : null;
+    if (degreeValue !== null) {
+        return degreesToRadians(degreeValue - 90);
+    }
+    return angleForIndex(index, count, -Math.PI / 2);
+}
+function resolveBandThickness(object, orbitRadius, metricContext, scaleModel) {
+    const innerMetric = toDistanceMetric(toUnitValue(object.properties.inner));
+    const outerMetric = toDistanceMetric(toUnitValue(object.properties.outer));
+    if (innerMetric !== null && outerMetric !== null) {
+        const thicknessMetric = Math.abs(outerMetric - innerMetric);
+        if (metricContext.metricSpread > 0) {
+            return clampNumber((thicknessMetric / metricContext.metricSpread) *
+                metricContext.pixelSpread *
+                scaleModel.ringThicknessMultiplier, 8, 54);
+        }
+        const referenceMetric = Math.max(Math.max(innerMetric, outerMetric), 0.0001);
+        return clampNumber((thicknessMetric / referenceMetric) *
+            orbitRadius *
+            0.75 *
+            scaleModel.ringThicknessMultiplier, 8, 48);
+    }
+    const fallbackBase = object.type === "belt" ? 18 : 12;
+    return fallbackBase * scaleModel.ringThicknessMultiplier;
+}
+function resolveAtPosition(reference, positions, objectMap, index, count, width, height, padding, context) {
+    if (reference.kind === "lagrange") {
+        return resolveLagrangePosition(reference, positions, objectMap, width, height);
+    }
+    if (reference.kind === "anchor") {
+        const anchor = positions.get(reference.objectId);
+        if (anchor) {
+            const angle = angleForIndex(index, count, Math.PI / 5);
+            const distance = (anchor.radius + 36) * context.scaleModel.labelMultiplier;
+            const offset = projectPolarOffset(angle, distance, context.projection, context.projection === "isometric" ? 0.92 : 1);
+            return {
+                x: anchor.x + offset.x,
+                y: anchor.y + offset.y,
+                anchorX: anchor.x,
+                anchorY: anchor.y,
+            };
+        }
+    }
+    if (reference.kind === "named") {
+        const anchor = positions.get(reference.name);
+        if (anchor) {
+            const angle = angleForIndex(index, count, Math.PI / 6);
+            const distance = (anchor.radius + 36) * context.scaleModel.labelMultiplier;
+            const offset = projectPolarOffset(angle, distance, context.projection, context.projection === "isometric" ? 0.92 : 1);
+            return {
+                x: anchor.x + offset.x,
+                y: anchor.y + offset.y,
+                anchorX: anchor.x,
+                anchorY: anchor.y,
+            };
+        }
+    }
+    return {
+        x: width - padding - 170,
+        y: height -
+            padding -
+            86 -
+            index * 58 * context.scaleModel.freePlacementMultiplier,
+    };
+}
+function resolveLagrangePosition(reference, positions, objectMap, width, height) {
+    const primary = reference.secondary
+        ? positions.get(reference.primary)
+        : deriveParentAnchor(reference.primary, positions, objectMap);
+    const secondary = positions.get(reference.secondary ?? reference.primary);
+    if (!primary || !secondary) {
+        return {
+            x: width * 0.7,
+            y: height * 0.25,
+        };
+    }
+    const dx = secondary.x - primary.x;
+    const dy = secondary.y - primary.y;
+    const distance = Math.hypot(dx, dy) || 1;
+    const ux = dx / distance;
+    const uy = dy / distance;
+    const nx = -uy;
+    const ny = ux;
+    const offset = clampNumber(distance * 0.25, 24, 68);
+    switch (reference.point) {
+        case "L1":
+            return {
+                x: secondary.x - ux * offset,
+                y: secondary.y - uy * offset,
+                anchorX: secondary.x,
+                anchorY: secondary.y,
+            };
+        case "L2":
+            return {
+                x: secondary.x + ux * offset,
+                y: secondary.y + uy * offset,
+                anchorX: secondary.x,
+                anchorY: secondary.y,
+            };
+        case "L3":
+            return {
+                x: primary.x - ux * offset,
+                y: primary.y - uy * offset,
+                anchorX: primary.x,
+                anchorY: primary.y,
+            };
+        case "L4":
+            return {
+                x: secondary.x + (ux * 0.5 - nx * 0.8660254) * offset,
+                y: secondary.y + (uy * 0.5 - ny * 0.8660254) * offset,
+                anchorX: secondary.x,
+                anchorY: secondary.y,
+            };
+        case "L5":
+            return {
+                x: secondary.x + (ux * 0.5 + nx * 0.8660254) * offset,
+                y: secondary.y + (uy * 0.5 + ny * 0.8660254) * offset,
+                anchorX: secondary.x,
+                anchorY: secondary.y,
+            };
+    }
+}
+function buildSceneRelationships(objects, objectMap) {
+    const parentIds = new Map();
+    const childIds = new Map();
+    for (const object of objects) {
+        const parentId = resolveParentId(object, objectMap);
+        parentIds.set(object.id, parentId);
+        if (parentId) {
+            const existing = childIds.get(parentId);
+            if (existing) {
+                existing.push(object.id);
+            }
+            else {
+                childIds.set(parentId, [object.id]);
+            }
+        }
+        if (!childIds.has(object.id)) {
+            childIds.set(object.id, []);
+        }
+    }
+    const ancestorIds = new Map();
+    const groupIds = new Map();
+    const groupRoots = new Map();
+    const buildAncestors = (objectId) => {
+        const cached = ancestorIds.get(objectId);
+        if (cached) {
+            return cached;
+        }
+        const seen = new Set();
+        const results = [];
+        let cursor = parentIds.get(objectId) ?? null;
+        while (cursor && !seen.has(cursor)) {
+            results.push(cursor);
+            seen.add(cursor);
+            cursor = parentIds.get(cursor) ?? null;
+        }
+        ancestorIds.set(objectId, results);
+        return results;
+    };
+    const resolveGroupRootObjectId = (objectId) => {
+        const cached = groupRoots.get(groupIds.get(objectId) ?? "");
+        if (cached) {
+            return cached;
+        }
+        const parentId = parentIds.get(objectId) ?? null;
+        const object = objectMap.get(objectId);
+        let rootObjectId = objectId;
+        if (object?.placement && object.placement.mode !== "free" && parentId) {
+            rootObjectId = resolveGroupRootObjectId(parentId);
+        }
+        return rootObjectId;
+    };
+    for (const object of objects) {
+        buildAncestors(object.id);
+        const rootObjectId = resolveGroupRootObjectId(object.id);
+        const groupId = createGroupId(rootObjectId);
+        groupIds.set(object.id, groupId);
+        groupRoots.set(groupId, rootObjectId);
+    }
+    return {
+        parentIds,
+        childIds,
+        ancestorIds,
+        groupIds,
+        groupRoots,
+    };
+}
+function resolveParentId(object, objectMap) {
+    const placement = object.placement;
+    if (!placement) {
+        return null;
+    }
+    switch (placement.mode) {
+        case "orbit":
+        case "surface":
+            return objectMap.has(placement.target) ? placement.target : null;
+        case "at":
+            switch (placement.reference.kind) {
+                case "anchor":
+                    return objectMap.has(placement.reference.objectId) ? placement.reference.objectId : null;
+                case "named":
+                    return objectMap.has(placement.reference.name) ? placement.reference.name : null;
+                case "lagrange":
+                    if (placement.reference.secondary && objectMap.has(placement.reference.secondary)) {
+                        return placement.reference.secondary;
+                    }
+                    return objectMap.has(placement.reference.primary) ? placement.reference.primary : null;
+            }
+        case "free":
+            return null;
+    }
+}
+function calculateGroupBounds(group, objects, orbitVisuals, leaders, labels, labelMultiplier) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    const include = (x, y) => {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    };
+    for (const object of objects) {
+        if (!object.hidden && group.objectIds.includes(object.objectId)) {
+            includeObjectBounds(object, include);
+        }
+    }
+    for (const orbit of orbitVisuals) {
+        if (!orbit.hidden && group.orbitIds.includes(orbit.objectId)) {
+            includeOrbitBounds(orbit, include);
+        }
+    }
+    for (const leader of leaders) {
+        if (!leader.hidden && group.leaderIds.includes(leader.objectId)) {
+            include(leader.x1, leader.y1);
+            include(leader.x2, leader.y2);
+        }
+    }
+    for (const label of labels) {
+        if (!label.hidden && group.labelIds.includes(label.objectId)) {
+            includeLabelBounds(label, include, labelMultiplier);
+        }
+    }
+    if (!Number.isFinite(minX) || !Number.isFinite(minY)) {
+        return createBounds(0, 0, 0, 0);
+    }
+    return createBounds(minX, minY, maxX, maxY);
+}
+function resolveGroupRootObjectId(object, objectMap) {
+    let current = object;
+    const seen = new Set();
+    while (current.placement && current.placement.mode !== "free" && !seen.has(current.id)) {
+        seen.add(current.id);
+        const parentId = resolveParentId(current, objectMap);
+        if (!parentId) {
+            break;
+        }
+        const parent = objectMap.get(parentId);
+        if (!parent) {
+            break;
+        }
+        current = parent;
+    }
+    return current.id;
+}
+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,
+        right,
+        top: Math.min(labelY, secondaryY) - topPadding,
+        bottom: Math.max(labelY, secondaryY) + bottomPadding,
+    };
+}
+function rectsOverlap(left, right) {
+    return !(left.right < right.left ||
+        right.right < left.left ||
+        left.bottom < right.top ||
+        right.bottom < left.top);
+}
+function deriveParentAnchor(objectId, positions, objectMap) {
+    const object = objectMap.get(objectId);
+    if (!object?.placement || object.placement.mode !== "orbit") {
+        return positions.get(objectId);
+    }
+    return positions.get(object.placement.target);
+}
+function visualRadiusFor(object, depth, scaleModel) {
+    const explicitRadius = toVisualSizeMetric(object.properties.radius, scaleModel);
+    if (explicitRadius !== null) {
+        return explicitRadius;
+    }
+    const multiplier = scaleModel.bodyRadiusMultiplier;
+    switch (object.type) {
+        case "star":
+            return clampNumber((depth === 0 ? 28 : 20) * multiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+        case "planet":
+            return clampNumber(12 * multiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+        case "moon":
+            return clampNumber(7 * multiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+        case "belt":
+            return clampNumber(5 * multiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+        case "asteroid":
+            return clampNumber(5 * multiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+        case "comet":
+            return clampNumber(6 * multiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+        case "ring":
+            return clampNumber(5 * multiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+        case "structure":
+            return clampNumber(6 * multiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+        case "phenomenon":
+            return clampNumber(8 * multiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+    }
+}
+function visualExtentForObject(object, radius, scaleModel) {
+    const atmosphereBoost = typeof object.properties.atmosphere === "string" ? 4 : 0;
+    switch (object.type) {
+        case "star":
+            return radius * 2.4;
+        case "phenomenon":
+            return radius * 1.25;
+        case "structure":
+            return radius + 2;
+        default:
+            return Math.min(radius + atmosphereBoost, scaleModel.maxBodyRadius + 10);
+    }
+}
+function toDistanceMetric(value) {
+    if (!value)
+        return null;
+    switch (value.unit) {
+        case "au":
+            return value.value;
+        case "km":
+            return value.value / AU_IN_KM;
+        case "m":
+            return (value.value / 1_000) / AU_IN_KM;
+        case "ly":
+            return value.value * LY_IN_AU;
+        case "pc":
+            return value.value * PC_IN_AU;
+        case "kpc":
+            return value.value * KPC_IN_AU;
+        case "re":
+            return (value.value * EARTH_RADIUS_IN_KM) / AU_IN_KM;
+        case "rj":
+            return (value.value * JUPITER_RADIUS_IN_KM) / AU_IN_KM;
+        case "sol":
+            return (value.value * SOLAR_RADIUS_IN_KM) / AU_IN_KM;
+        default:
+            // Unitless or non-distance units (me, mj, s, min, h, d, y, ky, my, gy, K, deg):
+            // return raw value — renderer treats it as an abstract metric
+            return value.value;
+    }
+}
+function freePlacementOffsetPx(distance, scaleModel) {
+    const metric = toDistanceMetric(distance ?? null);
+    if (metric === null || metric <= 0) {
+        return 0;
+    }
+    return clampNumber(metric * 96 * scaleModel.freePlacementMultiplier, 0, 420);
+}
+function toVisualSizeMetric(value, scaleModel) {
+    const unitValue = toUnitValue(value);
+    if (!unitValue) {
+        return null;
+    }
+    let size;
+    switch (unitValue.unit) {
+        case "sol":
+            size = clampNumber(unitValue.value * 22, 14, 40);
+            break;
+        case "re":
+            size = clampNumber(unitValue.value * 10, 6, 18);
+            break;
+        case "km":
+            size = clampNumber(Math.log10(Math.max(unitValue.value, 1)) * 2.6, 4, 16);
+            break;
+        default:
+            size = clampNumber(unitValue.value * 4, 4, 20);
+            break;
+    }
+    return clampNumber(size * scaleModel.bodyRadiusMultiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+}
+function toUnitValue(value) {
+    if (!value || typeof value !== "object" || !("value" in value)) {
+        return null;
+    }
+    return value;
+}
+function unitValueToDegrees(value) {
+    if (!value) {
+        return null;
+    }
+    return value.unit === "deg" || value.unit === null ? value.value : null;
+}
+function angleForIndex(index, count, startAngle) {
+    if (count <= 1)
+        return startAngle;
+    return startAngle + (index * Math.PI * 2) / count;
+}
+function buildEllipseArcPath(cx, cy, rx, ry, rotationDeg, start, end) {
+    const points = sampleEllipseArcPoints(cx, cy, rx, ry, rotationDeg, start, end, ARC_SAMPLE_COUNT);
+    if (points.length === 0) {
+        return "";
+    }
+    return points
+        .map((point, index) => `${index === 0 ? "M" : "L"} ${formatNumber(point.x)} ${formatNumber(point.y)}`)
+        .join(" ");
+}
+function sampleEllipseArcPoints(cx, cy, rx, ry, rotationDeg, start, end, segments) {
+    const points = [];
+    for (let index = 0; index <= segments; index += 1) {
+        const t = start + ((end - start) * index) / segments;
+        points.push(ellipsePoint(cx, cy, rx, ry, rotationDeg, t));
+    }
+    return points;
+}
+function ellipsePoint(cx, cy, rx, ry, rotationDeg, angle) {
+    const localX = rx * Math.cos(angle);
+    const localY = ry * Math.sin(angle);
+    const rotated = rotateOffset(localX, localY, rotationDeg);
+    return {
+        x: cx + rotated.x,
+        y: cy + rotated.y,
+    };
+}
+function rotateOffset(x, y, rotationDeg) {
+    const radians = degreesToRadians(rotationDeg);
+    return {
+        x: x * Math.cos(radians) - y * Math.sin(radians),
+        y: x * Math.sin(radians) + y * Math.cos(radians),
+    };
+}
+function projectPolarOffset(angle, distance, projection, verticalFactor) {
+    const yScale = projection === "isometric" ? ISO_FLATTENING * verticalFactor : verticalFactor;
+    return {
+        x: Math.cos(angle) * distance,
+        y: Math.sin(angle) * distance * yScale,
+    };
+}
+function computeSortKey(x, y, depth) {
+    return y * 1_000 + x + depth * 0.01;
+}
+function clampNumber(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function pushGrouped(map, key, value) {
+    const existing = map.get(key);
+    if (existing) {
+        existing.push(value);
+    }
+    else {
+        map.set(key, [value]);
+    }
+}
+function createRenderId(objectId) {
+    const normalized = objectId
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "object";
+    return `wo-${normalized}`;
+}
+function createGroupId(objectId) {
+    return `${createRenderId(objectId)}-group`;
+}
+function customColorFor(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function estimateLabelHalfWidth(object, labelMultiplier) {
+    const primaryWidth = object.label.length * 4.6 * labelMultiplier + 18;
+    const secondaryWidth = object.secondaryLabel.length * 3.9 * labelMultiplier + 18;
+    return Math.max(primaryWidth, secondaryWidth, object.visualRadius + 18);
+}
+function estimateLabelHalfWidthFromText(label, secondaryLabel, labelMultiplier) {
+    const primaryWidth = label.length * 4.6 * labelMultiplier + 18;
+    const secondaryWidth = secondaryLabel.length * 3.9 * labelMultiplier + 18;
+    return Math.max(primaryWidth, secondaryWidth, 24);
+}
+function capitalizeLabel(value) {
+    return value.length > 0 ? value[0].toUpperCase() + value.slice(1) : value;
+}
+function degreesToRadians(value) {
+    return (value * Math.PI) / 180;
+}
+function formatNumber(value) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(2);
+}