worldorbit 2.6.0 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worldorbit",
-  "version": "2.6.0",
+  "version": "3.0.1",
   "description": "A text-based DSL and parser pipeline for orbital worldbuilding",
   "type": "module",
   "main": "./dist/unpkg/worldorbit.esm.js",

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

@@ -7,6 +7,7 @@ export { normalizeDocument } from "./normalize.js";
 export { validateDocument } from "./validate.js";
 export { createDiagnostic, diagnosticFromError, normalizeWithDiagnostics, parseWithDiagnostics, validateDocumentWithDiagnostics, } from "./diagnostics.js";
 export { renderDocumentToScene, rotatePoint } from "./scene.js";
+export { evaluateSpatialSceneAtTime, renderDocumentToSpatialScene, } from "./spatial-scene.js";
 export { formatAtlasDocument, formatDocument, formatDraftDocument } from "./format.js";
 export { materializeAtlasDocument, materializeDraftDocument, upgradeDocumentToDraftV2, upgradeDocumentToV2, } from "./draft.js";
 export { parseWorldOrbitAtlas, parseWorldOrbitDraft } from "./draft-parse.js";

package/packages/core/dist/index.js

@@ -7,6 +7,7 @@ export { normalizeDocument } from "./normalize.js";
 export { validateDocument } from "./validate.js";
 export { createDiagnostic, diagnosticFromError, normalizeWithDiagnostics, parseWithDiagnostics, validateDocumentWithDiagnostics, } from "./diagnostics.js";
 export { renderDocumentToScene, rotatePoint } from "./scene.js";
+export { evaluateSpatialSceneAtTime, renderDocumentToSpatialScene, } from "./spatial-scene.js";
 export { formatAtlasDocument, formatDocument, formatDraftDocument } from "./format.js";
 export { materializeAtlasDocument, materializeDraftDocument, upgradeDocumentToDraftV2, upgradeDocumentToV2, } from "./draft.js";
 export { parseWorldOrbitAtlas, parseWorldOrbitDraft } from "./draft-parse.js";

package/packages/core/dist/spatial-scene.d.ts

@@ -0,0 +1,3 @@
+import type { CoordinatePoint3D, SpatialScene, SpatialSceneRenderOptions, WorldOrbitDocument } from "./types.js";
+export declare function renderDocumentToSpatialScene(document: WorldOrbitDocument, options?: SpatialSceneRenderOptions): SpatialScene;
+export declare function evaluateSpatialSceneAtTime(scene: SpatialScene, timeSeconds: number): Map<string, CoordinatePoint3D>;

package/packages/core/dist/spatial-scene.js

