@nebula-spatial/viewer 0.3.0 → 0.4.1

package/dist/stage-CFr9ZkwQ.js

@@ -0,0 +1,421 @@
+var v = Object.defineProperty;
+var y = (c, e, t) => e in c ? v(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var a = (c, e, t) => y(c, typeof e != "symbol" ? e + "" : e, t);
+import * as o from "three";
+import { V as p } from "./index-D0lW4RQP.js";
+const x = 1, b = (
+  /* glsl */
+  `
+  uniform mat4 textureMatrix;
+  varying vec4 vReflectionUv;
+  varying vec3 vWorldPosition;
+
+  void main() {
+    vec4 worldPosition = modelMatrix * vec4(position, 1.0);
+    vWorldPosition = worldPosition.xyz;
+    vReflectionUv = textureMatrix * vec4(position, 1.0);
+    // Match Three.js built-in materials: transform to view space before projection.
+    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+    gl_Position = projectionMatrix * mvPosition;
+  }
+`
+), M = (
+  /* glsl */
+  `
+  uniform sampler2D tDiffuse;
+  uniform vec2 resolution;
+  uniform vec3 fineGridColor;
+  uniform vec3 coarseGridColor;
+  uniform float blurIntensity;
+  uniform float reflectionMix;
+  uniform float gridOpacity;
+  uniform float gridScale;
+  uniform vec2 groundCenter;
+  uniform float maxRadius;
+  uniform float fadeSoftness;
+
+  varying vec4 vReflectionUv;
+  varying vec3 vWorldPosition;
+
+  vec4 blur9(sampler2D image, vec2 uv, vec2 res, float radius) {
+    vec4 color = vec4(0.0);
+    vec2 stepSize = radius / res;
+    color += texture2D(image, uv + vec2(-stepSize.x, -stepSize.y)) * 0.0625;
+    color += texture2D(image, uv + vec2(0.0, -stepSize.y)) * 0.125;
+    color += texture2D(image, uv + vec2(stepSize.x, -stepSize.y)) * 0.0625;
+    color += texture2D(image, uv + vec2(-stepSize.x, 0.0)) * 0.125;
+    color += texture2D(image, uv) * 0.25;
+    color += texture2D(image, uv + vec2(stepSize.x, 0.0)) * 0.125;
+    color += texture2D(image, uv + vec2(-stepSize.x, stepSize.y)) * 0.0625;
+    color += texture2D(image, uv + vec2(0.0, stepSize.y)) * 0.125;
+    color += texture2D(image, uv + vec2(stepSize.x, stepSize.y)) * 0.0625;
+    return color;
+  }
+
+  float gridLine(vec2 position, float scale) {
+    vec2 coordinate = position / scale;
+    vec2 width = max(fwidth(coordinate), vec2(0.0001));
+    vec2 distanceToLine = abs(fract(coordinate - 0.5) - 0.5) / width;
+    return 1.0 - min(min(distanceToLine.x, distanceToLine.y), 1.0);
+  }
+
+  void main() {
+    vec2 groundPosition = vWorldPosition.xy;
+    float edgeDistance = length(groundPosition - groundCenter);
+    float edgeFade = 1.0 - smoothstep(maxRadius - fadeSoftness, maxRadius, edgeDistance);
+
+    float fineLine = gridLine(groundPosition, gridScale);
+    float coarseLine = gridLine(groundPosition, gridScale * 10.0);
+    float gridAlpha = max(fineLine * 0.16, coarseLine * 0.42) * gridOpacity * edgeFade;
+    vec3 gridColor = mix(fineGridColor, coarseGridColor, coarseLine);
+
+    vec2 reflectionUv = vReflectionUv.xy / vReflectionUv.w;
+    bool validReflection = reflectionUv.x >= 0.0 && reflectionUv.x <= 1.0
+      && reflectionUv.y >= 0.0 && reflectionUv.y <= 1.0;
+    vec4 reflection = validReflection
+      ? blur9(tDiffuse, reflectionUv, resolution, blurIntensity)
+      : vec4(0.0);
+    float reflectionAlpha = reflectionMix * edgeFade * (validReflection ? 1.0 : 0.0);
+
+    float alpha = reflectionAlpha + gridAlpha * (1.0 - reflectionAlpha);
+    if (alpha <= 0.001) discard;
+    vec3 color = mix(reflection.rgb, gridColor, gridAlpha / max(alpha, 0.001));
+    gl_FragColor = vec4(color, alpha);
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+  }
+`
+);
+class w extends o.Mesh {
+  constructor({ size: t = 20, textureWidth: i = 512, textureHeight: r = 512 } = {}) {
+    const s = new o.Matrix4(), n = new o.WebGLRenderTarget(i, r, {
+      type: o.HalfFloatType,
+      minFilter: o.LinearFilter,
+      magFilter: o.LinearFilter,
+      format: o.RGBAFormat,
+      depthBuffer: !0,
+      samples: 0
+    }), l = new o.ShaderMaterial({
+      uniforms: {
+        tDiffuse: { value: n.texture },
+        textureMatrix: { value: s },
+        resolution: { value: new o.Vector2(i, r) },
+        fineGridColor: { value: new o.Color(2502702) },
+        coarseGridColor: { value: new o.Color(7897726) },
+        blurIntensity: { value: 1.7 },
+        reflectionMix: { value: 0.07 },
+        gridOpacity: { value: 1 },
+        gridScale: { value: 0.2 },
+        groundCenter: { value: new o.Vector2() },
+        maxRadius: { value: t * 0.5 },
+        fadeSoftness: { value: t * 0.325 }
+      },
+      vertexShader: b,
+      fragmentShader: M,
+      transparent: !0,
+      depthWrite: !1,
+      toneMapped: !0,
+      fog: !1
+    });
+    super(new o.PlaneGeometry(t, t), l);
+    a(this, "renderTarget");
+    a(this, "textureMatrix");
+    a(this, "virtualCamera");
+    a(this, "clipBias");
+    a(this, "reflectorPlane");
+    a(this, "normal");
+    a(this, "reflectorWorldPosition");
+    a(this, "cameraWorldPosition");
+    a(this, "rotationMatrix");
+    a(this, "lookAtPosition");
+    a(this, "clipPlane");
+    a(this, "view");
+    a(this, "target");
+    a(this, "q");
+    this.renderTarget = n, this.textureMatrix = s, this.virtualCamera = new o.PerspectiveCamera(), this.virtualCamera.layers.set(x), this.clipBias = 3e-3, this.frustumCulled = !1, this.renderOrder = 1, this.position.z = 2e-3, this.reflectorPlane = new o.Plane(), this.normal = new o.Vector3(), this.reflectorWorldPosition = new o.Vector3(), this.cameraWorldPosition = new o.Vector3(), this.rotationMatrix = new o.Matrix4(), this.lookAtPosition = new o.Vector3(0, 0, -1), this.clipPlane = new o.Vector4(), this.view = new o.Vector3(), this.target = new o.Vector3(), this.q = new o.Vector4();
+  }
+  renderReflection(t, i, r) {
+    if (this.reflectorWorldPosition.setFromMatrixPosition(this.matrixWorld), this.cameraWorldPosition.setFromMatrixPosition(r.matrixWorld), this.rotationMatrix.extractRotation(this.matrixWorld), this.normal.set(0, 0, 1).applyMatrix4(this.rotationMatrix), this.view.subVectors(this.reflectorWorldPosition, this.cameraWorldPosition), this.view.dot(this.normal) > 0) return;
+    this.view.reflect(this.normal).negate().add(this.reflectorWorldPosition), this.rotationMatrix.extractRotation(r.matrixWorld), this.lookAtPosition.set(0, 0, -1).applyMatrix4(this.rotationMatrix).add(this.cameraWorldPosition), this.target.subVectors(this.reflectorWorldPosition, this.lookAtPosition).reflect(this.normal).negate().add(this.reflectorWorldPosition), this.virtualCamera.position.copy(this.view), this.virtualCamera.up.set(0, 1, 0).applyMatrix4(this.rotationMatrix).reflect(this.normal), this.virtualCamera.lookAt(this.target), this.virtualCamera.near = r.near, this.virtualCamera.far = r.far, this.virtualCamera.updateMatrixWorld(), this.virtualCamera.projectionMatrix.copy(r.projectionMatrix), this.textureMatrix.set(
+      0.5,
+      0,
+      0,
+      0.5,
+      0,
+      0.5,
+      0,
+      0.5,
+      0,
+      0,
+      0.5,
+      0.5,
+      0,
+      0,
+      0,
+      1
+    ).multiply(this.virtualCamera.projectionMatrix).multiply(this.virtualCamera.matrixWorldInverse).multiply(this.matrixWorld), this.reflectorPlane.setFromNormalAndCoplanarPoint(this.normal, this.reflectorWorldPosition).applyMatrix4(this.virtualCamera.matrixWorldInverse), this.clipPlane.set(
+      this.reflectorPlane.normal.x,
+      this.reflectorPlane.normal.y,
+      this.reflectorPlane.normal.z,
+      this.reflectorPlane.constant
+    );
+    const s = this.virtualCamera.projectionMatrix;
+    this.q.set(
+      (Math.sign(this.clipPlane.x) + s.elements[8]) / s.elements[0],
+      (Math.sign(this.clipPlane.y) + s.elements[9]) / s.elements[5],
+      -1,
+      (1 + s.elements[10]) / s.elements[14]
+    ), this.clipPlane.multiplyScalar(2 / this.clipPlane.dot(this.q)), s.elements[2] = this.clipPlane.x, s.elements[6] = this.clipPlane.y, s.elements[10] = this.clipPlane.z + 1 - this.clipBias, s.elements[14] = this.clipPlane.w, this.virtualCamera.projectionMatrixInverse.copy(s).invert();
+    const n = t.getRenderTarget(), l = t.xr.enabled, u = t.shadowMap.autoUpdate, d = t.shadowMap.enabled;
+    try {
+      t.xr.enabled = !1, t.shadowMap.enabled = !1, t.shadowMap.autoUpdate = !1, t.setRenderTarget(this.renderTarget), t.state.buffers.depth.setMask(!0), t.clear(), t.render(i, this.virtualCamera);
+    } finally {
+      t.setRenderTarget(n), t.xr.enabled = l, t.shadowMap.enabled = d, t.shadowMap.autoUpdate = u;
+    }
+  }
+  setRenderSize(t, i) {
+    this.renderTarget.setSize(t, i), this.material.uniforms.resolution.value.set(t, i);
+  }
+  // Radius is in world units; the outer 65% fades before the square mesh edge.
+  setRadius(t, i, r = this.material.uniforms.groundCenter.value) {
+    this.scale.setScalar(t * 2 / this.geometry.parameters.width), this.position.x = r.x, this.position.y = r.y, this.material.uniforms.groundCenter.value.set(r.x, r.y), this.material.uniforms.gridScale.value = i, this.material.uniforms.maxRadius.value = t, this.material.uniforms.fadeSoftness.value = t * 0.65;
+  }
+}
+const g = {
+  light: {
+    background: p.light,
+    fineGrid: 5859168,
+    coarseGrid: 3427136,
+    gridOpacity: 0.85,
+    reflectionMix: 0.06
+  },
+  dark: {
+    background: p.dark,
+    fineGrid: 7375236,
+    coarseGrid: 5552554,
+    gridOpacity: 0.9,
+    reflectionMix: 0.06
+  }
+}, P = {
+  simulation: 0.68,
+  model: 1.4
+};
+function C(c) {
+  const e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+  c.traverse((s) => {
+    var l;
+    const n = s;
+    n.geometry && e.add(n.geometry);
+    for (const u of Array.isArray(n.material) ? n.material : [n.material])
+      if (u) {
+        t.add(u);
+        for (const d of Object.values(u)) {
+          if (!S(d)) continue;
+          i.add(d);
+          const h = (l = d.source) == null ? void 0 : l.data;
+          h && typeof h.close == "function" && r.add(h);
+        }
+      }
+  });
+  for (const s of e) s.dispose();
+  for (const s of t) s.dispose();
+  for (const s of i) s.dispose();
+  for (const s of r) s.close();
+}
+function S(c) {
+  return !!(c && typeof c == "object" && c.isTexture);
+}
+const f = 2213822, G = 6000111, R = 6;
+function L(c, e, t) {
+  e.updateMatrixWorld();
+  const i = new o.Vector3();
+  return e.getWorldDirection(i).normalize(), c.setFromNormalAndCoplanarPoint(i, t);
+}
+class F {
+  constructor(e, t = "dark", i, r = "simulation") {
+    a(this, "root", new o.Group());
+    a(this, "reflector", new w({ size: 100, textureWidth: 256, textureHeight: 256 }));
+    a(this, "values");
+    a(this, "fog");
+    a(this, "raycaster", new o.Raycaster());
+    a(this, "pointer", new o.Vector2());
+    a(this, "dragPlane", new o.Plane());
+    a(this, "dragTarget", new o.Vector3());
+    a(this, "dragIntersection", new o.Vector3());
+    a(this, "dragOffset", new o.Vector3());
+    a(this, "bodyGroups", /* @__PURE__ */ new Map());
+    a(this, "auxiliaries", /* @__PURE__ */ new Set());
+    a(this, "forceLine");
+    a(this, "forceBoosted", !1);
+    a(this, "grabCanvas", null);
+    a(this, "previousCursor", "");
+    a(this, "size", "");
+    a(this, "groundVisible");
+    a(this, "disposed", !1);
+    this.model = e, this.runtime = i, this.presentation = r, this.values = g[t];
+    const s = this.values, n = new o.Box3().setFromObject(e), l = Math.max(...n.getSize(new o.Vector3()).toArray());
+    if (!Number.isFinite(l) || l <= 0) throw new Error("Empty simulation geometry.");
+    this.root.add(e), this.forceLine = this.createForceLine(), this.root.add(this.forceLine), e.traverse((m) => {
+      m instanceof o.Mesh && m.layers.enable(x);
+    }), this.root.add(this.reflector);
+    const u = Math.max(n.getSize(new o.Vector3()).length() * 0.5, 0.02), d = this.reflector.material.uniforms;
+    d.fineGridColor.value.setHex(s.fineGrid), d.coarseGridColor.value.setHex(s.coarseGrid), d.gridOpacity.value = s.gridOpacity, d.reflectionMix.value = s.reflectionMix, this.layoutGround(n, u), this.groundVisible = r === "simulation", this.setGroundVisible(this.groundVisible);
+    const h = u / Math.sin(o.MathUtils.degToRad(38) / 2) * 1.25;
+    this.fog = new o.Fog(s.background, h * 2.5, h * 8);
+  }
+  setTheme(e) {
+    if (this.disposed) return;
+    const t = this.values = g[e], i = this.reflector.material.uniforms;
+    i.fineGridColor.value.setHex(t.fineGrid), i.coarseGridColor.value.setHex(t.coarseGrid), i.gridOpacity.value = t.gridOpacity, i.reflectionMix.value = t.reflectionMix, this.fog.color.setHex(t.background);
+  }
+  layoutGround(e, t) {
+    this.reflector.setRadius(t * 8, Math.pow(10, Math.floor(Math.log10(Math.max(t, 0.01)))), e.getCenter(new o.Vector3()));
+  }
+  /**
+   * Re-fits the ground disc and reflection to the model's current world bounds.
+   * Model previews call this after re-orienting the asset's authored up axis:
+   * an axis-aligned bounding box is not rotation invariant, so the floor that
+   * was sized to a wide-flat footprint can end up clipping an upright model.
+   */
+  reseatGround() {
+    if (this.disposed) return;
+    this.root.updateMatrixWorld(!0);
+    const e = new o.Box3().setFromObject(this.model);
+    e.isEmpty() || this.layoutGround(e, Math.max(e.getSize(new o.Vector3()).length() * 0.5, 0.02));
+  }
+  createForceLine() {
+    const e = new o.BufferGeometry().setFromPoints([
+      new o.Vector3(),
+      new o.Vector3()
+    ]), t = new o.LineBasicMaterial({
+      color: f,
+      depthTest: !1,
+      transparent: !0
+    }), i = new o.Line(e, t);
+    return i.renderOrder = 1e3, i.visible = !1, i;
+  }
+  findBodyGroup(e) {
+    var i;
+    let t = e;
+    for (; t && t !== this.model && t !== this.root; ) {
+      if (typeof ((i = t.userData) == null ? void 0 : i.bodyId) == "number") return t;
+      t = t.parent;
+    }
+    return null;
+  }
+  getBodyGroup(e) {
+    let t = this.bodyGroups.get(e);
+    return t || this.model.traverse((i) => {
+      var r;
+      ((r = i.userData) == null ? void 0 : r.bodyId) === e && (t = i, this.bodyGroups.set(e, i));
+    }), t;
+  }
+  pointerRay(e, t, i) {
+    const r = i.getBoundingClientRect();
+    this.pointer.set(
+      (e.clientX - r.left) / r.width * 2 - 1,
+      -((e.clientY - r.top) / r.height) * 2 + 1
+    ), this.raycaster.setFromCamera(this.pointer, t);
+  }
+  setForceBoost(e) {
+    var t;
+    !((t = this.runtime) != null && t.grab) || e === this.forceBoosted || (this.forceBoosted = e, this.runtime.updateGrabStrength(e ? R : 1), this.forceLine.material.color.setHex(e ? G : f));
+  }
+  beginGrab(e, t, i) {
+    if (!this.runtime || this.disposed) return !1;
+    this.pointerRay(e, t, i);
+    const r = this.raycaster.intersectObject(this.model, !0).find((u) => u.object.isMesh);
+    if (!r) return !1;
+    const s = this.findBodyGroup(r.object);
+    if (!s) return !1;
+    const n = s.worldToLocal(r.point.clone());
+    this.dragTarget.copy(r.point), L(this.dragPlane, t, r.point), this.dragOffset.set(0, 0, 0);
+    const l = this.root.worldToLocal(r.point.clone());
+    return this.bodyGroups.set(s.userData.bodyId, s), this.runtime.beginGrab({
+      bodyId: s.userData.bodyId,
+      localPoint: [n.x, n.y, n.z],
+      target: [l.x, l.y, l.z]
+    }), this.forceBoosted = !1, this.setForceBoost(e.shiftKey), this.forceLine.visible = !0, this.updateForceLine(), this.grabCanvas = i, i != null && i.style && (this.previousCursor = i.style.cursor, i.style.cursor = "grabbing"), !0;
+  }
+  moveGrab(e, t, i) {
+    var s;
+    if (!((s = this.runtime) != null && s.grab)) return;
+    if (this.pointerRay(e, t, i), this.setForceBoost(e.shiftKey), i != null && i.style && i.style.cursor !== "grabbing" && (i.style.cursor = "grabbing"), this.raycaster.ray.intersectPlane(this.dragPlane, this.dragIntersection))
+      this.dragTarget.copy(this.dragIntersection).add(this.dragOffset);
+    else
+      return;
+    const r = this.root.worldToLocal(this.dragTarget.clone());
+    this.runtime.updateGrabTarget([r.x, r.y, r.z]), this.updateForceLine();
+  }
+  endGrab() {
+    var e;
+    this.runtime && (this.runtime.endGrab(), this.forceBoosted = !1, this.forceLine.visible = !1, this.forceLine.material.color.setHex(f), (e = this.grabCanvas) != null && e.style && (this.grabCanvas.style.cursor = this.previousCursor), this.grabCanvas = null);
+  }
+  updateForceLine() {
+    var l;
+    const e = (l = this.runtime) == null ? void 0 : l.grab;
+    if (!e) return;
+    const t = this.getBodyGroup(e.bodyId);
+    if (!t) return;
+    const i = new o.Vector3().fromArray(e.localPoint), r = t.localToWorld(i), s = this.root.worldToLocal(r), n = this.forceLine.geometry.attributes.position;
+    n.setXYZ(0, s.x, s.y, s.z), n.setXYZ(1, e.target[0], e.target[1], e.target[2]), n.needsUpdate = !0;
+  }
+  beforeRender(e, t, i) {
+    var n;
+    const r = {
+      tone: e.toneMapping,
+      exposure: e.toneMappingExposure,
+      color: e.outputColorSpace,
+      environment: t.environment,
+      fog: t.fog,
+      background: t.background
+    }, s = () => {
+      e.toneMapping = r.tone, e.toneMappingExposure = r.exposure, e.outputColorSpace = r.color, t.environment = r.environment, t.fog = r.fog, t.background = r.background;
+    };
+    if (this.disposed) return s;
+    try {
+      (n = this.runtime) != null && n.grab && this.updateForceLine(), e.toneMapping = o.ACESFilmicToneMapping, e.toneMappingExposure = P[this.presentation], e.outputColorSpace = o.SRGBColorSpace, t.background = new o.Color(this.values.background), t.fog = this.fog;
+      const l = e.getSize(new o.Vector2()), u = `${l.x}:${l.y}`;
+      return u !== this.size && (this.size = u, this.reflector.setRenderSize(Math.max(1, Math.floor(l.x * 0.35)), Math.max(1, Math.floor(l.y * 0.35)))), t.updateMatrixWorld(!0), i.updateMatrixWorld(!0), this.groundVisible && i instanceof o.PerspectiveCamera && this.reflector.renderReflection(e, t, i), s;
+    } catch (l) {
+      throw s(), l;
+    }
+  }
+  /**
+   * The reflector mesh carries both the grid lines and the reflection. Hiding
+   * it also skips the reflection render pass, which only feeds its shader.
+   */
+  setGroundVisible(e) {
+    this.groundVisible = e, this.reflector.visible = e;
+  }
+  getGroundVisible() {
+    return this.groundVisible;
+  }
+  /**
+   * Adds a debug/auxiliary object next to the model rather than inside it.
+   * The model subtree is what the reflector pass and `getModelBounds` measure,
+   * so nesting hidden aids (collision meshes, which are far larger than the
+   * visual shell) would inflate both the reflection extent and the camera fit.
+   */
+  attachAuxiliary(e) {
+    this.auxiliaries.add(e), this.root.add(e);
+  }
+  getModelBounds() {
+    this.root.updateMatrixWorld(!0);
+    const e = new o.Box3().setFromObject(this.model);
+    if (!e.isEmpty()) return e;
+    const t = new o.Box3();
+    return t.min.set(-5e3, -5e3, -5e3), t.max.set(5e3, 5e3, 5e3), t;
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0, this.endGrab(), this.model.removeFromParent();
+      for (const e of this.auxiliaries) e.removeFromParent();
+      this.auxiliaries.clear(), this.root.removeFromParent(), this.reflector.renderTarget.dispose(), C(this.root);
+    }
+  }
+}
+export {
+  F as S,
+  C as d
+};

