@nebula-spatial/viewer 0.4.3 → 0.4.4

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export type { Disposable, ToolbarItem, ViewerState, ViewerInteractionHooks, View
 export { configureViewerText } from './cad/text';
 export type { ViewerTextBuilderOptions } from './cad/text';
 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, Viewer, ViewerEventMap, ViewerEnvironment, ViewerFitViewOptions, ViewerHighlightOptions, ViewerOptions, ViewerPickOptions, ViewerPickResult, ViewerPointerEvent, ViewerObjectOptions, ViewerCameraSnapshot, ViewerOrthographicSnapshot, ViewerOrbitSnapshot, ViewerRenderStats, ViewerDocumentRect, ViewerCadUiKeyboardOptions, ViewerUiOptions, ViewerCadUiParts, ViewerCadUiOptions, ViewerUiPreset, ViewerCadUiStateStore, ViewerUiTheme, ViewerViewMode, CadInteractionMode, CameraChangeReason, ViewerUiTokens, } from './types';
+export type { AssetInspection, UrdfEntityKind, UrdfInspection, UrdfInspectionEntity, UrdfInspectionIssue, UrdfInspectionJoint, UrdfInspectionLink, UrdfInspectionMode, UrdfInspectionNode, UrdfInspectionOverlays, UrdfInspectionRobot, UrdfInspectionSnapshot, UrdfSourceRange } from './inspection/types';

package/dist/index.js

