worldorbit 3.2.1 → 4.0.0

package/dist/unpkg/obsidian-plugin/dist/viewer-host.js

@@ -0,0 +1,110 @@
+import { createInteractiveViewer2D, renderSceneToSvg, } from "@worldorbit/viewer/interactive-2d";
+export class WorldOrbitEmbeddedView {
+    options;
+    viewer = null;
+    state;
+    constructor(options) {
+        this.options = {
+            ...options,
+            createViewer: options.createViewer ?? defaultCreateViewer,
+            renderStatic: options.renderStatic ?? defaultRenderStatic,
+        };
+        this.state = {
+            interactive: options.interactive,
+            destroyed: false,
+        };
+    }
+    getState() {
+        return { ...this.state };
+    }
+    mount() {
+        if (this.state.destroyed) {
+            return;
+        }
+        this.renderCurrent();
+    }
+    setInteractive(interactive) {
+        if (this.state.destroyed || this.state.interactive === interactive) {
+            return;
+        }
+        this.state.interactive = interactive;
+        this.renderCurrent();
+    }
+    resize() {
+        if (this.state.destroyed) {
+            return;
+        }
+        if (this.viewer) {
+            const viewport = measureViewport(this.options.container, this.options.scene);
+            this.viewer.setRenderOptions(viewport);
+            return;
+        }
+        this.renderCurrent();
+    }
+    destroy() {
+        if (this.state.destroyed) {
+            return;
+        }
+        this.state.destroyed = true;
+        this.destroyViewer();
+        clearElement(this.options.container);
+    }
+    renderCurrent() {
+        this.destroyViewer();
+        clearElement(this.options.container);
+        if (this.state.interactive) {
+            const viewport = measureViewport(this.options.container, this.options.scene);
+            this.viewer = this.options.createViewer(this.options.container, {
+                scene: this.options.scene,
+                theme: this.options.theme,
+                pointer: this.options.enablePointer,
+                touch: this.options.enableTouch,
+                ...viewport,
+            });
+            return;
+        }
+        const viewport = measureViewport(this.options.container, this.options.scene);
+        this.options.container.innerHTML = this.options.renderStatic(this.options.scene, {
+            theme: this.options.theme,
+            ...viewport,
+        });
+    }
+    destroyViewer() {
+        this.viewer?.destroy();
+        this.viewer = null;
+    }
+}
+function defaultCreateViewer(container, options) {
+    return createInteractiveViewer2D(container, options.scene, {
+        theme: options.theme,
+        pointer: options.pointer,
+        touch: options.touch,
+        selection: true,
+        width: options.width,
+        height: options.height,
+    });
+}
+function defaultRenderStatic(scene, options) {
+    return renderSceneToSvg(scene, {
+        theme: options.theme,
+        width: options.width,
+        height: options.height,
+    });
+}
+function measureViewport(container, scene) {
+    const rect = container.getBoundingClientRect();
+    const width = sanitizeDimension(container.clientWidth || rect.width) ?? scene.width;
+    const height = sanitizeDimension(container.clientHeight || rect.height) ??
+        Math.max(Math.round(width * (scene.height / Math.max(scene.width, 1))), 280);
+    return { width, height };
+}
+function sanitizeDimension(value) {
+    return Number.isFinite(value) && value > 0 ? Math.round(value) : undefined;
+}
+function clearElement(element) {
+    if (typeof element.empty === "function") {
+        element.empty();
+        return;
+    }
+    element.replaceChildren();
+}

package/dist/unpkg/viewer/dist/index.d.ts

