@honua/app-platform 0.0.20-alpha.0

package/scene-workspace/cesium-adapter.js

@@ -0,0 +1,493 @@
+/**
+ * Cesium 3D `SceneRuntimeAdapter` for the renderer-neutral scene workspace.
+ *
+ * This module deliberately keeps the camera-state mapping pure and free of any
+ * static Cesium import so that 2D-only consumers never pay the CesiumJS bundle
+ * cost. The CesiumJS runtime is only pulled in lazily (`await import("cesium")`)
+ * when a live {@link CesiumSceneRuntimeTarget} is actually driven.
+ *
+ * As of honua-server#1197 the adapter renders Honua 3D content end-to-end:
+ * 3D-Tiles tilesets (add/remove/visibility), terrain providers (quantized-mesh
+ * via `CesiumTerrainProvider`, with vertical exaggeration), and glTF/GLB model
+ * layers placed with heading/pitch/roll + scale. It also resolves a picked
+ * 3D-Tiles feature's attributes (batch properties / `EXT_structural_metadata`).
+ *
+ * The provider wiring is still kept Cesium-mockable: every CesiumJS symbol the
+ * adapter touches is read off the lazily-imported module, so the wiring is
+ * exercised against a `vi.mock("cesium")` stub without a live WebGL `Viewer`.
+ *
+ * @experimental Part of the experimental `scene-workspace` surface; not yet
+ *   covered by the SDK's semver contract prior to `1.0.0`.
+ * @module
+ */
+import { createSceneRuntimeAdapter, diagnoseScenePrimitives, summarizeDiagnosticStatus, } from "./primitives.js";
+/**
+ * Capabilities advertised by the Cesium adapter. Unlike the MapLibre 2.5D
+ * adapter, Cesium is a true globe renderer: full 3D camera with
+ * heading/pitch/roll/height, terrain across the common elevation protocols, and
+ * model layers for 3D Tiles / glTF / I3S / point clouds.
+ */
+export const CESIUM_SCENE_CAPABILITIES = {
+    renderer: "cesium",
+    camera: true,
+    ground: true,
+    terrain: {
+        protocols: ["quantized-mesh", "terrain-rgb", "raster-dem", "image-service", "custom"],
+        supportsExaggeration: true,
+    },
+    extrusion: true,
+    modelLayer: {
+        // glTF/glb single models and 3D Tiles tilesets (incl. point clouds) are
+        // rendered live by this adapter as of #1197. I3S scene layers remain
+        // declared-capable (Cesium can consume them) but Honua's server does not yet
+        // emit i3s model-layer primitives, so they fall through to diagnostics only.
+        formats: ["gltf", "glb", "3d-tiles", "i3s"],
+    },
+    sceneLayerMetadata: true,
+};
+const DEG2RAD = Math.PI / 180;
+const RAD2DEG = 180 / Math.PI;
+function toRadians(degrees) {
+    return degrees * DEG2RAD;
+}
+function toDegrees(radians) {
+    return radians * RAD2DEG;
+}
+/**
+ * Map a renderer-neutral {@link SceneCameraState} (degrees + metres) onto a
+ * Cesium `setView` description (degrees destination + radian orientation).
+ *
+ * Heading/pitch/roll default to Cesium's own defaults — heading 0 (north),
+ * pitch -90 (looking straight down), roll 0 — when the workspace omits them.
+ */
+export function cameraStateToCesiumView(camera) {
+    return {
+        destination: {
+            longitude: camera.longitude,
+            latitude: camera.latitude,
+            height: camera.height,
+        },
+        orientation: {
+            heading: toRadians(camera.heading ?? 0),
+            pitch: toRadians(camera.pitch ?? -90),
+            roll: toRadians(camera.roll ?? 0),
+        },
+    };
+}
+/**
+ * Read a live (or mocked) Cesium camera back into a renderer-neutral
+ * {@link SceneCameraState}. This is the inverse of
+ * {@link cameraStateToCesiumView} and is the load-bearing half of the
+ * camera-state round-trip through the workspace.
+ */
+export function cesiumCameraToSceneState(camera) {
+    return {
+        longitude: toDegrees(camera.positionCartographic.longitude),
+        latitude: toDegrees(camera.positionCartographic.latitude),
+        height: camera.positionCartographic.height,
+        heading: normalizeAngleDegrees(toDegrees(camera.heading)),
+        pitch: toDegrees(camera.pitch),
+        roll: toDegrees(camera.roll),
+    };
+}
+/**
+ * Apply a {@link SceneCameraState} to a live (or mocked) Cesium camera.
+ *
+ * The destination is left as degrees + height on the `setView` call; a live
+ * adapter (see {@link applyCesiumScenePrimitives}) converts it to a
+ * `Cartesian3` via the lazily-loaded Cesium module before calling `setView`.
+ * Tests can pass a mock camera and assert the orientation (in radians) directly.
+ */
+export function applyCameraStateToCesiumCamera(camera, state, toCartesian = (longitude, latitude, height) => ({
+    longitude,
+    latitude,
+    height,
+})) {
+    const view = cameraStateToCesiumView(state);
+    camera.setView({
+        destination: toCartesian(view.destination.longitude, view.destination.latitude, view.destination.height),
+        orientation: view.orientation,
+    });
+}
+/**
+ * Normalize a heading in degrees into the `[0, 360)` range so a round-trip
+ * through Cesium (which wraps headings) compares cleanly. Pitch and roll are
+ * left untouched because Cesium keeps them in their natural signed ranges.
+ */
+function normalizeAngleDegrees(degrees) {
+    if (!Number.isFinite(degrees))
+        return degrees;
+    const wrapped = degrees % 360;
+    return wrapped < 0 ? wrapped + 360 : wrapped;
+}
+/**
+ * Resolve the scale factor for a model layer. The primitive allows a uniform
+ * number or a per-axis triple; Cesium `Model.fromGltfAsync` takes a single
+ * uniform `scale`, so a triple collapses to its first finite component (with a
+ * sane `1` fallback). Non-finite / non-positive values fall back to `1`.
+ */
+export function resolveCesiumModelScale(scale) {
+    const candidate = Array.isArray(scale) ? scale[0] : scale;
+    return typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0 ? candidate : 1;
+}
+/**
+ * Map a {@link SceneModelLayerPrimitive} onto a renderer-neutral
+ * {@link CesiumModelPlacement} (degrees + metres position, radian orientation,
+ * uniform scale). Pure so the placement math is unit-testable without Cesium.
+ *
+ * `position` defaults to lon/lat 0 at height 0; `rotation` (degrees, in the
+ * workspace contract) defaults to heading/pitch/roll 0.
+ */
+export function modelLayerToCesiumPlacement(primitive) {
+    const [longitude = 0, latitude = 0, height = 0] = primitive.position ?? [];
+    const [heading = 0, pitch = 0, roll = 0] = primitive.rotation ?? [];
+    return {
+        position: { longitude, latitude, height: height ?? 0 },
+        orientation: { heading: toRadians(heading), pitch: toRadians(pitch), roll: toRadians(roll) },
+        scale: resolveCesiumModelScale(primitive.scale),
+    };
+}
+/**
+ * Lazily import the CesiumJS runtime. Kept in its own function so the dynamic
+ * `import("cesium")` is the *only* reference to the package in `src/`, which is
+ * what keeps Cesium out of the 2D bundle.
+ */
+async function loadCesium() {
+    return (await import("cesium"));
+}
+/**
+ * Build a Cesium `Matrix4` model matrix from a {@link CesiumModelPlacement}
+ * using the supplied (lazily-loaded) Cesium module. Position becomes an
+ * east-north-up fixed frame at the placement origin, then a uniform scale is
+ * folded in. Isolated so the live adapter and tests share one path.
+ */
+function placementToModelMatrix(cesium, placement) {
+    const origin = cesium.Cartesian3.fromDegrees(placement.position.longitude, placement.position.latitude, placement.position.height);
+    const hpr = new cesium.HeadingPitchRoll(placement.orientation.heading, placement.orientation.pitch, placement.orientation.roll);
+    const frame = cesium.Transforms.headingPitchRollToFixedFrame(origin, hpr);
+    return placement.scale === 1 ? frame : cesium.Matrix4.multiplyByUniformScale(frame, placement.scale, frame);
+}
+/**
+ * Read the `honua_style` descriptor off a tileset's (or tileset.json's)
+ * `extras`, if present and well-formed. Returns `undefined` when the tileset
+ * carries no Honua styling metadata (the common case for plain tilesets), so
+ * the auto-apply path can no-op silently.
+ */
+export function readHonua3DStyleDescriptor(extras) {
+    if (extras === null || typeof extras !== "object")
+        return undefined;
+    const candidate = extras.honua_style;
+    if (candidate === null || typeof candidate !== "object")
+        return undefined;
+    const descriptor = candidate;
+    if (descriptor.encoding !== "3d-tiles-styling")
+        return undefined;
+    if (typeof descriptor.uri !== "string" || descriptor.uri.trim() === "")
+        return undefined;
+    return {
+        encoding: "3d-tiles-styling",
+        version: typeof descriptor.version === "string" ? descriptor.version : "1.0",
+        uri: descriptor.uri,
+    };
+}
+/**
+ * Resolve a sidecar `uri` (relative, per the contract) against the
+ * `tileset.json` URL it was advertised in. Falls back to returning the raw
+ * `uri` unchanged when `tilesetUrl` is not a parseable absolute/base URL (e.g.
+ * a bare relative path in a test), which keeps a plain `fetch` workable.
+ */
+export function resolveHonua3DStyleUri(uri, tilesetUrl) {
+    try {
+        return new URL(uri, tilesetUrl).toString();
+    }
+    catch {
+        return uri;
+    }
+}
+/**
+ * Fetch + parse the `style.json` sidecar at `styleUrl`.
+ *
+ * The sidecar is a STATIC asset served next to `tileset.json` (not a Honua API
+ * call), so it is fetched with a plain global `fetch` rather than routed
+ * through the SDK's authenticated request path — this keeps the styling module
+ * free of a client dependency and mirrors how Cesium itself loads tileset
+ * assets. A custom `fetchImpl` can be injected (tests pass a mock).
+ */
+export async function fetchHonua3DStyleSpec(styleUrl, fetchImpl = fetch.bind(globalThis)) {
+    const response = await fetchImpl(styleUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch Honua 3D style "${styleUrl}": ${response.status} ${response.statusText}`);
+    }
+    return (await response.json());
+}
+/**
+ * Discover and load the Honua 3D styling spec advertised by a tileset.
+ *
+ * Reads `extras.honua_style` (off either a loaded `Cesium3DTileset` or a parsed
+ * tileset.json `extras` object), resolves the sidecar `uri` against
+ * `tilesetUrl`, and fetches the `style.json`. Returns `undefined` when the
+ * tileset advertises no Honua styling, so callers can treat "no style" as a
+ * silent no-op rather than an error.
+ */
+export async function loadHonua3DStyle(extras, tilesetUrl, fetchImpl = fetch.bind(globalThis)) {
+    const descriptor = readHonua3DStyleDescriptor(extras);
+    if (!descriptor)
+        return undefined;
+    const styleUrl = resolveHonua3DStyleUri(descriptor.uri, tilesetUrl);
+    return fetchHonua3DStyleSpec(styleUrl, fetchImpl);
+}
+/**
+ * Build a Cesium `Cesium3DTileStyle` options object from a spec, including only
+ * the blocks (`color` / `show`) that are present. The spec's blocks are already
+ * `Cesium3DTileStyle`-shaped, so they are passed through verbatim. Pure (no
+ * Cesium import) so the block-selection logic is unit-testable.
+ */
+export function honua3DStyleToCesiumStyleOptions(spec) {
+    const options = {};
+    if (spec.style.color)
+        options.color = spec.style.color;
+    if (spec.style.show)
+        options.show = spec.style.show;
+    return options;
+}
+/**
+ * Apply a Honua 3D styling spec to a tileset by constructing a
+ * `Cesium3DTileStyle` (only from the present `color` / `show` blocks) and
+ * assigning it to `tileset.style`. Lazily loads Cesium the same way the rest of
+ * the adapter does, so no static `import("cesium")` leaks into the 2D bundle.
+ *
+ * When the spec carries neither a `color` nor a `show` block, the tileset's
+ * `style` is left untouched (nothing to apply).
+ */
+export async function applyHonua3DStyle(tileset, spec, cesium) {
+    const options = honua3DStyleToCesiumStyleOptions(spec);
+    if (Object.keys(options).length === 0)
+        return;
+    const mod = cesium ?? (await loadCesium());
+    tileset.style = new mod.Cesium3DTileStyle(options);
+}
+/**
+ * Programmatic override for a tileset's styling: apply a (typically
+ * server-discovered, but possibly hand-authored) {@link Honua3DStyleSpec} to a
+ * live tileset. Thin alias over {@link applyHonua3DStyle} that reads as an
+ * intentional manual set at the call site.
+ */
+export function setTilesetStyle(tileset, spec, cesium) {
+    return applyHonua3DStyle(tileset, spec, cesium);
+}
+/**
+ * Discover and apply the server's attribute-driven styling to an already-loaded
+ * tileset, if it advertises any (`extras.honua_style`). Returns the applied
+ * spec (or `undefined` when the tileset carries no Honua styling). Used by
+ * {@link addCesium3DTileset}'s auto-apply path and exposed for callers that
+ * load a tileset themselves.
+ */
+export async function applyTilesetServerStyle(tileset, tilesetUrl, cesium, fetchImpl = fetch.bind(globalThis)) {
+    const spec = await loadHonua3DStyle(tileset.extras, tilesetUrl, fetchImpl);
+    if (!spec)
+        return undefined;
+    await applyHonua3DStyle(tileset, spec, cesium);
+    return spec;
+}
+/**
+ * Materialize a 3D-Tiles tileset from a model-layer primitive and add it to the
+ * scene's primitive collection, returning a handle for later visibility /
+ * teardown. Exported so consumers (and tests) can drive a single tileset.
+ *
+ * If the loaded tileset advertises the server's attribute-driven styling
+ * contract (`extras.honua_style`, honua-server#1206) the sidecar style is
+ * fetched and applied automatically (honua-server#1206). Pass
+ * `{ applyServerStyle: false }` to skip that and style the tileset manually via
+ * {@link setTilesetStyle}. A tileset without `honua_style` is added unchanged
+ * (no fetch), so existing callers are unaffected.
+ */
+export async function addCesium3DTileset(scene, primitive, cesium, options = {}) {
+    const mod = cesium ?? (await loadCesium());
+    const tileset = await mod.Cesium3DTileset.fromUrl(primitive.uri);
+    if (primitive.position) {
+        tileset.modelMatrix = placementToModelMatrix(mod, modelLayerToCesiumPlacement(primitive));
+    }
+    if (options.applyServerStyle !== false) {
+        await applyTilesetServerStyle(tileset, primitive.uri, mod, options.fetchImpl ?? fetch.bind(globalThis));
+    }
+    scene.primitives.add(tileset);
+    return makeLayerHandle(scene, primitive.id, tileset, "model-layer", primitive.format);
+}
+/**
+ * Materialize a glTF/GLB model from a model-layer primitive, placing it at the
+ * primitive's position/rotation/scale, and add it to the scene. Returns a
+ * handle for visibility / teardown.
+ */
+export async function addCesiumModel(scene, primitive, cesium) {
+    const mod = cesium ?? (await loadCesium());
+    const placement = modelLayerToCesiumPlacement(primitive);
+    // `placementToModelMatrix` already folds the uniform scale into the model
+    // matrix (alongside translation + rotation). Cesium applies `Model.scale` on
+    // top of `modelMatrix`, so passing it here too would square the scale
+    // (requested 3 → rendered 9). Apply it exactly once, via the matrix.
+    const model = await mod.Model.fromGltfAsync({
+        url: primitive.uri,
+        modelMatrix: placementToModelMatrix(mod, placement),
+    });
+    scene.primitives.add(model);
+    return makeLayerHandle(scene, primitive.id, model, "model-layer", primitive.format);
+}
+/**
+ * Wire a terrain provider from an elevation-source primitive onto the scene.
+ *
+ * `quantized-mesh` maps to `CesiumTerrainProvider.fromUrl` natively. `terrain-rgb`
+ * / `raster-dem` (Mapbox/Terrarium-encoded raster DEM tiles) are treated the
+ * same way: Cesium consumes a quantized-mesh-style endpoint at `url`, so we wire
+ * the provider when a `url` is present and otherwise leave the globe on its
+ * default ellipsoid (the diagnostic already flags a missing url). Exaggeration
+ * is applied via the scene's `verticalExaggeration`.
+ */
+export async function applyCesiumTerrain(scene, primitive, cesium) {
+    const url = typeof primitive.url === "string" && primitive.url.trim() !== "" ? primitive.url : undefined;
+    if (primitive.exaggeration !== undefined && Number.isFinite(primitive.exaggeration)) {
+        scene.verticalExaggeration = primitive.exaggeration;
+    }
+    if (!url)
+        return undefined;
+    const mod = cesium ?? (await loadCesium());
+    const provider = await mod.CesiumTerrainProvider.fromUrl(url);
+    scene.terrainProvider = provider;
+    return {
+        id: primitive.id,
+        kind: "elevation-source",
+        setVisible() {
+            /* terrain is always on once set; visibility is a no-op for the provider. */
+        },
+        remove() {
+            // Only tear down if *this* handle's provider is still the active one. If a
+            // newer elevation source has since replaced `scene.terrainProvider`,
+            // removing this (now-stale) handle must be a no-op so we don't clobber the
+            // active terrain/exaggeration.
+            if (scene.terrainProvider !== provider)
+                return;
+            scene.terrainProvider = undefined;
+            scene.verticalExaggeration = 1;
+        },
+    };
+}
+function makeLayerHandle(scene, id, primitive, kind, format) {
+    return {
+        id,
+        kind,
+        format,
+        setVisible(visible) {
+            primitive.show = visible;
+        },
+        remove() {
+            if (scene.primitives.contains(primitive))
+                scene.primitives.remove(primitive);
+        },
+    };
+}
+/**
+ * Resolve the attributes of a picked 3D-Tiles feature.
+ *
+ * Cesium returns a `Cesium3DTileFeature` from `scene.pick(...)` for tileset
+ * hits; its batch-table / `EXT_structural_metadata` properties are read via
+ * `getPropertyIds()` + `getProperty(id)`. Anything else (terrain, a glTF model
+ * primitive, empty space) yields `undefined`. Pure given a picked object, so it
+ * is unit-testable with a plain stub.
+ */
+export function resolvePickedFeatureAttributes(picked) {
+    if (picked === null || typeof picked !== "object")
+        return undefined;
+    const feature = picked;
+    if (typeof feature.getPropertyIds !== "function" || typeof feature.getProperty !== "function")
+        return undefined;
+    const attributes = {};
+    for (const propertyId of feature.getPropertyIds()) {
+        attributes[propertyId] = feature.getProperty(propertyId);
+    }
+    return attributes;
+}
+/**
+ * Pick a 3D-Tiles feature at the given window position and return its
+ * attributes (or `undefined` for a miss / non-feature hit). Convenience wrapper
+ * over `scene.pick` + {@link resolvePickedFeatureAttributes} for identify flows.
+ */
+export function pickCesiumFeatureAttributes(scene, windowPosition) {
+    if (typeof scene.pick !== "function")
+        return undefined;
+    return resolvePickedFeatureAttributes(scene.pick(windowPosition));
+}
+/**
+ * Apply scene primitives to a live Cesium target.
+ *
+ * As of #1197 this lands the full 3D stack against `target.scene`:
+ *  - `camera` → `Camera.setView` (via the lazily-loaded `Cartesian3`).
+ *  - `elevation-source` → `scene.terrainProvider` + `verticalExaggeration`.
+ *  - `model-layer` (`3d-tiles`) → `Cesium3DTileset.fromUrl` added to
+ *    `scene.primitives`; (`gltf`/`glb`) → `Model.fromGltfAsync` placed by
+ *    position/rotation/scale.
+ *
+ * Returns the diagnostics plus the live layer handles keyed by primitive id so
+ * callers can toggle visibility / tear layers down. Layer rendering is skipped
+ * (gracefully) when no `scene` is attached or when a primitive diagnoses as
+ * unsupported. I3S model layers and extrusions are declared-capable but not yet
+ * materialized here (no Honua server primitives emit them); point clouds ride
+ * the 3D-Tiles path and are gated on server ingest (honua-server#1201).
+ */
+export async function applyCesiumScenePrimitives(target, primitives, _state) {
+    const diagnostics = diagnoseScenePrimitives(primitives, CESIUM_SCENE_CAPABILITIES);
+    const cesium = await loadCesium();
+    const toCartesian = (longitude, latitude, height) => cesium.Cartesian3.fromDegrees(longitude, latitude, height);
+    const unsupportedIds = new Set(diagnostics.filter((diagnostic) => diagnostic.status === "unsupported").map((diagnostic) => diagnostic.primitiveId));
+    const layers = new Map();
+    const scene = target.scene;
+    for (const primitive of primitives) {
+        if (primitive.kind === "camera") {
+            applyCameraStateToCesiumCamera(target.camera, primitive.camera, toCartesian);
+            continue;
+        }
+        if (!scene || unsupportedIds.has(primitive.id))
+            continue;
+        if (primitive.kind === "elevation-source") {
+            const handle = await applyCesiumTerrain(scene, primitive, cesium);
+            if (handle)
+                layers.set(handle.id, handle);
+            continue;
+        }
+        if (primitive.kind === "model-layer") {
+            if (primitive.format === "3d-tiles") {
+                layers.set(primitive.id, await addCesium3DTileset(scene, primitive, cesium));
+            }
+            else if (primitive.format === "gltf" || primitive.format === "glb") {
+                layers.set(primitive.id, await addCesiumModel(scene, primitive, cesium));
+            }
+            // i3s / obj / custom: declared-capable but not materialized here.
+        }
+    }
+    return {
+        status: summarizeDiagnosticStatus(diagnostics),
+        diagnostics,
+        layers,
+    };
+}
+/**
+ * Create a {@link SceneRuntimeAdapter} backed by CesiumJS.
+ *
+ * When `options.target` (a live Cesium `Viewer`/`Scene` surface — a `camera`
+ * plus an optional `scene`) is supplied, `apply` drives the live globe: camera
+ * sync plus, when a `scene` is attached, terrain providers, 3D-Tiles tilesets,
+ * and glTF/GLB model layers (#1197). Without a target the adapter still
+ * diagnoses primitives against Cesium's true-3D capabilities — useful for
+ * migration analysis before a viewer exists. CesiumJS itself is only imported
+ * lazily when `apply` runs.
+ */
+export function createCesiumSceneAdapter(options = {}) {
+    const { id = "cesium-scene", target } = options;
+    return createSceneRuntimeAdapter({
+        id,
+        capabilities: CESIUM_SCENE_CAPABILITIES,
+        ...(target
+            ? {
+                apply: (primitives, state) => applyCesiumScenePrimitives(target, primitives, state),
+            }
+            : {}),
+    });
+}

package/scene-workspace/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `@honua/sdk-js/scene-workspace` — framework-neutral 3D scene workspace state.
+ *
+ * @experimental This entrypoint is not yet covered by the SDK's semver contract
+ *   — the surface may change in any minor release prior to `1.0.0`.
+ * @module
+ */
+export { createSceneWorkspace, emptySceneWorkspaceState, reduceSceneWorkspaceState, sceneWorkspaceIntentFromAdapterEvent, selectSceneDiagnosticsByStatus, selectSceneEvidenceForFeature, selectScenePrimitivesByKind, selectSceneVisibleLayers, } from "./workspace.js";
+export { MAPLIBRE_SCENE_CAPABILITIES, applyMapLibreScenePrimitives, createMapLibreSceneAdapter, createSceneRuntimeAdapter, diagnoseScenePrimitive, diagnoseScenePrimitives, summarizeDiagnosticStatus, toMapLibreExtrusionLayer, toMapLibreTerrainPatch, } from "./primitives.js";
+export { CESIUM_SCENE_CAPABILITIES, addCesium3DTileset, addCesiumModel, applyCameraStateToCesiumCamera, applyCesiumScenePrimitives, applyCesiumTerrain, applyHonua3DStyle, applyTilesetServerStyle, cameraStateToCesiumView, cesiumCameraToSceneState, createCesiumSceneAdapter, fetchHonua3DStyleSpec, honua3DStyleToCesiumStyleOptions, loadHonua3DStyle, modelLayerToCesiumPlacement, pickCesiumFeatureAttributes, readHonua3DStyleDescriptor, resolveCesiumModelScale, resolveHonua3DStyleUri, resolvePickedFeatureAttributes, setTilesetStyle, } from "./cesium-adapter.js";
+export type { AddCesium3DTilesetOptions, CesiumCameraLike, CesiumCameraView, CesiumHeadingPitchRollRadians, CesiumLayerHandle, CesiumModelLike, CesiumModelPlacement, CesiumPrimitiveCollectionLike, CesiumSceneLike, CesiumSceneRuntimeTarget, CesiumTilesetLike, Honua3DStyleConditions, Honua3DStyleDescriptor, Honua3DStyleSpec, } from "./cesium-adapter.js";
+export { buildElevationProfilePath, buildLineOfSightBody, buildViewshedBody, formatMeasurementLabel, haversineMeters, measureScenePositions, pathLengthMeters, positionsToWktLineString, renderElevationProfilePolyline, renderLineOfSight, renderMeasurement, renderViewshed, requestElevationProfile, requestLineOfSight, requestViewshed, slantDistanceMeters, sphericalPolygonAreaSquareMeters, } from "./analysis-widgets.js";
+export type { CesiumEntityCollectionLike, ElevationProfileRequest, ElevationProfileResult, ElevationProfileSample, LineOfSightRequest, LineOfSightResult, SceneAnalysisCesiumModule, SceneAnalysisOverlay, SceneAnalysisPosition, SceneAnalysisRequestExecutor, SceneMeasurement, ViewshedRequest, ViewshedResult, ViewshedSample, } from "./analysis-widgets.js";
+export { getScene, listScenes, normalizeScene, resolveSceneTilesetUrl, sceneCameraPrimitive, sceneLayerStates, sceneTerrainPrimitive, sceneTilesetPrimitive, sceneToRuntimePrimitives, sceneViewpointBookmarks, } from "./scene-discovery.js";
+export type { HonuaScene, SceneDiscoveryRequestExecutor, SceneExtent3D, SceneViewpoint, } from "./scene-discovery.js";
+export { SceneView } from "./scene-view.js";
+export type { SceneViewEvent, SceneViewEventListener, SceneViewOptions, SceneViewRequestExecutor, } from "./scene-view.js";
+export { SCENE_WORKSPACE_SLICES } from "./types.js";
+export type { MapLibreExtrusionLayerSpecification, MapLibreSceneRuntimeTarget, MapLibreTerrainOptions, MapLibreTerrainPatch, MapLibreTerrainSourceSpecification, SceneCacheMetadata, SceneCameraPrimitive, SceneElevationSourcePrimitive, SceneElevationSourceProtocol, SceneExtrusionPrimitive, SceneExtrusionValue, SceneGroundPrimitive, SceneLayerMetadataPrimitive, SceneModelFormat, SceneModelLayerPrimitive, ScenePrimitiveApplyResult, ScenePrimitiveDiagnostic, ScenePrimitiveDiagnosticSeverity, ScenePrimitiveStatus, SceneRendererKind, SceneRuntimeAdapter, SceneRuntimeCapabilities, SceneRuntimePrimitive, SceneRuntimePrimitiveKind, } from "./primitives.js";
+export type { SceneBookmark, SceneCameraState, SceneDetailState, SceneEvidenceReference, SceneLayerState, SceneRealtimeState, SceneTimelineState, SceneWorkspace, SceneWorkspaceAdapterEvent, SceneWorkspaceChangeEvent, SceneWorkspaceHistoryEntry, SceneWorkspaceIntent, SceneWorkspaceListener, SceneWorkspaceSlice, SceneWorkspaceSnapshot, SceneWorkspaceState, SceneWorkspaceUnsubscribe, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/scene-workspace/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scene-workspace/index.ts"],"names":[],"mappings":"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"}

package/scene-workspace/index.js

@@ -0,0 +1,14 @@
+/**
+ * `@honua/sdk-js/scene-workspace` — framework-neutral 3D scene workspace state.
+ *
+ * @experimental This entrypoint is not yet covered by the SDK's semver contract
+ *   — the surface may change in any minor release prior to `1.0.0`.
+ * @module
+ */
+export { createSceneWorkspace, emptySceneWorkspaceState, reduceSceneWorkspaceState, sceneWorkspaceIntentFromAdapterEvent, selectSceneDiagnosticsByStatus, selectSceneEvidenceForFeature, selectScenePrimitivesByKind, selectSceneVisibleLayers, } from "./workspace.js";
+export { MAPLIBRE_SCENE_CAPABILITIES, applyMapLibreScenePrimitives, createMapLibreSceneAdapter, createSceneRuntimeAdapter, diagnoseScenePrimitive, diagnoseScenePrimitives, summarizeDiagnosticStatus, toMapLibreExtrusionLayer, toMapLibreTerrainPatch, } from "./primitives.js";
+export { CESIUM_SCENE_CAPABILITIES, addCesium3DTileset, addCesiumModel, applyCameraStateToCesiumCamera, applyCesiumScenePrimitives, applyCesiumTerrain, applyHonua3DStyle, applyTilesetServerStyle, cameraStateToCesiumView, cesiumCameraToSceneState, createCesiumSceneAdapter, fetchHonua3DStyleSpec, honua3DStyleToCesiumStyleOptions, loadHonua3DStyle, modelLayerToCesiumPlacement, pickCesiumFeatureAttributes, readHonua3DStyleDescriptor, resolveCesiumModelScale, resolveHonua3DStyleUri, resolvePickedFeatureAttributes, setTilesetStyle, } from "./cesium-adapter.js";
+export { buildElevationProfilePath, buildLineOfSightBody, buildViewshedBody, formatMeasurementLabel, haversineMeters, measureScenePositions, pathLengthMeters, positionsToWktLineString, renderElevationProfilePolyline, renderLineOfSight, renderMeasurement, renderViewshed, requestElevationProfile, requestLineOfSight, requestViewshed, slantDistanceMeters, sphericalPolygonAreaSquareMeters, } from "./analysis-widgets.js";
+export { getScene, listScenes, normalizeScene, resolveSceneTilesetUrl, sceneCameraPrimitive, sceneLayerStates, sceneTerrainPrimitive, sceneTilesetPrimitive, sceneToRuntimePrimitives, sceneViewpointBookmarks, } from "./scene-discovery.js";
+export { SceneView } from "./scene-view.js";
+export { SCENE_WORKSPACE_SLICES } from "./types.js";