package/dist/types.d.ts

@@ -1,8 +1,16 @@
 import type { Box3, ColorRepresentation, Object3D, Vector3 } from 'three';
-import type { CadViewerCapability, CameraStateStore, ViewerUiOptions } from './cad/types';
-export type { CadBlockModel, CadDocumentHandle, CadDocumentUnits, CadFontResolver, CadFontRequest, CadResolvedFont, CadResolvedTextFont, CadTextWarmupOptions, CadHudModel, CadHudSnapshot, CadInspectorModel, CadInspectorSnapshot, CadLayerModel, CadLayerRow, CadBlockUsageRow, CadSessionPhase, CadWorldBounds, CadScaleRulerState, CadInsertDetails, CadInsertSelection, CadInsertSelectionId, CadTextDetails, CadTextSelection, CadTextSelectionId, CadSelection, CadHit, CadViewerSnapshot, CadLoadProgress, CadViewerErrorCode, CadViewerErrorEvent, CadLoadSource, CadOpenOptions, CadSessionLoadTiming, RenderDebugBreakdownEntry, SplitBlockLayerDetail, CadViewerCapability, ResolveTextFont, CadViewerEventMap, CameraStateStore, ViewerUiKeyboardOptions, ViewerUiOptions, ViewerUiParts, ViewerUiPreset, ViewerUiStateStore, ViewerUiTheme, ViewerUiTokens, } from './cad/types';
+import type { CadViewerCapability, CameraStateStore, ViewerUiOptions, ViewerUiTheme } from './cad/types';
+import type { AssetChangeEvent, AssetControlChangeEvent, AssetErrorEvent, AssetPreview, AssetSource, OpenAssetOptions, ViewerAssetOptions } from './assets/types';
+export type { CadBlockModel, CadDocumentHandle, CadDocumentUnits, CadFontResolver, CadFontRequest, CadResolvedFont, CadResolvedTextFont, CadTextWarmupOptions, CadHudModel, CadHudSnapshot, CadInspectorModel, CadInspectorSnapshot, CadLayerModel, CadLayerRow, CadBlockUsageRow, CadSessionPhase, CadWorldBounds, CadScaleRulerState, CadInsertDetails, CadInsertSelection, CadInsertSelectionId, CadTextDetails, CadTextSelection, CadTextSelectionId, CadSelection, CadHit, CadViewerSnapshot, CadLoadProgress, CadViewerErrorCode, CadViewerErrorEvent, CadLoadSource, CadOpenOptions, CadSessionLoadTiming, RenderDebugBreakdownEntry, SplitBlockLayerDetail, CadViewerCapability, ResolveTextFont, CadViewerEventMap, CameraStateStore, ViewerCadUiKeyboardOptions, ViewerUiOptions, ViewerCadUiParts, ViewerCadUiOptions, ViewerUiPreset, ViewerCadUiStateStore, ViewerUiTheme, ViewerUiTokens, } from './cad/types';
 export type ViewerViewMode = '2d' | '3d';
 export type CadInteractionMode = 'managed' | 'manual' | 'disabled';