@@ -8,3 +8,4 @@ export { createEmbedPayload, createWorldOrbitEmbedMarkup, deserializeWorldOrbitE
 export { defineWorldOrbitViewerElement } from "./custom-element.js";
 export { createAtlasViewer } from "./atlas-viewer.js";
 export { createInteractiveViewer } from "./viewer.js";
+export { createInteractiveViewer2D } from "./interactive-2d.js";

package/dist/unpkg/viewer/dist/index.js

@@ -7,3 +7,4 @@ export { createEmbedPayload, createWorldOrbitEmbedMarkup, deserializeWorldOrbitE
 export { defineWorldOrbitViewerElement } from "./custom-element.js";
 export { createAtlasViewer } from "./atlas-viewer.js";
 export { createInteractiveViewer } from "./viewer.js";
+export { createInteractiveViewer2D } from "./interactive-2d.js";

package/dist/unpkg/viewer/dist/interactive-2d.d.ts

@@ -0,0 +1,21 @@
+import type { RenderScene } from "@worldorbit/core/types";
+import type { SvgRenderOptions, ViewerState } from "./types.js";
+export interface InteractiveViewer2DOptions extends Pick<SvgRenderOptions, "width" | "height" | "padding" | "preset" | "theme" | "layers" | "subtitle"> {
+    pointer?: boolean;
+    touch?: boolean;
+    selection?: boolean;
+    minScale?: number;
+    maxScale?: number;
+    fitPadding?: number;
+}
+export interface WorldOrbitViewer2D {
+    getState(): ViewerState;
+    setState(state: Partial<ViewerState>): void;
+    setRenderOptions(options: Partial<InteractiveViewer2DOptions>): void;
+    fitToSystem(): void;
+    destroy(): void;
+}
+export { renderSceneToSvg } from "./render.js";
+export { resolveTheme } from "./theme.js";
+export type { WorldOrbitTheme } from "./types.js";
+export declare function createInteractiveViewer2D(container: HTMLElement, scene: RenderScene, options?: InteractiveViewer2DOptions): WorldOrbitViewer2D;

package/dist/unpkg/viewer/dist/interactive-2d.js

@@ -0,0 +1,201 @@
+import { renderSceneToSvg, WORLD_LAYER_ID } from "./render.js";
+import { DEFAULT_VIEWER_STATE, composeViewerTransform, fitViewerState, panViewerState, zoomViewerStateAt, } from "./viewer-state.js";
+export { renderSceneToSvg } from "./render.js";
+export { resolveTheme } from "./theme.js";
+const DEFAULT_VIEWER_LIMITS = {
+    minScale: 0.2,
+    maxScale: 8,
+    fitPadding: 48,
+};
+export function createInteractiveViewer2D(container, scene, options = {}) {
+    const constraints = {
+        minScale: options.minScale ?? DEFAULT_VIEWER_LIMITS.minScale,
+        maxScale: options.maxScale ?? DEFAULT_VIEWER_LIMITS.maxScale,
+        fitPadding: options.fitPadding ?? DEFAULT_VIEWER_LIMITS.fitPadding,
+    };
+    const behavior = {
+        pointer: options.pointer ?? true,
+        touch: options.touch ?? true,
+        selection: options.selection ?? true,
+    };
+    let renderOptions = {
+        width: options.width,
+        height: options.height,
+        padding: options.padding,
+        preset: options.preset,
+        theme: options.theme,
+        layers: options.layers,
+        subtitle: options.subtitle,
+        pointer: behavior.pointer,
+        touch: behavior.touch,
+        selection: behavior.selection,
+        minScale: constraints.minScale,
+        maxScale: constraints.maxScale,
+        fitPadding: constraints.fitPadding,
+    };
+    let state = fitViewerState(scene, DEFAULT_VIEWER_STATE, constraints);
+    let svgElement = null;
+    let cameraRoot = null;
+    let destroyed = false;
+    let activePointerId = null;
+    let lastPointerClientPoint = null;
+    let dragDistance = 0;
+    const previousTabIndex = container.getAttribute("tabindex");
+    const previousTouchAction = container.style.touchAction;
+    if (previousTabIndex === null) {
+        container.tabIndex = 0;
+    }
+    container.classList.add("wo-viewer-container");
+    container.style.touchAction = behavior.touch ? "none" : previousTouchAction;
+    const handleWheel = (event) => {
+        if (!behavior.pointer || destroyed || !svgElement) {
+            return;
+        }
+        event.preventDefault();
+        container.focus();
+        const anchor = getScenePointFromClient(event.clientX, event.clientY);
+        const factor = clamp(Math.exp(-event.deltaY * 0.002), 0.6, 1.6);
+        updateState(zoomViewerStateAt(scene, state, factor, anchor, constraints));
+    };
+    const handlePointerDown = (event) => {
+        if (destroyed) {
+            return;
+        }
+        const isTouch = event.pointerType === "touch";
+        if ((isTouch && !behavior.touch) || (!isTouch && !behavior.pointer)) {
+            return;
+        }
+        if (!isTouch && event.button !== 0) {
+            return;
+        }
+        activePointerId = event.pointerId;
+        lastPointerClientPoint = { x: event.clientX, y: event.clientY };
+        dragDistance = 0;
+        container.setPointerCapture?.(event.pointerId);
+        container.focus();
+    };
+    const handlePointerMove = (event) => {
+        if (destroyed || activePointerId !== event.pointerId || !lastPointerClientPoint) {
+            return;
+        }
+        const rect = svgElement?.getBoundingClientRect();
+        if (!rect || rect.width <= 0 || rect.height <= 0) {
+            return;
+        }
+        const dx = event.clientX - lastPointerClientPoint.x;
+        const dy = event.clientY - lastPointerClientPoint.y;
+        lastPointerClientPoint = { x: event.clientX, y: event.clientY };
+        dragDistance += Math.hypot(dx, dy);
+        updateState(panViewerState(state, dx * (scene.width / rect.width), dy * (scene.height / rect.height)));
+    };
+    const stopPointer = (event) => {
+        if (activePointerId !== event.pointerId) {
+            return;
+        }
+        activePointerId = null;
+        lastPointerClientPoint = null;
+        container.releasePointerCapture?.(event.pointerId);
+    };
+    const handleClick = (event) => {
+        if (destroyed || !behavior.selection || dragDistance > 6) {
+            return;
+        }
+        const objectEl = event.target?.closest(".wo-object[data-object-id]");
+        if (!objectEl) {
+            return;
+        }
+        updateState({
+            ...state,
+            selectedObjectId: objectEl.dataset.objectId ?? null,
+        });
+        renderSvg();
+    };
+    container.addEventListener("wheel", handleWheel, { passive: false });
+    container.addEventListener("pointerdown", handlePointerDown);
+    container.addEventListener("pointermove", handlePointerMove);
+    container.addEventListener("pointerup", stopPointer);
+    container.addEventListener("pointercancel", stopPointer);
+    container.addEventListener("click", handleClick);
+    renderSvg();
+    return {
+        getState() {
+            return { ...state };
+        },
+        setState(nextState) {
+            updateState({
+                ...state,
+                ...nextState,
+            });
+            if ("selectedObjectId" in nextState) {
+                renderSvg();
+            }
+        },
+        setRenderOptions(nextOptions) {
+            renderOptions = {
+                ...renderOptions,
+                ...nextOptions,
+            };
+            renderSvg();
+        },
+        fitToSystem() {
+            updateState(fitViewerState(scene, state, constraints));
+        },
+        destroy() {
+            if (destroyed) {
+                return;
+            }
+            destroyed = true;
+            container.removeEventListener("wheel", handleWheel);
+            container.removeEventListener("pointerdown", handlePointerDown);
+            container.removeEventListener("pointermove", handlePointerMove);
+            container.removeEventListener("pointerup", stopPointer);
+            container.removeEventListener("pointercancel", stopPointer);
+            container.removeEventListener("click", handleClick);
+            if (previousTabIndex === null) {
+                container.removeAttribute("tabindex");
+            }
+            container.style.touchAction = previousTouchAction;
+            container.replaceChildren();
+            svgElement = null;
+            cameraRoot = null;
+        },
+    };
+    function renderSvg() {
+        if (destroyed) {
+            return;
+        }
+        container.innerHTML = renderSceneToSvg(scene, {
+            width: renderOptions.width,
+            height: renderOptions.height,
+            padding: renderOptions.padding,
+            preset: renderOptions.preset,
+            theme: renderOptions.theme,
+            layers: renderOptions.layers,
+            subtitle: renderOptions.subtitle,
+            selectedObjectId: state.selectedObjectId,
+        });
+        svgElement = container.querySelector("svg");
+        cameraRoot = container.querySelector(`[data-worldorbit-camera-root="${WORLD_LAYER_ID}"]`);
+        applyTransform();
+    }
+    function applyTransform() {
+        cameraRoot?.setAttribute("transform", composeViewerTransform(scene, state));
+    }
+    function updateState(nextState) {
+        state = nextState;
+        applyTransform();
+    }
+    function getScenePointFromClient(clientX, clientY) {
+        const rect = svgElement?.getBoundingClientRect();
+        if (!rect || rect.width <= 0 || rect.height <= 0) {
+            return { x: scene.width / 2, y: scene.height / 2 };
+        }
+        return {
+            x: ((clientX - rect.left) / rect.width) * scene.width,
+            y: ((clientY - rect.top) / rect.height) * scene.height,
+        };
+    }
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}

package/dist/unpkg/viewer/dist/minimap.js

@@ -28,13 +28,13 @@ export function renderViewerMinimap(scene, state, visibleObjects) {
         return `<circle cx="${formatNumber(x)}" cy="${formatNumber(y)}" r="${formatNumber(radius)}" fill="${fill}" fill-opacity="0.92" />`;
     })
         .join("");
-    return `<div data-worldorbit-minimap="true" style="position:absolute;right:16px;bottom:16px;width:${MINIMAP_WIDTH}px;height:${MINIMAP_HEIGHT}px;padding:8px;border-radius:16px;background:rgba(5, 14, 22, 0.78);border:1px solid rgba(179, 216, 255, 0.16);box-shadow:0 14px 28px rgba(0, 0, 0, 0.24);backdrop-filter:blur(8px);pointer-events:none;">
-  <svg width="${MINIMAP_WIDTH}" height="${MINIMAP_HEIGHT}" viewBox="0 0 ${MINIMAP_WIDTH} ${MINIMAP_HEIGHT}" role="presentation" aria-hidden="true">
-    <rect x="0.5" y="0.5" width="${MINIMAP_WIDTH - 1}" height="${MINIMAP_HEIGHT - 1}" rx="12" ry="12" fill="rgba(7, 17, 27, 0.85)" stroke="rgba(179, 216, 255, 0.18)" />
-    <rect x="${formatNumber(bounds.minX * scale + translateX)}" y="${formatNumber(bounds.minY * scale + translateY)}" width="${formatNumber(bounds.width * scale)}" height="${formatNumber(bounds.height * scale)}" rx="10" ry="10" fill="rgba(163, 209, 255, 0.04)" stroke="rgba(163, 209, 255, 0.16)" />
-    ${objectsMarkup}
-    <rect x="${formatNumber(viewport.minX * scale + translateX)}" y="${formatNumber(viewport.minY * scale + translateY)}" width="${formatNumber(viewport.width * scale)}" height="${formatNumber(viewport.height * scale)}" rx="8" ry="8" fill="rgba(255, 180, 100, 0.09)" stroke="rgba(255, 180, 100, 0.88)" stroke-width="1.4" />
-  </svg>
+    return `<div data-worldorbit-minimap="true" style="position:absolute;right:16px;bottom:16px;width:${MINIMAP_WIDTH}px;height:${MINIMAP_HEIGHT}px;padding:8px;border-radius:16px;background:rgba(5, 14, 22, 0.78);border:1px solid rgba(179, 216, 255, 0.16);box-shadow:0 14px 28px rgba(0, 0, 0, 0.24);backdrop-filter:blur(8px);pointer-events:none;">
+  <svg width="${MINIMAP_WIDTH}" height="${MINIMAP_HEIGHT}" viewBox="0 0 ${MINIMAP_WIDTH} ${MINIMAP_HEIGHT}" role="presentation" aria-hidden="true">
+    <rect x="0.5" y="0.5" width="${MINIMAP_WIDTH - 1}" height="${MINIMAP_HEIGHT - 1}" rx="12" ry="12" fill="rgba(7, 17, 27, 0.85)" stroke="rgba(179, 216, 255, 0.18)" />
+    <rect x="${formatNumber(bounds.minX * scale + translateX)}" y="${formatNumber(bounds.minY * scale + translateY)}" width="${formatNumber(bounds.width * scale)}" height="${formatNumber(bounds.height * scale)}" rx="10" ry="10" fill="rgba(163, 209, 255, 0.04)" stroke="rgba(163, 209, 255, 0.16)" />
+    ${objectsMarkup}
+    <rect x="${formatNumber(viewport.minX * scale + translateX)}" y="${formatNumber(viewport.minY * scale + translateY)}" width="${formatNumber(viewport.width * scale)}" height="${formatNumber(viewport.height * scale)}" rx="8" ry="8" fill="rgba(255, 180, 100, 0.09)" stroke="rgba(255, 180, 100, 0.88)" stroke-width="1.4" />
+  </svg>
 </div>`;
 }
 function minimapColorForObject(type) {
@@ -52,6 +52,8 @@ function minimapColorForObject(type) {
             return "#a7a5b8";
         case "comet":
             return "#9ce7ff";
+        case "craft":
+            return "#ffb47f";
         case "structure":
             return "#ff7f5f";
         case "phenomenon":

package/dist/unpkg/viewer/dist/render.d.ts

@@ -1,4 +1,4 @@
-import { type RenderScene, type WorldOrbitDocument } from "@worldorbit/core";
+import { type RenderScene, type WorldOrbitDocument } from "@worldorbit/core/types";
 import type { SvgRenderOptions } from "./types.js";
 export declare const WORLD_LAYER_ID = "worldorbit-camera-root";
 export declare function renderSceneToSvg(scene: RenderScene, options?: SvgRenderOptions): string;

package/dist/unpkg/viewer/dist/render.js

@@ -1,4 +1,5 @@
-import { loadWorldOrbitSource, renderDocumentToScene, } from "@worldorbit/core";
+import { loadWorldOrbitSource } from "@worldorbit/core/load";
+import { renderDocumentToScene } from "@worldorbit/core/scene";
 import { computeVisibleObjectIds } from "./atlas-state.js";
 import { resolveLayers, resolveTheme } from "./theme.js";
 export const WORLD_LAYER_ID = "worldorbit-camera-root";
@@ -88,14 +89,14 @@ export function renderSceneToSvg(scene, options = {}) {
     .wo-bg-glow { fill: url(#wo-bg-glow); }
     .wo-grid { fill: none; stroke: ${theme.guide}; stroke-width: 1; }
     .wo-orbit { fill: none; stroke: ${theme.orbit}; stroke-width: 1.5; }
-    .wo-orbit-back { opacity: 0.38; stroke-dasharray: 8 6; }
-    .wo-orbit-front { opacity: 0.9; }
-    .wo-orbit-band { stroke: ${theme.orbitBand}; stroke-linecap: round; }
-    .wo-relation { stroke: ${theme.relation}; stroke-width: 2; stroke-dasharray: 10 6; }
-    .wo-event-line { stroke: ${theme.accent}; stroke-width: 1.6; stroke-dasharray: 5 5; opacity: 0.72; }
-    .wo-event-node { fill: ${theme.accent}; stroke: ${theme.selected}; stroke-width: 1.4; opacity: 0.92; }
-    .wo-event-label { fill: ${theme.accent}; font-family: ${theme.fontFamily}; font-weight: 700; letter-spacing: 0.04em; text-transform: uppercase; }
-    .wo-leader { stroke: ${theme.leader}; stroke-width: 1.5; stroke-dasharray: 6 5; }
+    .wo-orbit-back { opacity: 0.38; stroke-dasharray: 8 6; }
+    .wo-orbit-front { opacity: 0.9; }
+    .wo-orbit-band { stroke: ${theme.orbitBand}; stroke-linecap: round; }
+    .wo-relation { stroke: ${theme.relation}; stroke-width: 2; stroke-dasharray: 10 6; }
+    .wo-event-line { stroke: ${theme.accent}; stroke-width: 1.6; stroke-dasharray: 5 5; opacity: 0.72; }
+    .wo-event-node { fill: ${theme.accent}; stroke: ${theme.selected}; stroke-width: 1.4; opacity: 0.92; }
+    .wo-event-label { fill: ${theme.accent}; font-family: ${theme.fontFamily}; font-weight: 700; letter-spacing: 0.04em; text-transform: uppercase; }
+    .wo-leader { stroke: ${theme.leader}; stroke-width: 1.5; stroke-dasharray: 6 5; }
     .wo-label { fill: ${theme.ink}; font-family: ${theme.fontFamily}; font-weight: 600; letter-spacing: 0.02em; }
     .wo-label-secondary { fill: ${theme.muted}; font-family: ${theme.fontFamily}; font-weight: 500; }
     .wo-title { fill: ${theme.ink}; font: 700 24px ${theme.displayFont}; letter-spacing: 0.06em; text-transform: uppercase; }
@@ -126,13 +127,13 @@ export function renderSceneToSvg(scene, options = {}) {
   <g data-worldorbit-world="true">
     <g data-worldorbit-camera-root="${WORLD_LAYER_ID}" id="${WORLD_LAYER_ID}">
       <g data-worldorbit-world-content="true">
-        ${layers.orbits ? `<g data-layer-id="orbits-back">${orbitMarkup.back}</g>` : ""}
-        ${layers.guides ? `<g data-layer-id="guides">${leaderMarkup}</g>` : ""}
-        ${layers.relations ? `<g data-layer-id="relations">${relationMarkup}</g>` : ""}
-        ${layers.events ? `<g data-layer-id="events">${eventMarkup}</g>` : ""}
-        ${layers.objects ? `<g data-layer-id="objects">${objectMarkup}</g>` : ""}
-        ${layers.orbits ? `<g data-layer-id="orbits-front">${orbitMarkup.front}</g>` : ""}
-        ${layers.labels ? `<g data-layer-id="labels">${labelMarkup}</g>` : ""}
+        ${layers.orbits ? `<g data-layer-id="orbits-back">${orbitMarkup.back}</g>` : ""}
+        ${layers.guides ? `<g data-layer-id="guides">${leaderMarkup}</g>` : ""}
+        ${layers.relations ? `<g data-layer-id="relations">${relationMarkup}</g>` : ""}
+        ${layers.events ? `<g data-layer-id="events">${eventMarkup}</g>` : ""}
+        ${layers.objects ? `<g data-layer-id="objects">${objectMarkup}</g>` : ""}
+        ${layers.orbits ? `<g data-layer-id="orbits-front">${orbitMarkup.front}</g>` : ""}
+        ${layers.labels ? `<g data-layer-id="labels">${labelMarkup}</g>` : ""}
       </g>
     </g>
   </g>
@@ -151,10 +152,10 @@ function renderSceneEventOverlay(scene, event, visibleObjectIds, theme) {
     const lineMarkup = participants
         .map((object) => `<line class="wo-event-line" x1="${event.x}" y1="${event.y}" x2="${object.x}" y2="${object.y}" stroke="${escapeAttribute(stroke)}" data-event-id="${escapeAttribute(event.eventId)}" data-object-id="${escapeAttribute(object.objectId)}" />`)
         .join("");
-    return `<g class="wo-event" data-render-id="${escapeXml(event.renderId)}" data-event-id="${escapeAttribute(event.eventId)}">
-    ${lineMarkup}
-    <circle class="wo-event-node" cx="${event.x}" cy="${event.y}" r="5" fill="${escapeAttribute(stroke)}" />
-    <text class="wo-event-label" x="${event.x}" y="${event.y - 10}" text-anchor="middle" font-size="10">${escapeXml(label)}</text>
+    return `<g class="wo-event" data-render-id="${escapeXml(event.renderId)}" data-event-id="${escapeAttribute(event.eventId)}">
+    ${lineMarkup}
+    <circle class="wo-event-node" cx="${event.x}" cy="${event.y}" r="5" fill="${escapeAttribute(stroke)}" />
+    <text class="wo-event-label" x="${event.x}" y="${event.y - 10}" text-anchor="middle" font-size="10">${escapeXml(label)}</text>
   </g>`;
 }
 export function renderDocumentToSvg(document, options = {}) {
@@ -258,6 +259,8 @@ function renderObjectBody(object, x, y, radius, palette, options = {}) {
                 ? `<circle cx="${x}" cy="${y}" r="${radius}" fill="transparent" stroke="${palette.stroke}" stroke-width="1.4" />`
                 : `<path d="M ${x - radius * 2} ${y + radius * 1.3} Q ${x - radius * 0.7} ${y + radius * 0.3} ${x - radius * 0.45} ${y}" fill="none" stroke="${tail}" stroke-width="${Math.max(2, radius * 0.8)}" stroke-linecap="round" opacity="0.85" />
 <circle cx="${x}" cy="${y}" r="${radius}" fill="${fill}" stroke="${palette.stroke}" stroke-width="1.4" />`;
+        case "craft":
+            return `<polygon points="${diamondPoints(x, y, radius * 0.85)}" fill="${fill}" stroke="${palette.stroke}" stroke-width="1.4" />`;
         case "structure":
             return `<polygon points="${diamondPoints(x, y, radius)}" fill="${fill}" stroke="${palette.stroke}" stroke-width="1.4" />`;
         case "phenomenon": {
@@ -442,6 +445,8 @@ function basePaletteForType(type, kind, theme) {
             return { fill: "#9ce7ff", stroke: "#e7fbff" };
         case "ring":
             return { fill: "#e59f7d", stroke: "#fff0d3" };
+        case "craft":
+            return { fill: "#ffb47f", stroke: "#fff0d3" };
         case "structure":
             return { fill: theme.accentStrong, stroke: "#fff2ea" };
         case "phenomenon":

package/dist/unpkg/viewer/dist/runtime-3d.js

@@ -686,6 +686,8 @@ function colorForObject(object) {
             return "#b8926a";
         case "ring":
             return "#cdbf9a";
+        case "craft":
+            return "#ffce8a";
         case "structure":
             return "#ffce8a";
         case "phenomenon":

package/dist/unpkg/viewer/dist/viewer-state.d.ts

@@ -1,4 +1,4 @@
-import { type CoordinatePoint, type RenderBounds, type RenderScene } from "@worldorbit/core";
+import { type CoordinatePoint, type RenderBounds, type RenderScene } from "@worldorbit/core/types";
 import type { ViewerState } from "./types.js";
 export interface ViewerConstraints {
     minScale: number;

package/dist/unpkg/viewer/dist/viewer-state.js

@@ -1,4 +1,4 @@
-import { rotatePoint, } from "@worldorbit/core";
+import { rotatePoint } from "@worldorbit/core/scene";
 export const DEFAULT_VIEWER_STATE = {
     scale: 1,
     rotationDeg: 0,

package/dist/unpkg/viewer/dist/viewer.js

@@ -1086,7 +1086,7 @@ export function createInteractiveViewer(container, options) {
         tooltipRoot.hidden = false;
         tooltipRoot.dataset.mode = resolved.mode;
         tooltipRoot.classList.toggle("is-pinned", resolved.mode === "pinned");
-        tooltipRoot.style.pointerEvents = "auto";
+        tooltipRoot.style.pointerEvents = resolved.mode === "pinned" ? "auto" : "none";
         tooltipRoot.style.visibility = "hidden";
         renderTooltipContent(tooltipRoot, tooltipDetails, resolved.mode);
         positionTooltip(tooltipRoot, details.renderObject);
@@ -1732,7 +1732,11 @@ function getClosestObjectId(target) {
     if (!(target instanceof Element)) {
         return null;
     }
-    return target.closest("[data-object-id]")?.dataset.objectId ?? null;
+    const selectionTarget = target.closest("[data-object-id], [data-orbit-object-id]");
+    if (!selectionTarget) {
+        return null;
+    }
+    return selectionTarget.dataset.objectId ?? selectionTarget.dataset.orbitObjectId ?? null;
 }
 function ensureBrowserEnvironment(container) {
     if (typeof window === "undefined" || typeof document === "undefined") {
@@ -1864,7 +1868,7 @@ function installViewerOverlayStyles() {
       backdrop-filter: blur(12px);
       font: 500 13px/1.5 "Segoe UI Variable", "Segoe UI", sans-serif;
     }
-    .wo-viewer-tooltip-root[data-mode="hover"] { pointer-events: auto; }
+    .wo-viewer-tooltip-root[data-mode="hover"] { pointer-events: none; }
     .wo-viewer-tooltip-root[data-mode="pinned"] { pointer-events: auto; }
     .wo-tooltip-card { display: grid; gap: 10px; }
     .wo-tooltip-head { display: grid; grid-template-columns: 52px minmax(0, 1fr); gap: 12px; align-items: center; }