@@ -0,0 +1,420 @@
+import { renderDocumentToScene } from "./scene.js";
+const DAY_IN_SECONDS = 86_400;
+const YEAR_IN_SECONDS = DAY_IN_SECONDS * 365.25;
+const FASTEST_VISIBLE_ORBIT_SECONDS = 18;
+const SLOWEST_VISIBLE_ORBIT_SECONDS = 180;
+export function renderDocumentToSpatialScene(document, options = {}) {
+    const renderOptions = {
+        width: options.width,
+        height: options.height,
+        padding: options.padding,
+        preset: options.preset,
+        projection: options.projection,
+        camera: options.camera,
+        scaleModel: options.scaleModel,
+        activeEventId: options.activeEventId,
+    };
+    const scene = renderDocumentToScene(document, renderOptions);
+    const scaleModel = resolveSpatialScaleModel(scene.layoutPreset, options.spatialScaleModel);
+    const sceneCenter = {
+        x: scene.contentBounds.centerX,
+        y: scene.contentBounds.centerY,
+    };
+    const objectMap = new Map(scene.objects.map((object) => [object.objectId, object]));
+    const orbitMap = new Map(scene.orbitVisuals.map((orbit) => [orbit.objectId, orbit]));
+    const rawMotionMetrics = new Map();
+    for (const object of scene.objects) {
+        const placement = object.object.placement;
+        if (!placement || placement.mode !== "orbit") {
+            continue;
+        }
+        rawMotionMetrics.set(object.objectId, resolveRawOrbitMetric(placement));
+    }
+    const minimumMotionMetric = Math.min(...[...rawMotionMetrics.values()].filter((value) => Number.isFinite(value) && value > 0)) || 1;
+    const positionCache = new Map();
+    const spatialObjects = scene.objects.map((entry) => createSpatialObject(entry, scene, sceneCenter, objectMap, orbitMap, scaleModel, positionCache, minimumMotionMetric));
+    const spatialObjectMap = new Map(spatialObjects.map((object) => [object.objectId, object]));
+    const spatialOrbits = scene.orbitVisuals.map((orbit) => createSpatialOrbit(orbit, spatialObjectMap, minimumMotionMetric, scene.activeEventId !== null));
+    const focusTargets = spatialObjects.map((object) => ({
+        objectId: object.objectId,
+        center: { ...object.position },
+        radius: object.visualRadius + scaleModel.focusPadding,
+    }));
+    return {
+        width: scene.width,
+        height: scene.height,
+        padding: scene.padding,
+        renderPreset: scene.renderPreset,
+        projection: scene.projection,
+        camera: scene.camera,
+        scaleModel,
+        title: scene.title,
+        subtitle: scene.subtitle,
+        systemId: scene.systemId,
+        viewMode: "3d",
+        layoutPreset: scene.layoutPreset,
+        metadata: {
+            ...scene.metadata,
+            "viewer.mode": "3d",
+        },
+        contentBounds: calculateSpatialBounds(spatialObjects),
+        semanticGroups: scene.semanticGroups,
+        viewpoints: scene.viewpoints,
+        activeEventId: scene.activeEventId,
+        timeFrozen: scene.activeEventId !== null,
+        objects: spatialObjects,
+        orbits: spatialOrbits,
+        focusTargets,
+    };
+}
+function createSpatialObject(entry, scene, sceneCenter, objectMap, orbitMap, scaleModel, positionCache, minimumMotionMetric) {
+    const position = resolveSpatialObjectPosition(entry, scene, sceneCenter, objectMap, orbitMap, positionCache);
+    const motion = createMotionModel(entry.object, orbitMap.get(entry.objectId), minimumMotionMetric, scene.activeEventId !== null);
+    return {
+        objectId: entry.objectId,
+        object: entry.object,
+        parentId: entry.parentId,
+        ancestorIds: entry.ancestorIds.slice(),
+        childIds: entry.childIds.slice(),
+        groupId: entry.groupId,
+        semanticGroupIds: entry.semanticGroupIds.slice(),
+        position,
+        radius: clampNumber(entry.radius * scaleModel.bodyRadiusMultiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius),
+        visualRadius: clampNumber(entry.visualRadius * scaleModel.bodyRadiusMultiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius + 24),
+        label: entry.label,
+        secondaryLabel: entry.secondaryLabel,
+        fillColor: entry.fillColor,
+        imageHref: entry.imageHref,
+        hidden: entry.hidden,
+        motion,
+    };
+}
+function createSpatialOrbit(orbit, objectMap, minimumMotionMetric, frozen) {
+    const owner = objectMap.get(orbit.objectId);
+    const parent = objectMap.get(orbit.parentId);
+    return {
+        objectId: orbit.objectId,
+        object: orbit.object,
+        parentId: orbit.parentId,
+        groupId: orbit.groupId,
+        semanticGroupIds: orbit.semanticGroupIds.slice(),
+        center: parent?.position ?? { x: 0, y: 0, z: 0 },
+        kind: orbit.kind,
+        radius: orbit.radius,
+        semiMajor: orbit.radius ?? orbit.rx ?? 0,
+        semiMinor: orbit.radius ?? orbit.ry ?? 0,
+        rotationDeg: orbit.rotationDeg,
+        inclinationDeg: owner?.motion?.inclinationDeg ??
+            unitValueToDegrees(orbit.object.placement?.mode === "orbit"
+                ? orbit.object.placement.inclination
+                : undefined) ??
+            0,
+        band: orbit.band,
+        bandThickness: orbit.bandThickness,
+        hidden: orbit.hidden,
+        motion: owner?.motion ??
+            createMotionModel(orbit.object, orbit, minimumMotionMetric, frozen),
+    };
+}
+function resolveSpatialObjectPosition(entry, scene, sceneCenter, objectMap, orbitMap, cache) {
+    const cached = cache.get(entry.objectId);
+    if (cached) {
+        return cached;
+    }
+    const placement = entry.object.placement;
+    let position;
+    if (placement?.mode === "orbit" && entry.parentId) {
+        const parent = objectMap.get(entry.parentId);
+        const parentPosition = parent
+            ? resolveSpatialObjectPosition(parent, scene, sceneCenter, objectMap, orbitMap, cache)
+            : { x: 0, y: 0, z: 0 };
+        const orbit = orbitMap.get(entry.objectId);
+        const motion = createMotionModel(entry.object, orbit, 1, scene.activeEventId !== null);
+        const local = motion
+            ? computeOrbitPosition(motion, 0)
+            : {
+                x: (entry.x - sceneCenter.x) * 0.8,
+                y: 0,
+                z: (entry.y - sceneCenter.y) * 0.8,
+            };
+        position = addPoint3D(parentPosition, local);
+    }
+    else if (placement?.mode === "surface" && entry.parentId) {
+        const parent = objectMap.get(entry.parentId);
+        const parentPosition = parent
+            ? resolveSpatialObjectPosition(parent, scene, sceneCenter, objectMap, orbitMap, cache)
+            : { x: 0, y: 0, z: 0 };
+        const parentRadius = parent?.visualRadius ?? 16;
+        const seed = hashUnit(entry.objectId);
+        const angle = seed * Math.PI * 2;
+        position = {
+            x: parentPosition.x + Math.cos(angle) * (parentRadius + entry.visualRadius * 0.9),
+            y: parentPosition.y + Math.sin(seed * Math.PI) * Math.max(entry.visualRadius * 0.2, 2),
+            z: parentPosition.z + Math.sin(angle) * (parentRadius + entry.visualRadius * 0.9),
+        };
+    }
+    else if (placement?.mode === "at" && entry.parentId) {
+        const parent = objectMap.get(entry.parentId);
+        const parentPosition = parent
+            ? resolveSpatialObjectPosition(parent, scene, sceneCenter, objectMap, orbitMap, cache)
+            : { x: 0, y: 0, z: 0 };
+        const anchorX = entry.anchorX ?? parent?.x ?? sceneCenter.x;
+        const anchorY = entry.anchorY ?? parent?.y ?? sceneCenter.y;
+        position = {
+            x: parentPosition.x + (entry.x - anchorX),
+            y: parentPosition.y,
+            z: parentPosition.z + (entry.y - anchorY),
+        };
+    }
+    else {
+        position = {
+            x: (entry.x - sceneCenter.x) * 0.8,
+            y: 0,
+            z: (entry.y - sceneCenter.y) * 0.8,
+        };
+    }
+    cache.set(entry.objectId, position);
+    return position;
+}
+export function evaluateSpatialSceneAtTime(scene, timeSeconds) {
+    const objectMap = new Map(scene.objects.map((object) => [object.objectId, object]));
+    const cache = new Map();
+    const resolvePosition = (objectId) => {
+        const cached = cache.get(objectId);
+        if (cached) {
+            return cached;
+        }
+        const object = objectMap.get(objectId);
+        if (!object) {
+            return { x: 0, y: 0, z: 0 };
+        }
+        let next = { ...object.position };
+        if (object.motion && object.parentId) {
+            const parentPosition = resolvePosition(object.parentId);
+            const local = computeOrbitPosition(object.motion, scene.timeFrozen ? 0 : timeSeconds);
+            next = addPoint3D(parentPosition, local);
+        }
+        cache.set(objectId, next);
+        return next;
+    };
+    for (const object of scene.objects) {
+        resolvePosition(object.objectId);
+    }
+    return cache;
+}
+function computeOrbitPosition(motion, timeSeconds) {
+    const angleDeg = motion.phase0Deg + motion.angularVelocityDegPerSecond * timeSeconds;
+    const angle = degreesToRadians(angleDeg);
+    const rotation = degreesToRadians(motion.rotationDeg);
+    const inclination = degreesToRadians(motion.inclinationDeg);
+    const localX = Math.cos(angle) * motion.semiMajor;
+    const localZ = Math.sin(angle) * motion.semiMinor;
+    const rotatedX = localX * Math.cos(rotation) - localZ * Math.sin(rotation);
+    const rotatedZ = localX * Math.sin(rotation) + localZ * Math.cos(rotation);
+    return {
+        x: rotatedX,
+        y: rotatedZ * Math.sin(inclination),
+        z: rotatedZ * Math.cos(inclination),
+    };
+}
+function createMotionModel(object, orbit, minimumMotionMetric, frozen) {
+    const placement = object.placement;
+    if (!placement || placement.mode !== "orbit") {
+        return null;
+    }
+    const semiMajor = orbit?.radius ??
+        orbit?.rx ??
+        clampNumber(resolveRawOrbitMetric(placement) * 48, 24, 1_200);
+    const semiMinor = orbit?.radius ?? orbit?.ry ?? semiMajor;
+    const periodSeconds = unitValueToDurationSeconds(placement.period);
+    const rawMetric = resolveRawOrbitMetric(placement);
+    const ratio = clampNumber(rawMetric / Math.max(minimumMotionMetric, 0.0001), 1, 20);
+    const visualDurationSeconds = periodSeconds
+        ? clampNumber(FASTEST_VISIBLE_ORBIT_SECONDS * ratio, FASTEST_VISIBLE_ORBIT_SECONDS, SLOWEST_VISIBLE_ORBIT_SECONDS)
+        : clampNumber(FASTEST_VISIBLE_ORBIT_SECONDS * Math.pow(ratio, 0.75), FASTEST_VISIBLE_ORBIT_SECONDS, SLOWEST_VISIBLE_ORBIT_SECONDS);
+    return {
+        phase0Deg: unitValueToDegrees(placement.phase) ?? 0,
+        rotationDeg: unitValueToDegrees(placement.angle) ??
+            orbit?.rotationDeg ??
+            0,
+        inclinationDeg: unitValueToDegrees(placement.inclination) ?? 0,
+        semiMajor,
+        semiMinor,
+        eccentricity: placement.eccentricity ?? 0,
+        periodSeconds,
+        angularVelocityDegPerSecond: 360 / Math.max(visualDurationSeconds, 0.001),
+        heuristic: periodSeconds === null,
+        frozen,
+    };
+}
+function resolveRawOrbitMetric(placement) {
+    const distance = unitValueToDistanceMetric(placement.semiMajor) ??
+        unitValueToDistanceMetric(placement.distance) ??
+        1;
+    return Math.max(distance, 0.01);
+}
+function unitValueToDistanceMetric(value) {
+    if (!value) {
+        return null;
+    }
+    switch (value.unit) {
+        case "au":
+            return value.value;
+        case "km":
+            return value.value / 149_597_870.7;
+        case "m":
+            return value.value / 149_597_870_700;
+        case "re":
+            return (value.value * 6_371) / 149_597_870.7;
+        case "rj":
+            return (value.value * 71_492) / 149_597_870.7;
+        case "sol":
+            return (value.value * 695_700) / 149_597_870.7;
+        case "ly":
+            return value.value * 63_241.077;
+        case "pc":
+            return value.value * 206_264.806;
+        case "kpc":
+            return value.value * 206_264_806;
+        default:
+            return value.value;
+    }
+}
+function unitValueToDurationSeconds(value) {
+    if (!value) {
+        return null;
+    }
+    switch (value.unit) {
+        case "s":
+            return value.value;
+        case "min":
+            return value.value * 60;
+        case "h":
+            return value.value * 3_600;
+        case "d":
+            return value.value * DAY_IN_SECONDS;
+        case "y":
+            return value.value * YEAR_IN_SECONDS;
+        case "ky":
+            return value.value * YEAR_IN_SECONDS * 1_000;
+        case "my":
+            return value.value * YEAR_IN_SECONDS * 1_000_000;
+        case "gy":
+            return value.value * YEAR_IN_SECONDS * 1_000_000_000;
+        default:
+            return null;
+    }
+}
+function unitValueToDegrees(value) {
+    if (!value) {
+        return null;
+    }
+    return value.unit === "deg" || value.unit === null ? value.value : null;
+}
+function resolveSpatialScaleModel(layoutPreset, overrides) {
+    const defaults = defaultSpatialScaleModel(layoutPreset);
+    return {
+        ...defaults,
+        ...overrides,
+    };
+}
+function defaultSpatialScaleModel(layoutPreset) {
+    switch (layoutPreset) {
+        case "compact":
+            return {
+                orbitDistanceMultiplier: 0.92,
+                bodyRadiusMultiplier: 0.92,
+                markerSizeMultiplier: 0.92,
+                ringThicknessMultiplier: 0.9,
+                focusPadding: 10,
+                minBodyRadius: 4,
+                maxBodyRadius: 34,
+            };
+        case "presentation":
+            return {
+                orbitDistanceMultiplier: 1.15,
+                bodyRadiusMultiplier: 1.12,
+                markerSizeMultiplier: 1.08,
+                ringThicknessMultiplier: 1.14,
+                focusPadding: 16,
+                minBodyRadius: 5,
+                maxBodyRadius: 44,
+            };
+        default:
+            return {
+                orbitDistanceMultiplier: 1,
+                bodyRadiusMultiplier: 1,
+                markerSizeMultiplier: 1,
+                ringThicknessMultiplier: 1,
+                focusPadding: 12,
+                minBodyRadius: 4,
+                maxBodyRadius: 40,
+            };
+    }
+}
+function calculateSpatialBounds(objects) {
+    if (objects.length === 0) {
+        return {
+            minX: 0,
+            minY: 0,
+            minZ: 0,
+            maxX: 0,
+            maxY: 0,
+            maxZ: 0,
+            width: 0,
+            height: 0,
+            depth: 0,
+            center: { x: 0, y: 0, z: 0 },
+        };
+    }
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const object of objects) {
+        minX = Math.min(minX, object.position.x - object.visualRadius);
+        minY = Math.min(minY, object.position.y - object.visualRadius);
+        minZ = Math.min(minZ, object.position.z - object.visualRadius);
+        maxX = Math.max(maxX, object.position.x + object.visualRadius);
+        maxY = Math.max(maxY, object.position.y + object.visualRadius);
+        maxZ = Math.max(maxZ, object.position.z + object.visualRadius);
+    }
+    return {
+        minX,
+        minY,
+        minZ,
+        maxX,
+        maxY,
+        maxZ,
+        width: maxX - minX,
+        height: maxY - minY,
+        depth: maxZ - minZ,
+        center: {
+            x: (minX + maxX) / 2,
+            y: (minY + maxY) / 2,
+            z: (minZ + maxZ) / 2,
+        },
+    };
+}
+function addPoint3D(left, right) {
+    return {
+        x: left.x + right.x,
+        y: left.y + right.y,
+        z: left.z + right.z,
+    };
+}
+function hashUnit(value) {
+    let hash = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = (hash * 31 + value.charCodeAt(index)) >>> 0;
+    }
+    return (hash % 10_000) / 10_000;
+}
+function clampNumber(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function degreesToRadians(value) {
+    return (value * Math.PI) / 180;
+}

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

@@ -12,6 +12,11 @@ export interface CoordinatePoint {
     x: number;
     y: number;
 }
+export interface CoordinatePoint3D {
+    x: number;
+    y: number;
+    z: number;
+}
 export interface UnitValue {
     value: number;
     unit: Unit | null;
@@ -249,6 +254,18 @@ export interface SceneRenderOptions {
     scaleModel?: Partial<RenderScaleModel>;
     activeEventId?: string | null;
 }
+export interface SpatialScaleModel {
+    orbitDistanceMultiplier: number;
+    bodyRadiusMultiplier: number;
+    markerSizeMultiplier: number;
+    ringThicknessMultiplier: number;
+    focusPadding: number;
+    minBodyRadius: number;
+    maxBodyRadius: number;
+}
+export interface SpatialSceneRenderOptions extends SceneRenderOptions {
+    spatialScaleModel?: Partial<SpatialScaleModel>;
+}
 export interface RenderBounds {
     minX: number;
     minY: number;
@@ -400,6 +417,71 @@ export interface RenderSceneRelation {
     y2: number;
     hidden: boolean;
 }
+export interface SpatialBounds {
+    minX: number;
+    minY: number;
+    minZ: number;
+    maxX: number;
+    maxY: number;
+    maxZ: number;
+    width: number;
+    height: number;
+    depth: number;
+    center: CoordinatePoint3D;
+}
+export interface OrbitalMotionModel {
+    phase0Deg: number;
+    rotationDeg: number;
+    inclinationDeg: number;
+    semiMajor: number;
+    semiMinor: number;
+    eccentricity: number;
+    periodSeconds: number | null;
+    angularVelocityDegPerSecond: number;
+    heuristic: boolean;
+    frozen: boolean;
+}
+export interface SpatialSceneObject {
+    objectId: string;
+    object: WorldOrbitObject;
+    parentId: string | null;
+    ancestorIds: string[];
+    childIds: string[];
+    groupId: string | null;
+    semanticGroupIds: string[];
+    position: CoordinatePoint3D;
+    radius: number;
+    visualRadius: number;
+    label: string;
+    secondaryLabel: string;
+    fillColor?: string;
+    imageHref?: string;
+    hidden: boolean;
+    motion: OrbitalMotionModel | null;
+}
+export interface SpatialOrbit {
+    objectId: string;
+    object: WorldOrbitObject;
+    parentId: string;
+    groupId: string | null;
+    semanticGroupIds: string[];
+    center: CoordinatePoint3D;
+    kind: "circle" | "ellipse";
+    radius?: number;
+    semiMajor: number;
+    semiMinor: number;
+    rotationDeg: number;
+    inclinationDeg: number;
+    band: boolean;
+    bandThickness?: number;
+    hidden: boolean;
+    motion: OrbitalMotionModel | null;
+}
+export interface SpatialFocusTarget {
+    objectId: string;
+    center: CoordinatePoint3D;
+    radius: number;
+}
 export interface RenderScene {
     width: number;
     height: number;
@@ -428,6 +510,29 @@ export interface RenderScene {
     leaders: RenderLeaderLine[];
     labels: RenderSceneLabel[];
 }
+export interface SpatialScene {
+    width: number;
+    height: number;
+    padding: number;
+    renderPreset: RenderPresetName | null;
+    projection: ViewProjection;
+    camera: WorldOrbitViewCamera | null;
+    scaleModel: SpatialScaleModel;
+    title: string;
+    subtitle: string;
+    systemId: string | null;
+    viewMode: "3d";
+    layoutPreset: SceneLayoutPreset;
+    metadata: Record<string, string>;
+    contentBounds: SpatialBounds;
+    semanticGroups: RenderSceneSemanticGroup[];
+    viewpoints: RenderSceneViewpoint[];
+    activeEventId: string | null;
+    timeFrozen: boolean;
+    objects: SpatialSceneObject[];
+    orbits: SpatialOrbit[];
+    focusTargets: SpatialFocusTarget[];
+}
 export type SceneLayoutPreset = "compact" | "balanced" | "presentation";
 export type FieldValueKind = "string" | "list" | "boolean" | "number" | "unit";
 export type UnitFamily = "distance" | "radius" | "mass" | "duration" | "angle" | "generic";

package/packages/editor/dist/editor.js

@@ -246,6 +246,7 @@ export function createWorldOrbitEditor(container, options = {}) {
     const showInspector = options.showInspector ?? true;
     const showPreview = options.showPreview ?? true;
     const shortcutsEnabled = options.shortcuts ?? true;
+    let viewMode = options.viewMode ?? "2d";
     container.classList.add("wo-editor");
     container.dataset.woShowInspector = String(showInspector);
     container.dataset.woShowTextPane = String(showTextPane);
@@ -271,6 +272,7 @@ export function createWorldOrbitEditor(container, options = {}) {
         height: options.viewerHeight ?? 680,
         preset: atlasDocument.system?.defaults.preset ?? "atlas-card",
         projection: "document",
+        viewMode,
         minimap: true,
         tooltipMode: "hover",
         onSelectionChange(selectedObject) {
@@ -337,6 +339,22 @@ export function createWorldOrbitEditor(container, options = {}) {
         getSelection() {
             return selection ? { path: { ...selection } } : null;
         },
+        getViewMode() {
+            return viewMode;
+        },
+        setViewMode(mode) {
+            const previousViewMode = viewMode;
+            try {
+                viewer.setViewMode(mode);
+                viewMode = mode;
+                renderStageOverlay();
+                renderPreviewNow();
+            }
+            catch (error) {
+                viewMode = previousViewMode;
+                throw error;
+            }
+        },
         isDirty() {
             return dirty;
         },
@@ -461,7 +479,7 @@ export function createWorldOrbitEditor(container, options = {}) {
             return viewer.exportSvg();
         },
         exportEmbedMarkup() {
-            return buildEmbedMarkup(getCurrentSourceForExport(), atlasDocument);
+            return buildEmbedMarkup(getCurrentSourceForExport(), atlasDocument, viewMode);
         },
         destroy() {
             if (destroyed) {
@@ -906,6 +924,9 @@ export function createWorldOrbitEditor(container, options = {}) {
             return;
         }
         overlay.innerHTML = "";
+        if (viewMode === "3d") {
+            return;
+        }
         const selectedObjectId = selection?.kind === "object"
             ? selection.id ?? null
             : selection?.kind === "event-pose"
@@ -1577,7 +1598,7 @@ export function createWorldOrbitEditor(container, options = {}) {
             previewVisual.innerHTML = nextSvg;
             lastPreviewSvg = nextSvg;
         }
-        const nextMarkup = buildEmbedMarkup(getCurrentSourceForExport(), atlasDocument);
+        const nextMarkup = buildEmbedMarkup(getCurrentSourceForExport(), atlasDocument, viewMode);
         if (previewMarkup && nextMarkup !== lastPreviewMarkup) {
             previewMarkup.textContent = nextMarkup;
             lastPreviewMarkup = nextMarkup;
@@ -2969,9 +2990,9 @@ function mapDiagnosticFieldToInputNames(selection, field) {
             return [`prop-${field}`];
     }
 }
-function buildEmbedMarkup(source, document) {
+function buildEmbedMarkup(source, document, viewMode) {
     return renderWorldOrbitBlock(source, {
-        mode: "interactive",
+        mode: viewMode === "3d" ? "interactive-3d" : "interactive-2d",
         preset: document.system?.defaults.preset ?? "atlas-card",
         projection: document.system?.defaults.view ?? "topdown",
     });

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

@@ -1,4 +1,5 @@
 import type { AtlasDocumentPath, AtlasResolvedDiagnostic, WorldOrbitAtlasDocument, WorldOrbitEvent, WorldOrbitAtlasSystem, WorldOrbitAtlasViewpoint, WorldOrbitObject } from "@worldorbit/core";
+import type { WorldOrbitViewMode } from "@worldorbit/viewer";
 export interface WorldOrbitEditorSelection {
     path: AtlasDocumentPath | null;
 }
@@ -16,6 +17,7 @@ export interface WorldOrbitEditorOptions {
     showPreview?: boolean;
     viewerWidth?: number;
     viewerHeight?: number;
+    viewMode?: WorldOrbitViewMode;
     shortcuts?: boolean;
     onChange?: (snapshot: WorldOrbitEditorSnapshot) => void;
     onDiagnosticsChange?: (diagnostics: AtlasResolvedDiagnostic[]) => void;
@@ -29,6 +31,8 @@ export interface WorldOrbitEditor {
     getAtlasDocument(): WorldOrbitAtlasDocument;
     getDiagnostics(): AtlasResolvedDiagnostic[];
     getSelection(): WorldOrbitEditorSelection | null;
+    getViewMode(): WorldOrbitViewMode;
+    setViewMode(mode: WorldOrbitViewMode): void;
     isDirty(): boolean;
     markSaved(): void;
     selectPath(path: AtlasDocumentPath | null): void;