@vived/component-pneumatic-panel 1.2.0 → 3.0.0

package/dist/index.js

@@ -1,53 +1,1259 @@
-import { M as n, d as s, e as t, f as P, g as l, P as c, h as o, i, j as u, k as m, l as k, m as r, n as g, o as C, p as h, q as E, s as x, t as U, u as p, v as H, w as d, x as y, y as b, z as M, A as T, B as S, D as L, F as A, G as B, H as F, I as v, J as w, K as O, O as R, Q as V, R as f, U as I, V as N, W as _, X as j, Y as G, Z as q, $ as z, a0 as D, a1 as J, a2 as K, a3 as Q, a4 as W, a5 as X, a6 as Y } from "./index-CmNnQLDH.js";
+import { AppObjectEntity as B, MemoizedBoolean as f, MemoizedNumber as S, AppObjectEntityRepo as H, getSingletonComponent as j, generateUniqueID as _, AppObjectUC as k, AppObjectPM as G, AppObjectView as g, DomainFactory as N } from "@vived/core";
+import { getAssetBlobURL as K, BabylonEntity as z } from "@vived/app";
+import { Color3 as F, ActionManager as r, ExecuteCodeAction as y, Animation as d, CubicEase as W, EasingFunction as R, Material as D, LoadAssetContainerAsync as $ } from "@babylonjs/core";
+class c extends B {
+  static type = "PneumaticPanelEntity";
+  /**
+   * Retrieves the entity from an AppObject
+   */
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+  /**
+   * Retrieves the entity by AppObject ID
+   */
+  static getById(e, t) {
+    return t.get(e)?.getComponent(this.type);
+  }
+}
+function I(n) {
+  return new q(n);
+}
+class q extends c {
+  memoizedExhaustOpen = new f(!1, this.notifyOnChange);
+  memoizedIsLocked = new f(!1, this.notifyOnChange);
+  memoizedPressure = new S(60, this.notifyOnChange);
+  memoizedShowGhostLockHint = new f(
+    !1,
+    this.notifyOnChange
+  );
+  memoizedPanelHitboxEnabled = new f(
+    !1,
+    this.notifyOnChange
+  );
+  get exhaustOpen() {
+    return this.memoizedExhaustOpen.val;
+  }
+  set exhaustOpen(e) {
+    this.memoizedExhaustOpen.val = e;
+  }
+  get isLocked() {
+    return this.memoizedIsLocked.val;
+  }
+  set isLocked(e) {
+    this.memoizedIsLocked.val = e;
+  }
+  get pressure() {
+    return this.memoizedPressure.val;
+  }
+  set pressure(e) {
+    this.memoizedPressure.val = e;
+  }
+  get showGhostLockHint() {
+    return this.memoizedShowGhostLockHint.val;
+  }
+  set showGhostLockHint(e) {
+    this.memoizedShowGhostLockHint.val = e;
+  }
+  get panelHitboxEnabled() {
+    return this.memoizedPanelHitboxEnabled.val;
+  }
+  set panelHitboxEnabled(e) {
+    this.memoizedPanelHitboxEnabled.val = e;
+  }
+  constructor(e) {
+    super(e, c.type);
+  }
+}
+class P extends H {
+  static type = "PneumaticPanelRepo";
+  /**
+   * Global accessor for the singleton repository
+   */
+  static get(e) {
+    return j(
+      P.type,
+      e
+    );
+  }
+}
+function Q(n) {
+  return new Y(n);
+}
+class Y extends P {
+  pneumaticPanelEntityFactory = (e) => {
+    const t = this.appObjects.getOrCreate(e);
+    return I(t);
+  };
+  createPneumaticPanelEntity(e) {
+    const t = e ?? _(), s = this.getForAppObject(t);
+    if (s)
+      return s;
+    const i = this.pneumaticPanelEntityFactory(t);
+    return this.add(i), i;
+  }
+  deletePneumaticPanelEntity(e) {
+    const t = this.getForAppObject(e);
+    if (!t) {
+      this.warn(`Cannot delete: entity with id '${e}' not found`);
+      return;
+    }
+    t.appObject.dispose(), this.removeForAppObject(e);
+  }
+  constructor(e) {
+    super(e, P.type);
+  }
+}
+class l extends k {
+  static type = "PneumaticPanelToggleExhaustUC";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+  static getById(e, t) {
+    return t.get(e)?.getComponent(this.type);
+  }
+}
+function J(n) {
+  return new X(n);
+}
+class X extends l {
+  _maxPressure = 60;
+  onExhaustOpenedCallbacks = /* @__PURE__ */ new Set();
+  onExhaustClosedCallbacks = /* @__PURE__ */ new Set();
+  onExhaustCloseBlockedByLockCallbacks = /* @__PURE__ */ new Set();
+  get entity() {
+    try {
+      return this.getCachedLocalComponent(
+        c.type
+      );
+    } catch {
+      return;
+    }
+  }
+  get maxPressure() {
+    return this._maxPressure;
+  }
+  set maxPressure(e) {
+    this._maxPressure = e;
+  }
+  toggleExhaust() {
+    const e = this.entity;
+    return e ? e.isLocked ? (e.exhaustOpen && this.notifyCallbacks(
+      this.onExhaustCloseBlockedByLockCallbacks,
+      "onExhaustCloseBlockedByLock callback"
+    ), !1) : (e.exhaustOpen = !e.exhaustOpen, e.pressure = e.exhaustOpen ? 0 : this._maxPressure, e.exhaustOpen ? this.notifyCallbacks(
+      this.onExhaustOpenedCallbacks,
+      "onExhaustOpened callback"
+    ) : this.notifyCallbacks(
+      this.onExhaustClosedCallbacks,
+      "onExhaustClosed callback"
+    ), !0) : (this.warn("Missing PneumaticPanelEntity"), !1);
+  }
+  subscribeOnExhaustOpened(e) {
+    return this.onExhaustOpenedCallbacks.add(e), () => {
+      this.onExhaustOpenedCallbacks.delete(e);
+    };
+  }
+  subscribeOnExhaustClosed(e) {
+    return this.onExhaustClosedCallbacks.add(e), () => {
+      this.onExhaustClosedCallbacks.delete(e);
+    };
+  }
+  subscribeOnExhaustCloseBlockedByLock(e) {
+    return this.onExhaustCloseBlockedByLockCallbacks.add(e), () => {
+      this.onExhaustCloseBlockedByLockCallbacks.delete(e);
+    };
+  }
+  notifyCallbacks(e, t) {
+    for (const s of e)
+      try {
+        s();
+      } catch {
+        this.warn(`${t} threw an error`);
+      }
+  }
+  constructor(e) {
+    super(e, l.type);
+  }
+}
+class h extends k {
+  static type = "PneumaticPanelToggleLockUC";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+  static getById(e, t) {
+    return t.get(e)?.getComponent(this.type);
+  }
+}
+function Z(n) {
+  return new ee(n);
+}
+class ee extends h {
+  onPanelLockedCallbacks = /* @__PURE__ */ new Set();
+  onPanelUnlockedCallbacks = /* @__PURE__ */ new Set();
+  get entity() {
+    try {
+      return this.getCachedLocalComponent(
+        c.type
+      );
+    } catch {
+      return;
+    }
+  }
+  toggleLock() {
+    const e = this.entity;
+    return e ? e.isLocked ? (e.isLocked = !1, this.notifyCallbacks(
+      this.onPanelUnlockedCallbacks,
+      "onPanelUnlocked callback"
+    ), !0) : e.exhaustOpen ? (e.isLocked = !0, this.notifyCallbacks(this.onPanelLockedCallbacks, "onPanelLocked callback"), !0) : !1 : (this.warn("Missing PneumaticPanelEntity"), !1);
+  }
+  subscribeOnPanelLocked(e) {
+    return this.onPanelLockedCallbacks.add(e), () => {
+      this.onPanelLockedCallbacks.delete(e);
+    };
+  }
+  subscribeOnPanelUnlocked(e) {
+    return this.onPanelUnlockedCallbacks.add(e), () => {
+      this.onPanelUnlockedCallbacks.delete(e);
+    };
+  }
+  notifyCallbacks(e, t) {
+    for (const s of e)
+      try {
+        s();
+      } catch {
+        this.warn(`${t} threw an error`);
+      }
+  }
+  constructor(e) {
+    super(e, h.type);
+  }
+}
+class b extends k {
+  static type = "PneumaticPanelCheckPressureUC";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+  static getById(e, t) {
+    return t.get(e)?.getComponent(this.type);
+  }
+}
+function te(n) {
+  return new ne(n);
+}
+class ne extends b {
+  onCheckPressureCallbacks = /* @__PURE__ */ new Set();
+  checkPressure() {
+    this.notifyCallbacks(
+      this.onCheckPressureCallbacks,
+      "onCheckPressure callback"
+    );
+  }
+  subscribeOnCheckPressure(e) {
+    return this.onCheckPressureCallbacks.add(e), () => {
+      this.onCheckPressureCallbacks.delete(e);
+    };
+  }
+  notifyCallbacks(e, t) {
+    for (const s of e)
+      try {
+        s();
+      } catch {
+        this.warn(`${t} threw an error`);
+      }
+  }
+  constructor(e) {
+    super(e, b.type);
+  }
+}
+class u extends k {
+  static type = "PneumaticPanelSelectUC";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+  static getById(e, t) {
+    return t.get(e)?.getComponent(this.type);
+  }
+}
+function se(n) {
+  return new ie(n);
+}
+class ie extends u {
+  onPanelSelectedCallbacks = /* @__PURE__ */ new Set();
+  get entity() {
+    try {
+      return this.getCachedLocalComponent(
+        c.type
+      );
+    } catch {
+      return;
+    }
+  }
+  enableHitbox() {
+    const e = this.entity;
+    if (!e) {
+      this.warn("Missing PneumaticPanelEntity");
+      return;
+    }
+    e.panelHitboxEnabled = !0;
+  }
+  disableHitbox() {
+    const e = this.entity;
+    if (!e) {
+      this.warn("Missing PneumaticPanelEntity");
+      return;
+    }
+    e.panelHitboxEnabled = !1;
+  }
+  subscribeOnPanelSelected(e) {
+    return this.onPanelSelectedCallbacks.add(e), () => {
+      this.onPanelSelectedCallbacks.delete(e);
+    };
+  }
+  notifyPanelSelected() {
+    for (const e of this.onPanelSelectedCallbacks)
+      try {
+        e();
+      } catch {
+        this.warn("onPanelSelected callback threw an error");
+      }
+  }
+  constructor(e) {
+    super(e, u.type);
+  }
+}
+function V(n, e) {
+  const t = l.getById(n, e);
+  return t ? t.toggleExhaust() : (e.submitWarning(
+    "tryToggleExhaust",
+    "Unable to find PneumaticPanelToggleExhaustUC"
+  ), !1);
+}
+function U(n, e) {
+  const t = h.getById(n, e);
+  return t ? t.toggleLock() : (e.submitWarning(
+    "tryToggleLock",
+    "Unable to find PneumaticPanelToggleLockUC"
+  ), !1);
+}
+function A(n, e) {
+  const t = b.getById(n, e);
+  if (!t) {
+    e.submitWarning(
+      "checkPressure",
+      "Unable to find PneumaticPanelCheckPressureUC"
+    );
+    return;
+  }
+  t.checkPressure();
+}
+function ae(n, e, t) {
+  const s = c.getById(n, e);
+  if (!s) {
+    e.submitWarning(
+      "setShowGhostLockHint",
+      "Unable to find PneumaticPanelEntity"
+    );
+    return;
+  }
+  s.showGhostLockHint = t;
+}
+const m = {
+  exhaustOpen: !1,
+  isLocked: !1,
+  showGhostLockHint: !1,
+  panelHitboxEnabled: !1
+};
+function oe(n, e, t) {
+  const s = c.getById(n, e);
+  return s ? {
+    version: t,
+    exhaustOpen: s.exhaustOpen,
+    isLocked: s.isLocked,
+    showGhostLockHint: s.showGhostLockHint,
+    panelHitboxEnabled: s.panelHitboxEnabled
+  } : (e.submitWarning(
+    "getPanelState",
+    "Unable to find PneumaticPanelEntity"
+  ), {
+    version: t,
+    ...m
+  });
+}
+function ce(n, e, t) {
+  const s = c.getById(n, e);
+  if (!s) {
+    e.submitWarning(
+      "applyPanelState",
+      "Unable to find PneumaticPanelEntity"
+    );
+    return;
+  }
+  s.exhaustOpen = t.exhaustOpen ?? m.exhaustOpen, s.isLocked = t.isLocked ?? m.isLocked, s.showGhostLockHint = t.showGhostLockHint ?? m.showGhostLockHint, s.panelHitboxEnabled = t.panelHitboxEnabled ?? m.panelHitboxEnabled;
+}
+function re(n, e, t) {
+  const s = l.getById(n, e);
+  return s ? s.subscribeOnExhaustOpened(t) : (e.submitWarning(
+    "onExhaustOpened",
+    "Unable to find PneumaticPanelToggleExhaustUC"
+  ), () => {
+  });
+}
+function le(n, e, t) {
+  const s = l.getById(n, e);
+  return s ? s.subscribeOnExhaustClosed(t) : (e.submitWarning(
+    "onExhaustClosed",
+    "Unable to find PneumaticPanelToggleExhaustUC"
+  ), () => {
+  });
+}
+function ue(n, e, t) {
+  const s = l.getById(n, e);
+  return s ? s.subscribeOnExhaustCloseBlockedByLock(t) : (e.submitWarning(
+    "onExhaustCloseBlockedByLock",
+    "Unable to find PneumaticPanelToggleExhaustUC"
+  ), () => {
+  });
+}
+function he(n, e, t) {
+  const s = h.getById(n, e);
+  return s ? s.subscribeOnPanelLocked(t) : (e.submitWarning(
+    "onPanelLocked",
+    "Unable to find PneumaticPanelToggleLockUC"
+  ), () => {
+  });
+}
+function de(n, e, t) {
+  const s = h.getById(n, e);
+  return s ? s.subscribeOnPanelUnlocked(t) : (e.submitWarning(
+    "onPanelUnlocked",
+    "Unable to find PneumaticPanelToggleLockUC"
+  ), () => {
+  });
+}
+function be(n, e) {
+  const t = u.getById(n, e);
+  if (!t) {
+    e.submitWarning(
+      "enablePanelHitbox",
+      "Unable to find PneumaticPanelSelectUC"
+    );
+    return;
+  }
+  t.enableHitbox();
+}
+function pe(n, e) {
+  const t = u.getById(n, e);
+  if (!t) {
+    e.submitWarning(
+      "disablePanelHitbox",
+      "Unable to find PneumaticPanelSelectUC"
+    );
+    return;
+  }
+  t.disableHitbox();
+}
+function me(n, e, t) {
+  const s = u.getById(n, e);
+  return s ? s.subscribeOnPanelSelected(t) : (e.submitWarning(
+    "onPanelSelected",
+    "Unable to find PneumaticPanelSelectUC"
+  ), () => {
+  });
+}
+function Pe(n, e, t) {
+  const s = b.getById(n, e);
+  return s ? s.subscribeOnCheckPressure(t) : (e.submitWarning(
+    "onCheckPressure",
+    "Unable to find PneumaticPanelCheckPressureUC"
+  ), () => {
+  });
+}
+function ge(n, e) {
+  const t = u.getById(n, e);
+  if (!t) {
+    e.submitWarning(
+      "panelHitboxClicked",
+      "Unable to find PneumaticPanelSelectUC"
+    );
+    return;
+  }
+  t.notifyPanelSelected();
+}
+class p extends G {
+  static type = "PneumaticPanelPM";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+  static getById(e, t) {
+    return t.get(e)?.getComponent(this.type);
+  }
+}
+function fe(n) {
+  return new ke(n);
+}
+class ke extends p {
+  get entity() {
+    return this.getCachedLocalComponent(
+      c.type
+    );
+  }
+  vmsAreEqual(e, t) {
+    return e.exhaustOpen === t.exhaustOpen && e.isLocked === t.isLocked && e.pressure === t.pressure && e.showGhostLockHint === t.showGhostLockHint && e.panelHitboxEnabled === t.panelHitboxEnabled && e.subComponentsInteractive === t.subComponentsInteractive;
+  }
+  onEntityChange = () => {
+    const e = this.entity;
+    e && this.doUpdateView({
+      exhaustOpen: e.exhaustOpen,
+      isLocked: e.isLocked,
+      pressure: e.pressure,
+      showGhostLockHint: e.showGhostLockHint,
+      panelHitboxEnabled: e.panelHitboxEnabled,
+      subComponentsInteractive: !e.panelHitboxEnabled
+    });
+  };
+  constructor(e) {
+    super(e, p.type), this.entity?.addChangeObserver(this.onEntityChange), this.onEntityChange();
+  }
+}
+const o = {
+  defaultVM: {
+    exhaustOpen: !1,
+    isLocked: !1,
+    pressure: 60,
+    showGhostLockHint: !1,
+    panelHitboxEnabled: !1,
+    subComponentsInteractive: !0
+  },
+  subscribe: (n, e, t) => {
+    if (!n) return;
+    const s = p.getById(n, e);
+    if (!s) {
+      e.submitWarning(
+        "pneumaticPanelPMAdapter",
+        "Unable to find PneumaticPanelPM"
+      );
+      return;
+    }
+    s.addView(t);
+  },
+  unsubscribe: (n, e, t) => {
+    if (!n) return;
+    const s = p.getById(n, e);
+    s && s.removeView(t);
+  }
+}, ye = {
+  /** Machine-friendly name (used in package name, imports) */
+  name: "PneumaticPanel",
+  /** Human-friendly display name */
+  displayName: "Pneumatic Panel",
+  /** Semantic version */
+  version: "0.1.0",
+  /** Whether multiple instances can exist in a scene */
+  multiInstance: !0,
+  /** 3D asset files to include in the build */
+  assets: [
+    {
+      name: "default",
+      id: "db90a1dd-8cb9-4f56-954d-7a72610281a7",
+      file: "pneumaticPanel.glb"
+    }
+  ]
+}, xe = "lock", Ce = "ghost_lock";
+class x extends g {
+  static type = "PneumaticPanelLockView";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+}
+function we(n) {
+  return new Me(n);
+}
+class Me extends x {
+  lockTransform;
+  ghostLockMesh;
+  currentVM = o.defaultVM;
+  flashTimer;
+  bindMeshes(e) {
+    this.lockTransform = this.resolveLockTransform(e), this.ghostLockMesh = this.resolveGhostLockMesh(e), this.lockTransform || this.warn("Unable to find lock transform from provided nodes"), this.ghostLockMesh || this.warn("Unable to find ghost lock mesh from provided nodes"), this.bindClickActionsOnLockChildren(), this.bindClickAction(this.ghostLockMesh), this.applyMeshes();
+  }
+  applyView = (e) => {
+    this.currentVM = e, this.applyMeshes();
+  };
+  applyMeshes() {
+    this.setLockVisible(this.currentVM.isLocked), this.setGhostLockVisible(this.shouldShowGhostLock());
+  }
+  flash() {
+    if (!this.lockTransform) return;
+    this.flashTimer !== void 0 && clearTimeout(this.flashTimer);
+    const e = this.lockTransform.getChildMeshes(!1);
+    for (const t of e)
+      t.overlayColor = new F(1, 0, 0), t.overlayAlpha = 0.3, t.renderOverlay = !0;
+    this.flashTimer = setTimeout(() => {
+      this.flashTimer = void 0;
+      for (const t of e)
+        t.renderOverlay = !1;
+    }, 400);
+  }
+  shouldShowGhostLock() {
+    return this.currentVM.exhaustOpen && !this.currentVM.isLocked;
+  }
+  setLockVisible(e) {
+    if (this.lockTransform) {
+      this.lockTransform.setEnabled(e);
+      for (const t of this.lockTransform.getChildMeshes(!1))
+        t.isPickable = e && this.currentVM.subComponentsInteractive, t.setEnabled(e);
+    }
+  }
+  /**
+   * Ghost lock visibility is driven by authored domain state only. The mesh
+   * stays enabled and pickable so the Host can reach it via
+   * `highlightGroupsByObjectId` and reveal it on hover itself (ADR-0010).
+   */
+  setGhostLockVisible(e) {
+    this.ghostLockMesh && (this.ghostLockMesh.setEnabled(e), this.ghostLockMesh.isPickable = e && this.currentVM.subComponentsInteractive, this.ghostLockMesh.visibility = e && this.currentVM.showGhostLockHint ? 1 : 0);
+  }
+  bindClickActionsOnLockChildren() {
+    if (this.lockTransform)
+      for (const e of this.lockTransform.getChildMeshes(!1))
+        this.bindClickAction(e);
+  }
+  bindClickAction(e) {
+    if (!e) return;
+    const t = e.getScene();
+    if (!t) {
+      this.warn("Unable to wire lock mesh without a scene");
+      return;
+    }
+    e.isPickable = !0, e.actionManager ??= new r(t), e.actionManager.registerAction(
+      new y(r.OnPickTrigger, () => {
+        U(this.appObject.id, this.appObjects);
+      })
+    );
+  }
+  resolveLockTransform(e) {
+    const t = e.get(xe), s = t?.getClassName();
+    if (!(!t || s !== "TransformNode" && s !== "Mesh"))
+      return t;
+  }
+  resolveGhostLockMesh(e) {
+    const t = e.get(Ce);
+    if (t)
+      return t;
+  }
+  dispose() {
+    this.flashTimer !== void 0 && clearTimeout(this.flashTimer), o.unsubscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    ), super.dispose();
+  }
+  constructor(e) {
+    super(e, x.type), o.subscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    );
+  }
+}
+const Oe = "exhaust_knob";
+class M extends g {
+  static type = "PneumaticPanelExhaustView";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+}
+function Ee(n) {
+  return new Le(n);
+}
+class Le extends M {
+  exhaustKnobMesh;
+  currentVM = o.defaultVM;
+  currentAnimation;
+  bindMeshes(e) {
+    this.exhaustKnobMesh = e.get(
+      Oe
+    ), this.exhaustKnobMesh || this.warn("Unable to find exhaust knob mesh from provided nodes"), this.exhaustKnobMesh?.rotationQuaternion && (this.exhaustKnobMesh.rotationQuaternion = null), this.bindClickAction(this.exhaustKnobMesh), this.exhaustKnobMesh && (this.exhaustKnobMesh.isPickable = this.currentVM.subComponentsInteractive), this.snapKnobRotation(this.currentVM.exhaustOpen);
+  }
+  applyView = (e) => {
+    const t = this.currentVM;
+    this.currentVM = e, this.animateKnobRotation(this.currentVM.exhaustOpen), e.subComponentsInteractive !== t.subComponentsInteractive && this.exhaustKnobMesh && (this.exhaustKnobMesh.isPickable = e.subComponentsInteractive);
+  };
+  snapKnobRotation(e) {
+    this.exhaustKnobMesh && (this.exhaustKnobMesh.rotation.z = e ? -Math.PI / 2 : 0);
+  }
+  animateKnobRotation(e) {
+    if (!this.exhaustKnobMesh) return;
+    const t = e ? -Math.PI / 2 : 0;
+    if (Math.abs(this.exhaustKnobMesh.rotation.z - t) < 1e-3) return;
+    this.stopCurrentAnimation();
+    const s = this.exhaustKnobMesh.getScene();
+    if (!s) {
+      this.exhaustKnobMesh.rotation.z = t;
+      return;
+    }
+    const i = new d(
+      "exhaustKnobRotation",
+      "rotation.z",
+      60,
+      d.ANIMATIONTYPE_FLOAT,
+      d.ANIMATIONLOOPMODE_CONSTANT
+    ), a = new W();
+    a.setEasingMode(R.EASINGMODE_EASEINOUT), i.setEasingFunction(a), i.setKeys([
+      { frame: 0, value: this.exhaustKnobMesh.rotation.z },
+      { frame: 15, value: t }
+    ]), this.currentAnimation = s.beginDirectAnimation(
+      this.exhaustKnobMesh,
+      [i],
+      0,
+      15,
+      !1
+    );
+  }
+  shakeKnob() {
+    if (!this.exhaustKnobMesh) return;
+    const e = this.exhaustKnobMesh.getScene();
+    if (!e) return;
+    this.stopCurrentAnimation();
+    const t = this.currentVM.exhaustOpen ? -Math.PI / 2 : 0, s = Math.PI / 36, i = new d(
+      "exhaustKnobShake",
+      "rotation.z",
+      60,
+      d.ANIMATIONTYPE_FLOAT,
+      d.ANIMATIONLOOPMODE_CONSTANT
+    );
+    i.setKeys([
+      { frame: 0, value: t },
+      { frame: 4, value: t + s },
+      { frame: 12, value: t - s },
+      { frame: 18, value: t + s * 0.6 },
+      { frame: 22, value: t - s * 0.6 },
+      { frame: 26, value: t }
+    ]), this.currentAnimation = e.beginDirectAnimation(
+      this.exhaustKnobMesh,
+      [i],
+      0,
+      26,
+      !1
+    );
+  }
+  stopCurrentAnimation() {
+    this.currentAnimation && (this.currentAnimation.stop(), this.currentAnimation = void 0);
+  }
+  bindClickAction(e) {
+    if (!e) return;
+    const t = e.getScene();
+    if (!t) {
+      this.warn("Unable to wire exhaust knob mesh without a scene");
+      return;
+    }
+    e.isPickable = !0, e.actionManager ??= new r(t), e.actionManager.registerAction(
+      new y(r.OnPickTrigger, () => {
+        V(this.appObject.id, this.appObjects) || (this.shakeKnob(), x.get(this.appObject)?.flash());
+      })
+    );
+  }
+  dispose() {
+    this.stopCurrentAnimation(), o.unsubscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    ), super.dispose();
+  }
+  constructor(e) {
+    super(e, M.type), o.subscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    );
+  }
+}
+const Ie = "gauge";
+class O extends g {
+  static type = "PneumaticPanelGaugeView";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+}
+function Ve(n) {
+  return new Ue(n);
+}
+class Ue extends O {
+  gaugeMesh;
+  currentVM = o.defaultVM;
+  bindMeshes(e) {
+    this.gaugeMesh = e.get(Ie), this.gaugeMesh || this.warn("Unable to find gauge mesh from provided nodes"), this.bindClickAction(this.gaugeMesh), this.gaugeMesh && (this.gaugeMesh.isPickable = this.currentVM.subComponentsInteractive);
+  }
+  applyView = (e) => {
+    const t = this.currentVM;
+    this.currentVM = e, e.subComponentsInteractive !== t.subComponentsInteractive && this.gaugeMesh && (this.gaugeMesh.isPickable = e.subComponentsInteractive);
+  };
+  bindClickAction(e) {
+    if (!e) return;
+    const t = e.getScene();
+    if (!t) {
+      this.warn("Unable to wire gauge mesh without a scene");
+      return;
+    }
+    e.isPickable = !0, e.actionManager ??= new r(t), e.actionManager.registerAction(
+      new y(r.OnPickTrigger, () => {
+        A(this.appObject.id, this.appObjects);
+      })
+    );
+  }
+  constructor(e) {
+    super(e, O.type), o.subscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    );
+  }
+  dispose() {
+    o.unsubscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    ), super.dispose();
+  }
+}
+const Ae = "panel_hitbox";
+class E extends g {
+  static type = "PneumaticPanelHitboxView";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+}
+function ve(n) {
+  return new Te(n);
+}
+class Te extends E {
+  hitboxMesh;
+  currentVM = o.defaultVM;
+  bindMeshes(e) {
+    if (this.hitboxMesh = e.get(Ae), !this.hitboxMesh) {
+      this.warn("Unable to find panel hitbox mesh from provided nodes");
+      return;
+    }
+    const t = this.hitboxMesh.material;
+    t && (t.transparencyMode = D.MATERIAL_ALPHABLEND, t.alpha = 0), this.hitboxMesh.visibility = 0, this.hitboxMesh.isPickable = this.currentVM.panelHitboxEnabled, this.bindActions(this.hitboxMesh);
+  }
+  applyView = (e) => {
+    const t = this.currentVM;
+    this.currentVM = e, e.panelHitboxEnabled !== t.panelHitboxEnabled && this.hitboxMesh && (this.hitboxMesh.isPickable = e.panelHitboxEnabled);
+  };
+  bindActions(e) {
+    const t = e.getScene();
+    if (!t) {
+      this.warn("Unable to wire hitbox mesh without a scene");
+      return;
+    }
+    e.actionManager ??= new r(t), e.actionManager.registerAction(
+      new y(r.OnPickTrigger, () => {
+        ge(this.appObject.id, this.appObjects);
+      })
+    );
+  }
+  constructor(e) {
+    super(e, E.type), o.subscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    );
+  }
+  dispose() {
+    o.unsubscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    ), super.dispose();
+  }
+}
+let L = /* @__PURE__ */ new WeakMap();
+function Be(n) {
+  let e = L.get(n);
+  return e || (e = /* @__PURE__ */ new Map(), L.set(n, e)), e;
+}
+async function Se(n, e, t) {
+  const s = Be(n);
+  let i = s.get(t);
+  i || (i = K(t, e).then(
+    (a) => $(a, n, {
+      pluginExtension: ".glb"
+    })
+  ), s.set(t, i));
+  try {
+    return await i;
+  } catch (a) {
+    throw s.delete(t), a;
+  }
+}
+class C extends g {
+  static type = "PneumaticPanelBabylonView";
+  static get(e) {
+    return e.getComponent(this.type);
+  }
+}
+function v(n) {
+  return new He(n);
+}
+class He extends C {
+  lockView;
+  exhaustView;
+  gaugeView;
+  hitboxView;
+  meshes = [];
+  _nodesByObjectId = /* @__PURE__ */ new Map();
+  _highlightGroupsByObjectId = /* @__PURE__ */ new Map();
+  instantiatedEntries;
+  _rootTransformNode;
+  loadPromise;
+  async load() {
+    this.meshes.length > 0 || (this.loadPromise || (this.loadPromise = this.loadInternal().catch((e) => {
+      throw this.loadPromise = void 0, e;
+    })), await this.loadPromise);
+  }
+  async loadInternal() {
+    const e = this.getScene(), t = ye.assets[0]?.id;
+    if (!t) {
+      this.appObjects.submitError(
+        "PneumaticPanelBabylonView.load",
+        "Missing PneumaticPanel default asset configuration"
+      );
+      return;
+    }
+    const s = await Se(
+      e,
+      this.appObjects,
+      t
+    );
+    this.instantiatedEntries = s.instantiateModelsToScene(
+      (a) => a
+    ), this._rootTransformNode = this.instantiatedEntries.rootNodes[0], this.meshes = this.collectMeshesFromRoots(
+      this.instantiatedEntries.rootNodes
+    ), this._nodesByObjectId = this.buildNodeLookup(
+      this.instantiatedEntries.rootNodes
+    );
+    const i = this.meshes.filter(
+      (a) => a.metadata?.gltf?.extras?.objectId?.toLowerCase() !== "panel_hitbox"
+    );
+    this._highlightGroupsByObjectId = this.buildHighlightGroups(
+      this._nodesByObjectId,
+      i
+    ), this.lockView.bindMeshes(this._nodesByObjectId), this.exhaustView.bindMeshes(this._nodesByObjectId), this.gaugeView.bindMeshes(this._nodesByObjectId), this.hitboxView.bindMeshes(this._nodesByObjectId);
+  }
+  buildHighlightGroups(e, t) {
+    const s = /* @__PURE__ */ new Map();
+    s.set("panel_hitbox", t);
+    for (const [i, a] of e)
+      i !== "panel_hitbox" && a.getClassName() === "Mesh" && s.set(i, [a]);
+    return s;
+  }
+  buildNodeLookup(e) {
+    const t = /* @__PURE__ */ new Map(), s = (i) => {
+      const a = i.metadata?.gltf?.extras?.objectId;
+      if (typeof a == "string") {
+        const w = a.toLowerCase();
+        t.has(w) || t.set(w, i);
+      }
+    };
+    for (const i of e) {
+      s(i);
+      for (const a of i.getDescendants(
+        !1
+      ))
+        s(a);
+    }
+    return t;
+  }
+  collectMeshesFromRoots(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (const s of e) {
+      s.getClassName() === "Mesh" && t.add(s);
+      for (const i of s.getChildMeshes(!1))
+        t.add(i);
+    }
+    return [...t];
+  }
+  getScene() {
+    const e = z.get(this.appObjects);
+    if (!e?.scene)
+      throw new Error("BabylonEntity scene is not available");
+    return e.scene;
+  }
+  get nodesByObjectId() {
+    return this._nodesByObjectId;
+  }
+  get rootTransformNode() {
+    return this._rootTransformNode;
+  }
+  get shadowCasters() {
+    return this.meshes;
+  }
+  get highlightGroupsByObjectId() {
+    return this._highlightGroupsByObjectId;
+  }
+  dispose() {
+    this.instantiatedEntries?.dispose(), this.instantiatedEntries = void 0, this.meshes = [], this._nodesByObjectId = /* @__PURE__ */ new Map(), this._highlightGroupsByObjectId = /* @__PURE__ */ new Map(), this._rootTransformNode = void 0, this.loadPromise = void 0, this.lockView.dispose(), this.exhaustView.dispose(), this.gaugeView.dispose(), super.dispose();
+  }
+  constructor(e) {
+    super(e, C.type), this.lockView = we(e), this.exhaustView = Ee(e), this.gaugeView = Ve(e), this.hitboxView = ve(e);
+  }
+}
+const je = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  PneumaticPanelBabylonView: C,
+  makePneumaticPanelBabylonView: v
+}, Symbol.toStringTag, { value: "Module" }));
+class _e extends N {
+  factoryName = "PneumaticPanelFeatureFactory";
+  repo = null;
+  setupEntities() {
+    this.repo = Q(this.appObject), this.repo.pneumaticPanelEntityFactory = Ge(
+      this.appObjects
+    );
+  }
+  setupUCs() {
+  }
+  setupPMs() {
+  }
+  finalSetup() {
+  }
+}
+function We(n) {
+  const e = n.getOrCreate("PneumaticPanels");
+  return new _e(e);
+}
+function Ge(n) {
+  return function(e) {
+    const t = n.getOrCreate(e), s = I(t);
+    return J(t), Z(t), te(t), se(t), fe(t), s;
+  };
+}
+function T(n, e) {
+  const t = P.get(e);
+  if (!t) {
+    e.submitWarning(
+      "createPneumaticPanel",
+      "Unable to find PneumaticPanelRepo"
+    );
+    return;
+  }
+  return t.createPneumaticPanelEntity(n).appObject;
+}
+async function Re(n, e) {
+  const t = T(n, e);
+  return t ? (await v(t).load(), t) : void 0;
+}
+class De extends p {
+  vmsAreEqual = () => !0;
+  constructor(e) {
+    super(e, p.type);
+  }
+}
+class $e extends l {
+  maxPressure = 60;
+  toggleExhaust = () => !0;
+  subscribeOnExhaustOpened = (e) => () => {
+  };
+  subscribeOnExhaustClosed = (e) => () => {
+  };
+  subscribeOnExhaustCloseBlockedByLock = (e) => () => {
+  };
+  constructor(e) {
+    super(e, l.type);
+  }
+}
+class qe extends h {
+  toggleLock = () => !0;
+  subscribeOnPanelLocked = (e) => () => {
+  };
+  subscribeOnPanelUnlocked = (e) => () => {
+  };
+  constructor(e) {
+    super(e, h.type);
+  }
+}
+class Qe extends b {
+  checkPressure = () => {
+  };
+  subscribeOnCheckPressure = (e) => () => {
+  };
+  constructor(e) {
+    super(e, b.type);
+  }
+}
+class Ye extends u {
+  enableHitbox = () => {
+  };
+  disableHitbox = () => {
+  };
+  subscribeOnPanelSelected = () => () => {
+  };
+  notifyPanelSelected = () => {
+  };
+  constructor(e) {
+    super(e, u.type);
+  }
+}
+const Ne = 2;
+class Je {
+  id;
+  interfaceVersion = 1;
+  appObjects;
+  /**
+   * Dispatch map: event key → subscribe controller
+   * Each controller has signature: (id, appObjects, cb: () => void) => () => void
+   */
+  eventDispatchMap = {
+    exhaustOpened: re,
+    exhaustClosed: le,
+    exhaustCloseBlockedByLock: ue,
+    panelLocked: he,
+    panelUnlocked: de,
+    panelSelected: me,
+    pressureChecked: Pe
+  };
+  /**
+   * Constructor: synchronously wire the domain instance.
+   * No Babylon dependency; fully headless and testable.
+   *
+   * @param id - The instance identifier
+   * @param appObjects - The AppObject repository
+   */
+  constructor(e, t) {
+    this.id = e, this.appObjects = t, T(e, t);
+  }
+  /**
+   * Asynchronously load and attach the Babylon view.
+   * Required before the component renders in a 3D scene.
+   */
+  /**
+   * Asynchronously load and attach the Babylon view.
+   *
+   * @param variant - Optional asset variant. No variants are implemented yet,
+   *   so an omitted or unrecognized variant loads the default asset
+   *   (best-effort, per Contract v1).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async load(e) {
+    const { makePneumaticPanelBabylonView: t } = await Promise.resolve().then(() => je), s = this.appObjects.get(this.id);
+    s && await t(s).load();
+  }
+  /**
+   * Tear down the component and release all resources.
+   */
+  destroy() {
+    this.appObjects.get(this.id)?.dispose();
+  }
+  /**
+   * Toggle the exhaust valve open/closed.
+   * @returns true if toggle succeeded, false if blocked (e.g., by lock)
+   */
+  toggleExhaust() {
+    return V(this.id, this.appObjects);
+  }
+  /**
+   * Toggle the lock state.
+   * @returns true if toggle succeeded, false if blocked (e.g., exhaust open)
+   */
+  toggleLock() {
+    return U(this.id, this.appObjects);
+  }
+  /**
+   * Trigger a pressure check.
+   */
+  checkPressure() {
+    return A(this.id, this.appObjects);
+  }
+  /**
+   * Show or hide the ghost lock hint.
+   */
+  setShowGhostLockHint(e) {
+    return ae(this.id, this.appObjects, e);
+  }
+  /**
+   * Enable the whole-panel hitbox for single-target selection.
+   */
+  enableHitbox() {
+    return be(this.id, this.appObjects);
+  }
+  /**
+   * Disable the whole-panel hitbox, restoring sub-component interactivity.
+   */
+  disableHitbox() {
+    return pe(this.id, this.appObjects);
+  }
+  getState() {
+    return oe(
+      this.id,
+      this.appObjects,
+      Ne
+    );
+  }
+  applyState(e) {
+    return ce(this.id, this.appObjects, e);
+  }
+  /**
+   * Subscribe to a typed event.
+   * @param event - The event key (typed by PneumaticPanelEvents)
+   * @param cb - The callback function
+   * @returns An unsubscribe function
+   */
+  onEvent(e, t) {
+    const s = this.eventDispatchMap[e];
+    return s(this.id, this.appObjects, t);
+  }
+  /**
+   * Subscribe to the reactive view model. Emits the current VM immediately,
+   * then on every change. Returns an unsubscribe function.
+   */
+  onViewModel(e) {
+    return o.subscribe(this.id, this.appObjects, e), () => o.unsubscribe(this.id, this.appObjects, e);
+  }
+}
 export {
-  n as MockPneumaticPanelCheckPressureUC,
-  s as MockPneumaticPanelPM,
-  t as MockPneumaticPanelSelectUC,
-  P as MockPneumaticPanelToggleExhaustUC,
-  l as MockPneumaticPanelToggleLockUC,
-  c as PNEUMATIC_PANEL_STATE_VERSION,
-  o as PneumaticPanelBabylonView,
-  i as PneumaticPanelCheckPressureUC,
-  u as PneumaticPanelEntity,
-  m as PneumaticPanelFacade,
-  k as PneumaticPanelFeatureFactory,
-  r as PneumaticPanelPM,
-  g as PneumaticPanelRepo,
-  C as PneumaticPanelSelectUC,
-  h as PneumaticPanelToggleExhaustUC,
-  E as PneumaticPanelToggleLockUC,
-  x as applyPanelState,
-  U as checkPressure,
-  p as clearAllHighlights,
-  H as componentConfig,
-  d as createBabylonPneumaticPanel,
-  y as disablePanelHitbox,
-  b as enablePanelHitbox,
-  M as getPanelState,
-  T as makePneumaticPanelBabylonView,
-  S as makePneumaticPanelCheckPressureUC,
-  L as makePneumaticPanelEntity,
-  A as makePneumaticPanelFeatureFactory,
-  B as makePneumaticPanelPM,
-  F as makePneumaticPanelRepo,
-  v as makePneumaticPanelSelectUC,
-  w as makePneumaticPanelToggleExhaustUC,
-  O as makePneumaticPanelToggleLockUC,
-  R as onCheckPressure,
-  V as onExhaustCloseBlockedByLock,
-  f as onExhaustClosed,
-  I as onExhaustOpened,
-  N as onPanelHoverEnter,
-  _ as onPanelHoverExit,
-  j as onPanelLocked,
-  G as onPanelSelected,
-  q as onPanelUnlocked,
-  z as panelHitboxClicked,
-  D as panelHitboxHoverEnter,
-  J as panelHitboxHoverExit,
-  K as pneumaticPanelPMAdapter,
-  Q as setHighlightedObject,
-  W as setShowGhostLockHint,
-  X as tryToggleExhaust,
-  Y as tryToggleLock
+  Qe as MockPneumaticPanelCheckPressureUC,
+  De as MockPneumaticPanelPM,
+  Ye as MockPneumaticPanelSelectUC,
+  $e as MockPneumaticPanelToggleExhaustUC,
+  qe as MockPneumaticPanelToggleLockUC,
+  Ne as PNEUMATIC_PANEL_STATE_VERSION,
+  C as PneumaticPanelBabylonView,
+  b as PneumaticPanelCheckPressureUC,
+  c as PneumaticPanelEntity,
+  Je as PneumaticPanelFacade,
+  _e as PneumaticPanelFeatureFactory,
+  p as PneumaticPanelPM,
+  P as PneumaticPanelRepo,
+  u as PneumaticPanelSelectUC,
+  l as PneumaticPanelToggleExhaustUC,
+  h as PneumaticPanelToggleLockUC,
+  ce as applyPanelState,
+  A as checkPressure,
+  ye as componentConfig,
+  Re as createBabylonPneumaticPanel,
+  pe as disablePanelHitbox,
+  be as enablePanelHitbox,
+  oe as getPanelState,
+  v as makePneumaticPanelBabylonView,
+  te as makePneumaticPanelCheckPressureUC,
+  I as makePneumaticPanelEntity,
+  We as makePneumaticPanelFeatureFactory,
+  fe as makePneumaticPanelPM,
+  Q as makePneumaticPanelRepo,
+  se as makePneumaticPanelSelectUC,
+  J as makePneumaticPanelToggleExhaustUC,
+  Z as makePneumaticPanelToggleLockUC,
+  Pe as onCheckPressure,
+  ue as onExhaustCloseBlockedByLock,
+  le as onExhaustClosed,
+  re as onExhaustOpened,
+  he as onPanelLocked,
+  me as onPanelSelected,
+  de as onPanelUnlocked,
+  ge as panelHitboxClicked,
+  o as pneumaticPanelPMAdapter,
+  ae as setShowGhostLockHint,
+  V as tryToggleExhaust,
+  U as tryToggleLock
 };