@vived/component-abb-controller 0.1.0

package/dist/index.js

@@ -0,0 +1,1313 @@
+import { AppObjectEntity as H, MemoizedBoolean as C, MemoizedNumber as j, AppObjectEntityRepo as N, getSingletonComponent as G, generateUniqueID as _, AppObjectUC as w, AppObjectPM as W, DomainFactory as T, AppObjectView as O } from "@vived/core";
+import { getAssetBlobURL as F, BabylonEntity as z } from "@vived/app";
+import { LoadAssetContainerAsync as D, Quaternion as x, ActionManager as a, ExecuteCodeAction as y, Material as R } from "@babylonjs/core";
+class r extends H {
+  static type = "AbbControllerEntity";
+  /**
+   * Retrieves the entity from an AppObject
+   */
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+  /**
+   * Retrieves the entity by AppObject ID
+   */
+  static getById(t, e) {
+    return e.get(t)?.getComponent(this.type);
+  }
+}
+function v(o) {
+  return new K(o);
+}
+class K extends r {
+  memoizedIsPoweredOn = new C(!1, this.notifyOnChange);
+  memoizedIsLockedOut = new C(!1, this.notifyOnChange);
+  memoizedPowerOnVoltage = new j(480, this.notifyOnChange);
+  memoizedIsHitboxEnabled = new C(
+    !1,
+    this.notifyOnChange
+  );
+  memoizedIsShowingGhostLockHint = new C(
+    !1,
+    this.notifyOnChange
+  );
+  get isPoweredOn() {
+    return this.memoizedIsPoweredOn.val;
+  }
+  get isLockedOut() {
+    return this.memoizedIsLockedOut.val;
+  }
+  get powerOnVoltage() {
+    return this.memoizedPowerOnVoltage.val;
+  }
+  set powerOnVoltage(t) {
+    this.memoizedPowerOnVoltage.val = t;
+  }
+  get isHitboxEnabled() {
+    return this.memoizedIsHitboxEnabled.val;
+  }
+  set isHitboxEnabled(t) {
+    this.memoizedIsHitboxEnabled.val = t;
+  }
+  get isShowingGhostLockHint() {
+    return this.memoizedIsShowingGhostLockHint.val;
+  }
+  set isShowingGhostLockHint(t) {
+    this.memoizedIsShowingGhostLockHint.val = t;
+  }
+  tryPowerOn() {
+    return this.memoizedIsLockedOut.val ? !1 : (this.memoizedIsPoweredOn.val = !0, !0);
+  }
+  tryPowerOff() {
+    return this.memoizedIsPoweredOn.val = !1, !0;
+  }
+  tryLockOut() {
+    return this.memoizedIsPoweredOn.val ? !1 : (this.memoizedIsLockedOut.val = !0, !0);
+  }
+  tryUnlock() {
+    return this.memoizedIsLockedOut.val = !1, !0;
+  }
+  constructor(t) {
+    super(t, r.type);
+  }
+}
+class u extends N {
+  static type = "AbbControllerRepo";
+  /**
+   * Global accessor for the singleton repository
+   */
+  static get(t) {
+    return G(
+      u.type,
+      t
+    );
+  }
+}
+function Q(o) {
+  return new $(o);
+}
+class $ extends u {
+  abbControllerEntityFactory = (t) => {
+    const e = this.appObjects.getOrCreate(t);
+    return v(e);
+  };
+  createAbbControllerEntity(t) {
+    const e = t ?? _(), n = this.getForAppObject(e);
+    if (n)
+      return n;
+    const i = this.abbControllerEntityFactory(e);
+    return this.add(i), i;
+  }
+  deleteAbbControllerEntity(t) {
+    const e = this.getForAppObject(t);
+    if (!e) {
+      this.warn(`Cannot delete: entity with id '${t}' not found`);
+      return;
+    }
+    e.appObject.dispose(), this.removeForAppObject(t);
+  }
+  constructor(t) {
+    super(t, u.type);
+  }
+}
+function q(o, t) {
+  const e = u.get(t);
+  if (!e) {
+    t.submitWarning(
+      "createAbbController",
+      "Unable to find AbbControllerRepo"
+    );
+    return;
+  }
+  return e.createAbbControllerEntity(o).appObject;
+}
+class c extends w {
+  static type = "AbbControllerPowerUC";
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+  static getById(t, e) {
+    return e.get(t)?.getComponent(this.type);
+  }
+}
+function Y(o) {
+  return new J(o);
+}
+class J extends c {
+  onPoweredOnCallbacks = /* @__PURE__ */ new Set();
+  onPoweredOffCallbacks = /* @__PURE__ */ new Set();
+  onPowerOnBlockedByLockoutCallbacks = /* @__PURE__ */ new Set();
+  get entity() {
+    try {
+      return this.getCachedLocalComponent(
+        r.type
+      );
+    } catch {
+      return;
+    }
+  }
+  powerOn = () => {
+    const t = this.entity;
+    if (!t)
+      return this.warn("Missing AbbControllerEntity"), !1;
+    const e = t.tryPowerOn();
+    return e ? this.notifyCallbacks(this.onPoweredOnCallbacks, "onPoweredOn callback") : this.notifyCallbacks(
+      this.onPowerOnBlockedByLockoutCallbacks,
+      "onPowerOnBlockedByLockout callback"
+    ), e;
+  };
+  powerOff = () => {
+    const t = this.entity;
+    if (!t)
+      return this.warn("Missing AbbControllerEntity"), !1;
+    const e = t.tryPowerOff();
+    return e && this.notifyCallbacks(
+      this.onPoweredOffCallbacks,
+      "onPoweredOff callback"
+    ), e;
+  };
+  togglePower = () => {
+    const t = this.entity;
+    return t ? t.isPoweredOn ? this.powerOff() : this.powerOn() : (this.warn("Missing AbbControllerEntity"), !1);
+  };
+  subscribeOnPoweredOn(t) {
+    return this.onPoweredOnCallbacks.add(t), () => {
+      this.onPoweredOnCallbacks.delete(t);
+    };
+  }
+  subscribeOnPoweredOff(t) {
+    return this.onPoweredOffCallbacks.add(t), () => {
+      this.onPoweredOffCallbacks.delete(t);
+    };
+  }
+  subscribeOnPowerOnBlockedByLockout(t) {
+    return this.onPowerOnBlockedByLockoutCallbacks.add(t), () => {
+      this.onPowerOnBlockedByLockoutCallbacks.delete(t);
+    };
+  }
+  notifyCallbacks(t, e) {
+    for (const n of t)
+      try {
+        n();
+      } catch {
+        this.warn(`${e} threw an error`);
+      }
+  }
+  constructor(t) {
+    super(t, c.type);
+  }
+}
+function U(o, t) {
+  const e = c.getById(o, t);
+  return e ? e.togglePower() : (t.submitWarning(
+    "tryTogglePower",
+    "Unable to find AbbControllerPowerUC"
+  ), !1);
+}
+function X(o, t) {
+  const e = c.getById(o, t);
+  return e ? e.powerOn() : (t.submitWarning(
+    "tryPowerOn",
+    "Unable to find AbbControllerPowerUC"
+  ), !1);
+}
+function Z(o, t) {
+  const e = c.getById(o, t);
+  return e ? e.powerOff() : (t.submitWarning(
+    "tryPowerOff",
+    "Unable to find AbbControllerPowerUC"
+  ), !1);
+}
+class l extends w {
+  static type = "AbbControllerLockoutUC";
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+  static getById(t, e) {
+    return e.get(t)?.getComponent(this.type);
+  }
+}
+function tt(o) {
+  return new et(o);
+}
+class et extends l {
+  onLockoutEngagedCallbacks = /* @__PURE__ */ new Set();
+  onLockoutDisengagedCallbacks = /* @__PURE__ */ new Set();
+  onLockoutBlockedByPowerCallbacks = /* @__PURE__ */ new Set();
+  get entity() {
+    try {
+      return this.getCachedLocalComponent(
+        r.type
+      );
+    } catch {
+      return;
+    }
+  }
+  lockOut = () => {
+    const t = this.entity;
+    if (!t)
+      return this.warn("Missing AbbControllerEntity"), !1;
+    const e = t.tryLockOut();
+    return e ? this.notifyCallbacks(
+      this.onLockoutEngagedCallbacks,
+      "onLockoutEngaged callback"
+    ) : this.notifyCallbacks(
+      this.onLockoutBlockedByPowerCallbacks,
+      "onLockoutBlockedByPower callback"
+    ), e;
+  };
+  unlock = () => {
+    const t = this.entity;
+    if (!t)
+      return this.warn("Missing AbbControllerEntity"), !1;
+    const e = t.tryUnlock();
+    return e && this.notifyCallbacks(
+      this.onLockoutDisengagedCallbacks,
+      "onLockoutDisengaged callback"
+    ), e;
+  };
+  toggleLockout = () => {
+    const t = this.entity;
+    return t ? t.isLockedOut ? this.unlock() : this.lockOut() : (this.warn("Missing AbbControllerEntity"), !1);
+  };
+  subscribeOnLockoutEngaged(t) {
+    return this.onLockoutEngagedCallbacks.add(t), () => {
+      this.onLockoutEngagedCallbacks.delete(t);
+    };
+  }
+  subscribeOnLockoutDisengaged(t) {
+    return this.onLockoutDisengagedCallbacks.add(t), () => {
+      this.onLockoutDisengagedCallbacks.delete(t);
+    };
+  }
+  subscribeOnLockoutBlockedByPower(t) {
+    return this.onLockoutBlockedByPowerCallbacks.add(t), () => {
+      this.onLockoutBlockedByPowerCallbacks.delete(t);
+    };
+  }
+  notifyCallbacks(t, e) {
+    for (const n of t)
+      try {
+        n();
+      } catch {
+        this.warn(`${e} threw an error`);
+      }
+  }
+  constructor(t) {
+    super(t, l.type);
+  }
+}
+function V(o, t) {
+  const e = l.getById(o, t);
+  return e ? e.toggleLockout() : (t.submitWarning(
+    "tryToggleLockout",
+    "Unable to find AbbControllerLockoutUC"
+  ), !1);
+}
+function ot(o, t) {
+  const e = l.getById(o, t);
+  return e ? e.lockOut() : (t.submitWarning(
+    "tryLockOut",
+    "Unable to find AbbControllerLockoutUC"
+  ), !1);
+}
+function nt(o, t) {
+  const e = l.getById(o, t);
+  return e ? e.unlock() : (t.submitWarning(
+    "tryUnlock",
+    "Unable to find AbbControllerLockoutUC"
+  ), !1);
+}
+class d extends w {
+  static type = "AbbControllerCheckVoltageUC";
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+  static getById(t, e) {
+    return e.get(t)?.getComponent(this.type);
+  }
+}
+function it(o) {
+  return new st(o);
+}
+class st extends d {
+  onVoltageCheckedCallbacks = /* @__PURE__ */ new Set();
+  get entity() {
+    try {
+      return this.getCachedLocalComponent(
+        r.type
+      );
+    } catch {
+      return;
+    }
+  }
+  execute = () => {
+    if (!this.entity) {
+      this.warn("Missing AbbControllerEntity");
+      return;
+    }
+    this.notifyCallbacks(
+      this.onVoltageCheckedCallbacks,
+      "onVoltageChecked callback"
+    );
+  };
+  subscribeOnVoltageChecked(t) {
+    return this.onVoltageCheckedCallbacks.add(t), () => {
+      this.onVoltageCheckedCallbacks.delete(t);
+    };
+  }
+  notifyCallbacks(t, e) {
+    for (const n of t)
+      try {
+        n();
+      } catch {
+        this.warn(`${e} threw an error`);
+      }
+  }
+  constructor(t) {
+    super(t, d.type);
+  }
+}
+function rt(o, t) {
+  const e = d.getById(o, t);
+  if (!e) {
+    t.submitWarning(
+      "checkVoltage",
+      "Unable to find AbbControllerCheckVoltageUC"
+    );
+    return;
+  }
+  e.execute();
+}
+function ct(o, t, e) {
+  const n = r.getById(o, t);
+  if (!n) {
+    t.submitWarning(
+      "setShowGhostLockHint",
+      "Unable to find AbbControllerEntity"
+    );
+    return;
+  }
+  n.isShowingGhostLockHint = e;
+}
+class h extends w {
+  static type = "AbbControllerSelectUC";
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+  static getById(t, e) {
+    return e.get(t)?.getComponent(this.type);
+  }
+}
+function lt(o) {
+  return new at(o);
+}
+class at extends h {
+  onSelectedCallbacks = /* @__PURE__ */ new Set();
+  get entity() {
+    try {
+      return this.getCachedLocalComponent(
+        r.type
+      );
+    } catch {
+      return;
+    }
+  }
+  enableHitbox() {
+    const t = this.entity;
+    if (!t) {
+      this.warn("Missing AbbControllerEntity");
+      return;
+    }
+    t.isHitboxEnabled = !0;
+  }
+  disableHitbox() {
+    const t = this.entity;
+    if (!t) {
+      this.warn("Missing AbbControllerEntity");
+      return;
+    }
+    t.isHitboxEnabled = !1;
+  }
+  subscribeOnSelected(t) {
+    return this.onSelectedCallbacks.add(t), () => {
+      this.onSelectedCallbacks.delete(t);
+    };
+  }
+  notifySelected() {
+    for (const t of this.onSelectedCallbacks)
+      try {
+        t();
+      } catch {
+        this.warn("onSelected callback threw an error");
+      }
+  }
+  constructor(t) {
+    super(t, h.type);
+  }
+}
+function bt(o, t) {
+  const e = h.getById(o, t);
+  if (!e) {
+    t.submitWarning(
+      "enableHitbox",
+      "Unable to find AbbControllerSelectUC"
+    );
+    return;
+  }
+  e.enableHitbox();
+}
+function ht(o, t) {
+  const e = h.getById(o, t);
+  if (!e) {
+    t.submitWarning(
+      "disableHitbox",
+      "Unable to find AbbControllerSelectUC"
+    );
+    return;
+  }
+  e.disableHitbox();
+}
+function ut(o, t, e) {
+  const n = c.getById(o, t);
+  return n ? n.subscribeOnPoweredOn(e) : (t.submitWarning(
+    "onPoweredOn",
+    "Unable to find AbbControllerPowerUC"
+  ), () => {
+  });
+}
+function dt(o, t, e) {
+  const n = c.getById(o, t);
+  return n ? n.subscribeOnPoweredOff(e) : (t.submitWarning(
+    "onPoweredOff",
+    "Unable to find AbbControllerPowerUC"
+  ), () => {
+  });
+}
+function gt(o, t, e) {
+  const n = c.getById(o, t);
+  return n ? n.subscribeOnPowerOnBlockedByLockout(e) : (t.submitWarning(
+    "onPowerOnBlockedByLockout",
+    "Unable to find AbbControllerPowerUC"
+  ), () => {
+  });
+}
+function ft(o, t, e) {
+  const n = l.getById(o, t);
+  return n ? n.subscribeOnLockoutEngaged(e) : (t.submitWarning(
+    "onLockoutEngaged",
+    "Unable to find AbbControllerLockoutUC"
+  ), () => {
+  });
+}
+function kt(o, t, e) {
+  const n = l.getById(o, t);
+  return n ? n.subscribeOnLockoutDisengaged(e) : (t.submitWarning(
+    "onLockoutDisengaged",
+    "Unable to find AbbControllerLockoutUC"
+  ), () => {
+  });
+}
+function yt(o, t, e) {
+  const n = l.getById(o, t);
+  return n ? n.subscribeOnLockoutBlockedByPower(e) : (t.submitWarning(
+    "onLockoutBlockedByPower",
+    "Unable to find AbbControllerLockoutUC"
+  ), () => {
+  });
+}
+function pt(o, t, e) {
+  const n = d.getById(o, t);
+  return n ? n.subscribeOnVoltageChecked(e) : (t.submitWarning(
+    "onVoltageChecked",
+    "Unable to find AbbControllerCheckVoltageUC"
+  ), () => {
+  });
+}
+function Ct(o, t, e) {
+  const n = h.getById(o, t);
+  return n ? n.subscribeOnSelected(e) : (t.submitWarning(
+    "onAbbControllerSelected",
+    "Unable to find AbbControllerSelectUC"
+  ), () => {
+  });
+}
+const k = {
+  isPoweredOn: !1,
+  isLockedOut: !1,
+  isShowingGhostLockHint: !1,
+  isHitboxEnabled: !1
+};
+function wt(o, t, e) {
+  const n = r.getById(o, t);
+  return n ? {
+    version: e,
+    isPoweredOn: n.isPoweredOn,
+    isLockedOut: n.isLockedOut,
+    isShowingGhostLockHint: n.isShowingGhostLockHint,
+    isHitboxEnabled: n.isHitboxEnabled
+  } : (t.submitWarning(
+    "getAbbControllerState",
+    "Unable to find AbbControllerEntity"
+  ), {
+    version: e,
+    ...k
+  });
+}
+function Ot(o, t, e) {
+  const n = r.getById(o, t);
+  if (!n) {
+    t.submitWarning(
+      "applyAbbControllerState",
+      "Unable to find AbbControllerEntity"
+    );
+    return;
+  }
+  const i = e.isPoweredOn ?? k.isPoweredOn, s = e.isLockedOut ?? k.isLockedOut;
+  i && s ? t.submitWarning(
+    "applyAbbControllerState",
+    "Rejected invalid state: powered on and locked out cannot both be true"
+  ) : i ? (n.tryUnlock(), n.tryPowerOn()) : s ? (n.tryPowerOff(), n.tryLockOut()) : (n.tryPowerOff(), n.tryUnlock()), n.isShowingGhostLockHint = e.isShowingGhostLockHint ?? k.isShowingGhostLockHint, n.isHitboxEnabled = e.isHitboxEnabled ?? k.isHitboxEnabled;
+}
+class g extends W {
+  static type = "AbbControllerPM";
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+  static getById(t, e) {
+    return e.get(t)?.getComponent(this.type);
+  }
+}
+function mt(o) {
+  return new At(o);
+}
+class At extends g {
+  get entity() {
+    try {
+      return this.getCachedLocalComponent(
+        r.type
+      );
+    } catch {
+      return;
+    }
+  }
+  vmsAreEqual(t, e) {
+    return t.isPoweredOn === e.isPoweredOn && t.isLockedOut === e.isLockedOut && t.canPowerOn === e.canPowerOn && t.canLockOut === e.canLockOut && t.voltage === e.voltage;
+  }
+  onEntityChange = () => {
+    const t = this.entity;
+    if (!t) return;
+    const e = t.isPoweredOn, n = t.isLockedOut;
+    this.doUpdateView({
+      isPoweredOn: e,
+      isLockedOut: n,
+      canPowerOn: !n,
+      canLockOut: !e,
+      voltage: e ? t.powerOnVoltage : 0
+    });
+  };
+  dispose = () => {
+    super.dispose(), this.entity?.removeChangeObserver(this.onEntityChange);
+  };
+  constructor(t) {
+    super(t, g.type), this.entity?.addChangeObserver(this.onEntityChange), this.onEntityChange();
+  }
+}
+const b = {
+  defaultVM: {
+    isPoweredOn: !1,
+    isLockedOut: !1,
+    canPowerOn: !0,
+    canLockOut: !0,
+    voltage: 0
+  },
+  subscribe: (o, t, e) => {
+    if (!o) return;
+    const n = g.getById(o, t);
+    if (!n) {
+      t.submitWarning(
+        "abbControllerPMAdapter",
+        "Unable to find AbbControllerPM"
+      );
+      return;
+    }
+    n.addView(e);
+  },
+  unsubscribe: (o, t, e) => {
+    if (!o) return;
+    const n = g.getById(o, t);
+    n && n.removeView(e);
+  }
+}, Lt = 1;
+class zt {
+  id;
+  interfaceVersion = 1;
+  appObjects;
+  /**
+   * Dispatch map: event key → subscribe controller.
+   * Each controller has signature `(id, appObjects, cb: () => void) => () => void`.
+   */
+  eventDispatchMap = {
+    poweredOn: ut,
+    poweredOff: dt,
+    powerOnBlockedByLockout: gt,
+    lockoutEngaged: ft,
+    lockoutDisengaged: kt,
+    lockoutBlockedByPower: yt,
+    voltageChecked: pt,
+    selected: Ct
+  };
+  /**
+   * Synchronously wire the domain instance (entity, UCs, PM, adapter).
+   * Does NOT touch Babylon.
+   */
+  constructor(t, e) {
+    this.id = t, this.appObjects = e, q(t, e);
+  }
+  /**
+   * Asynchronously load and attach the Babylon view. Required before the
+   * component renders in a 3D scene.
+   *
+   * @param variant - Optional asset variant. No variants are implemented in the
+   *   starter, 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(t) {
+    const { makeAbbControllerBabylonView: e } = await Promise.resolve().then(() => _t), n = this.appObjects.get(this.id);
+    n && await e(n).load();
+  }
+  /** Tear down the component and release all resources. */
+  destroy() {
+    this.appObjects.get(this.id)?.dispose();
+  }
+  /** Toggle the power state of the component. Returns true if successful. */
+  togglePower() {
+    return U(this.id, this.appObjects);
+  }
+  /** Power on. Returns true if successful, false if refused (locked out). */
+  powerOn() {
+    return X(this.id, this.appObjects);
+  }
+  /** Power off. Always succeeds. */
+  powerOff() {
+    return Z(this.id, this.appObjects);
+  }
+  /** Toggle the lockout state. Returns true if successful. */
+  toggleLockout() {
+    return V(this.id, this.appObjects);
+  }
+  /** Engage the lockout. Returns true if successful, false if refused (powered on). */
+  lockOut() {
+    return ot(this.id, this.appObjects);
+  }
+  /** Disengage the lockout. Always succeeds. */
+  unlock() {
+    return nt(this.id, this.appObjects);
+  }
+  /** Check the controller's voltage. Notifies subscribers of the check. */
+  checkVoltage() {
+    rt(this.id, this.appObjects);
+  }
+  /** Show or hide the always-visible ghost lock hint (training mode). */
+  setShowGhostLockHint(t) {
+    ct(this.id, this.appObjects, t);
+  }
+  /** Enable the whole-controller hitbox for single-target selection. */
+  enableHitbox() {
+    bt(this.id, this.appObjects);
+  }
+  /** Disable the whole-controller hitbox, restoring sub-component interactivity. */
+  disableHitbox() {
+    ht(this.id, this.appObjects);
+  }
+  getState() {
+    return wt(
+      this.id,
+      this.appObjects,
+      Lt
+    );
+  }
+  applyState(t) {
+    Ot(this.id, this.appObjects, t);
+  }
+  /**
+   * Subscribe to a typed event. Returns an unsubscribe function.
+   */
+  onEvent(t, e) {
+    const n = this.eventDispatchMap[t];
+    return n(this.id, this.appObjects, e);
+  }
+  /**
+   * Subscribe to the reactive view model. Emits the current VM immediately,
+   * then on every change. Returns an unsubscribe function.
+   */
+  onViewModel(t) {
+    return b.subscribe(this.id, this.appObjects, t), () => b.unsubscribe(this.id, this.appObjects, t);
+  }
+}
+const Dt = {
+  poweredOn: "poweredOn",
+  poweredOff: "poweredOff",
+  powerOnBlockedByLockout: "powerOnBlockedByLockout",
+  lockoutEngaged: "lockoutEngaged",
+  lockoutDisengaged: "lockoutDisengaged",
+  lockoutBlockedByPower: "lockoutBlockedByPower",
+  voltageChecked: "voltageChecked",
+  selected: "selected"
+};
+function Pt(o, t) {
+  const e = h.getById(o, t);
+  if (!e) {
+    t.submitWarning(
+      "abbControllerHitboxClicked",
+      "Unable to find AbbControllerSelectUC"
+    );
+    return;
+  }
+  e.notifySelected();
+}
+function Mt(o) {
+  return function(t) {
+    const e = o.getOrCreate(t), n = v(e);
+    return Y(e), tt(e), it(e), lt(e), mt(e), n;
+  };
+}
+class Bt extends T {
+  factoryName = "AbbControllerFeatureFactory";
+  repo = null;
+  setupEntities() {
+    this.repo = Q(this.appObject), this.repo.abbControllerEntityFactory = Mt(this.appObjects);
+  }
+  setupUCs() {
+  }
+  setupPMs() {
+  }
+  finalSetup() {
+  }
+}
+function Rt(o) {
+  const t = o.getOrCreate("AbbControllers");
+  return new Bt(t);
+}
+const Et = {
+  /** Machine-friendly name (used in package name, imports) */
+  name: "AbbController",
+  /** Human-friendly display name */
+  displayName: "ABB Controller",
+  /** 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: "d9f9f9a5-b2b3-4fe1-86e4-343336211a23",
+      file: "AbbController.glb"
+    }
+  ]
+};
+let m = /* @__PURE__ */ new WeakMap();
+function It(o) {
+  let t = m.get(o);
+  return t || (t = /* @__PURE__ */ new Map(), m.set(o, t)), t;
+}
+async function xt(o, t, e) {
+  const n = It(o);
+  let i = n.get(e);
+  i || (i = F(e, t).then(
+    (s) => D(s, o, {
+      pluginExtension: ".glb"
+    })
+  ), n.set(e, i));
+  try {
+    return await i;
+  } catch (s) {
+    throw n.delete(e), s;
+  }
+}
+function Kt() {
+  m = /* @__PURE__ */ new WeakMap();
+}
+const L = "cutoff_knob", vt = x.FromEulerAngles(0, -Math.PI / 2, 0);
+class P extends O {
+  static type = "CutoffKnobView";
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+}
+function Ut(o) {
+  return new Vt(o);
+}
+class Vt extends P {
+  knobMesh;
+  initialPosition;
+  initialRotationQuaternion;
+  currentVM = b.defaultVM;
+  get entity() {
+    return r.getById(this.appObject.id, this.appObjects);
+  }
+  bindMeshes(t) {
+    if (this.knobMesh = t.get(L), !this.knobMesh) {
+      this.warn(
+        `Unable to find '${L}' mesh; cutoff knob inert until the asset provides it`
+      );
+      return;
+    }
+    this.knobMesh.rotationQuaternion || (this.knobMesh.rotationQuaternion = x.FromEulerAngles(
+      this.knobMesh.rotation.x,
+      this.knobMesh.rotation.y,
+      this.knobMesh.rotation.z
+    )), this.initialPosition = this.knobMesh.position.clone(), this.initialRotationQuaternion = this.knobMesh.rotationQuaternion.clone(), this.bindClickAction(this.knobMesh), this.knobMesh.isPickable = !(this.entity?.isHitboxEnabled ?? !1), this.applyPowerState(this.currentVM.isPoweredOn);
+  }
+  applyView = (t) => {
+    const e = this.currentVM;
+    this.currentVM = t, t.isPoweredOn !== e.isPoweredOn && this.applyPowerState(t.isPoweredOn);
+  };
+  onEntityChange = () => {
+    this.knobMesh && (this.knobMesh.isPickable = !(this.entity?.isHitboxEnabled ?? !1));
+  };
+  applyPowerState(t) {
+    !this.knobMesh || !this.initialPosition || !this.initialRotationQuaternion || (this.knobMesh.position.copyFrom(this.initialPosition), this.knobMesh.rotationQuaternion = t ? this.initialRotationQuaternion.multiply(vt) : this.initialRotationQuaternion.clone());
+  }
+  bindClickAction(t) {
+    const e = t.getScene();
+    if (!e) {
+      this.warn("Unable to wire cutoff knob without a scene");
+      return;
+    }
+    t.actionManager ??= new a(e), t.actionManager.registerAction(
+      new y(a.OnPickTrigger, () => {
+        U(this.appObject.id, this.appObjects);
+      })
+    );
+  }
+  dispose() {
+    b.unsubscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    ), this.entity?.removeChangeObserver(this.onEntityChange), super.dispose();
+  }
+  constructor(t) {
+    super(t, P.type), b.subscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    ), this.entity?.addChangeObserver(this.onEntityChange);
+  }
+}
+const M = "lock", B = "ghost_lock";
+class E extends O {
+  static type = "LockView";
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+}
+function St(o) {
+  return new Ht(o);
+}
+class Ht extends E {
+  lockNode;
+  ghostLockMesh;
+  currentVM = b.defaultVM;
+  get entity() {
+    return r.getById(this.appObject.id, this.appObjects);
+  }
+  get subComponentsInteractive() {
+    return !(this.entity?.isHitboxEnabled ?? !1);
+  }
+  get showGhostLockHint() {
+    return this.entity?.isShowingGhostLockHint ?? !1;
+  }
+  bindMeshes(t) {
+    this.lockNode = this.resolveLockNode(t), this.ghostLockMesh = this.resolveGhostLockMesh(t), this.lockNode || this.warn(
+      `Unable to find '${M}' node; lock inert until the asset provides it`
+    ), this.ghostLockMesh || this.warn(
+      `Unable to find '${B}' mesh; ghost lock inert until the asset provides it`
+    ), this.bindClickActionsOnLockChildren(), this.bindClickAction(this.ghostLockMesh), this.bindGhostHoverActions(this.ghostLockMesh), this.applyMeshes();
+  }
+  applyView = (t) => {
+    this.currentVM = t, this.applyMeshes();
+  };
+  onEntityChange = () => {
+    this.applyMeshes();
+  };
+  applyMeshes() {
+    this.setLockVisible(this.currentVM.isLockedOut), this.setGhostLockVisible(this.shouldShowGhostLockAffordance());
+  }
+  shouldShowGhostLockAffordance() {
+    return this.currentVM.canLockOut && !this.currentVM.isLockedOut;
+  }
+  setLockVisible(t) {
+    if (this.lockNode) {
+      this.lockNode.setEnabled(t);
+      for (const e of this.lockNode.getChildMeshes(!1))
+        e.isPickable = t && this.subComponentsInteractive, e.setEnabled(t);
+    }
+  }
+  setGhostLockVisible(t) {
+    this.ghostLockMesh && (this.ghostLockMesh.setEnabled(t), this.ghostLockMesh.isPickable = t && this.subComponentsInteractive, this.ghostLockMesh.visibility = t && this.showGhostLockHint ? 1 : 0);
+  }
+  bindClickActionsOnLockChildren() {
+    if (this.lockNode)
+      for (const t of this.lockNode.getChildMeshes(!1))
+        this.bindClickAction(t);
+  }
+  bindClickAction(t) {
+    if (!t) return;
+    const e = t.getScene();
+    if (!e) {
+      this.warn("Unable to wire lock mesh without a scene");
+      return;
+    }
+    t.isPickable = !0, t.actionManager ??= new a(e), t.actionManager.registerAction(
+      new y(a.OnPickTrigger, () => {
+        V(this.appObject.id, this.appObjects);
+      })
+    );
+  }
+  bindGhostHoverActions(t) {
+    if (!t) return;
+    const e = t.getScene();
+    e && (t.actionManager ??= new a(e), t.actionManager.registerAction(
+      new y(a.OnPointerOverTrigger, () => {
+        t.visibility = 1;
+      })
+    ), t.actionManager.registerAction(
+      new y(a.OnPointerOutTrigger, () => {
+        this.showGhostLockHint || (t.visibility = 0);
+      })
+    ));
+  }
+  resolveLockNode(t) {
+    const e = t.get(M), n = e?.getClassName();
+    if (!(!e || n !== "TransformNode" && n !== "Mesh"))
+      return e;
+  }
+  resolveGhostLockMesh(t) {
+    const e = t.get(B);
+    if (e)
+      return e;
+  }
+  dispose() {
+    b.unsubscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    ), this.entity?.removeChangeObserver(this.onEntityChange), super.dispose();
+  }
+  constructor(t) {
+    super(t, E.type), b.subscribe(
+      this.appObject.id,
+      this.appObjects,
+      this.applyView
+    ), this.entity?.addChangeObserver(this.onEntityChange);
+  }
+}
+const p = "abb_controller_hitbox";
+class I extends O {
+  static type = "HitboxView";
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+}
+function jt(o) {
+  return new Nt(o);
+}
+class Nt extends I {
+  hitboxMesh;
+  get entity() {
+    return r.getById(this.appObject.id, this.appObjects);
+  }
+  bindMeshes(t) {
+    if (this.hitboxMesh = t.get(p), !this.hitboxMesh) {
+      this.warn(
+        `Unable to find '${p}' mesh; whole-controller selection inert until the asset provides it`
+      );
+      return;
+    }
+    const e = this.hitboxMesh.material;
+    e && (e.transparencyMode = R.MATERIAL_ALPHABLEND, e.alpha = 0), this.hitboxMesh.visibility = 0, this.hitboxMesh.isPickable = this.entity?.isHitboxEnabled ?? !1, this.bindActions(this.hitboxMesh);
+  }
+  onEntityChange = () => {
+    this.hitboxMesh && (this.hitboxMesh.isPickable = this.entity?.isHitboxEnabled ?? !1);
+  };
+  bindActions(t) {
+    const e = t.getScene();
+    if (!e) {
+      this.warn("Unable to wire hitbox mesh without a scene");
+      return;
+    }
+    t.actionManager ??= new a(e), t.actionManager.registerAction(
+      new y(a.OnPickTrigger, () => {
+        Pt(this.appObject.id, this.appObjects);
+      })
+    );
+  }
+  dispose() {
+    this.entity?.removeChangeObserver(this.onEntityChange), super.dispose();
+  }
+  constructor(t) {
+    super(t, I.type), this.entity?.addChangeObserver(this.onEntityChange);
+  }
+}
+class A extends O {
+  static type = "AbbControllerBabylonView";
+  static get(t) {
+    return t.getComponent(this.type);
+  }
+}
+function S(o) {
+  return new Gt(o);
+}
+class Gt extends A {
+  cutoffKnobView;
+  lockView;
+  hitboxView;
+  meshes = [];
+  _nodesByObjectId = /* @__PURE__ */ new Map();
+  _highlightGroupsByObjectId = /* @__PURE__ */ new Map();
+  _rootTransformNode;
+  instantiatedEntries;
+  loadPromise;
+  async load() {
+    this.meshes.length > 0 || (this.loadPromise || (this.loadPromise = this.loadInternal().catch((t) => {
+      throw this.loadPromise = void 0, t;
+    })), await this.loadPromise);
+  }
+  async loadInternal() {
+    const t = this.getScene(), e = Et.assets[0]?.id;
+    if (!e) {
+      this.appObjects.submitError(
+        "AbbControllerBabylonView.load",
+        "Missing AbbController default asset configuration"
+      );
+      return;
+    }
+    const n = await xt(
+      t,
+      this.appObjects,
+      e
+    );
+    this.instantiatedEntries = n.instantiateModelsToScene(
+      (i) => i
+    ), this._rootTransformNode = this.instantiatedEntries.rootNodes[0], this.meshes = this.collectMeshesFromRoots(
+      this.instantiatedEntries.rootNodes
+    ), this._nodesByObjectId = this.buildNodeLookup(
+      this.instantiatedEntries.rootNodes
+    ), this._highlightGroupsByObjectId = this.buildHighlightGroups(
+      this._nodesByObjectId
+    ), this.cutoffKnobView.bindMeshes(this._nodesByObjectId), this.lockView.bindMeshes(this._nodesByObjectId), this.hitboxView.bindMeshes(this._nodesByObjectId);
+  }
+  /**
+   * `abb_controller_hitbox` → every visible mesh (all meshes except the
+   * invisible hitbox itself), so outlining the invisible hitbox outlines the
+   * whole visible controller. Every other objectId → a single-element array
+   * for its own mesh.
+   */
+  buildHighlightGroups(t) {
+    const e = /* @__PURE__ */ new Map(), n = this.meshes.filter(
+      (i) => i.metadata?.gltf?.extras?.objectId?.toLowerCase() !== p
+    );
+    e.set(p, n);
+    for (const [i, s] of t)
+      i !== p && s.getClassName() === "Mesh" && e.set(i, [s]);
+    return e;
+  }
+  buildNodeLookup(t) {
+    const e = /* @__PURE__ */ new Map(), n = (i) => {
+      const s = i.metadata?.gltf?.extras?.objectId;
+      if (typeof s == "string") {
+        const f = s.toLowerCase();
+        e.has(f) || e.set(f, i);
+      }
+    };
+    for (const i of t) {
+      n(i);
+      for (const s of i.getDescendants(
+        !1
+      ))
+        n(s);
+    }
+    return e;
+  }
+  collectMeshesFromRoots(t) {
+    const e = /* @__PURE__ */ new Set();
+    for (const n of t) {
+      n.getClassName() === "Mesh" && e.add(n);
+      for (const i of n.getChildMeshes(!1))
+        e.add(i);
+    }
+    return [...e];
+  }
+  getScene() {
+    const t = z.get(this.appObjects);
+    if (!t?.scene)
+      throw new Error("BabylonEntity scene is not available");
+    return t.scene;
+  }
+  get rootTransformNode() {
+    return this._rootTransformNode;
+  }
+  get nodesByObjectId() {
+    return this._nodesByObjectId;
+  }
+  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.cutoffKnobView.dispose(), this.lockView.dispose(), this.hitboxView.dispose(), super.dispose();
+  }
+  constructor(t) {
+    super(t, A.type), this.cutoffKnobView = Ut(t), this.lockView = St(t), this.hitboxView = jt(t);
+  }
+}
+const _t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AbbControllerBabylonView: A,
+  makeAbbControllerBabylonView: S
+}, Symbol.toStringTag, { value: "Module" }));
+async function Qt(o) {
+  const { id: t, appObjects: e, createIfMissing: n = !0 } = o;
+  if (!t) {
+    e.submitWarning(
+      "createBabylonAbbController",
+      "Expected non-empty component id"
+    );
+    return;
+  }
+  const i = u.get(e);
+  if (!i) {
+    e.submitWarning(
+      "createBabylonAbbController",
+      "Unable to find AbbControllerRepo"
+    );
+    return;
+  }
+  let s = r.getById(t, e);
+  if (!s && n && (s = i.createAbbControllerEntity(t)), !s) {
+    e.submitWarning(
+      "createBabylonAbbController",
+      "Unable to find AbbControllerEntity"
+    );
+    return;
+  }
+  const f = S(s.appObject);
+  return await f.load(), f;
+}
+class $t extends g {
+  vmsAreEqual = () => !0;
+  constructor(t) {
+    super(t, g.type);
+  }
+}
+class qt extends c {
+  powerOn = () => !0;
+  powerOff = () => !0;
+  togglePower = () => !0;
+  subscribeOnPoweredOn = () => () => {
+  };
+  subscribeOnPoweredOff = () => () => {
+  };
+  subscribeOnPowerOnBlockedByLockout = () => () => {
+  };
+  constructor(t) {
+    super(t, c.type);
+  }
+}
+class Yt extends l {
+  lockOut = () => !0;
+  unlock = () => !0;
+  toggleLockout = () => !0;
+  subscribeOnLockoutEngaged = () => () => {
+  };
+  subscribeOnLockoutDisengaged = () => () => {
+  };
+  subscribeOnLockoutBlockedByPower = () => () => {
+  };
+  constructor(t) {
+    super(t, l.type);
+  }
+}
+class Jt extends d {
+  execute = () => {
+  };
+  subscribeOnVoltageChecked = () => () => {
+  };
+  constructor(t) {
+    super(t, d.type);
+  }
+}
+class Xt extends h {
+  enableHitbox = () => {
+  };
+  disableHitbox = () => {
+  };
+  subscribeOnSelected = () => () => {
+  };
+  notifySelected = () => {
+  };
+  constructor(t) {
+    super(t, h.type);
+  }
+}
+export {
+  Lt as ABB_CONTROLLER_STATE_VERSION,
+  A as AbbControllerBabylonView,
+  d as AbbControllerCheckVoltageUC,
+  r as AbbControllerEntity,
+  Dt as AbbControllerEventKeys,
+  zt as AbbControllerFacade,
+  Bt as AbbControllerFeatureFactory,
+  l as AbbControllerLockoutUC,
+  g as AbbControllerPM,
+  c as AbbControllerPowerUC,
+  u as AbbControllerRepo,
+  h as AbbControllerSelectUC,
+  Jt as MockAbbControllerCheckVoltageUC,
+  Yt as MockAbbControllerLockoutUC,
+  $t as MockAbbControllerPM,
+  qt as MockAbbControllerPowerUC,
+  Xt as MockAbbControllerSelectUC,
+  Pt as abbControllerHitboxClicked,
+  b as abbControllerPMAdapter,
+  Ot as applyAbbControllerState,
+  rt as checkVoltage,
+  Kt as clearAbbControllerAssetCache,
+  Et as componentConfig,
+  q as createAbbController,
+  Qt as createBabylonAbbController,
+  ht as disableHitbox,
+  bt as enableHitbox,
+  xt as getAbbControllerAssetContainer,
+  wt as getAbbControllerState,
+  S as makeAbbControllerBabylonView,
+  it as makeAbbControllerCheckVoltageUC,
+  v as makeAbbControllerEntity,
+  Rt as makeAbbControllerFeatureFactory,
+  tt as makeAbbControllerLockoutUC,
+  mt as makeAbbControllerPM,
+  Y as makeAbbControllerPowerUC,
+  Q as makeAbbControllerRepo,
+  lt as makeAbbControllerSelectUC,
+  Ct as onAbbControllerSelected,
+  yt as onLockoutBlockedByPower,
+  kt as onLockoutDisengaged,
+  ft as onLockoutEngaged,
+  gt as onPowerOnBlockedByLockout,
+  dt as onPoweredOff,
+  ut as onPoweredOn,
+  pt as onVoltageChecked,
+  ct as setShowGhostLockHint,
+  ot as tryLockOut,
+  Z as tryPowerOff,
+  X as tryPowerOn,
+  V as tryToggleLockout,
+  U as tryTogglePower,
+  nt as tryUnlock
+};