@kosdev-code/kos-freestyle-sdk 2.1.39 → 3.0.1

package/service-BRuYqmJg.js

@@ -0,0 +1,2277 @@
+import { resolveServiceUrl, ServiceFactory, KosLog, createPropKey, kosStateProp, kosConfigProperty, kosStateEntry, kosStateExit, kosStateGuard, kosFuture, kosModel, kosLoggerAware, kosCompanion, DependencyLifecycle, kosFutureAware, kosStateMachine, KosModelContainer, kosChild, kosModelEffect, EventBus, KosModelRegistrationFactory, SingletonKosModelRegistrationFactory, FetchError, FutureManager, FutureEndState, FutureHandler, kosParentAware, KosFeatureFlags, getKosCompanionModel, getKosModelSync, kosContainerAware, KosContextManager, kosAction, KOS_MODEL_ID, kosMultipleFutureAware, kosTopicHandler, modelTypeEventTopicFactory, RegistrationManager, registerCoreModels, Trouble, ExtensionManager, EXTENSION_TROUBLE_DATA_MAPPER, createClient, kosServiceRequest as kosServiceRequest$5 } from "@kosdev-code/kos-ui-sdk";
+import { PourState, Assembly, KosModelRegistry as KosModelRegistry$1, registerDispenseModels, Nozzle, Pump, Holder, PumpContainer, PumpIndex } from "@kosdev-code/kos-dispense-sdk";
+const { URL: URL$6 } = resolveServiceUrl("ICE_AGITATOR_SERVICE");
+const { postModel: postModel$5 } = ServiceFactory.build({
+  basePath: `${URL$6}/api/ext/freestyle/ice`
+});
+KosLog.createLogger({
+  name: "carb-tank-service",
+  group: "Services"
+});
+const testCarbTank = async (path, tracker) => {
+  const response = await postModel$5({
+    model: {},
+    tracker,
+    urlOverride: `${URL$6}/api/handle/${path}/test`
+  });
+  if (!response?.data) {
+    throw new Error("No response from server");
+  }
+  return response?.data;
+};
+var __defProp$b = Object.defineProperty;
+var __getOwnPropDesc$e = Object.getOwnPropertyDescriptor;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$e = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$e(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$b(target, key, result);
+  return result;
+};
+var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, key + "", value);
+const MODEL_TYPE$e = "carb-agitator-model";
+const PROP_STATE_PATH$1 = createPropKey("statePath");
+let CarbAgitatorModelImpl = class {
+  /**
+   * Unique identifier for this carb agitator instance.
+   */
+  id;
+  /**
+   * Display name for this carb agitator.
+   */
+  name;
+  /**
+   * Device path for carb tank operations.
+   */
+  path;
+  /**
+   * State path for accessing probe and filling status.
+   */
+  statePath;
+  highProbeWet;
+  lowProbeWet;
+  filling;
+  enabled;
+  /**
+   * Creates a new carb agitator model instance.
+   *
+   * @param modelId - Unique identifier for this instance
+   * @param options - Configuration options including name
+   * @param context - KOS creation context providing assembly paths
+   */
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.name = options.name;
+    this.path = context.kosContext.get(`assembly-feature-carbTank`)?.path || "";
+    const statePath = context.kosContext.get(`assembly-state-path-carbTank`);
+    this.statePath = statePath;
+  }
+  /**
+   * Gets the carb holder associated with this agitator.
+   *
+   * Retrieves the first holder from the "carb" group in the parent assembly.
+   *
+   * @returns The carb holder model, or undefined if not found
+   */
+  get holder() {
+    const carbHolder = this.getCompanionParent()?.getHoldersByGroup("carb")[0];
+    return carbHolder;
+  }
+  /**
+   * Gets the pump associated with the carb holder.
+   *
+   * Returns the first pump from the holder's pump collection.
+   *
+   * @returns The pump model, or undefined if holder or pump not available
+   */
+  get pump() {
+    return this.holder?.pumps.data[0];
+  }
+  /**
+   * Indicates whether the carb tank is currently being filled.
+   *
+   * @returns true if the filling state property indicates active filling
+   */
+  get isFilling() {
+    return !!this.filling.value;
+  }
+  /**
+   * Indicates whether the carb tank has been initialized.
+   *
+   * @returns true if the carb tank enabled configuration is set to true
+   */
+  get isCarbInitialized() {
+    return !!this.enabled.value;
+  }
+  /**
+   * Indicates whether carb tank activation is allowed.
+   *
+   * Activation is only allowed when the carb tank is not already enabled.
+   *
+   * @returns true if the carb tank can be activated
+   */
+  get canActivate() {
+    return !this.enabled.value;
+  }
+  /**
+   * Indicates whether the workflow can proceed past carb initialization.
+   *
+   * The workflow can proceed when the state machine is in either INITIALIZED
+   * (carb tank activated) or SKIPPED (user chose to bypass carbonation).
+   *
+   * @returns true if ready to proceed with beverage operations
+   */
+  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(true);
+    this.transition("ACTIVATION_COMPLETE");
+  }
+  /**
+   * Deactivates the carb tank and resets to uninitialized state.
+   *
+   * This method:
+   * 1. Updates the enabled configuration property to false
+   * 2. Transitions back to UNINITIALIZED state
+   *
+   * Can be called from any state.
+   */
+  async deactivateCarbTank() {
+    this.enabled.updateProperty(false);
+    this.transition("RESET");
+  }
+  skip() {
+    this.transition("SKIP");
+  }
+  reset() {
+    this.enabled.updateProperty(false);
+    this.transition("RESET");
+  }
+  /**
+   * Toggles the carb tank between enabled and disabled states.
+   *
+   * If currently enabled, calls {@link deactivateCarbTank}.
+   * If currently disabled, calls {@link activateCarbTank}.
+   */
+  toggleCarbTank() {
+    if (this.enabled.value) {
+      this.deactivateCarbTank();
+    } else {
+      this.activateCarbTank();
+    }
+  }
+  handleTestCarbTank(tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    this.logger.info(`testing carb tank:  ${this.id}`);
+    return testCarbTank(this.path, tracker);
+  }
+};
+__publicField$4(CarbAgitatorModelImpl, "Registration");
+__decorateClass$e([
+  kosStateProp({
+    path: PROP_STATE_PATH$1,
+    attribute: "highProbeWet"
+  })
+], CarbAgitatorModelImpl.prototype, "highProbeWet", 2);
+__decorateClass$e([
+  kosStateProp({
+    path: PROP_STATE_PATH$1,
+    attribute: "lowProbeWet"
+  })
+], CarbAgitatorModelImpl.prototype, "lowProbeWet", 2);
+__decorateClass$e([
+  kosStateProp({
+    path: PROP_STATE_PATH$1,
+    attribute: "filling"
+  })
+], CarbAgitatorModelImpl.prototype, "filling", 2);
+__decorateClass$e([
+  kosConfigProperty({
+    path: "assembly:core:board:macksm:carbTank:carbTank",
+    attribute: "enabled"
+  })
+], CarbAgitatorModelImpl.prototype, "enabled", 2);
+__decorateClass$e([
+  kosStateEntry(
+    "ACTIVATING"
+    /* ACTIVATING */
+  )
+], CarbAgitatorModelImpl.prototype, "handleActivationStart", 1);
+__decorateClass$e([
+  kosStateExit(
+    "ACTIVATING"
+    /* ACTIVATING */
+  )
+], CarbAgitatorModelImpl.prototype, "handleActivationComplete", 1);
+__decorateClass$e([
+  kosStateEntry(
+    "INITIALIZED"
+    /* INITIALIZED */
+  )
+], CarbAgitatorModelImpl.prototype, "handleInitialized", 1);
+__decorateClass$e([
+  kosStateEntry(
+    "SKIPPED"
+    /* SKIPPED */
+  )
+], CarbAgitatorModelImpl.prototype, "handleSkipped", 1);
+__decorateClass$e([
+  kosStateGuard({ allowedStates: [
+    "UNINITIALIZED"
+    /* UNINITIALIZED */
+  ] })
+], CarbAgitatorModelImpl.prototype, "activateCarbTank", 1);
+__decorateClass$e([
+  kosStateGuard({ allowedStates: [
+    "UNINITIALIZED"
+    /* UNINITIALIZED */
+  ] })
+], CarbAgitatorModelImpl.prototype, "skip", 1);
+__decorateClass$e([
+  kosStateGuard({
+    allowedStates: [
+      "INITIALIZED",
+      "SKIPPED"
+      /* SKIPPED */
+    ]
+  })
+], CarbAgitatorModelImpl.prototype, "reset", 1);
+__decorateClass$e([
+  kosFuture()
+], CarbAgitatorModelImpl.prototype, "handleTestCarbTank", 1);
+CarbAgitatorModelImpl = __decorateClass$e([
+  kosModel({ modelTypeId: MODEL_TYPE$e, singleton: false }),
+  kosLoggerAware(),
+  kosCompanion({ mode: "composition", lifecycle: DependencyLifecycle.LOAD }),
+  kosFutureAware(),
+  kosStateMachine(
+    {
+      initial: "UNINITIALIZED",
+      states: {
+        [
+          "UNINITIALIZED"
+          /* UNINITIALIZED */
+        ]: {
+          on: {
+            ACTIVATE: "ACTIVATING",
+            SKIP: "SKIPPED"
+            /* SKIPPED */
+          }
+        },
+        [
+          "ACTIVATING"
+          /* ACTIVATING */
+        ]: {
+          on: {
+            ACTIVATION_COMPLETE: "INITIALIZED"
+            /* INITIALIZED */
+          }
+        },
+        [
+          "INITIALIZED"
+          /* INITIALIZED */
+        ]: {
+          on: {
+            RESET: "UNINITIALIZED"
+            /* UNINITIALIZED */
+          }
+        },
+        [
+          "SKIPPED"
+          /* SKIPPED */
+        ]: {
+          on: {
+            RESET: "UNINITIALIZED"
+            /* UNINITIALIZED */
+          }
+        }
+      }
+    },
+    {
+      throwOnInvalid: false
+      // Graceful handling for button clicks
+    }
+  )
+], CarbAgitatorModelImpl);
+const CarbAgitator = CarbAgitatorModelImpl.Registration;
+var __defProp$a = Object.defineProperty;
+var __getOwnPropDesc$d = Object.getOwnPropertyDescriptor;
+var __decorateClass$d = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$d(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$a(target, key, result);
+  return result;
+};
+const MODEL_TYPE$d = "cartridge-agitator-container-model";
+let CartridgeAgitatorContainerModelImpl = class {
+  id;
+  logger;
+  _models;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this._models = new KosModelContainer({
+      parentId: modelId
+    });
+  }
+  getModel(id) {
+    return this._models.getModel(id);
+  }
+  get models() {
+    return this._models;
+  }
+  get data() {
+    return this._models.data;
+  }
+  addModel(model) {
+    this._models.addModel(model);
+  }
+  removeModel(id) {
+    this._models.removeModel(id);
+  }
+  // -------------------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}`
+    );
+  }
+};
+__decorateClass$d([
+  kosChild
+], CartridgeAgitatorContainerModelImpl.prototype, "_models", 2);
+CartridgeAgitatorContainerModelImpl = __decorateClass$d([
+  kosModel(MODEL_TYPE$d)
+], CartridgeAgitatorContainerModelImpl);
+const { URL: URL$5 } = resolveServiceUrl("CARTRIDGE_AGITATOR_SERVICE");
+const { postModel: postModel$4 } = ServiceFactory.build({
+  basePath: `${URL$5}/api/ext/freestyle/freestyle/ice`
+});
+const agitate$1 = async (path, tracker) => {
+  const response = await postModel$4({
+    model: {},
+    tracker,
+    urlOverride: `${URL$5}/api/handle/${path}/test`
+  });
+  if (!response?.data) {
+    throw new Error("No response from server");
+  }
+  return response.data;
+};
+var __defProp$9 = Object.defineProperty;
+var __getOwnPropDesc$c = Object.getOwnPropertyDescriptor;
+var __decorateClass$c = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$c(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$9(target, key, result);
+  return result;
+};
+const MODEL_TYPE$c = "cartridge-agitator-model";
+class CartridgeAgitatorEvents {
+  static TOPIC_AGITATION_STARTED = "/kos/events/ddk/agitation-started";
+  static TOPIC_AGITATION_ENDED = "/kos/events/ddk/agitation-ended";
+}
+const PROP_PATH$1 = createPropKey("statePath");
+let CartridgeAgitatorModelImpl = class {
+  id;
+  agitating;
+  path;
+  statePath;
+  name;
+  constructor(modelId, options) {
+    this.id = modelId;
+    this.path = options.path;
+    this.name = options.name;
+    this.statePath = options.statePath;
+  }
+  get isAgitating() {
+    return !!this.agitating.value;
+  }
+  async testAgitate(tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    this.logger.info(`agitating cartridge-agitator ${this.id}`);
+    return agitate$1(this.path, tracker);
+  }
+  handleAgitation() {
+    if (this.isAgitating) {
+      this.logger.info(`agitating cartridge-agitator ${this.id}`);
+      EventBus.publish(CartridgeAgitatorEvents.TOPIC_AGITATION_STARTED, {
+        path: this.path,
+        futureId: this.future?.futureId
+      });
+    } else {
+      EventBus.publish(CartridgeAgitatorEvents.TOPIC_AGITATION_ENDED, {
+        path: this.path
+      });
+    }
+  }
+};
+__decorateClass$c([
+  kosStateProp({ path: PROP_PATH$1, attribute: "agitating" })
+], CartridgeAgitatorModelImpl.prototype, "agitating", 2);
+__decorateClass$c([
+  kosFuture()
+], CartridgeAgitatorModelImpl.prototype, "testAgitate", 1);
+__decorateClass$c([
+  kosModelEffect({
+    dependencies: (model) => [model.isAgitating]
+  })
+], CartridgeAgitatorModelImpl.prototype, "handleAgitation", 1);
+CartridgeAgitatorModelImpl = __decorateClass$c([
+  kosModel(MODEL_TYPE$c),
+  kosFutureAware(),
+  kosLoggerAware()
+], CartridgeAgitatorModelImpl);
+const CartridgeAgitator = new KosModelRegistrationFactory({
+  class: CartridgeAgitatorModelImpl,
+  type: MODEL_TYPE$c
+});
+const CartridgeAgitatorContainer = new SingletonKosModelRegistrationFactory({
+  class: CartridgeAgitatorContainerModelImpl,
+  type: MODEL_TYPE$d
+});
+CartridgeAgitatorContainer.addRelatedModel(CartridgeAgitator);
+var __defProp$8 = Object.defineProperty;
+var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$b = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$b(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$8(target, key, result);
+  return result;
+};
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, key + "", value);
+const MODEL_TYPE$b = "cgp-pump-model";
+const PROP_STATE_PATH = createPropKey("statePath");
+let CgpPumpModelImpl = class {
+  highProbeWet;
+  lowProbeWet;
+  filling;
+  id;
+  state;
+  constructor(modelId, options) {
+    this.id = modelId;
+    this.state = options.data?.state ?? { name: "unknown", path: "" };
+  }
+  get statePath() {
+    return this.state.path;
+  }
+};
+__publicField$3(CgpPumpModelImpl, "Registration");
+__decorateClass$b([
+  kosStateProp({
+    path: PROP_STATE_PATH,
+    attribute: "highProbeWet"
+  })
+], CgpPumpModelImpl.prototype, "highProbeWet", 2);
+__decorateClass$b([
+  kosStateProp({
+    path: PROP_STATE_PATH,
+    attribute: "lowProbeWet"
+  })
+], CgpPumpModelImpl.prototype, "lowProbeWet", 2);
+__decorateClass$b([
+  kosStateProp({
+    path: PROP_STATE_PATH,
+    attribute: "filling"
+  })
+], CgpPumpModelImpl.prototype, "filling", 2);
+CgpPumpModelImpl = __decorateClass$b([
+  kosModel({ modelTypeId: MODEL_TYPE$b, singleton: false }),
+  kosCompanion({
+    mode: "composition"
+  }),
+  kosLoggerAware()
+], CgpPumpModelImpl);
+const CgpPump = CgpPumpModelImpl.Registration;
+const { URL: URL$4 } = resolveServiceUrl("FCM-PUMP_SERVICE");
+const { postModel: postModel$3 } = ServiceFactory.build({
+  basePath: `${URL$4}/api/fcm-pump`
+});
+const log$5 = KosLog.createLogger({
+  name: "fcm-pump-service",
+  group: "Services"
+});
+const performElectricalTest = async (path) => {
+  log$5.debug(
+    `performElectricalTest - sending POST request to /api/ext/freestyle/fcm/diagnostics/${path}/electricalTest`
+  );
+  try {
+    const response = await postModel$3({
+      model: {},
+      urlOverride: `${URL$4}/api/ext/freestyle/fcm/diagnostics/${path}/electricalTest`
+    });
+    log$5.debug("performElectricalTest - response:", response);
+    if ((response?.status === 200 || response?.status === 499) && response.data?.error) {
+      return [response.data.error || "unknownError", response.data];
+    }
+    return [void 0, response?.data];
+  } catch (error) {
+    log$5.error(
+      `performElectricalTest - sending POST request to /api/ext/freestyle/fcm/diagnostics/${path}/electricalTest`,
+      error
+    );
+    if (error instanceof FetchError) {
+      const errorCode = error.payload?.data?.error || error.payload?.error || "unknownError";
+      return [errorCode, error.payload?.data || { error: errorCode }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+};
+const performPreCalibrate$1 = async (pump, tracker) => {
+  log$5.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${pump}/preCalibrate`
+  );
+  try {
+    const response = await postModel$3({
+      model: {},
+      urlOverride: `${URL$4}/api/ext/freestyle/fcm/calibration/${pump}/preCalibrate`,
+      tracker
+    });
+    log$5.debug("performPreCalibrate - response:", response);
+    if (response?.data) {
+      FutureManager.initiateFuture(response.data);
+    }
+    return response?.data;
+  } catch (error) {
+    log$5.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${pump}/preCalibrate`,
+      error
+    );
+    const futureResponse = {
+      id: tracker || "",
+      endState: FutureEndState.Fail,
+      tracker,
+      reason: "Failed to resolve trouble"
+    };
+    FutureManager.initiateFuture(futureResponse);
+    return futureResponse;
+  }
+};
+const performCalibrate$1 = async (pump, tracker) => {
+  log$5.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${pump}/calibrate`
+  );
+  try {
+    const response = await postModel$3({
+      model: {},
+      urlOverride: `${URL$4}/api/ext/freestyle/fcm/calibration/${pump}/calibrate`,
+      tracker
+    });
+    log$5.debug("performPreCalibrate - response:", response);
+    if (response?.data) {
+      FutureManager.initiateFuture(response.data);
+    }
+    return response?.data;
+  } catch (error) {
+    log$5.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${pump}/calibrate`,
+      error
+    );
+    const futureResponse = {
+      id: tracker || "",
+      endState: FutureEndState.Fail,
+      tracker,
+      reason: "Failed to resolve trouble"
+    };
+    FutureManager.initiateFuture(futureResponse);
+    return futureResponse;
+  }
+};
+const performVerify$1 = async (pump, volume, tracker) => {
+  log$5.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${pump}/verify/${volume}`
+  );
+  try {
+    const response = await postModel$3({
+      model: {},
+      urlOverride: `${URL$4}/api/ext/freestyle/fcm/calibration/${pump}/verify/${volume}`,
+      tracker
+    });
+    log$5.debug("performVerify - response:", response);
+    if (response?.data) {
+      FutureManager.initiateFuture(response.data);
+    }
+    return response?.data;
+  } catch (error) {
+    log$5.error(
+      `performVerify - sending POST request to /api/ext/freestyle/fcm/calibration/${pump}/verify/${volume}`,
+      error
+    );
+    const futureResponse = {
+      id: tracker || "",
+      endState: FutureEndState.Fail,
+      tracker,
+      reason: "Failed to resolve trouble"
+    };
+    FutureManager.initiateFuture(futureResponse);
+    return futureResponse;
+  }
+};
+const processResponse = (response) => {
+  if (response) {
+    if (response.data === "success" || !response.data) {
+      return "success";
+    } else {
+      return response.data;
+    }
+  }
+  return "error";
+};
+const performComplete$1 = async (pump, volume1, volume2) => {
+  log$5.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${pump}/complete/${volume1}/${volume2}`
+  );
+  try {
+    const response = await postModel$3({
+      model: {},
+      urlOverride: `${URL$4}/api/ext/freestyle/fcm/calibration/${pump}/complete/${volume1}/${volume2}`
+    });
+    log$5.debug("performPreCalibrate - response:", response);
+    return processResponse(response?.data);
+  } catch (error) {
+    log$5.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/fcm/calibration/${pump}/complete/${volume1}/${volume2}`,
+      error
+    );
+    return void 0;
+  }
+};
+var __defProp$7 = Object.defineProperty;
+var __getOwnPropDesc$a = Object.getOwnPropertyDescriptor;
+var __decorateClass$a = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$a(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$7(target, key, result);
+  return result;
+};
+const MODEL_TYPE$a = "fcm-pump-model";
+const log$4 = KosLog.createLogger({ name: "fcm-pump-model" });
+let FcmPumpModelImpl = class {
+  id;
+  logger;
+  pumpModel;
+  futureHandler;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.pumpModel = options.companionParent;
+    this.futureHandler = new FutureHandler(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(props) {
+    return this.pumpModel.performIntent(props);
+  }
+  async performElectricalTest() {
+    const [error, data] = await performElectricalTest(this.pumpModel.path);
+    if (error) {
+      log$4.error(`Failed to perform electrical test on pump ${this.id}`, error);
+    }
+    return data;
+  }
+  getChildren() {
+    const allFutures = this.futureHandler.allFutures;
+    return [...allFutures];
+  }
+  async performPreCalibrate(tracker) {
+    return performPreCalibrate$1(this.pumpModel.path, tracker);
+  }
+  async performCalibrate(tracker) {
+    return performCalibrate$1(this.pumpModel.path, tracker);
+  }
+  async performVerify(volume, tracker) {
+    return performVerify$1(this.pumpModel.path, volume, tracker);
+  }
+  async performComplete(volume1, volume2) {
+    return performComplete$1(this.pumpModel.path, volume1, volume2);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing fcm-pump ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading fcm-pump ${this.id}`);
+  }
+};
+__decorateClass$a([
+  kosFuture()
+], FcmPumpModelImpl.prototype, "performPreCalibrate", 1);
+__decorateClass$a([
+  kosFuture()
+], FcmPumpModelImpl.prototype, "performCalibrate", 1);
+__decorateClass$a([
+  kosFuture()
+], FcmPumpModelImpl.prototype, "performVerify", 1);
+FcmPumpModelImpl = __decorateClass$a([
+  kosModel(MODEL_TYPE$a)
+], FcmPumpModelImpl);
+const FcmPump = new KosModelRegistrationFactory({
+  class: FcmPumpModelImpl,
+  type: MODEL_TYPE$a
+});
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropDesc$9 = Object.getOwnPropertyDescriptor;
+var __decorateClass$9 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$9(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$6(target, key, result);
+  return result;
+};
+const MODEL_TYPE$9 = "freestyle-assembly-model";
+const FEATURE_SUPPORTS_ICE = "iceAgitator";
+const FEATURE_SUPPORTS_CARB = "carbTank";
+const FEATURE_SUPPORTS_REMOTE_TRAYS = "remoteTrays";
+let FreestyleAssemblyModelImpl = class {
+  id;
+  _carbTankModel;
+  logger;
+  assembly;
+  _remoteTrays;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.assembly = options.companionParent;
+  }
+  get holderGroups() {
+    return this.assembly.holderGroups;
+  }
+  get nozzlePaths() {
+    return this.assembly.nozzlePaths;
+  }
+  get allHolders() {
+    return this.assembly.allHolders;
+  }
+  getHoldersByGroup(group) {
+    return this.assembly.getHoldersByGroup(group);
+  }
+  getHoldersByNozzle(nozzlePath) {
+    return this.assembly.getHoldersByNozzle(nozzlePath);
+  }
+  get pumpsByNozzle() {
+    return this.assembly.pumpsByNozzle;
+  }
+  get pumpPaths() {
+    return this.assembly.pumpPaths;
+  }
+  get boards() {
+    return this.assembly.boards;
+  }
+  updateModel(options) {
+    return this.assembly.updateModel(options);
+  }
+  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 : false;
+  }
+  // -------------------LIFECYCLE----------------------------
+  get supportsRemoteTrays() {
+    return KosFeatureFlags.isFeatureEnabled(FEATURE_SUPPORTS_REMOTE_TRAYS);
+  }
+  get supportsIce() {
+    return KosFeatureFlags.isFeatureEnabled(FEATURE_SUPPORTS_ICE);
+  }
+  get supportsCarb() {
+    return KosFeatureFlags.isFeatureEnabled(FEATURE_SUPPORTS_CARB);
+  }
+  async init() {
+    this.logger.debug(`initializing freestyle-assembly ${this.id}`);
+  }
+  async ready() {
+    const _carbTank = getKosCompanionModel(
+      this.assembly,
+      CarbAgitator.type
+    );
+    this._carbTankModel = _carbTank;
+  }
+};
+__decorateClass$9([
+  kosChild
+], FreestyleAssemblyModelImpl.prototype, "_remoteTrays", 2);
+FreestyleAssemblyModelImpl = __decorateClass$9([
+  kosParentAware(),
+  kosModel(MODEL_TYPE$9)
+], FreestyleAssemblyModelImpl);
+const FreestyleAssembly = new SingletonKosModelRegistrationFactory({
+  class: FreestyleAssemblyModelImpl,
+  type: MODEL_TYPE$9
+});
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor;
+var __decorateClass$8 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$5(target, key, result);
+  return result;
+};
+const MODEL_TYPE$8 = "remote-tray-model";
+createPropKey("holderPath");
+const PROP_CONFIG_PATH = createPropKey("configPath");
+let RemoteTrayModelImpl = class {
+  /** Unique identifier for the remote tray instance */
+  id;
+  logger;
+  /** Path reference to the associated holder model */
+  holderPath;
+  /** Configuration path for tray-specific settings */
+  configPath;
+  /** Display name of the remote tray */
+  name;
+  remoteTrayEnabled;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.holderPath = options.holderPath;
+    this.configPath = options.configPath;
+    this.name = options.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() {
+    return this.holder?.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() {
+    return this.holder?.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(_options) {
+  }
+  /**
+   * 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 getKosModelSync(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}`);
+  }
+};
+__decorateClass$8([
+  kosConfigProperty({
+    path: PROP_CONFIG_PATH,
+    attribute: "enabled"
+  })
+], RemoteTrayModelImpl.prototype, "remoteTrayEnabled", 2);
+RemoteTrayModelImpl = __decorateClass$8([
+  kosModel(MODEL_TYPE$8)
+], RemoteTrayModelImpl);
+const RemoteTray = new KosModelRegistrationFactory({
+  class: RemoteTrayModelImpl,
+  type: MODEL_TYPE$8
+});
+var __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor;
+var __decorateClass$7 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$7 = "remote-tray-container-model";
+let RemoteTrayContainerModelImpl = class {
+  id;
+  constructor(modelId) {
+    this.id = modelId;
+  }
+};
+RemoteTrayContainerModelImpl = __decorateClass$7([
+  kosModel(MODEL_TYPE$7),
+  kosLoggerAware(),
+  kosContainerAware()
+], RemoteTrayContainerModelImpl);
+const RemoteTrayContainer = new SingletonKosModelRegistrationFactory({
+  class: RemoteTrayContainerModelImpl,
+  type: MODEL_TYPE$7
+});
+RemoteTrayContainer.addRelatedModel(RemoteTray);
+var __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor;
+var __decorateClass$6 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$6 = "freestyle-holder-model";
+function resolveFreestyleAssembly(id) {
+  const context = KosContextManager.getContext(id);
+  const freestyleAssembly = context?.get(
+    FreestyleAssembly.type
+  );
+  if (!freestyleAssembly) {
+    KosLog.error("Freestyle assembly not found");
+    return void 0;
+  }
+  return freestyleAssembly;
+}
+async function futureDelegate(model, method) {
+  if (!model || !method) {
+    return void 0;
+  }
+  const response = await model[method]();
+  if (response?.tracker) {
+    return FutureManager.getFuture(response.tracker);
+  }
+  return void 0;
+}
+let FreestyleHolderModelImpl = class {
+  id;
+  logger;
+  holder;
+  context;
+  future;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.context = context.kosContext;
+    this.holder = options.companionParent;
+  }
+  get altName() {
+    return this.holder.attributes["ncui_altName"];
+  }
+  get agitated() {
+    return this.holder.data.agitated;
+  }
+  async agitate() {
+    if (!this.holder.data.agitated) {
+      return void 0;
+    }
+    this.future = void 0;
+    const freestyleAssembly = resolveFreestyleAssembly(this.id);
+    if (!freestyleAssembly) {
+      return void 0;
+    }
+    const agitator = freestyleAssembly.defaultCartridgeAgitator;
+    if (!agitator) {
+      this.logger.error("Agitator not found");
+      return void 0;
+    }
+    this.future = await futureDelegate(
+      freestyleAssembly.defaultCartridgeAgitator,
+      "testAgitate"
+    );
+    return this.future;
+  }
+  get isRemote() {
+    const remoteTrayId = `${RemoteTray.type}-${this.holder.path}`;
+    const remoteTray = getKosModelSync(remoteTrayId);
+    if (!remoteTray?.model) {
+      return false;
+    }
+    return !!remoteTray.model.remoteTrayEnabled.value;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing freestyle-holder ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading freestyle-holder ${this.id}`);
+  }
+};
+FreestyleHolderModelImpl = __decorateClass$6([
+  kosModel(MODEL_TYPE$6)
+], FreestyleHolderModelImpl);
+const FreestyleHolder = new KosModelRegistrationFactory({
+  class: FreestyleHolderModelImpl,
+  type: MODEL_TYPE$6
+});
+const { URL: URL$3 } = resolveServiceUrl("FREESTYLE-NOZZLE_SERVICE");
+const { getOne } = ServiceFactory.build({
+  basePath: `${URL$3}/api/freestyle-nozzle`
+});
+const log$3 = KosLog.createLogger({
+  name: "freestyle-nozzle-service",
+  group: "Services"
+});
+class NutritionInfoError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NutritionInfoError";
+  }
+}
+class InvalidRequestError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidRequestError";
+  }
+}
+const getFreestyleNutritionInfo = async (nozzleUrlPrefix, beverageId, volumes, baseUrl = "http://localhost:8081") => {
+  log$3.debug("sending GET for freestyle-nozzle");
+  if (!beverageId) {
+    log$3.error("Invalid freestyle-nozzle request: beverageId is required");
+    throw new InvalidRequestError("No beverageId provided");
+  }
+  if (!volumes || volumes.length === 0) {
+    log$3.error("Invalid freestyle-nozzle request: volumes are required");
+    throw new InvalidRequestError("No volumes provided");
+  }
+  const response = await getOne({
+    urlOverride: `${baseUrl}${nozzleUrlPrefix}/pipeline/beverage/engine/nutrition/${beverageId}?volumes=${volumes.join(
+      ","
+    )}`
+  });
+  if (!response?.data) {
+    log$3.error("Failed to retrieve freestyle-nozzle data");
+    throw new Error("Failed to retrieve freestyle-nozzle data");
+  }
+  if (response.data.error) {
+    throw new NutritionInfoError(response.data.error);
+  }
+  return response.data;
+};
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$4(target, key, result);
+  return result;
+};
+const MODEL_TYPE$5 = "freestyle-nozzle-model";
+let FreestyleNozzleModelImpl = class {
+  id;
+  logger;
+  nozzleModel;
+  _cupSizes;
+  _nutritionInfo;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.nozzleModel = options.companionParent;
+    this._cupSizes = [100];
+  }
+  set cupSizes(cupSizes) {
+    this._cupSizes = cupSizes;
+  }
+  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 beverageId = this.nozzleModel.selectedPourable.beverage.rawId;
+      const prefix = this.nozzleModel.urlPrefix;
+      try {
+        const response = await getFreestyleNutritionInfo(
+          prefix,
+          beverageId,
+          this._cupSizes
+        );
+        kosAction(() => {
+          this._nutritionInfo = response;
+        });
+      } catch (error) {
+        this.logger.error(`Error fetching nutrition info: ${error}`);
+      }
+    }
+  }
+  // -------------------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}`);
+  }
+};
+__decorateClass$5([
+  kosModelEffect({
+    dependencies: (model) => [
+      model.selectedPourable.beverage
+    ]
+  })
+], FreestyleNozzleModelImpl.prototype, "handleBeverageSelection", 1);
+FreestyleNozzleModelImpl = __decorateClass$5([
+  kosParentAware(),
+  kosModel(MODEL_TYPE$5)
+], FreestyleNozzleModelImpl);
+const FreestyleNozzle = new KosModelRegistrationFactory({
+  class: FreestyleNozzleModelImpl,
+  type: MODEL_TYPE$5
+});
+const { URL: URL$2 } = resolveServiceUrl("PUMP_SERVICE");
+const { postModel: postModel$2 } = ServiceFactory.build({
+  basePath: `${URL$2}/api/ext/freestyle/microCalibration`
+});
+const log$2 = KosLog.createLogger({
+  name: "freestyle-pump-service",
+  group: "Services"
+});
+const replacePump = async (pumpId, code) => {
+  log$2.debug(
+    `replacePump - sending POST request to /api/ext/freestyle/microCalibration/cal/${pumpId}/code/${code}`
+  );
+  try {
+    const response = await postModel$2({
+      model: {},
+      urlOverride: `${URL$2}/api/ext/freestyle/microCalibration/cal/${pumpId}/code/${code}`
+    });
+    log$2.debug("replacePump - response:", response);
+    if ((response?.status === 200 || response?.status === 499) && response.data?.error) {
+      return [response.data.error || "unknownError", response.data];
+    }
+    return [void 0, response?.data];
+  } catch (error) {
+    log$2.error(
+      `replacePump - sending POST request to /api/cal/${pumpId}/code/${code}`,
+      error
+    );
+    if (error instanceof FetchError) {
+      const errorCode = error.payload?.data?.error || error.payload?.error || "unknownError";
+      return [errorCode, error.payload?.data || { error: errorCode }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+};
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$4 = "freestyle-pump-model";
+let FreestylePumpModelImpl = class {
+  id;
+  logger;
+  pump;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.pump = options.companionParent;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async replacePump(code) {
+    const [error, data] = await replacePump(this.pump.path, code);
+    if (error) {
+      this.logger.error(`Failed to replace the pump, ${this.pump.id}`, error);
+    }
+    return [error, data];
+  }
+};
+FreestylePumpModelImpl = __decorateClass$4([
+  kosModel(MODEL_TYPE$4)
+], FreestylePumpModelImpl);
+const FreestylePump = new KosModelRegistrationFactory({
+  class: FreestylePumpModelImpl,
+  type: MODEL_TYPE$4
+});
+const { URL: URL$1 } = resolveServiceUrl("ICE_AGITATOR_SERVICE");
+const { getAll, postModel: postModel$1 } = ServiceFactory.build({
+  basePath: `${URL$1}/api/ext/freestyle/ice`
+});
+const log$1 = KosLog.createLogger({
+  name: "ice-agitator-service",
+  group: "Services"
+});
+const getIceTypes = async (path) => {
+  log$1.debug("sending GET for ice types");
+  const response = await getAll({
+    urlOverride: `${URL$1}/api/handle/${path}/types`
+  });
+  return response;
+};
+const updateIceType = async (agitator, type) => {
+  log$1.debug("sending POST for ice types");
+  const response = await postModel$1({
+    urlOverride: `${URL$1}/api/handle/${agitator}/type/${type}`,
+    model: {}
+  });
+  return response;
+};
+const resetIceSetting = async (path) => {
+  const response = await getAll({
+    urlOverride: `${URL$1}/api/kos/config/details/${path}/4`
+  });
+  return response;
+};
+const pour = async (path, tracker) => {
+  const response = await postModel$1({
+    model: {},
+    tracker,
+    urlOverride: `${URL$1}/api/handle/${path}/pour`
+  });
+  if (!response?.data) {
+    throw new Error("No response from server");
+  }
+  return response?.data;
+};
+const agitate = async (path, tracker) => {
+  const response = await postModel$1({
+    model: {},
+    tracker,
+    urlOverride: `${URL$1}/api/handle/${path}/test/agitation`
+  });
+  if (!response?.data) {
+    throw new Error("No response from server");
+  }
+  return response?.data;
+};
+const testGate = async (path, tracker) => {
+  const response = await postModel$1({
+    model: {},
+    tracker,
+    urlOverride: `${URL$1}/api/handle/${path}/test/gate`
+  });
+  if (!response?.data) {
+    throw new Error("No response from server");
+  }
+  return response?.data;
+};
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$3(target, key, result);
+  return result;
+};
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, key + "", value);
+class IceAgitatorEvents {
+  static TOPIC_AGITATION_STARTED = "/kos/events/ddk/ice-agitation-started";
+  static TOPIC_AGITATION_ENDED = "/kos/events/ddk/ice-agitation-ended";
+}
+const MODEL_TYPE$3 = "ice-agitator-model";
+const PROP_PATH = createPropKey("statePath");
+let IceAgitatorModelImpl = class {
+  id;
+  name;
+  path;
+  volWithoutIceMl;
+  durationSec;
+  enableIceChuteClear;
+  iceChuteClearDurationMs;
+  iceChuteClearIntervalSec;
+  iceChuteClearRetryIntervalSec;
+  maxDispenseSec;
+  type;
+  dilutionOffset;
+  inactivitySec;
+  agitating;
+  iceChuteOpen;
+  statePath;
+  _allIceTypes;
+  currentState = PourState.IDLE;
+  constructor(modelId, options) {
+    this.id = modelId;
+    this.name = options.name;
+    this.path = options.path;
+    this.statePath = options.statePath;
+    this._allIceTypes = [];
+  }
+  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() {
+    return !!(this.pourFuture && !this.pourFuture?.endState) || this.currentState === PourState.POUR_STARTING || this.currentState === PourState.POURING || this.currentState === PourState.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 === PourState.IDLE;
+  }
+  updateIfCurrent(currentState, nextState) {
+    if (this.currentState === currentState) {
+      kosAction(() => {
+        this.currentState = nextState;
+      });
+    }
+  }
+  async pourIce(tracker) {
+    try {
+      if (this.currentState === PourState.IDLE) {
+        this.updateIfCurrent(PourState.IDLE, PourState.POUR_STARTING);
+        if (!tracker) {
+          throw new Error("No tracker provided");
+        }
+        const result = await pour(this.path, tracker);
+        this.updateIfCurrent(PourState.POUR_STARTING, PourState.POURING);
+        if (result?.endState) {
+          this.updateIfCurrent(PourState.POURING, PourState.IDLE);
+        }
+        return result;
+      } else {
+        throw new Error(`Cannot pour in state ${this.currentState}`);
+      }
+    } catch (e) {
+      this.logger.error(e);
+      this.currentState = PourState.IDLE;
+      throw e;
+    }
+  }
+  /**
+   * An action that will cancel the ice dispense if it is currently in progress.
+   * */
+  async cancelIceDispense() {
+    if (this.currentState === PourState.POURING || this.currentState === PourState.POUR_STARTING) {
+      this.currentState = PourState.POUR_CANCELING;
+      await this.pourFuture?.cancelFuture();
+      kosAction(() => {
+        this.currentState = PourState.IDLE;
+      });
+    } else {
+      this.logger.warn(
+        `Cannot cancel ice dispense in state ${this.currentState}`
+      );
+    }
+  }
+  async testAgitate(tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    this.logger.info(`agitating ice-agitator ${this.id}`);
+    return agitate(this.path, tracker);
+  }
+  async testGate(tracker) {
+    if (!tracker) {
+      throw new Error("No tracker provided");
+    }
+    this.logger.info(`testing ice gate:  ${this.id}`);
+    return testGate(this.path, tracker);
+  }
+  handleAgitationChange() {
+    if (this.isAgitating) {
+      this.logger.info(`agitating ice-agitator ${this.id}`);
+      EventBus.publish(IceAgitatorEvents.TOPIC_AGITATION_STARTED, {
+        path: this.path,
+        futureId: this.futureHandler.future?.futureId
+      });
+    } else {
+      EventBus.publish(IceAgitatorEvents.TOPIC_AGITATION_ENDED, {
+        path: this.path
+      });
+    }
+  }
+  async updateIceType(type) {
+    await updateIceType(this.path, type);
+  }
+  resetDefaultValues = async () => {
+    const defaults = await resetIceSetting(this.path);
+    return defaults;
+  };
+  async init() {
+    this.logger.debug(`initializing ice-agitator ${this.id}`);
+  }
+  async load() {
+    try {
+      this.logger.debug(`loading ice-agitator ${this.id}`);
+      const iceTypes = await getIceTypes(this.path);
+      if (iceTypes?.status === 200) {
+        kosAction(() => {
+          this._allIceTypes = iceTypes.data || [];
+        });
+      }
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+};
+__publicField$2(IceAgitatorModelImpl, "Registration");
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "settings.volWithoutIceMl"
+  })
+], IceAgitatorModelImpl.prototype, "volWithoutIceMl", 2);
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "settings.durationSec",
+    converter: {
+      to: "second"
+    }
+  })
+], IceAgitatorModelImpl.prototype, "durationSec", 2);
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "enableIceChuteClear"
+  })
+], IceAgitatorModelImpl.prototype, "enableIceChuteClear", 2);
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "iceChuteClearDurationMs"
+  })
+], IceAgitatorModelImpl.prototype, "iceChuteClearDurationMs", 2);
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "iceChuteClearIntervalSec"
+  })
+], IceAgitatorModelImpl.prototype, "iceChuteClearIntervalSec", 2);
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "iceChuteClearRetryIntervalSec"
+  })
+], IceAgitatorModelImpl.prototype, "iceChuteClearRetryIntervalSec", 2);
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "maxDispenseSec"
+  })
+], IceAgitatorModelImpl.prototype, "maxDispenseSec", 2);
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "type"
+  })
+], IceAgitatorModelImpl.prototype, "type", 2);
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "settings.dilutionOffset"
+  })
+], IceAgitatorModelImpl.prototype, "dilutionOffset", 2);
+__decorateClass$3([
+  kosConfigProperty({
+    path: KOS_MODEL_ID,
+    attribute: "settings.inactivitySec",
+    converter: {
+      to: "minute"
+    }
+  })
+], IceAgitatorModelImpl.prototype, "inactivitySec", 2);
+__decorateClass$3([
+  kosStateProp({ path: PROP_PATH, attribute: "agitating" })
+], IceAgitatorModelImpl.prototype, "agitating", 2);
+__decorateClass$3([
+  kosStateProp({ path: PROP_PATH, attribute: "iceChuteOpen" })
+], IceAgitatorModelImpl.prototype, "iceChuteOpen", 2);
+__decorateClass$3([
+  kosFuture({ alias: "pour" })
+], IceAgitatorModelImpl.prototype, "pourIce", 1);
+__decorateClass$3([
+  kosFuture({ alias: "agitate" })
+], IceAgitatorModelImpl.prototype, "testAgitate", 1);
+__decorateClass$3([
+  kosFuture({
+    alias: "gate"
+  })
+], IceAgitatorModelImpl.prototype, "testGate", 1);
+__decorateClass$3([
+  kosModelEffect({
+    dependencies: (model) => [model.isAgitating]
+  })
+], IceAgitatorModelImpl.prototype, "handleAgitationChange", 1);
+IceAgitatorModelImpl = __decorateClass$3([
+  kosModel({ modelTypeId: MODEL_TYPE$3, singleton: false }),
+  kosLoggerAware(),
+  kosMultipleFutureAware()
+], IceAgitatorModelImpl);
+const IceAgitator = IceAgitatorModelImpl.Registration;
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(result) || result;
+  return result;
+};
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "", value);
+const MODEL_TYPE$2 = "lfcv-pump-model";
+let LfcvPumpModelImpl = class {
+  id;
+  constructor(modelId, _options) {
+    this.id = modelId;
+  }
+  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(props) {
+    return this.pumpModel.performIntent(props);
+  }
+};
+__publicField$1(LfcvPumpModelImpl, "Registration");
+LfcvPumpModelImpl = __decorateClass$2([
+  kosModel({ modelTypeId: MODEL_TYPE$2, singleton: false }),
+  kosLoggerAware(),
+  kosCompanion({
+    mode: "composition",
+    parentProperty: "pumpModel"
+  })
+], LfcvPumpModelImpl);
+const LfcvPump = LfcvPumpModelImpl.Registration;
+const { URL } = resolveServiceUrl("SPM-PUMP_SERVICE");
+const { postModel } = ServiceFactory.build({
+  basePath: `${URL}/api/spm-pump`
+});
+const log = KosLog.createLogger({
+  name: "spm-pump-service",
+  group: "Services"
+});
+const performPreCalibrate = async (pump, tracker) => {
+  log.debug(
+    `performPreCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${pump}/preCalibrate`
+  );
+  try {
+    const response = await postModel({
+      model: {},
+      urlOverride: `${URL}/api/ext/freestyle/microCalibration/pour/${pump}/preCalibrate`,
+      tracker
+    });
+    log.debug("performPreCalibrate - response:", response);
+    if (response?.data) {
+      FutureManager.initiateFuture(response.data);
+    }
+    return response?.data;
+  } catch (error) {
+    log.error(
+      `performPreCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${pump}/preCalibrate`,
+      error
+    );
+    const futureResponse = {
+      id: tracker || "",
+      endState: FutureEndState.Fail,
+      tracker,
+      reason: "Failed to resolve trouble"
+    };
+    FutureManager.initiateFuture(futureResponse);
+    return futureResponse;
+  }
+};
+const performCalibrate = async (pump, tracker) => {
+  log.debug(
+    `performCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${pump}/calibrate`
+  );
+  try {
+    const response = await postModel({
+      model: {},
+      urlOverride: `${URL}/api/ext/freestyle/microCalibration/pour/${pump}/calibrate`,
+      tracker
+    });
+    log.debug("performCalibrate - response:", response);
+    if (response?.data) {
+      FutureManager.initiateFuture(response.data);
+    }
+    return response?.data;
+  } catch (error) {
+    log.error(
+      `performCalibrate - sending POST request to /api/ext/freestyle/microCalibration/pour/${pump}/calibrate`,
+      error
+    );
+    const futureResponse = {
+      id: tracker || "",
+      endState: FutureEndState.Fail,
+      tracker,
+      reason: "Failed to resolve trouble"
+    };
+    FutureManager.initiateFuture(futureResponse);
+    return futureResponse;
+  }
+};
+const performVerify = async (pump, volume, payload, tracker) => {
+  log.debug(
+    `performVerify - sending POST request to /api/ext/freestyle/microCalibration/pour/${pump}/verify`
+  );
+  try {
+    const response = await postModel({
+      model: {
+        ...payload,
+        // commandedCalibrationVolume: 0,
+        measuredCalibrationVolume: volume
+        // measuredVerificationVolume: 0,
+        // newCalibrationValue: 0,
+        // pouredCalibrationVolume: 0,
+      },
+      urlOverride: `${URL}/api/ext/freestyle/microCalibration/pour/${pump}/verify`,
+      tracker
+    });
+    log.debug("performVerify - response:", response);
+    if (response?.data) {
+      FutureManager.initiateFuture(response.data);
+    }
+    return response?.data;
+  } catch (error) {
+    log.error(
+      `performVerify - sending POST request to /api/ext/freestyle/microCalibration/pour/${pump}/verify`,
+      error
+    );
+    const futureResponse = {
+      id: tracker || "",
+      endState: FutureEndState.Fail,
+      tracker,
+      reason: "Failed to resolve trouble"
+    };
+    FutureManager.initiateFuture(futureResponse);
+    return futureResponse;
+  }
+};
+const performComplete = async (pump, volume1, volume2, payload) => {
+  log.debug(
+    `performComplete - sending POST request to /api/ext/freestyle/microCalibration/pour/${pump}/complete`
+  );
+  try {
+    const response = await postModel({
+      model: {
+        ...payload,
+        // commandedCalibrationVolume: 0,
+        measuredCalibrationVolume: volume1,
+        measuredVerificationVolume: volume2
+        // newCalibrationValue: 0,
+        // pouredCalibrationVolume: 0,
+      },
+      urlOverride: `${URL}/api/ext/freestyle/microCalibration/pour/${pump}/complete`
+    });
+    log.debug("performComplete - response:", response);
+    if ((response?.status === 200 || response?.status === 499) && response.data?.error) {
+      return [response.data.error || "unknownError", response.data];
+    }
+    return [void 0, response?.data];
+  } catch (error) {
+    log.error(
+      `performComplete - sending POST request to /api/ext/freestyle/microCalibration/pour/${pump}/complete`,
+      error
+    );
+    if (error instanceof FetchError) {
+      const errorCode = error.payload?.data?.error || error.payload?.error || "unknownError";
+      return [errorCode, error.payload?.data || { error: errorCode }];
+    }
+  }
+  return ["unknownError", { error: "unknownError" }];
+};
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$1(target, key, result);
+  return result;
+};
+const MODEL_TYPE$1 = "spm-pump-model";
+let SpmPumpModelImpl = class {
+  id;
+  logger;
+  pump;
+  futureHandler;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.pump = options.companionParent;
+    this.futureHandler = new FutureHandler(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(props) {
+    return this.pump.performIntent(props);
+  }
+  get future() {
+    return this.futureHandler.future;
+  }
+  async performPreCalibrate(tracker) {
+    return performPreCalibrate(this.pump.path, tracker);
+  }
+  async performCalibrate(tracker) {
+    return performCalibrate(this.pump.path, tracker);
+  }
+  async performVerify(volume, payload, tracker) {
+    return performVerify(this.pump.path, volume, payload, tracker);
+  }
+  async performComplete(volume1, volume2, payload) {
+    return performComplete(this.pump.path, volume1, volume2, payload);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing spm-pump ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading spm-pump ${this.id}`);
+  }
+};
+__decorateClass$1([
+  kosFuture()
+], SpmPumpModelImpl.prototype, "performPreCalibrate", 1);
+__decorateClass$1([
+  kosFuture()
+], SpmPumpModelImpl.prototype, "performCalibrate", 1);
+__decorateClass$1([
+  kosFuture()
+], SpmPumpModelImpl.prototype, "performVerify", 1);
+SpmPumpModelImpl = __decorateClass$1([
+  kosModel(MODEL_TYPE$1)
+], SpmPumpModelImpl);
+const SpmPump = new KosModelRegistrationFactory({
+  class: SpmPumpModelImpl,
+  type: MODEL_TYPE$1
+});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "", value);
+const MODEL_TYPE = "agitation-required-trouble-model";
+const agitationModelFactory = (troubleModel) => {
+  if (troubleModel.data.agitationRequired) {
+    return MODEL_TYPE;
+  }
+  return void 0;
+};
+const AGITATION_REQUIRED_TROUBLE = "InsufficientAgitationTrouble";
+let AgitationRequiredTroubleModelImpl = class {
+  /**
+   * Unique identifier for this model instance.
+   */
+  id;
+  _deferred;
+  _holdersLoaded = false;
+  agitateBeforePour;
+  /**
+   * Creates a new AgitationRequiredTrouble model instance.
+   *
+   * @param modelId - Unique identifier for this model instance (typically matches parent trouble ID)
+   */
+  constructor(modelId) {
+    this.id = modelId;
+    this._deferred = false;
+  }
+  /**
+   * Resolves the agitation trouble by delegating to the parent trouble model.
+   *
+   * Resolution typically involves completing the agitation process and clearing
+   * the trouble state once carbonation or mixing levels are acceptable.
+   *
+   * @returns Promise resolving to the future response from the parent trouble's resolution
+   */
+  async resolve() {
+    return this.trouble.resolve();
+  }
+  /**
+   * Gets the holder model associated with this agitation trouble.
+   *
+   * The holder is the physical container (cartridge holder, ingredient holder, etc.)
+   * that requires agitation. Returns undefined if the holder model hasn't been
+   * loaded yet through the Assembly model initialization.
+   *
+   * @returns The holder model or undefined if not yet loaded
+   */
+  get holder() {
+    if (!this.trouble) {
+      return void 0;
+    }
+    const holderPath = this.trouble.data.holderPaths[0];
+    const holderModel = getKosModelSync(holderPath);
+    if (!this._holdersLoaded && !holderModel.model) {
+      return void 0;
+    }
+    return holderModel?.model;
+  }
+  updateHolder() {
+    if (!this._holdersLoaded && !!this.trouble) {
+      const holderPath = this.trouble.data.holderPaths[0];
+      const holderModel = getKosModelSync(holderPath);
+      if (holderModel.model) {
+        this._holdersLoaded = true;
+      }
+    }
+  }
+  /**
+   * Determines if trouble resolution should be deferred until agitation completes.
+   *
+   * Trouble resolution is deferred when:
+   * 1. The holder has active insufficient agitation troubles
+   * 2. The `agitateBeforePour` configuration is enabled
+   *
+   * This ensures that operations requiring agitation (prime, purge, or other
+   * holder-related troubles) wait for proper carbonation or mixing before
+   * being marked as resolved.
+   *
+   * @returns true if trouble resolution should wait for agitation to complete
+   */
+  get shouldDefer() {
+    if (!this.holder) {
+      return true;
+    }
+    const troubleList = this.holder?.troublesByType[AGITATION_REQUIRED_TROUBLE] || [];
+    const hasInsufficientAgitationTrouble = troubleList.length > 0;
+    const waitForAgitation = !!this.agitateBeforePour?.value;
+    return waitForAgitation && hasInsufficientAgitationTrouble;
+  }
+  /**
+   * Gets the current deferral state of this trouble.
+   *
+   * @returns true if this trouble resolution is currently deferred
+   */
+  get deferred() {
+    return this._deferred;
+  }
+  /**
+   * Marks this trouble as deferred, preventing immediate resolution.
+   *
+   * Called by the trouble system to indicate that trouble resolution
+   * should wait for agitation to complete before being marked as resolved.
+   */
+  defer() {
+    this._deferred = true;
+  }
+  /**
+   * Clears the deferral state, allowing trouble resolution to proceed.
+   *
+   * Typically called after agitation has completed and the trouble can
+   * now be safely resolved.
+   */
+  clearDefer() {
+    this._deferred = false;
+  }
+};
+__publicField(AgitationRequiredTroubleModelImpl, "Registration");
+__decorateClass([
+  kosConfigProperty({
+    path: "app:kosdev.ddk:app",
+    attribute: "ncui.agitateBeforePour"
+  })
+], AgitationRequiredTroubleModelImpl.prototype, "agitateBeforePour", 2);
+__decorateClass([
+  kosTopicHandler({
+    topic: modelTypeEventTopicFactory(Assembly.type),
+    lifecycle: DependencyLifecycle.INIT
+  })
+], AgitationRequiredTroubleModelImpl.prototype, "updateHolder", 1);
+AgitationRequiredTroubleModelImpl = __decorateClass([
+  kosModel({ modelTypeId: MODEL_TYPE, singleton: false }),
+  kosLoggerAware(),
+  kosCompanion({ mode: "composition", parentProperty: "trouble" })
+], AgitationRequiredTroubleModelImpl);
+const AgitationRequiredTrouble = AgitationRequiredTroubleModelImpl.Registration;
+const AGITATOR_KEYS = ["iceAgitator"];
+const AGITATOR_FACTORY_MAP = {
+  iceAgitator: IceAgitator
+};
+const logger = KosLog.createLogger({ name: "freestyle-assembly-data-mapper" });
+const freestyleAssemblyDataMapper = async (data) => {
+  const cartridgeAgitators = CartridgeAgitatorContainer.instance().options({}).build();
+  const remoteTrays = RemoteTrayContainer.instance().options({}).build();
+  const response = data.assemblies.reduce((acc, assembly) => {
+    AGITATOR_KEYS.forEach((key) => {
+      const agitator = assembly[key];
+      if (agitator) {
+        const factory = AGITATOR_FACTORY_MAP[key];
+        acc[key] = factory.instance(agitator.path).options({
+          name: agitator.name,
+          path: agitator.path,
+          statePath: agitator.state?.path || ""
+        }).build();
+      }
+    });
+    assembly.cartridgeAgitators?.forEach((cartridgeAgitatorData) => {
+      const cartridgeAgitator = CartridgeAgitator.instance(
+        cartridgeAgitatorData.path
+      ).options({
+        name: cartridgeAgitatorData.name,
+        path: cartridgeAgitatorData.path,
+        statePath: cartridgeAgitatorData.state?.path || ""
+      }).build();
+      cartridgeAgitators.addModel(cartridgeAgitator);
+    });
+    if (assembly.remoteTrays) {
+      assembly.remoteTrays.forEach((tray) => {
+        logger.info(`Found remote tray ${tray.name} with path ${tray.path}`);
+        const trayId = `${RemoteTray.type}-${tray.holderPath}`;
+        const trayModel = RemoteTray.instance(trayId).options({
+          holderPath: tray.holderPath,
+          configPath: tray.path,
+          name: tray.name
+        }).build();
+        remoteTrays.addModel(trayModel);
+      });
+    }
+    return acc;
+  }, {});
+  const supportsIce = !!response.iceAgitator;
+  const supportsCarb = !!response["carbTank"];
+  return {
+    ...response,
+    cartridgeAgitators,
+    remoteTrays,
+    supportsCarb,
+    supportsIce
+  };
+};
+const registerFreestyleModels = (root) => () => {
+  registerCoreModels(root)();
+  registerDispenseModels(root)();
+  FreestyleNozzle.register();
+  FreestyleAssembly.register();
+  IceAgitator.register();
+  CarbAgitator.register();
+  CartridgeAgitatorContainer.register();
+  SpmPump.register();
+  FcmPump.register();
+  LfcvPump.register();
+  CgpPump.register();
+  FreestylePump.register();
+  FreestyleHolder.register();
+  RemoteTray.register();
+  RemoteTrayContainer.register();
+  RegistrationManager.companion.register(root)(
+    Nozzle.type,
+    FreestyleNozzle.type
+  );
+  RegistrationManager.companion.register(root)(
+    Assembly.type,
+    FreestyleAssembly.type
+  );
+  AgitationRequiredTrouble.register();
+  RegistrationManager.companion.register(root)(
+    Trouble.type,
+    agitationModelFactory
+  );
+  RegistrationManager.companion.register(root)(Pump.type, FreestylePump.type);
+  RegistrationManager.companion.register(root)(
+    Holder.type,
+    FreestyleHolder.type
+  );
+  ExtensionManager[EXTENSION_TROUBLE_DATA_MAPPER].register(
+    "EnjoyByTrouble",
+    async (trouble) => {
+      if (trouble.data.enjoyByDate) {
+        const enjoyByDate = new Date(trouble.data.enjoyByDate);
+        const now = /* @__PURE__ */ new Date();
+        const daysSinceEnjoyBy = Math.floor(
+          (now.getTime() - enjoyByDate.getTime()) / (1e3 * 60 * 60 * 24)
+        );
+        return {
+          enjoyByDays: daysSinceEnjoyBy || ""
+        };
+      }
+      return {};
+    }
+  );
+  ExtensionManager[EXTENSION_TROUBLE_DATA_MAPPER].register(
+    "SuperPumpRequiredTrouble",
+    // This is the trouble type
+    async (_trouble) => {
+      const { model: pumpContainer } = getKosModelSync(
+        PumpContainer.type
+      );
+      if (pumpContainer) {
+        const superPumpModels = pumpContainer.models.getIndexByKey(
+          PumpIndex.byType,
+          "microSuper"
+        );
+        const superPumps = superPumpModels.map((model) => model.name).join(", ");
+        return {
+          superPumps
+        };
+      }
+      return {};
+    }
+  );
+  ExtensionManager[EXTENSION_TROUBLE_DATA_MAPPER].register(
+    "MicroPumpAirDetectTrouble",
+    async (trouble) => {
+      if (trouble.ifaces.includes("container")) {
+        return {};
+      }
+      if (trouble.data.pumpPath) {
+        const { model: pumpModel } = getKosModelSync(
+          trouble.data.pumpPath
+        );
+        if (pumpModel) {
+          const ingredientModel = pumpModel.ingredientId ? getKosModelSync(pumpModel.ingredientId).model : void 0;
+          return {
+            ingredientId: pumpModel.ingredientId,
+            ingredientName: ingredientModel?.name || ""
+          };
+        }
+      }
+      return {};
+    }
+  );
+  return {
+    preload: RegistrationManager.model.preloadModel(root),
+    model: RegistrationManager.model.register(root),
+    companion: RegistrationManager.companion.register(root),
+    legacy: RegistrationManager.model.registerLegacyModel(root)
+  };
+};
+const _KosModelRegistry = {
+  ...KosModelRegistry$1
+};
+_KosModelRegistry.freestyle = {
+  models: registerFreestyleModels(_KosModelRegistry)
+};
+_KosModelRegistry.preload = RegistrationManager.model.preloadModel(_KosModelRegistry);
+_KosModelRegistry.model = RegistrationManager.model.register(_KosModelRegistry);
+_KosModelRegistry.companion = RegistrationManager.companion.register(_KosModelRegistry);
+_KosModelRegistry.legacy = RegistrationManager.model.registerLegacyModel(_KosModelRegistry);
+const KosModelRegistry = _KosModelRegistry;
+function kosServiceRequest$4(params) {
+  return kosServiceRequest$5(params);
+}
+const api$4 = createClient();
+const service$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  api: api$4,
+  default: api$4,
+  kosServiceRequest: kosServiceRequest$4
+}, Symbol.toStringTag, { value: "Module" }));
+function kosServiceRequest$3(params) {
+  return kosServiceRequest$5(params);
+}
+const api$3 = createClient();
+const service$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  api: api$3,
+  default: api$3,
+  kosServiceRequest: kosServiceRequest$3
+}, Symbol.toStringTag, { value: "Module" }));
+function kosServiceRequest$2(params) {
+  return kosServiceRequest$5(params);
+}
+const api$2 = createClient();
+const service$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  api: api$2,
+  default: api$2,
+  kosServiceRequest: kosServiceRequest$2
+}, Symbol.toStringTag, { value: "Module" }));
+function kosServiceRequest$1(params) {
+  return kosServiceRequest$5(params);
+}
+const api$1 = createClient();
+const service$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  api: api$1,
+  default: api$1,
+  kosServiceRequest: kosServiceRequest$1
+}, Symbol.toStringTag, { value: "Module" }));
+function kosServiceRequest(params) {
+  return kosServiceRequest$5(params);
+}
+const api = createClient();
+const service = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  api,
+  default: api,
+  kosServiceRequest
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  AGITATION_REQUIRED_TROUBLE as A,
+  performComplete as B,
+  CarbAgitator as C,
+  performPreCalibrate as D,
+  performVerify as E,
+  FcmPump as F,
+  freestyleAssemblyDataMapper as G,
+  FEATURE_SUPPORTS_ICE as H,
+  IceAgitator as I,
+  KosModelRegistry as K,
+  LfcvPump as L,
+  NutritionInfoError as N,
+  RemoteTray as R,
+  SpmPump as S,
+  AgitationRequiredTrouble as a,
+  CartridgeAgitator as b,
+  CartridgeAgitatorContainer as c,
+  CartridgeAgitatorEvents as d,
+  CgpPump as e,
+  service$3 as f,
+  service$2 as g,
+  FreestyleAssembly as h,
+  FreestyleHolder as i,
+  FreestyleNozzle as j,
+  FreestylePump as k,
+  service$1 as l,
+  service as m,
+  IceAgitatorEvents as n,
+  RemoteTrayContainer as o,
+  performCalibrate$1 as p,
+  performComplete$1 as q,
+  registerFreestyleModels as r,
+  service$4 as s,
+  performElectricalTest as t,
+  performPreCalibrate$1 as u,
+  performVerify$1 as v,
+  InvalidRequestError as w,
+  getFreestyleNutritionInfo as x,
+  replacePump as y,
+  performCalibrate as z
+};
+//# sourceMappingURL=service-BRuYqmJg.js.map