+/**
+ * Which 3D navigation implementation the runtime drives.
+ * `viewer` is the CAD path; `preview` is the model/simulation particle viewer
+ * matching sim-studio. Kept as its own union so the viewer's public surface
+ * does not re-export the runtime package's type.
+ */
+export type ViewerNavigationPolicy = 'legacy' | 'viewer' | 'preview';
 export type CameraChangeReason = 'pointer' | 'wheel' | 'fit' | 'restore' | 'api' | 'view-mode';
 export type ViewerEnvironment = 'room' | {
     /** Load an external equirectangular HDR texture for image-based lighting. */
@@ -72,6 +80,8 @@ export interface ViewerOptions {
     /** Max delay for merged viewport demands while the interaction is active. Default 160ms. */
     viewportDemandCoalesceMs?: number;
     ui?: ViewerUiOptions;
+    assets?: ViewerAssetOptions;
+    onCleanupError?: (event: AssetErrorEvent) => void;
 }
 export interface ViewerFitViewOptions {
     padding?: number;
@@ -126,6 +136,9 @@ export interface ViewerEventMap {
     'view-mode-change': {
         viewMode: ViewerViewMode;
     };
+    'theme-change': {
+        theme: ViewerUiTheme;
+    };
     resize: {
         resized: boolean;
     };
@@ -156,6 +169,9 @@ export interface ViewerEventMap {
         layerPanelOpen: boolean;
         propertyPanelOpen: boolean;
     };
+    'asset-change': AssetChangeEvent;
+    'asset-error': AssetErrorEvent;
+    'asset-control-change': AssetControlChangeEvent;
 }
 export interface Viewer {
     readonly viewport: HTMLElement;
@@ -184,12 +200,16 @@ export interface Viewer {
         execute(id: string, args?: unknown): boolean;
         has(id: string): boolean;
     };
+    openAsset(source: AssetSource, options?: OpenAssetOptions): AssetPreview;
+    closeAsset(): Promise<void>;
     addObject(object: Object3D, options?: ViewerObjectOptions): void;
     removeObject(object: Object3D): boolean;
     setVisible(object: Object3D, visible: boolean): void;
     setViewMode(mode: ViewerViewMode, options?: {
         preserveOrbit?: boolean;
     }): void;
+    /** Switches the UI and active preview stage theme at runtime. */
+    setTheme(theme: ViewerUiTheme): boolean;
     fitView(target?: Object3D | Box3, options?: ViewerFitViewOptions): boolean;
     fitAll(options?: ViewerFitViewOptions): boolean;
     screenToWorldOnPlane(clientX: number, clientY: number, planeZ?: number): Vector3 | null;
@@ -199,6 +219,8 @@ export interface Viewer {
     on<K extends keyof ViewerEventMap>(type: K, listener: (event: ViewerEventMap[K]) => void): () => void;
     resize(): boolean;
     requestRender(): void;
+    getActiveCamera(): import('three').Camera;
+    setNavigationEnabled(enabled: boolean): void;
     dispose(): void;
     use(plugins: readonly import('./plugins').ViewerPlugin[], options?: {
         replace?: boolean;

package/dist/ui/types.d.ts

@@ -0,0 +1,45 @@
+import type { ViewerCadUiOptions } from '../cad/types';
+/** Theme shared by every package-owned UI group. */
+export type ViewerUiTheme = 'dark' | 'light';
+/** Which built-in UI groups the viewer registers. */
+export type ViewerUiPreset = 'auto' | 'cad-readonly' | 'none';
+/** Options for the built-in model/simulation scene UI group. */
+export interface ViewerSceneUiOptions {
+    parts?: ViewerSceneUiParts;
+}
+export interface ViewerSceneUiParts {
+    filename?: boolean;
+    playback?: boolean;
+    reset?: boolean;
+    fit?: boolean;
+    upAxis?: boolean;
+    ground?: boolean;
+    collision?: boolean;
+    theme?: boolean;
+}
+/** Shared UI configuration; asset-specific controls live in their named groups. */
+export interface ViewerUiOptions {
+    root: HTMLElement;
+    preset?: ViewerUiPreset;
+    /** Single initial theme source; built-in buttons switch it internally at runtime. */
+    theme?: ViewerUiTheme;
+    tokens?: ViewerUiTokens;
+    style?: string | ((root: ShadowRoot) => void);
+    locale?: string;
+    messages?: Readonly<Record<string, string>>;
+    messageResolver?: (key: string, params?: Readonly<Record<string, string | number>>) => string | undefined;
+    /** Defaults to the viewport; 'none' only broadcasts layout changes. */
+    insetTarget?: HTMLElement | 'none';
+    cad?: ViewerCadUiOptions;
+    /** Shared scene controls for model and simulation assets, gated by capabilities. */
+    scene?: ViewerSceneUiOptions;
+}
+export interface ViewerUiTokens {
+    accent?: string;
+    panelBackground?: string;
+    background?: string;
+    text?: string;
+    textDim?: string;
+    border?: string;
+    hudBackground?: string;
+}