@kosdev-code/kos-freestyle-sdk 2.1.16 → 2.1.18

package/freestyle-registration-manager-DSugLmqT.js

@@ -0,0 +1,1739 @@
+var pt = Object.defineProperty;
+var gt = (e, t, r) => t in e ? pt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var i = (e, t, r) => (gt(e, typeof t != "symbol" ? t + "" : t, r), r);
+import { resolveServiceUrl as w, ServiceFactory as S, KosLog as C, createPropKey as x, kosStateProp as O, kosConfigProperty as b, kosStateEntry as me, kosStateExit as ht, kosStateGuard as ye, kosFuture as _, kosModel as f, kosLoggerAware as ee, kosCompanion as Me, kosFutureAware as Re, kosStateMachine as ft, DependencyLifecycle as De, KosModelContainer as mt, kosChild as Le, kosModelEffect as be, EventBus as Y, KosModelRegistrationFactory as $, SingletonKosModelRegistrationFactory as Pe, FetchError as ve, FutureManager as y, FutureEndState as U, FutureHandler as Fe, kosParentAware as Ne, KosFeatureFlags as ne, getKosCompanionModel as yt, getKosModelSync as R, kosContainerAware as bt, KosContextManager as Pt, kosAction as K, KOS_MODEL_ID as E, kosMultipleFutureAware as vt, kosTopicHandler as Tt, modelTypeEventTopicFactory as It, RegistrationManager as m, registerCoreModels as _t, Trouble as Ct, ExtensionManager as le, EXTENSION_TROUBLE_DATA_MAPPER as ue } from "@kosdev-code/kos-ui-sdk";
+import { PourState as d, Assembly as ze, KosModelRegistry as $t, registerDispenseModels as Et, Nozzle as Ot, Pump as At, Holder as wt, PumpContainer as St, PumpIndex as Mt } from "@kosdev-code/kos-dispense-sdk";
+const { URL: xe } = w("ICE_AGITATOR_SERVICE"), { postModel: Rt } = S.build({
+  basePath: `${xe}/api/ext/freestyle/ice`
+});
+C.createLogger({
+  name: "carb-tank-service",
+  group: "Services"
+});
+const Dt = async (e, t) => {
+  const r = await Rt({
+    model: {},
+    tracker: t,
+    urlOverride: `${xe}/api/handle/${e}/test`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r == null ? void 0 : r.data;
+};
+var Ue = Object.defineProperty, Lt = Object.getOwnPropertyDescriptor, Ft = (e, t, r) => t in e ? Ue(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, P = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? Lt(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && Ue(t, r, a), a;
+}, Nt = (e, t, r) => (Ft(e, t + "", r), r);
+const zt = "carb-agitator-model", Te = x("statePath");
+let g = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "name");
+    i(this, "path");
+    i(this, "statePath");
+    i(this, "highProbeWet");
+    i(this, "lowProbeWet");
+    i(this, "filling");
+    i(this, "enabled");
+    var a;
+    this.id = e, this.name = t.name, this.path = ((a = r.kosContext.get("assembly-feature-carbTank")) == null ? void 0 : a.path) || "";
+    const o = r.kosContext.get("assembly-state-path-carbTank");
+    this.statePath = o;
+  }
+  get holder() {
+    var t;
+    return (t = this.getCompanionParent()) == null ? void 0 : t.getHoldersByGroup("carb")[0];
+  }
+  get pump() {
+    var e;
+    return (e = this.holder) == null ? void 0 : e.pumps.data[0];
+  }
+  get isFilling() {
+    return !!this.filling.value;
+  }
+  get isCarbInitialized() {
+    return !!this.enabled.value;
+  }
+  get canActivate() {
+    return !this.enabled.value;
+  }
+  get canProceed() {
+    return this.isInState(
+      "INITIALIZED"
+      /* INITIALIZED */
+    ) || this.isInState(
+      "SKIPPED"
+      /* SKIPPED */
+    );
+  }
+  handleActivationStart() {
+    this.logger.info("Carb tank activation started");
+  }
+  handleActivationComplete() {
+    this.logger.info("Carb tank initialized");
+  }
+  handleInitialized() {
+    this.logger.info("Carb tank ready to proceed");
+  }
+  handleSkipped() {
+    this.logger.info("Proceeding without carbinator");
+  }
+  async activateCarbTank() {
+    this.transition("ACTIVATE"), this.enabled.updateProperty(!0), this.transition("ACTIVATION_COMPLETE");
+  }
+  async deactivateCarbTank() {
+    this.enabled.updateProperty(!1), this.transition("RESET");
+  }
+  skip() {
+    this.transition("SKIP");
+  }
+  reset() {
+    this.enabled.updateProperty(!1), this.transition("RESET");
+  }
+  toggleCarbTank() {
+    this.enabled.value ? this.deactivateCarbTank() : this.activateCarbTank();
+  }
+  handleTestCarbTank(e) {
+    if (!e)
+      throw new Error("No tracker provided");
+    return this.logger.info(`testing carb tank:  ${this.id}`), Dt(this.path, e);
+  }
+};
+Nt(g, "Registration");
+P([
+  O({
+    path: Te,
+    attribute: "highProbeWet"
+  })
+], g.prototype, "highProbeWet", 2);
+P([
+  O({
+    path: Te,
+    attribute: "lowProbeWet"
+  })
+], g.prototype, "lowProbeWet", 2);
+P([
+  O({
+    path: Te,
+    attribute: "filling"
+  })
+], g.prototype, "filling", 2);
+P([
+  b({
+    path: "assembly:core:board:macksm:carbTank:carbTank",
+    attribute: "enabled"
+  })
+], g.prototype, "enabled", 2);
+P([
+  me(
+    "ACTIVATING"
+    /* ACTIVATING */
+  )
+], g.prototype, "handleActivationStart", 1);
+P([
+  ht(
+    "ACTIVATING"
+    /* ACTIVATING */
+  )
+], g.prototype, "handleActivationComplete", 1);
+P([
+  me(
+    "INITIALIZED"
+    /* INITIALIZED */
+  )
+], g.prototype, "handleInitialized", 1);
+P([
+  me(
+    "SKIPPED"
+    /* SKIPPED */
+  )
+], g.prototype, "handleSkipped", 1);
+P([
+  ye({ allowedStates: [
+    "UNINITIALIZED"
+    /* UNINITIALIZED */
+  ] })
+], g.prototype, "activateCarbTank", 1);
+P([
+  ye({ allowedStates: [
+    "UNINITIALIZED"
+    /* UNINITIALIZED */
+  ] })
+], g.prototype, "skip", 1);
+P([
+  ye({
+    allowedStates: [
+      "INITIALIZED",
+      "SKIPPED"
+      /* SKIPPED */
+    ]
+  })
+], g.prototype, "reset", 1);
+P([
+  _()
+], g.prototype, "handleTestCarbTank", 1);
+g = P([
+  f({ modelTypeId: zt, singleton: !1 }),
+  ee(),
+  Me({ mode: "composition", lifecycle: De.LOAD }),
+  Re(),
+  ft(
+    {
+      initial: "UNINITIALIZED",
+      states: {
+        UNINITIALIZED: {
+          on: {
+            ACTIVATE: "ACTIVATING",
+            SKIP: "SKIPPED"
+            /* SKIPPED */
+          }
+        },
+        ACTIVATING: {
+          on: {
+            ACTIVATION_COMPLETE: "INITIALIZED"
+            /* INITIALIZED */
+          }
+        },
+        INITIALIZED: {
+          on: {
+            RESET: "UNINITIALIZED"
+            /* UNINITIALIZED */
+          }
+        },
+        SKIPPED: {
+          on: {
+            RESET: "UNINITIALIZED"
+            /* UNINITIALIZED */
+          }
+        }
+      }
+    },
+    {
+      throwOnInvalid: !1
+      // Graceful handling for button clicks
+    }
+  )
+], g);
+const Ge = g.Registration;
+var xt = Object.defineProperty, Ut = Object.getOwnPropertyDescriptor, Ve = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? Ut(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && xt(t, r, a), a;
+};
+const je = "cartridge-agitator-container-model";
+let W = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "_models");
+    this.id = e, this.logger = r.logger, this._models = new mt({
+      parentId: e
+    });
+  }
+  getModel(e) {
+    return this._models.getModel(e);
+  }
+  get models() {
+    return this._models;
+  }
+  get data() {
+    return this._models.data;
+  }
+  addModel(e) {
+    this._models.addModel(e);
+  }
+  removeModel(e) {
+    this._models.removeModel(e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(
+      `initializing cartridge-agitator-container container ${this.id}`
+    );
+  }
+  async load() {
+    this.logger.debug(
+      `loading cartridge-agitator-container container ${this.id}`
+    );
+  }
+};
+Ve([
+  Le
+], W.prototype, "_models", 2);
+W = Ve([
+  f(je)
+], W);
+const { URL: qe } = w("CARTRIDGE_AGITATOR_SERVICE"), { postModel: Gt } = S.build({
+  basePath: `${qe}/api/ext/freestyle/freestyle/ice`
+}), Vt = async (e, t) => {
+  const r = await Gt({
+    model: {},
+    tracker: t,
+    urlOverride: `${qe}/api/handle/${e}/test`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r.data;
+};
+var jt = Object.defineProperty, qt = Object.getOwnPropertyDescriptor, te = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? qt(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && jt(t, r, a), a;
+};
+const Be = "cartridge-agitator-model";
+class Z {
+}
+i(Z, "TOPIC_AGITATION_STARTED", "/kos/events/ddk/agitation-started"), i(Z, "TOPIC_AGITATION_ENDED", "/kos/events/ddk/agitation-ended");
+const Bt = x("statePath");
+let F = class {
+  constructor(e, t) {
+    i(this, "id");
+    i(this, "agitating");
+    i(this, "path");
+    i(this, "statePath");
+    i(this, "name");
+    this.id = e, this.path = t.path, this.name = t.name, this.statePath = t.statePath;
+  }
+  get isAgitating() {
+    return !!this.agitating.value;
+  }
+  async testAgitate(e) {
+    if (!e)
+      throw new Error("No tracker provided");
+    return this.logger.info(`agitating cartridge-agitator ${this.id}`), Vt(this.path, e);
+  }
+  handleAgitation() {
+    var e;
+    this.isAgitating ? (this.logger.info(`agitating cartridge-agitator ${this.id}`), Y.publish(Z.TOPIC_AGITATION_STARTED, {
+      path: this.path,
+      futureId: (e = this.future) == null ? void 0 : e.futureId
+    })) : Y.publish(Z.TOPIC_AGITATION_ENDED, {
+      path: this.path
+    });
+  }
+};
+te([
+  O({ path: Bt, attribute: "agitating" })
+], F.prototype, "agitating", 2);
+te([
+  _()
+], F.prototype, "testAgitate", 1);
+te([
+  be({
+    dependencies: (e) => [e.isAgitating]
+  })
+], F.prototype, "handleAgitation", 1);
+F = te([
+  f(Be),
+  Re(),
+  ee()
+], F);
+const He = new $({
+  class: F,
+  type: Be
+}), Ie = new Pe({
+  class: W,
+  type: je
+});
+Ie.addRelatedModel(He);
+var Ke = Object.defineProperty, Ht = Object.getOwnPropertyDescriptor, Kt = (e, t, r) => t in e ? Ke(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, re = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? Ht(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && Ke(t, r, a), a;
+}, Yt = (e, t, r) => (Kt(e, t + "", r), r);
+const Wt = "cgp-pump-model", _e = x("statePath");
+let D = class {
+  constructor(e, t) {
+    i(this, "highProbeWet");
+    i(this, "lowProbeWet");
+    i(this, "filling");
+    i(this, "id");
+    i(this, "state");
+    var r;
+    this.id = e, this.state = ((r = t.data) == null ? void 0 : r.state) ?? { name: "unknown", path: "" };
+  }
+  get statePath() {
+    return this.state.path;
+  }
+};
+Yt(D, "Registration");
+re([
+  O({
+    path: _e,
+    attribute: "highProbeWet"
+  })
+], D.prototype, "highProbeWet", 2);
+re([
+  O({
+    path: _e,
+    attribute: "lowProbeWet"
+  })
+], D.prototype, "lowProbeWet", 2);
+re([
+  O({
+    path: _e,
+    attribute: "filling"
+  })
+], D.prototype, "filling", 2);
+D = re([
+  f({ modelTypeId: Wt, singleton: !1 }),
+  Me({
+    mode: "composition"
+  }),
+  ee()
+], D);
+const Zt = D.Registration, { URL: G } = w("FCM-PUMP_SERVICE"), { postModel: q } = S.build({
+  basePath: `${G}/api/fcm-pump`
+}), h = C.createLogger({
+  name: "fcm-pump-service",
+  group: "Services"
+}), kt = async (e) => {
+  var t, r, o, a, n;
+  h.debug(
+    `performElectricalTest - sending POST request to /api/ext/freestyle/fcm/diagnostics/${e}/electricalTest`
+  );
+  try {
+    const s = await q({
+      model: {},
+      urlOverride: `${G}/api/ext/freestyle/fcm/diagnostics/${e}/electricalTest`
+    });
+    return h.debug("performElectricalTest - response:", s), ((s == null ? void 0 : s.status) === 200 || (s == null ? void 0 : s.status) === 499) && ((t = s.data) != null && t.error) ? [s.data.error || "unknownError", s.data] : [void 0, s == null ? void 0 : s.data];
+  } catch (s) {
+    if (h.error(
+      `performElectricalTest - sending POST request to /api/ext/freestyle/fcm/diagnostics/${e}/electricalTest`,
+      s
+    ), s instanceof ve) {
+      const u = ((o = (r = s.payload) == null ? void 0 : r.data) == null ? void 0 : o.error) || ((a = s.payload) == null ? void 0 : a.error) || "unknownError";
+      return [u, ((n = s.payload) == null ? void 0 : n.data) || { error: u }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+}, Qt = async (e, t) => {
+  h.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/preCalibrate`
+  );
+  try {
+    const r = await q({
+      model: {},
+      urlOverride: `${G}/api/ext/freestyle/fcm/calibration/${e}/preCalibrate`,
+      tracker: t
+    });
+    return h.debug("performPreCalibrate - response:", r), r != null && r.data && y.initiateFuture(r.data), r == null ? void 0 : r.data;
+  } catch (r) {
+    h.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/preCalibrate`,
+      r
+    );
+    const o = {
+      id: t || "",
+      endState: U.Fail,
+      tracker: t,
+      reason: "Failed to resolve trouble"
+    };
+    return y.initiateFuture(o), o;
+  }
+}, Xt = async (e, t) => {
+  h.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/calibrate`
+  );
+  try {
+    const r = await q({
+      model: {},
+      urlOverride: `${G}/api/ext/freestyle/fcm/calibration/${e}/calibrate`,
+      tracker: t
+    });
+    return h.debug("performPreCalibrate - response:", r), r != null && r.data && y.initiateFuture(r.data), r == null ? void 0 : r.data;
+  } catch (r) {
+    h.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/calibrate`,
+      r
+    );
+    const o = {
+      id: t || "",
+      endState: U.Fail,
+      tracker: t,
+      reason: "Failed to resolve trouble"
+    };
+    return y.initiateFuture(o), o;
+  }
+}, Jt = async (e, t, r) => {
+  h.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/verify/${t}`
+  );
+  try {
+    const o = await q({
+      model: {},
+      urlOverride: `${G}/api/ext/freestyle/fcm/calibration/${e}/verify/${t}`,
+      tracker: r
+    });
+    return h.debug("performVerify - response:", o), o != null && o.data && y.initiateFuture(o.data), o == null ? void 0 : o.data;
+  } catch (o) {
+    h.error(
+      `performVerify - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/verify/${t}`,
+      o
+    );
+    const a = {
+      id: r || "",
+      endState: U.Fail,
+      tracker: r,
+      reason: "Failed to resolve trouble"
+    };
+    return y.initiateFuture(a), a;
+  }
+}, er = (e) => e ? e.data === "success" || !e.data ? "success" : e.data : "error", tr = async (e, t, r) => {
+  h.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/complete/${t}/${r}`
+  );
+  try {
+    const o = await q({
+      model: {},
+      urlOverride: `${G}/api/ext/freestyle/fcm/calibration/${e}/complete/${t}/${r}`
+    });
+    return h.debug("performPreCalibrate - response:", o), er(o == null ? void 0 : o.data);
+  } catch (o) {
+    h.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${e}/complete/${t}/${r}`,
+      o
+    );
+    return;
+  }
+};
+var rr = Object.defineProperty, ar = Object.getOwnPropertyDescriptor, ae = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? ar(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && rr(t, r, a), a;
+};
+const Ye = "fcm-pump-model", or = C.createLogger({ name: "fcm-pump-model" });
+let N = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "pumpModel");
+    i(this, "futureHandler");
+    this.id = e, this.logger = r.logger, this.pumpModel = t.companionParent, this.futureHandler = new Fe(this);
+  }
+  get future() {
+    return this.futureHandler.future;
+  }
+  get name() {
+    return this.pumpModel.name;
+  }
+  get canPour() {
+    return this.pumpModel.canPour;
+  }
+  get isPouring() {
+    return this.pumpModel.isPouring;
+  }
+  async cancelPour() {
+    return this.pumpModel.cancelPour();
+  }
+  performIntent(e) {
+    return this.pumpModel.performIntent(e);
+  }
+  async performElectricalTest() {
+    const [e, t] = await kt(this.pumpModel.path);
+    return e && or.error(`Failed to perform electrical test on pump ${this.id}`, e), t;
+  }
+  getChildren() {
+    return [...this.futureHandler.allFutures];
+  }
+  async performPreCalibrate(e) {
+    return Qt(this.pumpModel.path, e);
+  }
+  async performCalibrate(e) {
+    return Xt(this.pumpModel.path, e);
+  }
+  async performVerify(e, t) {
+    return Jt(this.pumpModel.path, e, t);
+  }
+  async performComplete(e, t) {
+    return tr(this.pumpModel.path, e, t);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing fcm-pump ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading fcm-pump ${this.id}`);
+  }
+};
+ae([
+  _()
+], N.prototype, "performPreCalibrate", 1);
+ae([
+  _()
+], N.prototype, "performCalibrate", 1);
+ae([
+  _()
+], N.prototype, "performVerify", 1);
+N = ae([
+  f(Ye)
+], N);
+const ir = new $({
+  class: N,
+  type: Ye
+});
+var sr = Object.defineProperty, nr = Object.getOwnPropertyDescriptor, We = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? nr(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && sr(t, r, a), a;
+};
+const Ze = "freestyle-assembly-model", lr = "iceAgitator", ur = "carbTank", cr = "remoteTrays";
+let k = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "_carbTankModel");
+    i(this, "logger");
+    i(this, "assembly");
+    i(this, "_remoteTrays");
+    this.id = e, this.logger = r.logger, this.assembly = t.companionParent;
+  }
+  get holderGroups() {
+    return this.assembly.holderGroups;
+  }
+  get nozzlePaths() {
+    return this.assembly.nozzlePaths;
+  }
+  get allHolders() {
+    return this.assembly.allHolders;
+  }
+  getHoldersByGroup(e) {
+    return this.assembly.getHoldersByGroup(e);
+  }
+  getHoldersByNozzle(e) {
+    return this.assembly.getHoldersByNozzle(e);
+  }
+  get pumpsByNozzle() {
+    return this.assembly.pumpsByNozzle;
+  }
+  get pumpPaths() {
+    return this.assembly.pumpPaths;
+  }
+  get boards() {
+    return this.assembly.boards;
+  }
+  updateModel(e) {
+    return this.assembly.updateModel(e);
+  }
+  get iceAgitator() {
+    return this.assembly.iceAgitator;
+  }
+  get carbTank() {
+    return this._carbTankModel;
+  }
+  get cartridgeAgitators() {
+    return this.assembly.cartridgeAgitators;
+  }
+  get defaultCartridgeAgitator() {
+    return this.assembly.cartridgeAgitators.data[0];
+  }
+  get cartridgeAgitatorModels() {
+    return this.assembly.cartridgeAgitators.data;
+  }
+  get hasCartridgeAgitators() {
+    return this.assembly.cartridgeAgitators.data.length > 0;
+  }
+  get remoteTrays() {
+    return this.assembly.remoteTrays;
+  }
+  get hasRemoteTrays() {
+    return this.assembly.remoteTrays ? this.assembly.remoteTrays.data.length > 0 : !1;
+  }
+  // -------------------LIFECYCLE----------------------------
+  get supportsRemoteTrays() {
+    return ne.isFeatureEnabled(cr);
+  }
+  get supportsIce() {
+    return ne.isFeatureEnabled(lr);
+  }
+  get supportsCarb() {
+    return ne.isFeatureEnabled(ur);
+  }
+  async init() {
+    this.logger.debug(`initializing freestyle-assembly ${this.id}`);
+  }
+  async ready() {
+    const e = yt(
+      this.assembly,
+      Ge.type
+    );
+    this._carbTankModel = e;
+  }
+};
+We([
+  Le
+], k.prototype, "_remoteTrays", 2);
+k = We([
+  Ne(),
+  f(Ze)
+], k);
+const de = new Pe({
+  class: k,
+  type: Ze
+});
+var dr = Object.defineProperty, pr = Object.getOwnPropertyDescriptor, ke = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? pr(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && dr(t, r, a), a;
+};
+const Qe = "remote-tray-model";
+x("holderPath");
+const gr = x("configPath");
+let Q = class {
+  constructor(e, t, r) {
+    /** Unique identifier for the remote tray instance */
+    i(this, "id");
+    i(this, "logger");
+    /** Path reference to the associated holder model */
+    i(this, "holderPath");
+    /** Configuration path for tray-specific settings */
+    i(this, "configPath");
+    /** Display name of the remote tray */
+    i(this, "name");
+    i(this, "remoteTrayEnabled");
+    this.id = e, this.logger = r.logger, this.holderPath = t.holderPath, this.configPath = t.configPath, this.name = t.name;
+  }
+  /**
+   * Gets the troubles from the associated holder model.
+   * Propagates trouble states from the holder to this remote tray.
+   *
+   * @returns Array of trouble models from the holder, or empty array if no holder
+   */
+  get troubles() {
+    var e;
+    return ((e = this.holder) == null ? void 0 : e.troubles) ?? [];
+  }
+  /**
+   * Gets the highest priority trouble status.
+   * Currently returns empty string as troubles are managed by the holder.
+   *
+   * @returns Empty string (trouble status handled by holder)
+   */
+  get troubleStatus() {
+    return "";
+  }
+  /**
+   * Gets troubles grouped by type from the associated holder.
+   *
+   * @returns Record of troubles grouped by type from the holder, or empty object if no holder
+   */
+  get troublesByType() {
+    var e;
+    return ((e = this.holder) == null ? void 0 : e.troublesByType) ?? {};
+  }
+  /**
+   * Updates the model with new configuration options.
+   * Can be used to modify the holder path, config path, or name after initialization.
+   *
+   * @param _options - New configuration options for the remote tray
+   */
+  updateModel(e) {
+  }
+  /**
+   * Gets the associated holder model for this remote tray.
+   * Uses synchronous model lookup to retrieve the holder by path.
+   *
+   * @returns The HolderModel instance referenced by holderPath, or undefined if not found
+   */
+  get holder() {
+    return R(this.holderPath).model;
+  }
+  /**
+   * Determines if the remote tray is currently active.
+   * Active state is based on the remoteTrayEnabled configuration property.
+   *
+   * @returns true if the tray is enabled, false otherwise
+   */
+  get active() {
+    return !!this.remoteTrayEnabled.value;
+  }
+  // -------------------LIFECYCLE----------------------------
+  /**
+   * Initializes the remote tray model.
+   * Called during the model lifecycle initialization phase.
+   * Sets up initial state and prepares the model for use.
+   *
+   * @returns Promise that resolves when initialization is complete
+   */
+  async init() {
+    this.logger.debug(`initializing remote-tray ${this.id}`);
+  }
+  /**
+   * Loads the remote tray configuration and associated data.
+   * Called during the model lifecycle load phase.
+   * Typically loads configuration settings and establishes holder references.
+   *
+   * @returns Promise that resolves when loading is complete
+   */
+  async load() {
+    this.logger.debug(`loading remote-tray ${this.id}`);
+  }
+};
+ke([
+  b({
+    path: gr,
+    attribute: "enabled"
+  })
+], Q.prototype, "remoteTrayEnabled", 2);
+Q = ke([
+  f(Qe)
+], Q);
+const V = new $({
+  class: Q,
+  type: Qe
+});
+var hr = Object.getOwnPropertyDescriptor, fr = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? hr(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = s(a) || a);
+  return a;
+};
+const Xe = "remote-tray-container-model";
+let pe = class {
+  constructor(e) {
+    i(this, "id");
+    this.id = e;
+  }
+};
+pe = fr([
+  f(Xe),
+  ee(),
+  bt()
+], pe);
+const Ce = new Pe({
+  class: pe,
+  type: Xe
+});
+Ce.addRelatedModel(V);
+var mr = Object.getOwnPropertyDescriptor, yr = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? mr(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = s(a) || a);
+  return a;
+};
+const Je = "freestyle-holder-model";
+function br(e) {
+  const t = Pt.getContext(e), r = t == null ? void 0 : t.get(
+    de.type
+  );
+  if (!r) {
+    C.error("Freestyle assembly not found");
+    return;
+  }
+  return r;
+}
+async function Pr(e, t) {
+  if (!e || !t)
+    return;
+  const r = await e[t]();
+  if (r != null && r.tracker)
+    return y.getFuture(r.tracker);
+}
+let ge = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "holder");
+    i(this, "context");
+    i(this, "future");
+    this.id = e, this.logger = r.logger, this.context = r.kosContext, this.holder = t.companionParent;
+  }
+  get agitated() {
+    return this.holder.data.agitated;
+  }
+  async agitate() {
+    if (!this.holder.data.agitated)
+      return;
+    this.future = void 0;
+    const e = br(this.id);
+    if (!e)
+      return;
+    if (!e.defaultCartridgeAgitator) {
+      this.logger.error("Agitator not found");
+      return;
+    }
+    return this.future = await Pr(
+      e.defaultCartridgeAgitator,
+      "testAgitate"
+    ), this.future;
+  }
+  get isRemote() {
+    const e = `${V.type}-${this.holder.path}`, t = R(e);
+    return t != null && t.model ? !!t.model.remoteTrayEnabled.value : !1;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing freestyle-holder ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading freestyle-holder ${this.id}`);
+  }
+};
+ge = yr([
+  f(Je)
+], ge);
+const Oe = new $({
+  class: ge,
+  type: Je
+}), { URL: vr } = w("FREESTYLE-NOZZLE_SERVICE"), { getOne: Tr } = S.build({
+  basePath: `${vr}/api/freestyle-nozzle`
+}), H = C.createLogger({
+  name: "freestyle-nozzle-service",
+  group: "Services"
+});
+class Ir extends Error {
+  constructor(t) {
+    super(t), this.name = "NutritionInfoError";
+  }
+}
+class Ae extends Error {
+  constructor(t) {
+    super(t), this.name = "InvalidRequestError";
+  }
+}
+const _r = async (e, t, r, o = "http://localhost:8081") => {
+  if (H.debug("sending GET for freestyle-nozzle"), !t)
+    throw H.error("Invalid freestyle-nozzle request: beverageId is required"), new Ae("No beverageId provided");
+  if (!r || r.length === 0)
+    throw H.error("Invalid freestyle-nozzle request: volumes are required"), new Ae("No volumes provided");
+  const a = await Tr({
+    urlOverride: `${o}${e}/pipeline/beverage/engine/nutrition/${t}?volumes=${r.join(
+      ","
+    )}`
+  });
+  if (!(a != null && a.data))
+    throw H.error("Failed to retrieve freestyle-nozzle data"), new Error("Failed to retrieve freestyle-nozzle data");
+  if (a.data.error)
+    throw new Ir(a.data.error);
+  return a.data;
+};
+var Cr = Object.defineProperty, $r = Object.getOwnPropertyDescriptor, et = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? $r(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && Cr(t, r, a), a;
+};
+const tt = "freestyle-nozzle-model";
+let X = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "nozzleModel");
+    i(this, "_cupSizes");
+    i(this, "_nutritionInfo");
+    this.id = e, this.logger = r.logger, this.nozzleModel = t.companionParent, this._cupSizes = [100];
+  }
+  set cupSizes(e) {
+    this._cupSizes = e;
+  }
+  get nutritionInfo() {
+    return this._nutritionInfo;
+  }
+  get selectedPourable() {
+    return this.nozzleModel.selectedPourable;
+  }
+  async handleBeverageSelection() {
+    if (this.nozzleModel.selectedPourable.beverage && this._cupSizes.length) {
+      this.logger.debug(
+        `selected beverage: ${this.nozzleModel.selectedPourable.beverage.rawId}.  Volume: ${this._cupSizes.join(", ")}`
+      );
+      const e = this.nozzleModel.selectedPourable.beverage.rawId, t = this.nozzleModel.urlPrefix;
+      try {
+        const r = await _r(
+          t,
+          e,
+          this._cupSizes
+        );
+        K(() => {
+          this._nutritionInfo = r;
+        });
+      } catch (r) {
+        this.logger.error(`Error fetching nutrition info: ${r}`);
+      }
+    }
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing freestyle-nozzle ${this.id}`);
+  }
+  unload() {
+    this.logger.debug(`unloading freestyle-nozzle ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading freestyle-nozzle ${this.id}`);
+  }
+};
+et([
+  be({
+    dependencies: (e) => [
+      e.selectedPourable.beverage
+    ]
+  })
+], X.prototype, "handleBeverageSelection", 1);
+X = et([
+  Ne(),
+  f(tt)
+], X);
+const we = new $({
+  class: X,
+  type: tt
+}), { URL: rt } = w("PUMP_SERVICE"), { postModel: Er } = S.build({
+  basePath: `${rt}/api/ext/freestyle/microCalibration`
+}), ce = C.createLogger({
+  name: "freestyle-pump-service",
+  group: "Services"
+}), Or = async (e, t) => {
+  var r, o, a, n, s;
+  ce.debug(
+    `replacePump - sending POST request to /api/ext/freestyle/microCalibration/cal/${e}/code/${t}`
+  );
+  try {
+    const u = await Er({
+      model: {},
+      urlOverride: `${rt}/api/ext/freestyle/microCalibration/cal/${e}/code/${t}`
+    });
+    return ce.debug("replacePump - response:", u), ((u == null ? void 0 : u.status) === 200 || (u == null ? void 0 : u.status) === 499) && ((r = u.data) != null && r.error) ? [u.data.error || "unknownError", u.data] : [void 0, u == null ? void 0 : u.data];
+  } catch (u) {
+    if (ce.error(
+      `replacePump - sending POST request to /api/cal/${e}/code/${t}`,
+      u
+    ), u instanceof ve) {
+      const A = ((a = (o = u.payload) == null ? void 0 : o.data) == null ? void 0 : a.error) || ((n = u.payload) == null ? void 0 : n.error) || "unknownError";
+      return [A, ((s = u.payload) == null ? void 0 : s.data) || { error: A }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+};
+var Ar = Object.getOwnPropertyDescriptor, wr = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? Ar(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = s(a) || a);
+  return a;
+};
+const at = "freestyle-pump-model";
+let he = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "pump");
+    this.id = e, this.logger = r.logger, this.pump = t.companionParent;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async replacePump(e) {
+    const [t, r] = await Or(this.pump.path, e);
+    return t && this.logger.error(`Failed to replace the pump, ${this.pump.id}`, t), [t, r];
+  }
+};
+he = wr([
+  f(at)
+], he);
+const Se = new $({
+  class: he,
+  type: at
+}), { URL: L } = w("ICE_AGITATOR_SERVICE"), { getAll: ot, postModel: oe } = S.build({
+  basePath: `${L}/api/ext/freestyle/ice`
+}), it = C.createLogger({
+  name: "ice-agitator-service",
+  group: "Services"
+}), Sr = async (e) => (it.debug("sending GET for ice types"), await ot({
+  urlOverride: `${L}/api/handle/${e}/types`
+})), Mr = async (e, t) => (it.debug("sending POST for ice types"), await oe({
+  urlOverride: `${L}/api/handle/${e}/type/${t}`,
+  model: {}
+})), Rr = async (e) => await ot({
+  urlOverride: `${L}/api/kos/config/details/${e}/4`
+}), Dr = async (e, t) => {
+  const r = await oe({
+    model: {},
+    tracker: t,
+    urlOverride: `${L}/api/handle/${e}/pour`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r == null ? void 0 : r.data;
+}, Lr = async (e, t) => {
+  const r = await oe({
+    model: {},
+    tracker: t,
+    urlOverride: `${L}/api/handle/${e}/test/agitation`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r == null ? void 0 : r.data;
+}, Fr = async (e, t) => {
+  const r = await oe({
+    model: {},
+    tracker: t,
+    urlOverride: `${L}/api/handle/${e}/test/gate`
+  });
+  if (!(r != null && r.data))
+    throw new Error("No response from server");
+  return r == null ? void 0 : r.data;
+};
+var Nr = Object.defineProperty, zr = Object.getOwnPropertyDescriptor, p = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? zr(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && Nr(t, r, a), a;
+};
+class J {
+}
+i(J, "TOPIC_AGITATION_STARTED", "/kos/events/ddk/ice-agitation-started"), i(J, "TOPIC_AGITATION_ENDED", "/kos/events/ddk/ice-agitation-ended");
+const st = "ice-agitator-model", nt = x("statePath");
+let c = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "name");
+    i(this, "path");
+    i(this, "volWithoutIceMl");
+    i(this, "durationSec");
+    i(this, "enableIceChuteClear");
+    i(this, "iceChuteClearDurationMs");
+    i(this, "iceChuteClearIntervalSec");
+    i(this, "iceChuteClearRetryIntervalSec");
+    i(this, "maxDispenseSec");
+    i(this, "type");
+    i(this, "dilutionOffset");
+    i(this, "inactivitySec");
+    i(this, "agitating");
+    i(this, "iceChuteOpen");
+    i(this, "statePath");
+    i(this, "_allIceTypes");
+    i(this, "logger");
+    i(this, "currentState", d.IDLE);
+    i(this, "resetDefaultValues", async () => await Rr(this.path));
+    this.id = e, this.name = t.name, this.path = t.path, this.statePath = t.statePath, this._allIceTypes = [], this.logger = r.logger;
+  }
+  get iceTypes() {
+    return this._allIceTypes;
+  }
+  get isAgitating() {
+    return !!this.agitating.value;
+  }
+  get isIceChuteOpen() {
+    return !!this.iceChuteOpen.value;
+  }
+  // future, pourFuture, agitateFuture, gateFuture getters are now provided by @kosMultipleFutureAware decorator
+  /**
+   * A derived value that indicates if the nozzle is currently pouring a beverage.
+   * @readonly
+   */
+  get isPouring() {
+    var e;
+    return !!(this.pourFuture && !((e = this.pourFuture) != null && e.endState)) || this.currentState === d.POUR_STARTING || this.currentState === d.POURING || this.currentState === d.POUR_CANCELING;
+  }
+  /**
+   * A derived value that indicates if it is possible to dispense ice.
+   *
+   * The value is observable and will change as the current dispense state changes
+   * @readonly
+   * */
+  get canPour() {
+    return this.currentState === d.IDLE;
+  }
+  updateIfCurrent(e, t) {
+    this.currentState === e && K(() => {
+      this.currentState = t;
+    });
+  }
+  async pourIce(e) {
+    try {
+      if (this.currentState === d.IDLE) {
+        if (this.updateIfCurrent(d.IDLE, d.POUR_STARTING), !e)
+          throw new Error("No tracker provided");
+        const t = await Dr(this.path, e);
+        return this.updateIfCurrent(d.POUR_STARTING, d.POURING), t != null && t.endState && this.updateIfCurrent(d.POURING, d.IDLE), t;
+      } else
+        throw new Error(`Cannot pour in state ${this.currentState}`);
+    } catch (t) {
+      throw this.logger.error(t), this.currentState = d.IDLE, t;
+    }
+  }
+  /**
+   * An action that will cancel the ice dispense if it is currently in progress.
+   * */
+  async cancelIceDispense() {
+    var e;
+    this.currentState === d.POURING || this.currentState === d.POUR_STARTING ? (this.currentState = d.POUR_CANCELING, await ((e = this.pourFuture) == null ? void 0 : e.cancelFuture()), K(() => {
+      this.currentState = d.IDLE;
+    })) : this.logger.warn(
+      `Cannot cancel ice dispense in state ${this.currentState}`
+    );
+  }
+  async testAgitate(e) {
+    if (!e)
+      throw new Error("No tracker provided");
+    return this.logger.info(`agitating ice-agitator ${this.id}`), Lr(this.path, e);
+  }
+  async testGate(e) {
+    if (!e)
+      throw new Error("No tracker provided");
+    return this.logger.info(`testing ice gate:  ${this.id}`), Fr(this.path, e);
+  }
+  handleAgitationChange() {
+    var e;
+    this.isAgitating ? (this.logger.info(`agitating ice-agitator ${this.id}`), Y.publish(J.TOPIC_AGITATION_STARTED, {
+      path: this.path,
+      futureId: (e = this.futureHandler.future) == null ? void 0 : e.futureId
+    })) : Y.publish(J.TOPIC_AGITATION_ENDED, {
+      path: this.path
+    });
+  }
+  async updateIceType(e) {
+    await Mr(this.path, e);
+  }
+  async init() {
+    this.logger.debug(`initializing ice-agitator ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading ice-agitator ${this.id}`);
+    const e = await Sr(this.path);
+    (e == null ? void 0 : e.status) === 200 && K(() => {
+      this._allIceTypes = e.data || [];
+    });
+  }
+};
+p([
+  b({
+    path: E,
+    attribute: "settings.volWithoutIceMl"
+  })
+], c.prototype, "volWithoutIceMl", 2);
+p([
+  b({
+    path: E,
+    attribute: "settings.durationSec",
+    converter: {
+      to: "second"
+    }
+  })
+], c.prototype, "durationSec", 2);
+p([
+  b({
+    path: E,
+    attribute: "enableIceChuteClear"
+  })
+], c.prototype, "enableIceChuteClear", 2);
+p([
+  b({
+    path: E,
+    attribute: "iceChuteClearDurationMs"
+  })
+], c.prototype, "iceChuteClearDurationMs", 2);
+p([
+  b({
+    path: E,
+    attribute: "iceChuteClearIntervalSec"
+  })
+], c.prototype, "iceChuteClearIntervalSec", 2);
+p([
+  b({
+    path: E,
+    attribute: "iceChuteClearRetryIntervalSec"
+  })
+], c.prototype, "iceChuteClearRetryIntervalSec", 2);
+p([
+  b({
+    path: E,
+    attribute: "maxDispenseSec"
+  })
+], c.prototype, "maxDispenseSec", 2);
+p([
+  b({
+    path: E,
+    attribute: "type"
+  })
+], c.prototype, "type", 2);
+p([
+  b({
+    path: E,
+    attribute: "settings.dilutionOffset"
+  })
+], c.prototype, "dilutionOffset", 2);
+p([
+  b({
+    path: E,
+    attribute: "settings.inactivitySec",
+    converter: {
+      to: "minute"
+    }
+  })
+], c.prototype, "inactivitySec", 2);
+p([
+  O({ path: nt, attribute: "agitating" })
+], c.prototype, "agitating", 2);
+p([
+  O({ path: nt, attribute: "iceChuteOpen" })
+], c.prototype, "iceChuteOpen", 2);
+p([
+  _({ alias: "pour" })
+], c.prototype, "pourIce", 1);
+p([
+  _({ alias: "agitate" })
+], c.prototype, "testAgitate", 1);
+p([
+  _({
+    alias: "gate"
+  })
+], c.prototype, "testGate", 1);
+p([
+  be({
+    dependencies: (e) => [e.isAgitating]
+  })
+], c.prototype, "handleAgitationChange", 1);
+c = p([
+  f(st),
+  vt()
+], c);
+const lt = new $({
+  class: c,
+  type: st
+});
+var xr = Object.getOwnPropertyDescriptor, Ur = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? xr(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = s(a) || a);
+  return a;
+};
+const ut = "lfcv-pump-model";
+let fe = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "pumpModel");
+    this.id = e, this.logger = r.logger, this.pumpModel = t.companionParent;
+  }
+  get name() {
+    return this.pumpModel.name;
+  }
+  get canPour() {
+    return this.pumpModel.canPour;
+  }
+  get isPouring() {
+    return this.pumpModel.isPouring;
+  }
+  async cancelPour() {
+    return this.pumpModel.cancelPour();
+  }
+  performIntent(e) {
+    return this.pumpModel.performIntent(e);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing lfcv-pump ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading lfcv-pump ${this.id}`);
+  }
+};
+fe = Ur([
+  f(ut)
+], fe);
+const Gr = new $({
+  class: fe,
+  type: ut
+}), { URL: Vr } = w("LFCV-PUMP_SERVICE"), { getAll: jr } = S.build({
+  basePath: `${Vr}/api/lfcv-pump`
+}), qr = C.createLogger({
+  name: "lfcv-pump-service",
+  group: "Services"
+}), ua = async () => (qr.debug("sending GET for lfcv-pump"), await jr({})), { URL: B } = w("SPM-PUMP_SERVICE"), { postModel: ie } = S.build({
+  basePath: `${B}/api/spm-pump`
+}), T = C.createLogger({
+  name: "spm-pump-service",
+  group: "Services"
+}), Br = async (e, t) => {
+  T.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/preCalibrate`
+  );
+  try {
+    const r = await ie({
+      model: {},
+      urlOverride: `${B}/api/ext/freestyle/microCalibration/pour/${e}/preCalibrate`,
+      tracker: t
+    });
+    return T.debug("performPreCalibrate - response:", r), r != null && r.data && y.initiateFuture(r.data), r == null ? void 0 : r.data;
+  } catch (r) {
+    T.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/preCalibrate`,
+      r
+    );
+    const o = {
+      id: t || "",
+      endState: U.Fail,
+      tracker: t,
+      reason: "Failed to resolve trouble"
+    };
+    return y.initiateFuture(o), o;
+  }
+}, Hr = async (e, t) => {
+  T.debug(
+    `performCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/calibrate`
+  );
+  try {
+    const r = await ie({
+      model: {},
+      urlOverride: `${B}/api/ext/freestyle/microCalibration/pour/${e}/calibrate`,
+      tracker: t
+    });
+    return T.debug("performCalibrate - response:", r), r != null && r.data && y.initiateFuture(r.data), r == null ? void 0 : r.data;
+  } catch (r) {
+    T.error(
+      `performCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/calibrate`,
+      r
+    );
+    const o = {
+      id: t || "",
+      endState: U.Fail,
+      tracker: t,
+      reason: "Failed to resolve trouble"
+    };
+    return y.initiateFuture(o), o;
+  }
+}, Kr = async (e, t, r, o) => {
+  T.debug(
+    `performVerify - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/verify`
+  );
+  try {
+    const a = await ie({
+      model: {
+        ...r,
+        // commandedCalibrationVolume: 0,
+        measuredCalibrationVolume: t
+        // measuredVerificationVolume: 0,
+        // newCalibrationValue: 0,
+        // pouredCalibrationVolume: 0,
+      },
+      urlOverride: `${B}/api/ext/freestyle/microCalibration/pour/${e}/verify`,
+      tracker: o
+    });
+    return T.debug("performVerify - response:", a), a != null && a.data && y.initiateFuture(a.data), a == null ? void 0 : a.data;
+  } catch (a) {
+    T.error(
+      `performVerify - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/verify`,
+      a
+    );
+    const n = {
+      id: o || "",
+      endState: U.Fail,
+      tracker: o,
+      reason: "Failed to resolve trouble"
+    };
+    return y.initiateFuture(n), n;
+  }
+}, Yr = async (e, t, r, o) => {
+  var a, n, s, u, A;
+  T.debug(
+    `performComplete - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/complete`
+  );
+  try {
+    const l = await ie({
+      model: {
+        ...o,
+        // commandedCalibrationVolume: 0,
+        measuredCalibrationVolume: t,
+        measuredVerificationVolume: r
+        // newCalibrationValue: 0,
+        // pouredCalibrationVolume: 0,
+      },
+      urlOverride: `${B}/api/ext/freestyle/microCalibration/pour/${e}/complete`
+    });
+    return T.debug("performComplete - response:", l), ((l == null ? void 0 : l.status) === 200 || (l == null ? void 0 : l.status) === 499) && ((a = l.data) != null && a.error) ? [l.data.error || "unknownError", l.data] : [void 0, l == null ? void 0 : l.data];
+  } catch (l) {
+    if (T.error(
+      `performComplete - sending POST request to /api/ext/freestyle/microCalibration/pour/${e}/complete`,
+      l
+    ), l instanceof ve) {
+      const v = ((s = (n = l.payload) == null ? void 0 : n.data) == null ? void 0 : s.error) || ((u = l.payload) == null ? void 0 : u.error) || "unknownError";
+      return [v, ((A = l.payload) == null ? void 0 : A.data) || { error: v }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+};
+var Wr = Object.defineProperty, Zr = Object.getOwnPropertyDescriptor, se = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? Zr(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && Wr(t, r, a), a;
+};
+const ct = "spm-pump-model";
+let z = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "pump");
+    i(this, "futureHandler");
+    this.id = e, this.logger = r.logger, this.pump = t.companionParent, this.futureHandler = new Fe(this);
+  }
+  get name() {
+    return this.pump.name;
+  }
+  get canPour() {
+    return this.pump.canPour;
+  }
+  get isPouring() {
+    return this.pump.isPouring;
+  }
+  async cancelPour() {
+    return this.pump.cancelPour();
+  }
+  performIntent(e) {
+    return this.pump.performIntent(e);
+  }
+  get future() {
+    return this.futureHandler.future;
+  }
+  async performPreCalibrate(e) {
+    return Br(this.pump.path, e);
+  }
+  async performCalibrate(e) {
+    return Hr(this.pump.path, e);
+  }
+  async performVerify(e, t, r) {
+    return Kr(this.pump.path, e, t, r);
+  }
+  async performComplete(e, t, r) {
+    return Yr(this.pump.path, e, t, r);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing spm-pump ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading spm-pump ${this.id}`);
+  }
+};
+se([
+  _()
+], z.prototype, "performPreCalibrate", 1);
+se([
+  _()
+], z.prototype, "performCalibrate", 1);
+se([
+  _()
+], z.prototype, "performVerify", 1);
+z = se([
+  f(ct)
+], z);
+const kr = new $({
+  class: z,
+  type: ct
+});
+var Qr = Object.defineProperty, Xr = Object.getOwnPropertyDescriptor, $e = (e, t, r, o) => {
+  for (var a = o > 1 ? void 0 : o ? Xr(t, r) : t, n = e.length - 1, s; n >= 0; n--)
+    (s = e[n]) && (a = (o ? s(t, r, a) : s(a)) || a);
+  return o && a && Qr(t, r, a), a;
+};
+const Ee = "agitation-required-trouble-model", Jr = (e) => {
+  if (e.data.agitationRequired)
+    return Ee;
+}, ea = "InsufficientAgitationTrouble";
+let j = class {
+  constructor(e, t, r) {
+    i(this, "id");
+    i(this, "logger");
+    i(this, "trouble");
+    i(this, "_deferred");
+    i(this, "_holdersLoaded", !1);
+    i(this, "agitateBeforePour");
+    this.id = e, this.logger = r.logger, this._deferred = !1, this.trouble = t.companionParent;
+  }
+  async resolve() {
+    return this.trouble.resolve();
+  }
+  get holder() {
+    const e = this.trouble.data.holderPaths[0], t = R(e);
+    if (!(!this._holdersLoaded && !t.model))
+      return t == null ? void 0 : t.model;
+  }
+  updateHolder() {
+    if (!this._holdersLoaded) {
+      const e = this.trouble.data.holderPaths[0];
+      R(e).model && (this._holdersLoaded = !0);
+    }
+  }
+  get shouldDefer() {
+    var o, a;
+    if (!this.holder)
+      return !0;
+    const t = (((o = this.holder) == null ? void 0 : o.troublesByType[ea]) || []).length > 0;
+    return !!((a = this.agitateBeforePour) != null && a.value) && t;
+  }
+  get deferred() {
+    return this._deferred;
+  }
+  defer() {
+    this._deferred = !0;
+  }
+  clearDefer() {
+    this._deferred = !1;
+  }
+};
+$e([
+  b({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.agitateBeforePour"
+  })
+], j.prototype, "agitateBeforePour", 2);
+$e([
+  Tt({
+    topic: It(ze.type),
+    lifecycle: De.INIT
+  })
+], j.prototype, "updateHolder", 1);
+j = $e([
+  f(Ee)
+], j);
+const ta = new $({
+  class: j,
+  type: Ee
+}), ra = ["iceAgitator"], aa = {
+  iceAgitator: lt.factory
+}, oa = C.createLogger({ name: "freestyle-assembly-data-mapper" }), ca = async (e) => {
+  const t = Ie.instance().options({}).build(), r = Ce.instance().options({}).build(), o = e.assemblies.reduce((s, u) => {
+    var A;
+    return ra.forEach((l) => {
+      var M;
+      const v = u[l];
+      if (v) {
+        const dt = aa[l](v.path);
+        s[l] = dt({
+          name: v.name,
+          path: v.path,
+          statePath: ((M = v.state) == null ? void 0 : M.path) || ""
+        });
+      }
+    }), (A = u.cartridgeAgitators) == null || A.forEach((l) => {
+      var M;
+      const v = He.instance(
+        l.path
+      ).options({
+        name: l.name,
+        path: l.path,
+        statePath: ((M = l.state) == null ? void 0 : M.path) || ""
+      }).build();
+      t.addModel(v);
+    }), u.remoteTrays && u.remoteTrays.forEach((l) => {
+      oa.info(`Found remote tray ${l.name} with path ${l.path}`);
+      const v = `${V.type}-${l.holderPath}`, M = V.instance(v).options({
+        holderPath: l.holderPath,
+        configPath: l.path,
+        name: l.name
+      }).build();
+      r.addModel(M);
+    }), s;
+  }, {}), a = !!o.iceAgitator, n = !!o.carbTank;
+  return {
+    ...o,
+    cartridgeAgitators: t,
+    remoteTrays: r,
+    supportsCarb: n,
+    supportsIce: a
+  };
+}, ia = (e) => () => (_t(e)(), Et(e)(), we.register(), de.register(), lt.register(), Ge.register(), Ie.register(), kr.register(), ir.register(), Gr.register(), Zt.register(), Se.register(), Oe.register(), V.register(), Ce.register(), m.companion.register(e)(
+  Ot.type,
+  we.type
+), m.companion.register(e)(
+  ze.type,
+  de.type
+), ta.register(), m.companion.register(e)(
+  Ct.type,
+  Jr
+), m.companion.register(e)(At.type, Se.type), m.companion.register(e)(
+  wt.type,
+  Oe.type
+), le[ue].register(
+  "EnjoyByTrouble",
+  async (t) => {
+    if (t.data.enjoyByDate) {
+      const r = new Date(t.data.enjoyByDate);
+      return {
+        enjoyByDays: Math.floor(
+          ((/* @__PURE__ */ new Date()).getTime() - r.getTime()) / (1e3 * 60 * 60 * 24)
+        ) || ""
+      };
+    }
+    return {};
+  }
+), le[ue].register(
+  "SuperPumpRequiredTrouble",
+  // This is the trouble type
+  async (t) => {
+    const { model: r } = R(
+      St.type
+    );
+    return r ? {
+      superPumps: r.models.getIndexByKey(
+        Mt.byType,
+        "microSuper"
+      ).map((n) => n.name).join(", ")
+    } : {};
+  }
+), le[ue].register(
+  "MicroPumpAirDetectTrouble",
+  async (t) => {
+    if (t.ifaces.includes("container"))
+      return {};
+    if (t.data.pumpPath) {
+      const { model: r } = R(
+        t.data.pumpPath
+      );
+      if (r) {
+        const o = r.ingredientId ? R(r.ingredientId).model : void 0;
+        return {
+          ingredientId: r.ingredientId,
+          ingredientName: (o == null ? void 0 : o.name) || ""
+        };
+      }
+    }
+    return {};
+  }
+), {
+  preload: m.model.preloadModel(e),
+  model: m.model.register(e),
+  companion: m.companion.register(e),
+  legacy: m.model.registerLegacyModel(e)
+}), I = {
+  ...$t
+};
+I.freestyle = {
+  models: ia(I)
+};
+I.preload = m.model.preloadModel(I);
+I.model = m.model.register(I);
+I.companion = m.companion.register(I);
+I.legacy = m.model.registerLegacyModel(I);
+const da = I;
+export {
+  ea as A,
+  lr as B,
+  Ge as C,
+  ir as F,
+  J as I,
+  da as K,
+  Gr as L,
+  Ir as N,
+  Ce as R,
+  kr as S,
+  Ie as a,
+  Z as b,
+  He as c,
+  Zt as d,
+  de as e,
+  Oe as f,
+  we as g,
+  Se as h,
+  lt as i,
+  ta as j,
+  V as k,
+  tr as l,
+  kt as m,
+  Qt as n,
+  Jt as o,
+  Xt as p,
+  Ae as q,
+  ia as r,
+  _r as s,
+  Or as t,
+  ua as u,
+  Hr as v,
+  Yr as w,
+  Br as x,
+  Kr as y,
+  ca as z
+};
+//# sourceMappingURL=freestyle-registration-manager-DSugLmqT.js.map