@@ -1,4 +1,4 @@
-import { c as o } from "./index-BDo6voB2.js";
+import { c as o } from "./index-D-o1ODOX.js";
 import { configureCadTextBuilder as t } from "@nebula-spatial/cad-loader";
 export {
   t as configureViewerText,

package/dist/inspection/types.d.ts

@@ -0,0 +1,99 @@
+export type UrdfEntityKind = 'robot' | 'link' | 'joint';
+export interface UrdfSourceRange {
+    readonly file: string;
+    readonly startOffset: number;
+    readonly endOffset: number;
+    readonly startLine: number;
+    readonly startColumn: number;
+    readonly endLine: number;
+    readonly endColumn: number;
+}
+export interface UrdfInspectionEntity {
+    readonly id: string;
+    readonly kind: UrdfEntityKind;
+    readonly name: string;
+    readonly parentId?: string;
+    readonly childIds: readonly string[];
+    readonly source?: UrdfSourceRange;
+}
+export interface UrdfInspectionLink extends UrdfInspectionEntity {
+    readonly kind: 'link';
+    readonly mass?: number;
+    readonly centerOfMass?: readonly number[];
+    readonly inertiaTensor?: readonly number[];
+    readonly inertiaMass?: number;
+    readonly visualCount: number;
+    readonly collisionCount: number;
+}
+export interface UrdfInspectionJoint extends UrdfInspectionEntity {
+    readonly kind: 'joint';
+    readonly jointType: string;
+    readonly parentLink: string;
+    readonly childLink: string;
+    readonly axis: readonly number[];
+    readonly originPosition: readonly number[];
+    readonly originRotationRpy: readonly number[];
+    readonly limits?: {
+        readonly lower: number;
+        readonly upper: number;
+    };
+    readonly effort?: number;
+    readonly velocity?: number;
+    readonly movable: boolean;
+}
+export interface UrdfInspectionRobot extends UrdfInspectionEntity {
+    readonly kind: 'robot';
+    readonly rootLinkIds: readonly string[];
+}
+export type UrdfInspectionNode = UrdfInspectionRobot | UrdfInspectionLink | UrdfInspectionJoint;
+export interface UrdfInspectionIssue {
+    readonly id: string;
+    readonly ruleId: string;
+    readonly severity: 'error';
+    readonly title: string;
+    readonly message: string;
+    readonly entityId: string;
+    readonly source?: UrdfSourceRange;
+    readonly values?: Readonly<Record<string, unknown>>;
+}
+export interface UrdfInspectionOverlays {
+    readonly collision: boolean;
+    readonly jointAxis: boolean;
+    readonly centerOfMass: boolean;
+    readonly inertia?: boolean;
+}
+export type UrdfInspectionMode = 'kinematic' | 'dynamics-initializing' | 'dynamics-paused' | 'dynamics-running' | 'dynamics-unavailable';
+export interface UrdfInspectionSnapshot {
+    readonly revision: number;
+    readonly kind: 'urdf';
+    readonly robotName: string;
+    readonly sourcePath: string;
+    readonly sourceText: string;
+    readonly nodes: readonly UrdfInspectionNode[];
+    readonly rootEntityId: string;
+    readonly selectedEntityId: string | null;
+    readonly jointValues: Readonly<Record<string, number>>;
+    readonly overlays: UrdfInspectionOverlays;
+    readonly issues: readonly UrdfInspectionIssue[];
+    readonly mode: UrdfInspectionMode;
+    readonly dynamicsAvailable: boolean;
+    readonly dynamicsMessage?: string;
+}
+export interface UrdfInspection {
+    readonly kind: 'urdf';
+    getSnapshot(): UrdfInspectionSnapshot;
+    subscribe(listener: (snapshot: UrdfInspectionSnapshot) => void): () => void;
+    select(entityId: string | null): void;
+    setJointValue(jointId: string, value: number): void;
+    resetJoint(jointId: string): void;
+    resetPose(): void;
+    setOverlay(name: keyof UrdfInspectionOverlays, visible: boolean): void;
+    enterKinematicPreview(): void;
+    jointWorldFrame?(jointId: string): {
+        position: import('three').Vector3;
+        axis: import('three').Vector3;
+    } | null;
+    pickRoots?(): readonly import('three').Object3D[];
+}
+/** Tagged inspection surface. Future formats can extend this union without changing AssetPreview. */
+export type AssetInspection = UrdfInspection;

package/dist/{mjcf-visual--X39MVO9.js → mjcf-visual-M1lmyjvw.js}

@@ -1,5 +1,5 @@
 import { Group as A, Euler as C, BoxGeometry as E, SphereGeometry as F, CylinderGeometry as x, CapsuleGeometry as J, PlaneGeometry as q, MeshStandardMaterial as G, Mesh as z } from "three";
-import { d as S } from "./stage-BKqg5vNe.js";
+import { d as S } from "./stage-D113SHD8.js";
 function v(d) {
   const f = d.extension.documents, l = new A();
   l.name = d.name;

package/dist/mujoco-runtime-C29PXDOl.js

@@ -0,0 +1,258 @@
+var M = Object.defineProperty;
+var O = (l, t, i) => t in l ? M(l, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : l[t] = i;
+var _ = (l, t, i) => O(l, typeof t != "symbol" ? t + "" : t, i);
+import I from "@mujoco/mujoco";
+import T from "@mujoco/mujoco/mujoco.wasm?url";
+let v = 0;
+function G(l, t) {
+  const i = `/viewer-simulation-${++v}`;
+  l.mkdir(i);
+  const n = /* @__PURE__ */ new Set([i]), o = /* @__PURE__ */ new Set(), a = (e, s) => {
+    const m = e.replaceAll("\\", "/").split("/");
+    if (m[0] === "" || m.some((d) => d === ".." || d.includes(":"))) throw p(`Invalid package path: ${e}`, "E_SIMULATION_PATH");
+    const h = m.filter((d) => d && d !== ".");
+    if (!h.length) throw p("Package path is empty.", "E_SIMULATION_PATH");
+    let c = i;
+    for (const d of h.slice(0, -1))
+      c += `/${d}`, n.has(c) || (l.mkdir(c), n.add(c));
+    const u = `${i}/${h.join("/")}`;
+    return l.writeFile(u, s), o.add(u), u;
+  }, r = () => {
+    for (const e of o) l.unlink(e);
+    o.clear();
+    for (const e of [...n].reverse()) l.rmdir(e);
+    n.clear();
+  };
+  try {
+    for (const [e, s] of t) a(e, s);
+    return { writeEntry: (e) => a("__viewer_entry.xml", e), dispose: r };
+  } catch (e) {
+    throw r(), e;
+  }
+}
+function p(l, t) {
+  return Object.assign(new Error(l), { code: t });
+}
+function w({
+  target: l,
+  point: t,
+  velocity: i,
+  stiffness: n,
+  damping: o,
+  maxForce: a,
+  strength: r
+}) {
+  const e = [
+    n * (l[0] - t[0]) - o * i[0],
+    n * (l[1] - t[1]) - o * i[1],
+    n * (l[2] - t[2]) - o * i[2]
+  ], s = Math.hypot(e[0], e[1], e[2]), m = a * r;
+  if (s > m && s > 0) {
+    const h = m / s;
+    e[0] *= h, e[1] *= h, e[2] *= h;
+  }
+  return e;
+}
+const g = 1 / 240, F = 0.05, x = 80, J = 1.15, b = 3.5, y = 14;
+class S {
+  constructor() {
+    _(this, "mujoco", null);
+    _(this, "model", null);
+    _(this, "data", null);
+    _(this, "grab", null);
+    _(this, "lastGrabForce", [0, 0, 0]);
+    _(this, "velocityBuffer", new Float64Array(6));
+    _(this, "initialControls", []);
+    _(this, "accumulator", 0);
+    _(this, "initialGround", null);
+    _(this, "initialVelocities", []);
+  }
+  async initialize(t, i) {
+    var e;
+    this.mujoco ?? (this.mujoco = await I({ locateFile: (s) => s.endsWith(".wasm") ? i ? new URL(s, i).href : T : s }));
+    const n = G(this.mujoco.FS, t.files);
+    let o = null, a = null;
+    try {
+      o = this.mujoco.MjModel.from_xml_path(n.writeEntry(t.xml));
+      for (const s of t.massOverrides ?? []) {
+        const m = this.mujoco.mj_name2id(o, this.mujoco.mjtObj.mjOBJ_BODY.value, s.body);
+        if (m <= 0 || !Number.isFinite(s.mass) || s.mass <= 0 || !(o.body_mass[m] > 0)) throw new Error(`Invalid mass override: ${s.body}`);
+        const h = s.mass / o.body_mass[m];
+        o.body_mass[m] = s.mass;
+        for (let c = 0; c < 3; c++) o.body_inertia[m * 3 + c] *= h;
+      }
+      a = new this.mujoco.MjData(o), (e = t.massOverrides) != null && e.length && this.mujoco.mj_setConst(o, a), o.opt.timestep = g, this.applyInitialControls(a, t.initialControls), this.applyInitialVelocities(o, a, t.initialVelocities), this.mujoco.mj_forward(o, a), this.seatDefaultGround(o, a);
+    } catch (s) {
+      throw a == null || a.delete(), o == null || o.delete(), f(s, "E_MUJOCO_INITIALIZE");
+    } finally {
+      n.dispose();
+    }
+    this.disposeModel(), this.model = o, this.data = a, this.initialControls = t.initialControls ?? [], this.initialVelocities = t.initialVelocities ?? [], this.accumulator = 0;
+    const r = this.mujoco.mj_name2id(o, this.mujoco.mjtObj.mjOBJ_GEOM.value, "__viewer_default_ground__");
+    this.initialGround = r < 0 ? null : { id: r, height: o.geom_pos[r * 3 + 2], sameFrame: o.geom_sameframe[r] };
+  }
+  get defaultGroundHeight() {
+    if (!this.mujoco || !this.model) return;
+    const t = this.mujoco.mj_name2id(this.model, this.mujoco.mjtObj.mjOBJ_GEOM.value, "__viewer_default_ground__");
+    return t < 0 ? void 0 : this.model.geom_pos[t * 3 + 2];
+  }
+  /** Lower only the viewer-owned plane, never authored bodies or authored floors.
+   * Run after forward kinematics, not during stepping (the floor must not follow falling bodies).
+   */
+  seatDefaultGround(t, i) {
+    const n = this.mujoco, o = n.mj_name2id(t, n.mjtObj.mjOBJ_GEOM.value, "__viewer_default_ground__");
+    if (o < 0 || t.geom_bodyid[o] !== 0 || t.geom_type[o] !== n.mjtGeom.mjGEOM_PLANE.value) return;
+    let a = t.geom_pos[o * 3 + 2];
+    for (let r = 0; r < t.ngeom; r++) {
+      if (r === o || t.geom_type[r] === n.mjtGeom.mjGEOM_PLANE.value || !(t.geom_contype[r] & t.geom_conaffinity[o]) && !(t.geom_conaffinity[r] & t.geom_contype[o])) continue;
+      const e = r * 6, s = r * 9, m = i.geom_xmat[s + 6], h = i.geom_xmat[s + 7], c = i.geom_xmat[s + 8], u = i.geom_xpos[r * 3 + 2] + m * t.geom_aabb[e] + h * t.geom_aabb[e + 1] + c * t.geom_aabb[e + 2], d = Math.abs(m) * t.geom_aabb[e + 3] + Math.abs(h) * t.geom_aabb[e + 4] + Math.abs(c) * t.geom_aabb[e + 5], j = u - d, E = Math.max(1e-3, t.geom_margin[r] + t.geom_margin[o]);
+      Number.isFinite(j) && j < a && (a = Math.min(a, j - E));
+    }
+    a !== t.geom_pos[o * 3 + 2] && (t.geom_pos[o * 3 + 2] = a, t.geom_sameframe[o] = 0, n.mj_forward(t, i));
+  }
+  beginGrab({
+    bodyId: t,
+    localPoint: i,
+    target: n,
+    stiffness: o = x,
+    damping: a,
+    maxForce: r,
+    dampingRatio: e = J,
+    maxTargetSpeed: s = b,
+    targetResponse: m = y
+  }) {
+    var j;
+    const h = Math.max(((j = this.model) == null ? void 0 : j.body_mass[t]) ?? 1, 1e-3), c = a ?? 2 * Math.sqrt(o * h) * e, u = r ?? Math.max(120, h * 60), d = [n[0], n[1], n[2]];
+    this.grab = {
+      bodyId: t,
+      localPoint: [i[0], i[1], i[2]],
+      target: [...d],
+      requestedTarget: d,
+      stiffness: o,
+      damping: c,
+      maxForce: u,
+      strength: 1,
+      maxTargetSpeed: s,
+      targetResponse: m
+    };
+  }
+  updateGrabTarget(t) {
+    this.grab && (this.grab.requestedTarget = [t[0], t[1], t[2]]);
+  }
+  updateGrabStrength(t) {
+    this.grab && (this.grab.strength = t);
+  }
+  applyGrabForce() {
+    if (!this.grab || !this.model || !this.data || !this.mujoco) return;
+    const { bodyId: t, localPoint: i, target: n, stiffness: o, damping: a, maxForce: r, strength: e } = this.grab, s = this.data.xmat.subarray(t * 9, t * 9 + 9), m = this.data.xpos.subarray(t * 3, t * 3 + 3), h = [
+      m[0] + s[0] * i[0] + s[1] * i[1] + s[2] * i[2],
+      m[1] + s[3] * i[0] + s[4] * i[1] + s[5] * i[2],
+      m[2] + s[6] * i[0] + s[7] * i[1] + s[8] * i[2]
+    ];
+    this.mujoco.mj_objectVelocity(
+      this.model,
+      this.data,
+      this.mujoco.mjtObj.mjOBJ_BODY.value,
+      t,
+      this.velocityBuffer,
+      0
+    );
+    const c = this.velocityBuffer, u = [
+      h[0] - m[0],
+      h[1] - m[1],
+      h[2] - m[2]
+    ], d = [
+      c[3] + c[1] * u[2] - c[2] * u[1],
+      c[4] + c[2] * u[0] - c[0] * u[2],
+      c[5] + c[0] * u[1] - c[1] * u[0]
+    ], j = w({ target: n, point: h, velocity: d, stiffness: o, damping: a, maxForce: r, strength: e });
+    this.lastGrabForce = [...j], this.data.qfrc_applied.fill(0), this.mujoco.mj_applyFT(
+      this.model,
+      this.data,
+      j,
+      [0, 0, 0],
+      h,
+      t,
+      this.data.qfrc_applied
+    );
+  }
+  endGrab() {
+    this.data && this.data.qfrc_applied.fill(0), this.lastGrabForce = [0, 0, 0], this.grab = null;
+  }
+  step(t) {
+    if (!this.mujoco || !this.model || !this.data || t <= 0) return !1;
+    this.accumulator += Math.min(t, F);
+    let i = !1;
+    for (; this.accumulator >= g; )
+      this.updateGrabTargetForStep(), this.applyGrabForce(), this.mujoco.mj_step(this.model, this.data), this.accumulator -= g, i = !0;
+    return i;
+  }
+  updateGrabTargetForStep() {
+    const t = this.grab;
+    if (!t) return;
+    const i = t.requestedTarget ?? t.target, n = (t.maxTargetSpeed ?? b) * Math.max(1, Math.sqrt(t.strength)), o = t.targetResponse ?? y, a = 1 - Math.exp(-o * g), r = n * g;
+    for (let e = 0; e < 3; e++) {
+      const s = i[e] - t.target[e], m = Math.sign(s) * Math.min(Math.abs(s) * a, r);
+      t.target[e] += m;
+    }
+  }
+  setJointValues(t) {
+    if (!(!this.mujoco || !this.model || !this.data)) {
+      for (const [i, n] of Object.entries(t)) {
+        const o = this.mujoco.mj_name2id(this.model, this.mujoco.mjtObj.mjOBJ_JOINT.value, i);
+        if (o < 0 || !Number.isFinite(n)) continue;
+        const a = this.model.jnt_type[o], r = this.mujoco.mjtJoint.mjJNT_HINGE.value, e = this.mujoco.mjtJoint.mjJNT_SLIDE.value;
+        a !== r && a !== e || (this.data.qpos[this.model.jnt_qposadr[o]] = n);
+      }
+      this.mujoco.mj_forward(this.model, this.data), this.seatDefaultGround(this.model, this.data), this.accumulator = 0;
+    }
+  }
+  getJointValues(t) {
+    const i = {};
+    if (!this.mujoco || !this.model || !this.data) return i;
+    for (const n of t) {
+      const o = this.mujoco.mj_name2id(this.model, this.mujoco.mjtObj.mjOBJ_JOINT.value, n);
+      if (o < 0) continue;
+      const a = this.model.jnt_type[o], r = this.mujoco.mjtJoint.mjJNT_HINGE.value, e = this.mujoco.mjtJoint.mjJNT_SLIDE.value;
+      (a === r || a === e) && (i[n] = this.data.qpos[this.model.jnt_qposadr[o]]);
+    }
+    return i;
+  }
+  reset() {
+    if (!(!this.mujoco || !this.model || !this.data)) {
+      if (this.endGrab(), this.initialGround) {
+        const { id: t, height: i, sameFrame: n } = this.initialGround;
+        this.model.geom_pos[t * 3 + 2] = i, this.model.geom_sameframe[t] = n;
+      }
+      this.mujoco.mj_resetData(this.model, this.data), this.applyInitialControls(this.data, this.initialControls), this.applyInitialVelocities(this.model, this.data, this.initialVelocities), this.mujoco.mj_forward(this.model, this.data), this.accumulator = 0;
+    }
+  }
+  dispose() {
+    this.disposeModel(), this.mujoco = null;
+  }
+  applyInitialControls(t, i) {
+    if (i != null && i.length) {
+      if (i.length !== t.ctrl.length) throw f(new Error(`Initial control count ${i.length} does not match MuJoCo actuator count ${t.ctrl.length}.`), "E_MUJOCO_INITIALIZE");
+      t.ctrl.set(i);
+    }
+  }
+  applyInitialVelocities(t, i, n) {
+    for (const o of n ?? []) {
+      const a = this.mujoco.mj_name2id(t, this.mujoco.mjtObj.mjOBJ_BODY.value, o.body), r = a >= 0 ? t.body_jntadr[a] : -1;
+      if (r < 0 || t.jnt_type[r] !== this.mujoco.mjtJoint.mjJNT_FREE.value || o.velocity.length !== 6 || !o.velocity.every(Number.isFinite))
+        throw f(new Error(`Invalid free-body initial velocity: ${o.body}`), "E_MUJOCO_INITIALIZE");
+      i.qvel.set(o.velocity, t.jnt_dofadr[r]);
+    }
+  }
+  disposeModel() {
+    var t, i;
+    this.endGrab(), (t = this.data) == null || t.delete(), (i = this.model) == null || i.delete(), this.data = null, this.model = null, this.initialGround = null, this.initialControls = [], this.initialVelocities = [], this.accumulator = 0;
+  }
+}
+function f(l, t) {
+  const i = l instanceof Error ? l : new Error(String(l));
+  return Object.assign(i, { code: t });
+}
+export {
+  S as MujocoRuntime
+};

package/dist/plugins.d.ts

@@ -2,6 +2,7 @@ import type { Box3, Object3D } from 'three';
 import type { CadHit, CadSelection, CadViewerSnapshot, CadViewerEventMap } from './cad/types';
 import type { ViewerEventMap, ViewerViewMode, ViewerUiTheme } from './types';
 import type { AssetControlState, AssetLoaderContribution, AssetPreviewSnapshot, AssetUpAxis } from './assets/types';
+import type { AssetInspection } from './inspection/types';
 export interface Disposable {
     dispose(): void;
 }
@@ -27,6 +28,7 @@ export interface ViewerAssetReadApi {
     $read(): AssetPreviewSnapshot | null;
     /** Authoritative control state, safe to bind button pressed states to. */
     $readControl(): AssetControlState;
+    $inspection(): AssetInspection | null;
 }
 export interface ViewerPluginContext {
     readonly cad: {
@@ -112,6 +114,7 @@ type SnapshotReader = () => CadViewerSnapshot;
 type StateReader = () => ViewerState;
 type AssetReader = () => AssetPreviewSnapshot | null;
 type ControlStateReader = () => AssetControlState;
+type InspectionReader = () => AssetInspection | null;
 type PluginEventMap = ViewerEventMap & CadViewerEventMap;
 type EventSubscriber = <K extends keyof PluginEventMap>(type: K, listener: (event: PluginEventMap[K]) => void) => () => void;
 type CommandApi = ViewerPluginContext['commands'];
@@ -137,6 +140,7 @@ export declare class ViewerPluginManager implements ViewerPluginRegistry {
     private readonly commands;
     private readonly hostElement;
     private readonly layout;
+    private readonly readInspection;
     private readonly pluginsById;
     private readonly contributions;
     private readonly commandContributions;
@@ -144,7 +148,7 @@ export declare class ViewerPluginManager implements ViewerPluginRegistry {
     private readonly contributionRemovedListeners;
     private refreshingInspectors;
     private disposed;
-    constructor(readCad: SnapshotReader, readState: StateReader, readAsset: AssetReader, readControlState: ControlStateReader, subscribe: EventSubscriber, commands: CommandApi, hostElement: HTMLElement, layout?: PluginLayoutPort | null);
+    constructor(readCad: SnapshotReader, readState: StateReader, readAsset: AssetReader, readControlState: ControlStateReader, subscribe: EventSubscriber, commands: CommandApi, hostElement: HTMLElement, layout?: PluginLayoutPort | null, readInspection?: InspectionReader);
     register(plugin: ViewerPlugin): Disposable;
     use(plugins: readonly ViewerPlugin[], options?: {
         replace?: boolean;