@kosdev-code/kos-dispense-sdk 2.1.38 → 3.0.0

package/dispense-registration-manager-BSKa5Oi9.js

@@ -0,0 +1,2674 @@
+import { kosModel, Kos, isKosModel, resolveServiceUrl, ServiceFactory, KosLog, KosModelContainer, KosExtensionUtils, kosChild, FetchError, ExtensionManager, EXTENSION_TROUBLE_MAPPER, EXTENSION_TROUBLE_DATA_MAPPER, getKosModelSync, kosDependency, kosTroubleAware, kosAction, kosTopicHandler, DependencyLifecycle, getKosModel, FutureManager, kosFuture, FutureHandler, EXTENSION_FEATURE_FLAG_RESOLVER, isKosDataModel, ChildModels, KosFeatureFlags, kosParentAware, createPropKey, kosStateEntry, kosStateExit, kosStateGuard, kosLoggerAware, kosStateMachine, MultipleFutureHandler, arraysEqual, getAllKosCompanionModels, EventBus, KosContextManager, destroyKosModel, SingletonKosModelRegistrationFactory, kosFutureAware, ObservableData, KosModelRegistrationFactory, KosModelRegistry as KosModelRegistry$1, RegistrationManager, registerCoreModels, registerLegacyModel } from "@kosdev-code/kos-ui-sdk";
+import "react";
+var ExtensionType = /* @__PURE__ */ ((ExtensionType2) => {
+  ExtensionType2["IngredientLoader"] = "kos.ingredient.loader";
+  ExtensionType2["IngredientMapper"] = "kos.ingredient.mapper";
+  ExtensionType2["IngredientIndex"] = "kos.ingredient.index";
+  ExtensionType2["IngredientTypeMapper"] = "kos.ingredient.type.mapper";
+  ExtensionType2["HolderTypeMapper"] = "kos.holder.type.mapper";
+  ExtensionType2["HolderMapper"] = "kos.holder.mapper";
+  ExtensionType2["HolderIndex"] = "kos.holder.index";
+  ExtensionType2["HolderIngredientMapper"] = "kos.holder.ingredient.mapper";
+  ExtensionType2["AvailabilityMapper"] = "kos.availability.mapper";
+  ExtensionType2["AvailabilityLoader"] = "kos.availability.loader";
+  ExtensionType2["SelectedPourableMapper"] = "kos.selected.pourable.mapper";
+  ExtensionType2["AssemblyMapper"] = "kos.assembly.mapper";
+  ExtensionType2["BoardMapper"] = "kos.board.mapper";
+  ExtensionType2["BoardIndex"] = "kos.board.index";
+  ExtensionType2["PumpIndex"] = "kos.pump.index";
+  ExtensionType2["AssemblyFeatureFlags"] = "kos.assembly.feature.flags";
+  return ExtensionType2;
+})(ExtensionType || {});
+var DispenseModelType = /* @__PURE__ */ ((DispenseModelType2) => {
+  DispenseModelType2["Nozzle"] = "nozzle-model";
+  DispenseModelType2["Availability"] = "availability-model";
+  DispenseModelType2["Holder"] = "holder-model";
+  DispenseModelType2["HolderContainer"] = "holder-container-model";
+  DispenseModelType2["IngredientContainer"] = "ingredient-container-model";
+  DispenseModelType2["Ingredient"] = "ingredient-model";
+  DispenseModelType2["Pump"] = "pump-model";
+  DispenseModelType2["PumpContainer"] = "pump-container-model";
+  return DispenseModelType2;
+})(DispenseModelType || {});
+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 = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$c = "ingredient-model";
+let IngredientModelImpl = class {
+  id;
+  ingredientId;
+  name;
+  type;
+  data;
+  constructor(modelId, {
+    name,
+    type,
+    data,
+    ingredientId,
+    ...rest
+  }) {
+    this.id = modelId;
+    this.ingredientId = ingredientId;
+    this.name = name;
+    this.type = type;
+    this.data = data;
+    Object.assign(this, rest);
+  }
+  updateModel({
+    name,
+    type,
+    data,
+    ingredientId,
+    ...rest
+  }) {
+    this.name = name;
+    this.type = type;
+    this.ingredientId = ingredientId;
+    this.data = data;
+    Object.assign(this, rest);
+  }
+  // -------------------LIFECYCLE----------------------------
+  // -------------------ENTITY----------------------------
+};
+IngredientModelImpl = __decorateClass$c([
+  kosModel(MODEL_TYPE$c)
+], IngredientModelImpl);
+const Ingredient = {
+  registration: {
+    [MODEL_TYPE$c]: {
+      class: IngredientModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$c,
+  predicate: isKosModel(MODEL_TYPE$c),
+  factory: Kos.Factory.create(MODEL_TYPE$c)
+};
+const { URL: URL$6 } = resolveServiceUrl("INGREDIENT_SERVICE");
+const { getOne: getOne$3 } = ServiceFactory.build({
+  basePath: `${URL$6}/api/ext/dispense/ingredients`
+});
+const getIngredients = async () => {
+  const response = await getOne$3({
+    urlOverride: `${URL$6}/api/ext/dispense/ingredients`
+  });
+  return response;
+};
+var __defProp$9 = Object.defineProperty;
+var __getOwnPropDesc$b = Object.getOwnPropertyDescriptor;
+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$9(target, key, result);
+  return result;
+};
+const MODEL_TYPE$b = "ingredient-container-model";
+const log$3 = KosLog.createLogger({ name: "ingredient-container-model" });
+let IngredientContainerModelImpl = class {
+  id;
+  ingredients;
+  constructor(modelId, options) {
+    this.id = modelId;
+    this.ingredients = new KosModelContainer({
+      indexMap: {
+        ingredientType: "type"
+      },
+      extensionId: ExtensionType.IngredientIndex,
+      parentId: modelId
+    });
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  getIngredientsByType(type) {
+    return this.ingredients.getIndexByKey("ingredientType", type);
+  }
+  async load(context) {
+    log$3.debug(`loading ingredient container ${this.id}`);
+    const allIngredients = await getIngredients();
+    if (allIngredients?.status !== 200) {
+      throw new Error("Failed to load ingredients");
+    }
+    const ingredientContext = await KosExtensionUtils.executeLoaderExtension({
+      context,
+      extension: ExtensionType.IngredientLoader
+    });
+    const ingredientData = allIngredients?.data ?? {};
+    for (const key of Object.keys(ingredientData)) {
+      for (const ingredientData2 of allIngredients?.data?.[key] || []) {
+        const data = await KosExtensionUtils.executeDataMapperExtension({
+          extension: ExtensionType.IngredientMapper,
+          data: ingredientData2,
+          contextData: ingredientContext
+        });
+        const type = await KosExtensionUtils.executePropertyMapperExtension({
+          extension: ExtensionType.IngredientTypeMapper,
+          data: ingredientData2,
+          contextData: ingredientContext
+        });
+        const ingredientOptions = {
+          ...ingredientData2,
+          type: type || ingredientData2.type,
+          ...data,
+          data
+        };
+        const ingredient = Ingredient.factory(ingredientData2.id)(
+          ingredientOptions
+        );
+        this.ingredients.addModel(ingredient);
+      }
+    }
+  }
+  // -------------------ENTITY----------------------------
+};
+__decorateClass$b([
+  kosChild
+], IngredientContainerModelImpl.prototype, "ingredients", 2);
+IngredientContainerModelImpl = __decorateClass$b([
+  kosModel(MODEL_TYPE$b)
+], IngredientContainerModelImpl);
+const IngredientContainer = {
+  registration: {
+    [MODEL_TYPE$b]: {
+      class: IngredientContainerModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$b,
+  predicate: isKosModel(MODEL_TYPE$b),
+  factory: Kos.Singleton.create(MODEL_TYPE$b)
+};
+const { URL: URL$5 } = resolveServiceUrl("HOLDER_SERVICE");
+const { getAll: getAll$1, postModel: postModel$4, deleteModel: deleteModel$2 } = ServiceFactory.build({
+  basePath: `${URL$5}/api/kos/holders`
+});
+const log$2 = KosLog.createLogger({
+  name: "holder-service",
+  group: "Services"
+});
+const getHolders = async () => {
+  const response = await getAll$1({});
+  return response;
+};
+const assignHolderIngredient = async (holderPath, ingredientId) => {
+  if (!holderPath || !ingredientId) {
+    throw new Error("Missing holderPath or ingredientId");
+  }
+  const response = await postModel$4({
+    model: { holderPath, ingredientId },
+    urlOverride: `${URL$5}/api/ext/dispense/assignments`
+  });
+  return response;
+};
+const unassignHolderIngredient = async (holderPath) => {
+  if (!holderPath) {
+    throw new Error("Missing holderPath");
+  }
+  const response = await deleteModel$2({
+    id: holderPath,
+    urlOverride: `${URL$5}/api/ext/dispense/assignments/${holderPath}`
+  });
+  return response;
+};
+const replaceLine = async (holderPath) => {
+  if (!holderPath) throw new Error("Missing holderPath");
+  log$2.debug(
+    `sending POST request to /api/ext/dispense/pumpEvents/replaceLine/${holderPath}`
+  );
+  const response = await postModel$4({
+    model: {},
+    urlOverride: `${URL$5}/api/ext/dispense/pumpEvents/replaceLine/${holderPath}`
+  });
+  return response;
+};
+const { URL: URL$4 } = resolveServiceUrl("ASSIGNMENT_SERVICE");
+const { getAll, postModel: postModel$3, deleteModel: deleteModel$1 } = ServiceFactory.build({
+  destinationAddress: "",
+  basePath: `${URL$4}/api/ext/dispense/assignments`
+});
+const useFos = window.kosUseFos;
+const getAssignments = async () => {
+  const response = await getAll({ fos: useFos });
+  return response;
+};
+const sendRfidOverride = async (holderPath, overrides) => {
+  const factoryJson = JSON.stringify(overrides);
+  const url = `${URL$4}/api/ext/dispense/assignments`;
+  try {
+    const response = await postModel$3({
+      model: { holderPath, factoryJson },
+      urlOverride: url
+    });
+    if (response?.status === 200 && response?.data?.error) {
+      return [response.data.error || "unknownError", response.data];
+    }
+    return [void 0, response?.data];
+  } catch (error) {
+    if (error instanceof FetchError) {
+      return [
+        error.payload?.data?.error || "unknownError",
+        error.payload?.data
+      ];
+    }
+  }
+  return ["unknownError", void 0];
+};
+const addAssignment = async (assignment) => {
+  const url = useFos ? `${URL$4}/api/ingredients/assignments/${assignment.holderPath}` : `${URL$4}/api/ext/dispense/assignments`;
+  const response = await postModel$3({
+    model: { ...assignment, fuelGauge: 680 },
+    fos: useFos,
+    urlOverride: url
+  });
+  return response;
+};
+const deleteAssignment = async (id) => {
+  const response = await deleteModel$1({ id, fos: useFos });
+  return response;
+};
+var __defProp$8 = 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$8(target, key, result);
+  return result;
+};
+const MODEL_TYPE$a = DispenseModelType.Holder;
+const log$1 = KosLog.createLogger({ name: "holder-model" });
+ExtensionManager[EXTENSION_TROUBLE_MAPPER].register(
+  "holder",
+  async (trouble) => {
+    const result = [];
+    result.push(...trouble.data.holderPaths);
+    return result;
+  }
+);
+ExtensionManager[EXTENSION_TROUBLE_DATA_MAPPER].register(
+  "pump",
+  async (trouble) => {
+    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?.displayName ?? (ingredientModel?.name || ""),
+          childPumpName: pumpModel.name
+        };
+      }
+    }
+    return {};
+  }
+);
+ExtensionManager[EXTENSION_TROUBLE_DATA_MAPPER].register(
+  "holder",
+  async (trouble) => {
+    if (trouble.data.holderNames.length > 0) {
+      const holderName = trouble.data.holderNames[0];
+      return {
+        holderName: holderName || ""
+      };
+    }
+    return {};
+  }
+);
+ExtensionManager[EXTENSION_TROUBLE_DATA_MAPPER].register(
+  "container",
+  async (trouble) => {
+    if (trouble.data.ingredients.length > 0) {
+      const ingredientId = trouble.data.ingredients[0];
+      const { model } = getKosModelSync(ingredientId);
+      return {
+        ingredientName: model?.displayName ?? (model?.name || ""),
+        ingredients: trouble.data.ingredients ? trouble.data.ingredients : [],
+        unknonwnIngredientId: trouble.data.unknonwnIngredientId ?? ""
+      };
+    }
+    return {};
+  }
+);
+class AssignmentError extends Error {
+  type;
+  constructor(type, message) {
+    super(message);
+    this.name = "AssignmentError";
+    this.type = type;
+  }
+}
+let HolderModelImpl = class {
+  id;
+  path;
+  name;
+  ingredientId;
+  ingredientType;
+  ingredientSource;
+  group;
+  slice;
+  logger;
+  data;
+  enjoyByDate;
+  attributes;
+  pumps;
+  ingredientContainer;
+  constructor(modelId, {
+    path,
+    name,
+    ingredientSource,
+    ingredientId,
+    ingredientType,
+    slice,
+    group,
+    data,
+    enjoyByDate,
+    attributes
+  }, context) {
+    this.id = modelId;
+    this.path = path;
+    this.name = name;
+    this.ingredientType = ingredientType;
+    this.ingredientSource = ingredientSource;
+    this.ingredientId = ingredientId;
+    this.group = group;
+    this.slice = slice;
+    this.enjoyByDate = enjoyByDate;
+    this.data = data;
+    this.pumps = new KosModelContainer({
+      parentId: modelId,
+      sortKey: "path"
+    });
+    this.attributes = attributes || {};
+    this.logger = context.logger;
+  }
+  updateModel({
+    path,
+    name,
+    ingredientSource,
+    ingredientId,
+    ingredientType,
+    group,
+    slice,
+    enjoyByDate,
+    data
+  }) {
+    this.path = path;
+    this.name = name;
+    this.ingredientId = ingredientId;
+    this.ingredientType = ingredientType;
+    this.ingredientSource = ingredientSource;
+    this.enjoyByDate = enjoyByDate;
+    this.slice = slice;
+    this.group = group;
+    this.data = data;
+  }
+  get hasEnjoyByDate() {
+    return !!this.enjoyByDate && !this.unassigned;
+  }
+  get hasEnjoyByWarning() {
+    return this.troublesByType["EnjoyByTrouble"]?.length > 0;
+  }
+  get nozzlePaths() {
+    return this.pumps.data.map((pump) => pump.nozzlePath);
+  }
+  async cancelPour() {
+    await Promise.all(
+      this.pumps.data.filter((pump) => pump.isPouring).map((pump) => pump.cancelPour())
+    );
+  }
+  get canPour() {
+    return !this.shouldDefer && this.pumps.data.every((pump) => pump.canPour);
+  }
+  get isPouring() {
+    const _isPouring = this.pumps.data.some((pump) => pump.isPouring);
+    this.logger.debug(`isPouring: ${!!_isPouring}`);
+    return _isPouring;
+  }
+  async performIntent(props) {
+    const intent = typeof props === "string" ? props : props.intent;
+    const pumpPath = typeof props === "string" ? void 0 : props.pumpPath;
+    const pump = pumpPath ? this.pumps.getModel(pumpPath) : this.pumps.data[0];
+    return pump?.performIntent({ intent });
+  }
+  get pourState() {
+    const state = this.pumps.data.reduce((resolvedState, pump) => {
+      if (pump.pouringState) {
+        return pump.pouringState;
+      }
+      return resolvedState;
+    }, "");
+    return state;
+  }
+  get nozzlePath() {
+    return this.pumps.data[0]?.nozzlePath;
+  }
+  get pumpPaths() {
+    return this.pumps.data.map((pump) => pump.id);
+  }
+  get sortedPumps() {
+    return this.pumps.data.sort((a, b) => {
+      if (a.virtual && !b.virtual) {
+        return -1;
+      }
+      if (!a.virtual && b.virtual) {
+        return 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+  }
+  get ingredient() {
+    if (!this.ingredientId) {
+      return void 0;
+    }
+    const ingredient = this.ingredientContainer?.ingredients.getModel(
+      this.ingredientId
+    );
+    return ingredient;
+  }
+  get ingredientName() {
+    if (this.ingredient) {
+      return this.ingredient.displayName ?? this.ingredient.name;
+    } else if (this.ingredientId) {
+      return "unknown";
+    } else {
+      return "";
+    }
+  }
+  get previousIngredient() {
+    if (!this.prevIngredientId) {
+      return void 0;
+    }
+    const ingredient = this.ingredientContainer?.ingredients.getModel(
+      this.prevIngredientId
+    );
+    return ingredient;
+  }
+  get previousIngredientName() {
+    if (this.previousIngredient) {
+      return this.previousIngredient.displayName ?? this.previousIngredient.name;
+    } else if (this.prevIngredientId) {
+      return "unknown";
+    } else {
+      return "";
+    }
+  }
+  get prevIngredientId() {
+    return this.pumps.data?.[0]?.prevIngredientId;
+  }
+  get unassigned() {
+    return (!this.ingredientId || this.ingredientId === "0") && (!this.prevIngredientId || this.prevIngredientId === "0");
+  }
+  get removed() {
+    return (!this.ingredientId || this.ingredientId === "0") && this.prevIngredientId !== void 0 && this.prevIngredientId !== "0";
+  }
+  get maxVolume() {
+    return this.slice.maxVolMl ?? 0;
+  }
+  get remainingVolume() {
+    return this.slice.currentVolMl ?? 0;
+  }
+  get hasMaxVolume() {
+    return this.slice.maxVolMl !== void 0;
+  }
+  get hasRemainingVolume() {
+    return this.slice.currentVolMl !== void 0;
+  }
+  get fillPercent() {
+    return this.remainingVolume <= 0 ? 0 : Math.floor((this.remainingVolume || 1) / (this.maxVolume || 1) * 100);
+  }
+  get hasFuelGuage() {
+    return this.hasMaxVolume && this.hasRemainingVolume;
+  }
+  updateIngredient(ingredientId) {
+    if (this.ingredientId === ingredientId) {
+      return;
+    }
+    kosAction(() => {
+      this.ingredientId = ingredientId;
+    });
+  }
+  async resolveIntentVolume(intent) {
+    const pump = this.pumps.data[0];
+    if (!pump) {
+      return { volume: -1 };
+    }
+    return pump.resolveIntentVolume(intent);
+  }
+  async overrideRfidCode(overrides) {
+    if (!overrides) {
+      throw new Error("Invalid override");
+    }
+    try {
+      const [error, result] = await sendRfidOverride(this.path, overrides);
+      if (error) {
+        throw new AssignmentError(
+          error,
+          `Failed to perform rfid override on holder ${this.id}`
+        );
+      }
+      kosAction(() => {
+        this.ingredientId = result?.ingredientId;
+      });
+      return result;
+    } catch (e) {
+      log$1.error(`Failed to perform rfid override on holder ${this.id}`, e);
+      throw e;
+    }
+  }
+  async assignIngredient(ingredientId) {
+    try {
+      if (ingredientId) {
+        await assignHolderIngredient(this.path, ingredientId);
+      } else {
+        await unassignHolderIngredient(this.path);
+      }
+      kosAction(() => {
+        this.ingredientId = ingredientId;
+      });
+    } catch (e) {
+      log$1.error(`Failed to perform assign ingredient to holder ${this.id}`, e);
+      throw e;
+    }
+  }
+  /**
+   * @kosApiLevel 3
+   */
+  get shouldDefer() {
+    return this.troubles.some((trouble) => trouble.shouldDefer);
+  }
+  async replaceLine() {
+    await replaceLine(this.path);
+    return;
+  }
+  // -------------------LIFECYCLE----------------------------
+  // ----------------------------------
+  // UNCOMMENT FOR TESTING FUEL GAUGE
+  // ----------------------------------
+  // async load() {
+  //   const random = Math.max(1000, Math.floor(Math.random() * 5000));
+  //   this.slice.maxVolMl = 1000;
+  //   setInterval(() => {
+  //     kosAction(() => {
+  //       if (this.remainingVolume < -100) {
+  //         this.slice.maxVolMl = 1000;
+  //         this.slice.currentVolMl = this.maxVolume;
+  //       } else {
+  //         this.slice.currentVolMl = this.remainingVolume - 50;
+  //       }
+  //     });
+  //   }, random);
+  // }
+  // -------------------ENTITY----------------------------
+};
+__decorateClass$a([
+  kosChild
+], HolderModelImpl.prototype, "pumps", 2);
+__decorateClass$a([
+  kosDependency({ modelType: IngredientContainer.type })
+], HolderModelImpl.prototype, "ingredientContainer", 2);
+HolderModelImpl = __decorateClass$a([
+  kosModel(MODEL_TYPE$a),
+  kosTroubleAware()
+], HolderModelImpl);
+const Holder = {
+  registration: {
+    [MODEL_TYPE$a]: {
+      class: HolderModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$a,
+  predicate: isKosModel(MODEL_TYPE$a),
+  factory: Kos.Factory.create(MODEL_TYPE$a)
+};
+const mapAssemblyHolderToModel = async (group, holderData) => {
+  const _ingredientId = ExtensionManager.propertyMapper.executeMapper(
+    ExtensionType.HolderIngredientMapper,
+    holderData
+  );
+  const type = ExtensionManager.propertyMapper.executeMapper(
+    ExtensionType.HolderTypeMapper,
+    holderData
+  ) || holderData.ingType;
+  const holderExtData = await KosExtensionUtils.executeDataMapperExtension({
+    extension: ExtensionType.HolderMapper,
+    data: holderData,
+    contextData: {}
+  });
+  const {
+    name,
+    path,
+    ingredientId,
+    ingType,
+    ingSource,
+    slice,
+    attributes,
+    ...rest
+  } = holderData;
+  const extData = { ...rest, ...holderExtData };
+  const sliceData = slice || { pos: 0 };
+  const holderOptions = {
+    name,
+    path,
+    ingredientId: _ingredientId || ingredientId,
+    ingredientType: type || ingType,
+    ingredientSource: ingSource,
+    enjoyByDate: holderData.container?.enjoyByDate ? new Date(holderData.container.enjoyByDate) : void 0,
+    slice: sliceData,
+    group,
+    attributes,
+    data: extData
+  };
+  const holder = Holder.factory(holderData.path)(holderOptions);
+  return holder;
+};
+const { URL: URL$3 } = resolveServiceUrl("ASSEMBLY_SERVICE");
+const { getOne: getOne$2 } = ServiceFactory.build({
+  basePath: `${URL$3}/api/kos/device/assemblies`
+});
+const log = KosLog.createLogger({
+  name: "assembly-service",
+  group: "Services"
+});
+const getAssembly = async () => {
+  log.debug("sending GET for assembly");
+  const response = await getOne$2({});
+  return response;
+};
+var __defProp$7 = 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$7(target, key, result);
+  return result;
+};
+const MODEL_TYPE$9 = "board-container-model";
+const TOPIC_BOARD_LINKED = "/kos/hardware/board/linked";
+const TOPIC_BOARD_UNLINKED = "/kos/hardware/board/unlinked";
+let BoardContainerModel = class {
+  id;
+  logger;
+  models;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.models = new KosModelContainer({
+      parentId: modelId,
+      extensionId: ExtensionType.BoardIndex
+    });
+  }
+  get boardList() {
+    return this.models.data;
+  }
+  updateModel() {
+  }
+  addModel(model) {
+    this.models.addModel(model);
+  }
+  removeModel(id) {
+    this.models.removeModel(id);
+  }
+  updateBoard(boardLinkEvent) {
+    const boardId = boardLinkEvent.path;
+    const board = this.models.getModel(boardId);
+    if (!board) {
+      this.logger.warn(`board ${boardId} not found`);
+      return;
+    }
+    board.updateModel(boardLinkEvent);
+  }
+  handleBoardLinkEvent(boardLinkEvent) {
+    this.logger.debug(`handling ${TOPIC_BOARD_LINKED} event ${boardLinkEvent}`);
+    if (boardLinkEvent) {
+      this.updateBoard(boardLinkEvent);
+    } else {
+      this.logger.debug(`- boardLinkEvent is undefined`);
+    }
+  }
+  handleBoardUnlinkEvent(boardLinkEvent) {
+    this.logger.debug(
+      `handling ${TOPIC_BOARD_UNLINKED} event ${boardLinkEvent}`
+    );
+    if (boardLinkEvent) {
+      this.updateBoard(boardLinkEvent);
+    } else {
+      this.logger.debug(`- boardLinkEvent is undefined`);
+    }
+  }
+};
+__decorateClass$9([
+  kosChild
+], BoardContainerModel.prototype, "models", 2);
+__decorateClass$9([
+  kosTopicHandler({
+    lifecycle: DependencyLifecycle.INIT,
+    topic: TOPIC_BOARD_LINKED,
+    websocket: true
+  })
+], BoardContainerModel.prototype, "handleBoardLinkEvent", 1);
+__decorateClass$9([
+  kosTopicHandler({
+    lifecycle: DependencyLifecycle.INIT,
+    topic: TOPIC_BOARD_UNLINKED,
+    websocket: true
+  })
+], BoardContainerModel.prototype, "handleBoardUnlinkEvent", 1);
+BoardContainerModel = __decorateClass$9([
+  kosModel(MODEL_TYPE$9)
+], BoardContainerModel);
+const boardTroubleDataMapper = async (trouble) => {
+  const boardPath = trouble.data.boardPath;
+  const { model } = getKosModelSync(boardPath);
+  return {
+    boardName: model?.name || ""
+  };
+};
+var __defProp$6 = 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$6(target, key, result);
+  return result;
+};
+const MODEL_TYPE$8 = DispenseModelType.PumpContainer;
+var PumpIndex = /* @__PURE__ */ ((PumpIndex2) => {
+  PumpIndex2["byBoard"] = "byBoard";
+  PumpIndex2["byType"] = "byType";
+  PumpIndex2["byNozzle"] = "byNozzle";
+  return PumpIndex2;
+})(PumpIndex || {});
+let PumpContainerModelImpl = class {
+  id;
+  pumps;
+  constructor(modelId, options) {
+    this.id = modelId;
+    this.pumps = new KosModelContainer({
+      indexMap: {
+        byNozzle: (pump) => pump.nozzlePaths,
+        byBoard: (pump) => pump.boardPath,
+        byType: "type"
+      },
+      parentId: modelId,
+      extensionId: ExtensionType.PumpIndex
+    });
+  }
+  /**
+   * The collection of pump models.
+   */
+  get pumpModels() {
+    return this.pumps.data;
+  }
+  /**
+   * The collection of pump paths.
+   */
+  get pumpPaths() {
+    return this.pumpModels.map((pump) => pump.path);
+  }
+  addModel(model) {
+    this.pumps.addModel(model);
+  }
+  removeModel(id) {
+    this.pumps.removeModel(id);
+  }
+  getModel(id) {
+    return this.pumps.getModel(id);
+  }
+  get models() {
+    return this.pumps;
+  }
+  get data() {
+    return this.pumps.data;
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  async load() {
+  }
+  // -------------------ENTITY----------------------------
+};
+__decorateClass$8([
+  kosChild
+], PumpContainerModelImpl.prototype, "pumps", 2);
+PumpContainerModelImpl = __decorateClass$8([
+  kosModel(MODEL_TYPE$8)
+], PumpContainerModelImpl);
+const PumpContainer = {
+  registration: {
+    [MODEL_TYPE$8]: {
+      class: PumpContainerModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$8,
+  predicate: isKosModel(MODEL_TYPE$8),
+  factory: Kos.Singleton.create(
+    MODEL_TYPE$8
+  )
+};
+const getPumpRelatedPaths = async (pumpPath) => {
+  const result = [];
+  const { model } = await getKosModel(pumpPath);
+  if (model) {
+    result.push(model.boardPath);
+    result.push(model.nozzlePath);
+    result.push(model.holderPath);
+  }
+  return result;
+};
+const pumpTroubleResolver = async (trouble) => {
+  const result = [];
+  const pumpPath = trouble.data.pumpPath;
+  result.push(pumpPath);
+  const relatedPaths = await getPumpRelatedPaths(pumpPath);
+  return [...result, ...relatedPaths];
+};
+const boardTroubleResolver = async (trouble) => {
+  const result = [];
+  const boardPath = trouble.data.boardPath;
+  result.push(trouble.data.boardPath);
+  const pumpContainer = await getKosModel(
+    PumpContainer.type
+  );
+  if (pumpContainer?.model) {
+    const boardPumps = pumpContainer.model.models.getIndexByKey(
+      PumpIndex.byBoard,
+      boardPath
+    );
+    const pumpPromises = boardPumps.map(
+      (pump) => getPumpRelatedPaths(pump.path)
+    );
+    const pumpResults = await Promise.allSettled(pumpPromises);
+    pumpResults.forEach((r) => {
+      if (r.status === "fulfilled") {
+        r.value.forEach((path) => result.push(path));
+      }
+    });
+  }
+  return Array.from(new Set(result));
+};
+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 = "board-model";
+const mapOptionsToModel = (options, model) => {
+  const { type, name, path, linked, instanceId, link, ...rest } = options;
+  model.type = type;
+  model.name = name;
+  model.path = path;
+  model.linked = linked;
+  model.link = Object.freeze(link);
+  model.instanceId = instanceId;
+  Object.assign(model, rest);
+};
+ExtensionManager[EXTENSION_TROUBLE_MAPPER].register(
+  "board",
+  boardTroubleResolver
+);
+ExtensionManager[EXTENSION_TROUBLE_DATA_MAPPER].register(
+  "board",
+  boardTroubleDataMapper
+);
+let BoardModelImpl = class {
+  id;
+  type;
+  name;
+  path;
+  linked;
+  instanceId;
+  logger;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    mapOptionsToModel(options, this);
+  }
+  updateModel(options) {
+    mapOptionsToModel(options, this);
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing board ${this.id}`);
+  }
+  async load() {
+    this.logger.debug(`loading board ${this.id}`);
+  }
+};
+BoardModelImpl = __decorateClass$7([
+  kosModel(MODEL_TYPE$7)
+], BoardModelImpl);
+const Board = {
+  registration: {
+    [MODEL_TYPE$7]: {
+      class: BoardModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$7,
+  predicate: isKosModel(MODEL_TYPE$7),
+  factory: Kos.Factory.create(MODEL_TYPE$7)
+};
+const BoardContainer = {
+  registration: {
+    [MODEL_TYPE$9]: {
+      class: BoardContainerModel,
+      singleton: true
+    },
+    ...Board.registration
+  },
+  type: MODEL_TYPE$9,
+  predicate: isKosModel(MODEL_TYPE$9),
+  factory: Kos.Singleton.create(
+    MODEL_TYPE$9
+  )
+};
+var __defProp$5 = Object.defineProperty;
+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 = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$5(target, key, result);
+  return result;
+};
+const MODEL_TYPE$6 = DispenseModelType.HolderContainer;
+const TOPIC_INSERT_START = "/kos/insertion/insert/start";
+const TOPIC_INSERT_COMPLETE = "/kos/insertion/insert/complete";
+const TOPIC_INSERT_UPDATE = "/kos/insertion/insert/update";
+const TOPIC_REMOVE = "/kos/insertion/remove";
+const TOPIC_REPLACE_LINE = "/kos/pumpEvent/replaceLine";
+const TOPIC_HOLDER_CHANGED = "/kos/handle/*";
+let HolderContainerModelImpl = class {
+  id;
+  holders;
+  logger;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.holders = new KosModelContainer({
+      indexMap: {
+        nozzle: (holder) => holder.nozzlePaths,
+        group: "group"
+      },
+      parentId: modelId,
+      extensionId: ExtensionType.HolderIndex
+    });
+    this.logger = context.logger;
+  }
+  updateModel() {
+  }
+  handleHolderEvents(event) {
+    KosLog.ifDebug(
+      () => this.logger.debug("Received holder change event", JSON.stringify(event))
+    );
+    const holder = this.holders.getModel(event.path);
+    if (holder) {
+      this.logger.info(
+        `Received change event for holder ${holder.path}.  Updating fuel gauge data.`
+      );
+      holder.slice.currentVolMl = event.slice?.currentVolMl;
+      holder.slice.maxVolMl = event.slice?.maxVolMl;
+      if (event?.container?.enjoyByDate) {
+        holder.enjoyByDate = new Date(event.container.enjoyByDate);
+      } else {
+        holder.enjoyByDate = void 0;
+      }
+    }
+  }
+  handleInsertion(data) {
+    KosLog.ifDebug(
+      () => this.logger.debug("Received insertion event", JSON.stringify(data))
+    );
+    const wrappedData = Array.isArray(data) ? data : [data];
+    wrappedData.forEach((event) => {
+      kosAction(() => {
+        const ingredientId = event.ingredientId;
+        const holder = this.holders.getModel(event.path);
+        if (holder) {
+          this.logger.info(
+            `Received insertion event for holder ${holder.path}`
+          );
+          holder.updateIngredient(ingredientId);
+          holder.slice.currentVolMl = event.slice?.currentVolMl;
+          holder.slice.maxVolMl = event.slice?.maxVolMl;
+          if (event?.container?.enjoyByDate) {
+            holder.enjoyByDate = new Date(event.container.enjoyByDate);
+          } else {
+            holder.enjoyByDate = void 0;
+          }
+          event.pumps.forEach((pump) => {
+            kosAction(() => {
+              const pumpModel = holder.pumps.getModel(pump.path);
+              if (pumpModel) {
+                pumpModel.ingredientId = pump.ingredientId;
+                pumpModel.inserted = pump.inserted;
+                pumpModel.prevIngredientId = pump.prevIngredientId;
+              }
+            });
+          });
+        }
+      });
+    });
+  }
+  // -------------------ENTITY----------------------------
+};
+__decorateClass$6([
+  kosChild
+], HolderContainerModelImpl.prototype, "holders", 2);
+__decorateClass$6([
+  kosTopicHandler({
+    topic: TOPIC_HOLDER_CHANGED,
+    websocket: true,
+    condition: (event, model) => model.holders.getModel(event.path) !== void 0
+  })
+], HolderContainerModelImpl.prototype, "handleHolderEvents", 1);
+__decorateClass$6([
+  kosTopicHandler({
+    topic: [
+      TOPIC_INSERT_START,
+      TOPIC_INSERT_COMPLETE,
+      TOPIC_INSERT_UPDATE,
+      TOPIC_REMOVE,
+      TOPIC_REPLACE_LINE
+    ],
+    websocket: true
+  })
+], HolderContainerModelImpl.prototype, "handleInsertion", 1);
+HolderContainerModelImpl = __decorateClass$6([
+  kosModel(MODEL_TYPE$6)
+], HolderContainerModelImpl);
+const HolderContainer = {
+  registration: {
+    [MODEL_TYPE$6]: {
+      class: HolderContainerModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$6,
+  predicate: isKosModel(MODEL_TYPE$6),
+  factory: Kos.Singleton.create(
+    MODEL_TYPE$6
+  )
+};
+const Logger$1 = KosLog.createLogger({ name: "board-utils" });
+const mapAssemblyBoardToModel = async (board) => {
+  const boardExtData = await KosExtensionUtils.executeDataMapperExtension({
+    extension: ExtensionType.BoardMapper,
+    data: board,
+    contextData: {}
+  });
+  const { type, name, path, linked, instanceId, ...rest } = board;
+  const extData = { ...rest, ...boardExtData };
+  const options = {
+    type,
+    name,
+    path,
+    linked,
+    instanceId,
+    ...extData
+  };
+  const boardModel = Board.factory(board.path)(options);
+  boardModel.updateModel(options);
+  return boardModel;
+};
+const assemblyBoardMap = (boardContainer) => async (board) => {
+  Logger$1.debug(`adding board ${board.name}`);
+  const boardModel = await mapAssemblyBoardToModel(board);
+  boardContainer.addModel(boardModel);
+};
+var PourState = /* @__PURE__ */ ((PourState2) => {
+  PourState2["IDLE"] = "IDLE";
+  PourState2["POURING"] = "POURING";
+  PourState2["POUR_STARTING"] = "POUR_STARTING";
+  PourState2["POUR_CANCELING"] = "POUR_CANCELING";
+  return PourState2;
+})(PourState || {});
+const { URL: URL$2 } = resolveServiceUrl("PUMP_SERVICE");
+const { postModel: postModel$2, getOne: getOne$1 } = ServiceFactory.build({
+  basePath: `${URL$2}/api/kos/holders`
+});
+KosLog.createLogger({
+  name: "pump-service",
+  group: "Services"
+});
+const sendIntent = async ({
+  intent,
+  pumpId,
+  tracker
+}) => {
+  const url = `${URL$2}/api/ext/dispense/nozzle/nozzle/pipeline/ingredient/pour/${pumpId}/${intent}`;
+  const response = await postModel$2({ model: {}, urlOverride: url, tracker });
+  if (response?.data) {
+    FutureManager.initiateFuture(response.data);
+  }
+  return response;
+};
+const getIntentVolume = async (pumpId, intent) => {
+  const url = `${URL$2}/api/ext/dispense/nozzle/nozzle/pipeline/ingredient/intent/${pumpId}/${intent}/volume`;
+  const response = await getOne$1({ urlOverride: url });
+  if (!response?.data) {
+    return { volume: -1 };
+  }
+  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 = DispenseModelType.Pump;
+ExtensionManager[EXTENSION_TROUBLE_MAPPER].register(
+  "pump",
+  pumpTroubleResolver
+);
+let PumpModelImpl = class {
+  id;
+  inserted;
+  type;
+  virtual;
+  ingredientId;
+  holderPath;
+  boardPath;
+  nozzlePath;
+  childPump;
+  name;
+  path;
+  prevIngredientId;
+  /**
+   * @kosApiLevel 12
+   */
+  state;
+  futureHandler;
+  currentState = PourState.IDLE;
+  constructor(modelId, options) {
+    this.id = modelId;
+    const {
+      inserted,
+      holderPath,
+      boardPath,
+      nozzlePath,
+      name,
+      path,
+      childPump,
+      virtual,
+      prevIngredientId,
+      state,
+      ...rest
+    } = options;
+    this.inserted = inserted;
+    this.type = options.type;
+    this.ingredientId = options.ingredientId;
+    this.holderPath = holderPath;
+    this.boardPath = boardPath;
+    this.nozzlePath = nozzlePath;
+    this.name = name;
+    this.path = path;
+    this.childPump = !!childPump;
+    this.virtual = !!virtual;
+    this.prevIngredientId = prevIngredientId;
+    this.state = state;
+    Object.assign(this, rest);
+    this.futureHandler = new FutureHandler(this);
+  }
+  updateModel(options) {
+    const {
+      inserted,
+      holderPath,
+      boardPath,
+      nozzlePath,
+      childPump,
+      name,
+      path,
+      ...rest
+    } = options;
+    this.inserted = inserted;
+    this.type = options.type;
+    this.ingredientId = options.ingredientId;
+    this.holderPath = holderPath;
+    this.boardPath = boardPath;
+    this.nozzlePath = nozzlePath;
+    this.childPump = this.childPump ? this.childPump : !!childPump;
+    this.name = name;
+    this.path = path;
+    this.prevIngredientId = options.prevIngredientId;
+    Object.assign(this, rest);
+  }
+  // -------------------LIFECYCLE----------------------------
+  get pouringState() {
+    return this.future?.endState || "";
+  }
+  get isPouring() {
+    return !!(this.future && !this.future?.endState) || this.currentState === PourState.POUR_STARTING || this.currentState === PourState.POURING;
+  }
+  get canPour() {
+    return !!this.ingredientId && !this.isPouring;
+  }
+  onFutureUpdate(future) {
+    if (future.endState) {
+      kosAction(() => {
+        this.currentState = PourState.IDLE;
+      });
+    }
+  }
+  async cancelPour() {
+    if (this.currentState === PourState.POURING || this.currentState === PourState.POUR_STARTING) {
+      this.currentState = PourState.POUR_CANCELING;
+      await this.future?.cancelFuture();
+      kosAction(() => {
+        this.currentState = PourState.IDLE;
+      });
+    } else {
+      KosLog.warn(`Cannot cancel pour in state ${this.currentState}`);
+    }
+  }
+  get future() {
+    return this.futureHandler.future;
+  }
+  async resolveIntentVolume(intent) {
+    return await getIntentVolume(this.path, intent);
+  }
+  async performIntent(props, tracker) {
+    const intent = typeof props === "string" ? props : props.intent;
+    if (!intent) {
+      throw new Error("No intent provided");
+    }
+    try {
+      if (this.currentState === PourState.IDLE) {
+        this.currentState = PourState.POUR_STARTING;
+        if (!tracker) {
+          throw new Error("No tracker provided");
+        }
+        const result = await sendIntent({
+          tracker,
+          intent,
+          pumpId: this.path
+        });
+        if (this.currentState === PourState.POUR_STARTING) {
+          kosAction(() => {
+            this.currentState = PourState.POURING;
+          });
+        }
+        return result?.data;
+      } else {
+        throw new Error(`Cannot pour in state ${this.currentState}`);
+      }
+    } catch (e) {
+      KosLog.error(e);
+      this.currentState = PourState.IDLE;
+      throw e;
+    }
+  }
+  // -------------------ENTITY----------------------------
+};
+__decorateClass$5([
+  kosFuture()
+], PumpModelImpl.prototype, "performIntent", 1);
+PumpModelImpl = __decorateClass$5([
+  kosModel(MODEL_TYPE$5)
+], PumpModelImpl);
+const Pump = {
+  registration: {
+    [MODEL_TYPE$5]: {
+      class: PumpModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$5,
+  predicate: isKosModel(MODEL_TYPE$5),
+  factory: Kos.Factory.create(MODEL_TYPE$5)
+};
+const Logger = KosLog.createLogger({ name: "pump-utils" });
+const mapAssemblyPumpToModel = (nozzlePath, pump) => {
+  const virtual = (pump.pumps ?? []).length > 1;
+  const options = {
+    boardPath: pump.boardPath,
+    holderPath: pump.holderPath,
+    ingredientId: pump.ingredientId,
+    childPump: !!pump.childPump,
+    virtual,
+    inserted: pump.inserted,
+    name: pump.name,
+    path: pump.path,
+    type: pump.type,
+    nozzlePath,
+    prevIngredientId: pump.prevIngredientId,
+    state: pump.state
+  };
+  const pumpModel = Pump.factory(pump.path)(options);
+  pumpModel.updateModel(options);
+  return pumpModel;
+};
+const assemblyPumpMap = (pumpContainer) => (holderContainer) => (nozzle) => (assemblyPump) => {
+  try {
+    Logger.debug(`adding pump ${assemblyPump.name}`);
+    const pump = mapAssemblyPumpToModel(nozzle.path, assemblyPump);
+    pumpContainer.addModel(pump);
+    const holderPath = pump.holderPath;
+    const holder = holderContainer.holders.getModel(holderPath);
+    holder?.pumps.addModel(pump);
+    if (!holder?.nozzlePaths.includes(nozzle.path)) {
+      holder?.nozzlePaths.push(nozzle.path);
+    }
+    assemblyPump?.pumps?.forEach((subPump) => {
+      const subHolderPath = pump.holderPath;
+      const subPumpData = {
+        ...subPump,
+        childPump: true,
+        holderPath: subHolderPath,
+        ingredientId: pump.ingredientId
+      };
+      assemblyPumpMap(pumpContainer)(holderContainer)(nozzle)(subPumpData);
+    });
+  } catch (error) {
+    Logger.error(`Error mapping assembly pump: ${error}`);
+    throw error;
+  }
+};
+var __defProp$3 = Object.defineProperty;
+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 = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$3(target, key, result);
+  return result;
+};
+const MODEL_TYPE$4 = "assembly-model";
+const CONTEXT_ASSEMBLY_DATA = "assembly-data";
+const CONTEXT_ASSEMBLY_RAW_DATA = "assembly-raw-data";
+let AssemblyModelImpl = class {
+  id;
+  _nozzlePaths = /* @__PURE__ */ new Set();
+  troubleContainer;
+  holderContainer;
+  boardContainer;
+  pumpContainer;
+  logger;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.holderContainer = HolderContainer.factory({});
+    this.boardContainer = BoardContainer.factory({});
+    this.pumpContainer = PumpContainer.factory({});
+    this.logger = context.logger;
+  }
+  updateModel(_options) {
+  }
+  get allHolders() {
+    return this.holderContainer.holders.data;
+  }
+  get holderGroups() {
+    return this.holderContainer.holders.getIndexKeys("group");
+  }
+  get nozzlePaths() {
+    return Array.from(this._nozzlePaths);
+  }
+  getHoldersByGroup(group) {
+    return this.holderContainer.holders.getIndexByKey("group", group);
+  }
+  getHoldersByNozzle(nozzlePath) {
+    return this.holderContainer.holders.getIndexByKey("nozzle", nozzlePath);
+  }
+  /**
+   * Returns a map of the pumps associated with each nozzle
+   *
+   * Can be used in conjunction with the nozzlePaths to get the pumps associated with each nozzle
+   * @returns Record<string, PumpModel[]>
+   */
+  get pumpsByNozzle() {
+    return this.pumpContainer.models.idx.byNozzle;
+  }
+  /**
+   * Returns a list of all fo the pumps paths across the entire assembly.
+   */
+  get pumpPaths() {
+    return this.pumpContainer.models.data.map((pump) => pump.path);
+  }
+  get boards() {
+    return this.boardContainer.boardList;
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing assembly ${this.id}`);
+  }
+  async ready() {
+    this.troubleContainer?.troubles.increment();
+    ExtensionManager[EXTENSION_FEATURE_FLAG_RESOLVER].execute(
+      ExtensionType.AssemblyFeatureFlags,
+      this
+    );
+  }
+  async load(context) {
+    this.logger.debug(`loading assembly ${this.id}`);
+    const result = await getAssembly();
+    if (result?.status === 200) {
+      const data = await KosExtensionUtils.executeDataMapperExtension({
+        extension: ExtensionType.AssemblyMapper,
+        data: result.data,
+        contextData: {}
+      });
+      context.set(CONTEXT_ASSEMBLY_DATA, data);
+      Object.assign(this, data);
+      Object.entries(data).forEach(([key, value]) => {
+        if (isKosDataModel(value)) {
+          this.logger.debug(`adding child model ${key} from extension data`);
+          this[ChildModels][key] = true;
+        }
+      });
+      context.set(CONTEXT_ASSEMBLY_RAW_DATA, result.data);
+      for await (const assembly of result.data.assemblies) {
+        const {
+          boards = [],
+          holders: assemblyHolders = {},
+          nozzles = [],
+          core: _core,
+          name,
+          path: _path,
+          ...rest
+        } = assembly;
+        this.logger.debug(`adding assembly ${name}`);
+        this.logger.warn(`Assembly rest keys: ${Object.keys(rest).join(", ")}`);
+        Object.keys(rest).forEach((key) => {
+          this.logger.warn(`Enabling feature flag: ${key}`);
+          KosFeatureFlags.enableFeature(key);
+          context.set(`assembly-feature-${key}`, rest[key]);
+          if (rest[key]["state"]?.["path"] !== void 0) {
+            const statePath = rest[key]["state"]["path"];
+            this.logger.warn(`Feature flag ${key} state path: ${statePath}`);
+            context.set(`assembly-state-path-${key}`, statePath);
+          }
+        });
+        for await (const board of boards) {
+          this.logger.debug(`adding board ${board.name}`);
+          const mapper = assemblyBoardMap(this.boardContainer);
+          await mapper(board);
+        }
+        for await (const [group, holders] of Object.entries(
+          assemblyHolders ?? {}
+        )) {
+          for await (const holder of holders) {
+            this.logger.debug(`adding holder ${holder.name}`);
+            const holderModel = await mapAssemblyHolderToModel(group, holder);
+            this.holderContainer.holders.addModel(holderModel);
+          }
+        }
+        const nozzlePumpMap = assemblyPumpMap(this.pumpContainer)(
+          this.holderContainer
+        );
+        nozzles.forEach((nozzle) => {
+          this._nozzlePaths.add(nozzle.path);
+          const pumpMap = nozzlePumpMap(nozzle);
+          nozzle.pumps.forEach(pumpMap);
+        });
+      }
+    }
+  }
+};
+__decorateClass$4([
+  kosDependency({
+    modelType: "trouble-container-model"
+  })
+], AssemblyModelImpl.prototype, "troubleContainer", 2);
+__decorateClass$4([
+  kosChild
+], AssemblyModelImpl.prototype, "holderContainer", 2);
+__decorateClass$4([
+  kosChild
+], AssemblyModelImpl.prototype, "boardContainer", 2);
+__decorateClass$4([
+  kosChild
+], AssemblyModelImpl.prototype, "pumpContainer", 2);
+AssemblyModelImpl = __decorateClass$4([
+  kosModel(MODEL_TYPE$4)
+], AssemblyModelImpl);
+const Assembly = {
+  registration: {
+    [MODEL_TYPE$4]: {
+      class: AssemblyModelImpl,
+      singleton: true
+    }
+  },
+  type: MODEL_TYPE$4,
+  predicate: isKosModel(MODEL_TYPE$4),
+  factory: Kos.Singleton.create(MODEL_TYPE$4)
+};
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+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 = decorator(result) || result;
+  return result;
+};
+const MODEL_TYPE$3 = DispenseModelType.Availability;
+let AvailabilityModelImpl = class {
+  id;
+  data;
+  properties;
+  available;
+  visible;
+  groupId;
+  rawId;
+  altId;
+  type;
+  note;
+  taggedIds;
+  parentId;
+  logger;
+  constructor(modelId, options, context) {
+    this.id = modelId;
+    this.taggedIds = options.taggedIds || [];
+    this.logger = context.logger;
+    this.available = options.available;
+    this.visible = options.visible;
+    this.groupId = options.groupId;
+    this.rawId = options.rawId;
+    this.altId = options.altId;
+    this.type = options.type;
+    this.parentId = options.kosParentId;
+    this.data = options.data;
+    this.note = options.note;
+    this.properties = options.properties || {};
+  }
+  updateModel(options) {
+    this.taggedIds = options.taggedIds || [];
+    this.available = options.available;
+    this.visible = options.visible;
+    this.groupId = options.groupId;
+    this.rawId = options.rawId;
+    this.altId = options.altId;
+    this.type = options.type;
+    this.data = options.data;
+  }
+  updateAvailability(available) {
+    this.available = available;
+  }
+  // -------------------LIFECYCLE----------------------------
+  // -------------------ENTITY----------------------------
+};
+AvailabilityModelImpl = __decorateClass$3([
+  kosParentAware(),
+  kosModel(MODEL_TYPE$3)
+], AvailabilityModelImpl);
+const Availability = {
+  registration: {
+    [MODEL_TYPE$3]: {
+      class: AvailabilityModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$3,
+  predicate: isKosModel(MODEL_TYPE$3),
+  factory: Kos.Factory.create(
+    MODEL_TYPE$3
+  )
+};
+const { URL: URL$1 } = resolveServiceUrl("NOZZLE_SERVICE");
+const { postModel: postModel$1, deleteModel, getOne } = ServiceFactory.build({
+  basePath: `${URL$1}/api/nozzle`
+});
+const pourPourable = async (nozzleId, tracker) => {
+  const response = await postModel$1({
+    model: {},
+    urlOverride: `${URL$1}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/pour/selected/maxVolume`,
+    ordered: true,
+    tracker
+  });
+  if (response?.data) {
+    FutureManager.initiateFuture(response.data);
+  }
+  return response;
+};
+const pourNamedPourable = async (name, nozzleId, tracker) => {
+  const response = await postModel$1({
+    model: {},
+    urlOverride: `${URL$1}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/fixed/${name}`,
+    ordered: true,
+    tracker
+  });
+  if (response?.data) {
+    FutureManager.initiateFuture(response.data);
+  }
+  return response;
+};
+const getAvailability = async (urlPrefix) => {
+  const response = await getOne({
+    urlOverride: `${URL$1}${urlPrefix}/pipeline/beverage/availability`
+  });
+  return response;
+};
+const selectPourable = async (nozzleId, payload) => {
+  const response = await postModel$1({
+    model: payload,
+    urlOverride: `${URL$1}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/select`
+  });
+  return response;
+};
+const clearPourable = async (nozzleId) => {
+  const response = await deleteModel({
+    id: nozzleId,
+    urlOverride: `${URL$1}/api/ext/dispense/nozzle/${nozzleId}/pipeline/beverage/select`
+  });
+  return response;
+};
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+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 = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp$2(target, key, result);
+  return result;
+};
+const MODEL_TYPE$2 = DispenseModelType.Nozzle;
+const PROP_BEVERAGE_TOPIC_PREFIX = createPropKey(
+  "beverageTopicPrefix"
+);
+const isPourAware$1 = (model) => model.onPourStart !== void 0 && model.onPourCancel !== void 0 && model.onPourProgress !== void 0;
+const TOPIC_NOZZLE_POUR_STARTED = "/kos/nozzle/pour/started";
+const TOPIC_NOZZLE_POUR_PROGRESS = "/kos/nozzle/pour/progress";
+const TOPIC_NOZZLE_POUR_CANCEL = "/kos/nozzle/pour/cancel";
+let NozzleModelImpl = class {
+  /** the unique identifier for this nozzle.*/
+  id;
+  path;
+  name;
+  _selectedBeverage;
+  _selectedBrand;
+  _additionalItems;
+  _availabilityItems;
+  futureHandler;
+  beverageTopicPrefix;
+  topicPrefix;
+  urlPrefix;
+  /**
+   * The availability nodes that can be dispensed from this nozzle.
+   * This is a subset of the availability for the entire dispenser
+   * and is determined by the nodes associated with a nozzle.
+   */
+  get beverages() {
+    return this._availabilityItems.getIndexByKey("byGroup", "beverages");
+  }
+  /**
+   * The availability nodes that have been grouped into the "brands" group.
+   *
+   */
+  get brands() {
+    return this._availabilityItems.getIndexByKey("byGroup", "brands");
+  }
+  get visibleBrands() {
+    return this.brands.filter((brand) => brand.visible);
+  }
+  get visibleBeverages() {
+    return this.beverages.filter((beverage) => beverage.visible);
+  }
+  /**
+   * A derived value that indicates if the nozzle is currently pouring a beverage.
+   * @readonly
+   */
+  get isPouring() {
+    return !!(this.futureHandler.getFuture() && !this.futureHandler.getFuture()?.endState) || this.currentState === PourState.POUR_STARTING || this.currentState === PourState.POURING || this.currentState === PourState.POUR_CANCELING;
+  }
+  /**
+   * A derived value that indicates if the nozzle is currently available to pour a beverage.
+   *
+   * This will generally be determined by whether there is a currently selected pourable AND
+   * the nozzle is not currently pouring.
+   *
+   * The value is observable and will change when the selected pourable changes or the nozzle
+   * starts or stops pouring.
+   * @readonly
+   * */
+  get canPour() {
+    return !!this._selectedBeverage && this._selectedBeverage.available && this.currentState === PourState.IDLE;
+  }
+  /**
+   * The selected pourable for this nozzle.  Its shape is determined by the results of the
+   * {@link ExtensionType.SelectedPourableMapper} extension.
+   * @readonly
+   *
+   * */
+  get selectedPourable() {
+    return {
+      beverage: this._selectedBeverage,
+      additional: this._additionalItems
+    };
+  }
+  get future() {
+    return this.futureHandler.getFuture();
+  }
+  get pourProgress() {
+    return this.future?.progress ?? 0;
+  }
+  constructor(modelId, options) {
+    this.id = modelId;
+    this.path = options.path;
+    this.name = options.name;
+    this.beverageTopicPrefix = options.beverageTopicPrefix;
+    this.topicPrefix = options.topicPrefix;
+    this.urlPrefix = options.urlPrefix;
+    this._selectedBeverage = void 0;
+    this._selectedBrand = void 0;
+    this._additionalItems = [];
+    this.futureHandler = new MultipleFutureHandler(this);
+    this._availabilityItems = new KosModelContainer({
+      indexMap: {
+        byGroup: "groupId",
+        byParent: "parentId"
+      },
+      parentId: modelId
+    });
+  }
+  updateModel() {
+  }
+  // -------------------LIFECYCLE----------------------------
+  setSelectedBrand(brand, _context) {
+    if (_context) {
+      this.logger.debug(`context is currenty being ignored when setting brand`);
+    }
+    this._selectedBrand = brand;
+    this._selectedBeverage = void 0;
+  }
+  get selectedBrand() {
+    return this._selectedBrand;
+  }
+  /**
+   * Set the values used to determine the selected pourable for this nozzle.
+   *
+   * @param pourable The pourable to set.
+   * @param pourable.beverage The beverage selected.
+   * @param pourable.additional The additional items such as flavors or other items that could be incorporated
+   * into the pourable.
+   * */
+  async setSelectedPourable({ beverage, additional, context }, forceUpdate = false) {
+    if (!beverage) {
+      const response2 = await clearPourable(this.name);
+      if (response2?.status !== 200) {
+        throw new Error("Failed to clear pourable");
+      }
+      this._selectedBeverage = void 0;
+      return;
+    }
+    if (!forceUpdate && beverage === this._selectedBeverage && arraysEqual(this._additionalItems, additional)) {
+      this.logger.info("No change in selected pourable");
+      return;
+    }
+    this._selectedBeverage = beverage;
+    this._additionalItems = additional;
+    let selectedPayload;
+    try {
+      selectedPayload = await ExtensionManager.dataMapper.executeMapper(
+        ExtensionType.SelectedPourableMapper,
+        {
+          beverage,
+          additional,
+          context
+        }
+      );
+    } catch (e) {
+      this.logger.error(
+        `Error executing SelectedPourableMapper, falling back to default payload. Error: ${e}`
+      );
+      selectedPayload = void 0;
+    }
+    const defaultPayload = {
+      bevId: beverage.rawId
+    };
+    if (!selectedPayload || Object.keys(selectedPayload).length === 0) {
+      this.logger.info(
+        `No selected pourable mapper defined, using the default payload ${defaultPayload}`
+      );
+      selectedPayload = defaultPayload;
+    }
+    const payload = selectedPayload ?? defaultPayload;
+    const response = await selectPourable(this.name, payload);
+    if (response?.status !== 200) {
+      throw new Error("Failed to select pourable");
+    }
+  }
+  /**
+   * Utility method that will return the availability nodes that belong to the specified
+   * group as defined in the dispenser beverage graph.  For example, a dispenser
+   * implementation may group availability nodes by Brand, Beverage, or Flavors
+   *
+   * @param groupId The group to filter by.
+   * @returns The availability nodes that are available to be dispensed from this nozzle
+   * and are in the specified group.
+   * */
+  getGroupAvailabilityItems(groupId) {
+    return this._availabilityItems.getIndexByKey(
+      "byGroup",
+      groupId
+    );
+  }
+  /**
+   * Utility method that will return the availability nodes that are tagged with the specified parent id.
+   *
+   * This is useful when brandsets use the taggedIds property to associate nodes with a parent node. For example,
+   * when organizing a brandset into brands and beverages, the brand nodes will be tagged with the beverage nodes.
+   *
+   * @param parentId - The parent id to filter by.
+   * @returns the availability nodes that are tagged with the specified parent id.
+   */
+  getAvailabilityByParent(parentId) {
+    return this._availabilityItems.getIndexByKey(
+      "byParent",
+      parentId
+    );
+  }
+  handlePouringStart() {
+    this.logger.info("Pour started");
+    getAllKosCompanionModels(this).forEach((model) => {
+      if (isPourAware$1(model)) {
+        model.onPourStart?.();
+      }
+    });
+  }
+  handlePouringEnd() {
+    this.logger.info("Pour ended");
+  }
+  handleCancelStart() {
+    this.logger.info("Pour canceling");
+  }
+  handleCanceled() {
+    this.logger.info("Pour canceled");
+    getAllKosCompanionModels(this).forEach((model) => {
+      if (isPourAware$1(model)) {
+        model.onPourCancel?.();
+      }
+    });
+    const evt = {
+      nozzleId: this.id
+    };
+    EventBus.publish(TOPIC_NOZZLE_POUR_CANCEL, evt);
+  }
+  // ============================================================================
+  // Future Lifecycle Handler
+  // ============================================================================
+  onFutureUpdate(future) {
+    const companions = getAllKosCompanionModels(this);
+    companions.forEach((model) => {
+      if (isPourAware$1(model)) {
+        model.onPourProgress(future);
+      }
+    });
+    const evt = {
+      nozzleId: this.id,
+      progress: future.progress,
+      status: future.status,
+      clientData: future.clientData,
+      futureId: future.futureId,
+      remainingTimeMs: future.remainingTimeMs,
+      endState: future.endState,
+      reason: future.reason,
+      timeRemaining: future.timeRemaining
+    };
+    EventBus.publish(TOPIC_NOZZLE_POUR_PROGRESS, evt);
+    if (future.endState) {
+      kosAction(() => {
+        if (this.currentState === PourState.POURING) {
+          this.transition("POUR_COMPLETED");
+        }
+      });
+    }
+  }
+  // Inherits throwOnInvalid: false from class
+  async pour(tracker) {
+    try {
+      this.transition("START_POUR");
+      if (!tracker) {
+        throw new Error("No tracker provided");
+      }
+      const result = await pourPourable(this.name, tracker);
+      this.transition("POUR_ACTIVE");
+      const evt = {
+        nozzleId: this.id,
+        type: "free"
+      };
+      EventBus.publish(TOPIC_NOZZLE_POUR_STARTED, evt);
+      if (result?.data?.endState) {
+        this.transition("POUR_COMPLETED");
+      }
+      return result;
+    } catch (e) {
+      this.logger.error(e);
+      if (this.currentState !== PourState.IDLE) {
+        this.transition("POUR_COMPLETED");
+      }
+      throw e;
+    }
+  }
+  // Inherits throwOnInvalid: false from class
+  async fixedPour(name, tracker) {
+    try {
+      this.transition("START_POUR");
+      if (!tracker) {
+        throw new Error("No tracker provided");
+      }
+      const result = await pourNamedPourable(name, this.name, tracker);
+      this.transition("POUR_ACTIVE");
+      const evt = {
+        nozzleId: this.id,
+        type: "fixed"
+      };
+      EventBus.publish(TOPIC_NOZZLE_POUR_STARTED, evt);
+      if (result?.data?.endState) {
+        this.transition("POUR_COMPLETED");
+      }
+      return result;
+    } catch (e) {
+      this.logger.error(e);
+      if (this.currentState !== PourState.IDLE) {
+        this.transition("POUR_COMPLETED");
+      }
+      throw e;
+    }
+  }
+  // Inherits throwOnInvalid: false - silently ignore if already idle
+  async cancelPour() {
+    this.transition("CANCEL_POUR");
+    await this.futureHandler.getFuture()?.cancelFuture();
+    this.transition("POUR_CANCELED");
+  }
+  updateGroupMembers() {
+    this._availabilityItems.data.forEach((item) => {
+      const taggedIds = item.taggedIds || [];
+      taggedIds.forEach((taggedId) => {
+        const childItem = this._availabilityItems.data.find(
+          (beverage) => beverage.rawId === taggedId
+        );
+        if (childItem && childItem.parentId !== item.id) {
+          childItem.parentId = item.id;
+          this._availabilityItems.updateModel(childItem);
+        }
+      });
+    });
+  }
+  async reload() {
+    this.logger.info(`reloading nozzle ${this.id}`);
+    const context = KosContextManager.getContext(this.id);
+    context?.get(ExtensionType.AvailabilityLoader) || {};
+    const availability = await getAvailability(this.urlPrefix);
+    if (availability?.status !== 200 || !availability?.data) {
+      this.logger.error("Failed to load nozzle availability");
+      return;
+    }
+    const update = availability?.data;
+    if (update) {
+      await this.updateAvailability(update);
+    }
+  }
+  /** @internal */
+  async load(context) {
+    this.logger.debug(`loading nozzle ${this.id}`);
+    const availability = await getAvailability(this.urlPrefix);
+    if (availability?.status !== 200) {
+      throw new Error("Failed to load nozzle availability");
+    }
+    const beverageContext = await ExtensionManager.loader.executeLoader(
+      ExtensionType.AvailabilityLoader,
+      {}
+    );
+    context?.set(ExtensionType.AvailabilityLoader, beverageContext);
+    context?.set(Nozzle.type, this);
+    for (const group of Object.keys(availability.data?.groups) || []) {
+      for (const beverageData of availability.data?.groups[group] || []) {
+        const extensionData = await ExtensionManager.dataMapper.executeMapper(
+          ExtensionType.AvailabilityMapper,
+          { ...beverageData, groupId: group },
+          beverageContext
+        );
+        const beverageOptions = {
+          ...beverageData,
+          note: beverageData.note ?? void 0,
+          kosParentId: this.id,
+          rawId: beverageData.id,
+          groupId: group,
+          data: extensionData,
+          properties: beverageData.properties || {}
+        };
+        const beverage = Availability.factory(
+          `${this.id}-${group}-${beverageData.id}`
+        )(beverageOptions);
+        this._availabilityItems.addModel(beverage);
+      }
+    }
+    this.updateGroupMembers();
+  }
+  async updateAvailability(update) {
+    const context = KosContextManager.getContext(this.id);
+    const beverageContext = context?.get(ExtensionType.AvailabilityLoader) || {};
+    if (update.rebuild) {
+      this.logger.info(
+        `Received rebuild update for nozzle ${this.path}, rebuilding entire availability set`
+      );
+      for (const group of Object.keys(update?.groups) || []) {
+        const deletedBeverages = this._availabilityItems.getIndexByKey("group", group).filter(
+          (beverage) => !update.groups[group].find(
+            (b) => `${this.id}-${group}-${b.id}` === beverage.id
+          )
+        );
+        deletedBeverages.forEach((beverage) => {
+          this.logger.info(
+            `Removing beverage ${beverage.id} from nozzle ${this.path} due to rebuild update`
+          );
+          this._availabilityItems.removeModel(beverage.id);
+          destroyKosModel(beverage);
+        });
+        for (const beverageData of update?.groups[group] || []) {
+          const extensionData = await ExtensionManager.dataMapper.executeMapper(
+            ExtensionType.AvailabilityMapper,
+            { ...beverageData, groupId: group },
+            beverageContext
+          );
+          const beverageOptions = {
+            ...beverageData,
+            note: beverageData.note ?? void 0,
+            kosParentId: this.id,
+            groupId: group,
+            rawId: beverageData.id,
+            data: extensionData,
+            taggedIds: beverageData.taggedIds,
+            properties: beverageData.properties || {}
+          };
+          const existing = this._availabilityItems.getModel(
+            `${this.id}-${group}-${beverageData.id}`
+          );
+          if (existing) {
+            if (existing.available !== beverageOptions.available) {
+              this.logger.info(
+                `Updating availability of beverage ${existing.id} in nozzle ${this.path} to ${beverageOptions.available}`
+              );
+            }
+            existing.updateModel(beverageOptions);
+          } else {
+            this.logger.info(
+              `Adding beverage ${beverageData.id} to nozzle ${this.path}`
+            );
+            const beverage = Availability.factory(
+              `${this.id}-${group}-${beverageData.id}`
+            )(beverageOptions);
+            this._availabilityItems.addModel(beverage);
+          }
+        }
+      }
+    } else {
+      this.logger.info(
+        `Received delta update for nozzle ${this.path}, updating availability nodes`
+      );
+      for (const group of Object.keys(update?.groups) || []) {
+        for (const beverageData of update?.groups[group] || []) {
+          const extensionData = await ExtensionManager.dataMapper.executeMapper(
+            ExtensionType.AvailabilityMapper,
+            { ...beverageData, groupId: group },
+            beverageContext
+          );
+          const beverageOptions = {
+            ...beverageData,
+            note: beverageData.note ?? void 0,
+            kosParentId: this.id,
+            groupId: group,
+            rawId: beverageData.id,
+            data: extensionData,
+            type: beverageData.type,
+            taggedIds: beverageData.taggedIds,
+            properties: beverageData.properties || {}
+          };
+          const existing = this._availabilityItems.getModel(
+            `${this.id}-${group}-${beverageData.id}`
+          );
+          if (existing) {
+            if (existing.available !== beverageOptions.available) {
+              this.logger.info(
+                `Updating availability of beverage ${existing.id} in nozzle ${this.path} to ${beverageOptions.available}`
+              );
+            }
+            existing.updateModel(beverageOptions);
+          }
+        }
+      }
+    }
+    this.updateGroupMembers();
+  }
+  // -------------------ENTITY----------------------------
+};
+__decorateClass$2([
+  kosChild
+], NozzleModelImpl.prototype, "_availabilityItems", 2);
+__decorateClass$2([
+  kosStateEntry(PourState.POURING)
+], NozzleModelImpl.prototype, "handlePouringStart", 1);
+__decorateClass$2([
+  kosStateExit(PourState.POURING)
+], NozzleModelImpl.prototype, "handlePouringEnd", 1);
+__decorateClass$2([
+  kosStateEntry(PourState.POUR_CANCELING)
+], NozzleModelImpl.prototype, "handleCancelStart", 1);
+__decorateClass$2([
+  kosStateExit(PourState.POUR_CANCELING)
+], NozzleModelImpl.prototype, "handleCanceled", 1);
+__decorateClass$2([
+  kosFuture(),
+  kosStateGuard({ allowedStates: [PourState.IDLE] })
+], NozzleModelImpl.prototype, "pour", 1);
+__decorateClass$2([
+  kosFuture(),
+  kosStateGuard({ allowedStates: [PourState.IDLE] })
+], NozzleModelImpl.prototype, "fixedPour", 1);
+__decorateClass$2([
+  kosStateGuard({
+    allowedStates: [PourState.POUR_STARTING, PourState.POURING]
+  })
+], NozzleModelImpl.prototype, "cancelPour", 1);
+__decorateClass$2([
+  kosTopicHandler({
+    topic: `${PROP_BEVERAGE_TOPIC_PREFIX}/availability`,
+    websocket: true
+  })
+], NozzleModelImpl.prototype, "updateAvailability", 1);
+NozzleModelImpl = __decorateClass$2([
+  kosModel({ modelTypeId: MODEL_TYPE$2, singleton: false }),
+  kosLoggerAware(),
+  kosStateMachine(
+    {
+      initial: PourState.IDLE,
+      initializeAt: DependencyLifecycle.READY,
+      states: {
+        [PourState.IDLE]: {
+          on: {
+            START_POUR: PourState.POUR_STARTING
+          }
+        },
+        [PourState.POUR_STARTING]: {
+          on: {
+            POUR_ACTIVE: PourState.POURING,
+            CANCEL_POUR: PourState.POUR_CANCELING,
+            POUR_COMPLETED: PourState.IDLE
+          }
+        },
+        [PourState.POURING]: {
+          on: {
+            CANCEL_POUR: PourState.POUR_CANCELING,
+            POUR_COMPLETED: PourState.IDLE
+          }
+        },
+        [PourState.POUR_CANCELING]: {
+          on: {
+            POUR_CANCELED: PourState.IDLE
+          }
+        }
+      }
+    },
+    {
+      trackHistory: false,
+      throwOnInvalid: false
+      // Gracefully ignore invalid state calls (expected runtime scenarios)
+    }
+  )
+], NozzleModelImpl);
+const Nozzle = {
+  registration: {
+    [MODEL_TYPE$2]: {
+      class: NozzleModelImpl,
+      singleton: false
+    }
+  },
+  type: MODEL_TYPE$2,
+  predicate: isKosModel(MODEL_TYPE$2),
+  factory: Kos.Factory.create(MODEL_TYPE$2)
+};
+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 = "device-assembly-model";
+let DeviceAssemblyModelImpl = class {
+  id;
+  deviceNozzles;
+  logger;
+  constructor(modelId, _options, context) {
+    this.id = modelId;
+    this.logger = context.logger;
+    this.deviceNozzles = new KosModelContainer();
+  }
+  // -------------------LIFECYCLE----------------------------
+  async init() {
+    this.logger.debug(`initializing device-assembly ${this.id}`);
+  }
+  getNozzle(path) {
+    return this.deviceNozzles.getModel(path);
+  }
+  get nozzlePaths() {
+    return this.deviceNozzles.data.map((nozzle) => nozzle.path);
+  }
+  async load() {
+    this.logger.debug(`loading device-assembly ${this.id}`);
+    const result = await getAssembly();
+    if (result?.status === 200) {
+      const nozzles = result.data.assemblies.map((assembly) => assembly.nozzles ?? []).flat();
+      nozzles.forEach((nozzleData) => {
+        const nozzleId = nozzleData.path;
+        const beverageTopicPrefix = nozzleData.pipelines.find((pipeline) => pipeline.name === "beverage")?.topicPrefix || "";
+        const nozzle = Nozzle.factory(nozzleId)({
+          path: nozzleData.path,
+          name: nozzleData.name,
+          urlPrefix: nozzleData.urlPrefix,
+          topicPrefix: nozzleData.topicPrefix,
+          beverageTopicPrefix
+        });
+        this.deviceNozzles.addModel(nozzle);
+      });
+    }
+  }
+};
+__decorateClass$1([
+  kosChild
+], DeviceAssemblyModelImpl.prototype, "deviceNozzles", 2);
+DeviceAssemblyModelImpl = __decorateClass$1([
+  kosModel(MODEL_TYPE$1)
+], DeviceAssemblyModelImpl);
+const DeviceAssembly = new SingletonKosModelRegistrationFactory({
+  class: DeviceAssemblyModelImpl,
+  type: MODEL_TYPE$1
+});
+const { URL } = resolveServiceUrl("GENERIC_POUR_SERVICE");
+const { postModel } = ServiceFactory.build({
+  basePath: `${URL}/api/nozzle`
+});
+const pourOnTarget = async (path, tracker) => {
+  const response = await postModel({
+    model: {},
+    urlOverride: `${URL}${path}`,
+    ordered: true,
+    tracker
+  });
+  if (response?.data) {
+    FutureManager.initiateFuture(response.data);
+  }
+  return response;
+};
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+const MODEL_TYPE = "generic-pour-model";
+const TOPIC_GENERIC_POUR_STARTED = "/kos/generic/pour/started";
+const TOPIC_GENERIC_POUR_PROGRESS = "/kos/generic/pour/progress";
+const TOPIC_GENERIC_POUR_CANCEL = "/kos/generic/pour/cancel";
+const isPourAware = (model) => model.onPourStart !== void 0 && model.onPourCancel !== void 0 && model.onPourProgress !== void 0;
+let GenericPourModelImpl = class {
+  id;
+  /**
+   * @kosApiLevel 5
+   */
+  servicePathFactory;
+  pourType;
+  /**
+   * @kosApiLevel 5
+   */
+  selectedId;
+  state;
+  constructor(modelId, options) {
+    this.id = modelId;
+    this.futureHandler = new FutureHandler(this);
+    this.servicePathFactory = options.servicePathFactory;
+    this.pourType = options.pourType || "free";
+    this.selectedId = options.selectedId;
+    this.state = ObservableData(options.initialData || {});
+  }
+  get servicePath() {
+    if (!this.selectedId) {
+      return "";
+    }
+    return this.servicePathFactory(this.selectedId, this.state);
+  }
+  /**
+   * @kosApiLevel 12
+   */
+  updateContextData(key, value) {
+    this.state[key] = value;
+  }
+  /**
+   * @kosApiLevel 12
+   */
+  removeContextData(key) {
+    delete this.state[key];
+  }
+  /**
+   * @kosApiLevel 12
+   */
+  clearContextData() {
+    this.state = ObservableData();
+  }
+  /**
+   * @kosApiLevel 14
+   */
+  updateModel(options) {
+    if (options.pourType) {
+      this.pourType = options.pourType;
+    }
+    if (options.initialData) {
+      this.state.setValues(options.initialData);
+    }
+  }
+  handlePouringStart() {
+    this.logger.info("Pour started");
+    getAllKosCompanionModels(this).forEach((model) => {
+      if (isPourAware(model)) {
+        model.onPourStart?.();
+      }
+    });
+    const evt = {
+      pourTarget: this.id,
+      type: this.pourType
+    };
+    EventBus.publish(TOPIC_GENERIC_POUR_STARTED, evt);
+  }
+  handlePouringEnd() {
+    this.logger.info("Pour ended");
+  }
+  handleCancelStart() {
+    this.logger.info("Pour canceling");
+  }
+  handleCanceled() {
+    this.logger.info("Pour canceled");
+    getAllKosCompanionModels(this).forEach((model) => {
+      if (isPourAware(model)) {
+        model.onPourCancel?.();
+      }
+    });
+    const evt = {
+      pourTarget: this.id
+    };
+    EventBus.publish(TOPIC_GENERIC_POUR_CANCEL, evt);
+  }
+  // Inherits throwOnInvalid: false from class
+  async pour(tracker) {
+    try {
+      this.transition("START_POUR");
+      if (!tracker) {
+        throw new Error("No tracker provided");
+      }
+      const result = await pourOnTarget(this.servicePath, tracker);
+      this.transition("POUR_ACTIVE");
+      if (result?.data?.endState) {
+        this.transition("POUR_COMPLETED");
+      }
+      return result;
+    } catch (e) {
+      this.logger.error(e);
+      if (this.currentState !== PourState.IDLE) {
+        this.transition("POUR_COMPLETED");
+      }
+      throw e;
+    }
+  }
+  // Inherits throwOnInvalid: false - silently ignore if already idle
+  async cancelPour() {
+    this.transition("CANCEL_POUR");
+    await this.futureHandler.getFuture()?.cancelFuture();
+    this.transition("POUR_CANCELED");
+  }
+  // ============================================================================
+  // Computed Properties
+  // ============================================================================
+  /**
+   * A derived value that indicates if the nozzle is currently pouring a beverage.
+   * @readonly
+   */
+  get isPouring() {
+    return !!(this.future && !this.future?.endState) || this.currentState === PourState.POUR_STARTING || this.currentState === PourState.POURING || this.currentState === PourState.POUR_CANCELING;
+  }
+  /**
+   * A derived value that indicates if the pour target is currently available to pour a beverage.
+   *
+   * Generally this means that the pour target is currently idle and not in the process of pouring,
+   * initiating a pour, or canceling a pour.
+   * The value is observable and will change when the selected pourable changes or the pour target
+   * starts or stops pouring.
+   * @readonly
+   */
+  get canPour() {
+    return this.currentState === PourState.IDLE;
+  }
+  get pourProgress() {
+    return this.progress ?? 0;
+  }
+  // ============================================================================
+  // Future Lifecycle Handler
+  // ============================================================================
+  onFutureUpdate(future) {
+    getAllKosCompanionModels(this).forEach((model) => {
+      if (isPourAware(model)) {
+        model.onPourProgress(future);
+      }
+    });
+    const evt = {
+      pourTarget: this.id,
+      progress: future.progress,
+      status: future.status,
+      clientData: future.clientData,
+      futureId: future.futureId,
+      remainingTimeMs: future.remainingTimeMs,
+      endState: future.endState,
+      reason: future.reason,
+      timeRemaining: future.timeRemaining
+    };
+    EventBus.publish(TOPIC_GENERIC_POUR_PROGRESS, evt);
+    if (future.endState) {
+      kosAction(() => {
+        if (this.currentState === PourState.POURING) {
+          this.transition("POUR_COMPLETED");
+        }
+      });
+    }
+  }
+};
+__decorateClass([
+  kosStateEntry(PourState.POURING)
+], GenericPourModelImpl.prototype, "handlePouringStart", 1);
+__decorateClass([
+  kosStateExit(PourState.POURING)
+], GenericPourModelImpl.prototype, "handlePouringEnd", 1);
+__decorateClass([
+  kosStateEntry(PourState.POUR_CANCELING)
+], GenericPourModelImpl.prototype, "handleCancelStart", 1);
+__decorateClass([
+  kosStateExit(PourState.POUR_CANCELING)
+], GenericPourModelImpl.prototype, "handleCanceled", 1);
+__decorateClass([
+  kosFuture(),
+  kosStateGuard({ allowedStates: [PourState.IDLE] })
+], GenericPourModelImpl.prototype, "pour", 1);
+__decorateClass([
+  kosStateGuard({
+    allowedStates: [PourState.POUR_STARTING, PourState.POURING]
+  })
+], GenericPourModelImpl.prototype, "cancelPour", 1);
+GenericPourModelImpl = __decorateClass([
+  kosModel(MODEL_TYPE),
+  kosLoggerAware(),
+  kosFutureAware(),
+  kosStateMachine(
+    {
+      initial: PourState.IDLE,
+      initializeAt: DependencyLifecycle.READY,
+      states: {
+        [PourState.IDLE]: {
+          on: {
+            START_POUR: PourState.POUR_STARTING
+          }
+        },
+        [PourState.POUR_STARTING]: {
+          on: {
+            POUR_ACTIVE: PourState.POURING,
+            CANCEL_POUR: PourState.POUR_CANCELING,
+            POUR_COMPLETED: PourState.IDLE
+          }
+        },
+        [PourState.POURING]: {
+          on: {
+            CANCEL_POUR: PourState.POUR_CANCELING,
+            POUR_COMPLETED: PourState.IDLE
+          }
+        },
+        [PourState.POUR_CANCELING]: {
+          on: {
+            POUR_CANCELED: PourState.IDLE
+          }
+        }
+      }
+    },
+    {
+      trackHistory: false,
+      throwOnInvalid: false
+      // Gracefully ignore invalid state calls (expected runtime scenarios)
+    }
+  )
+], GenericPourModelImpl);
+const GenericPour = new KosModelRegistrationFactory({
+  class: GenericPourModelImpl,
+  type: MODEL_TYPE
+});
+const kosModels = {
+  ...IngredientContainer.registration,
+  ...Ingredient.registration,
+  ...HolderContainer.registration,
+  ...Holder.registration,
+  ...Nozzle.registration,
+  ...Pump.registration,
+  ...PumpContainer.registration,
+  ...Availability.registration,
+  ...Assembly.registration,
+  ...BoardContainer.registration
+};
+const registerDispenseModels = (root) => () => {
+  registerCoreModels(root)();
+  DeviceAssembly.register();
+  Object.keys(kosModels).forEach((key) => {
+    const model = kosModels[key];
+    registerLegacyModel(root)(key, model);
+  });
+  ExtensionManager[EXTENSION_TROUBLE_DATA_MAPPER].register(
+    "FirmwareUpdateInProgressTrouble",
+    async (trouble) => {
+      if (trouble.data?.deviceId) {
+        const { model: assemblyModel } = getKosModelSync(
+          Assembly.type
+        );
+        if (assemblyModel) {
+          const boardModel = assemblyModel.boards.find(
+            (b) => b.id === trouble.data.deviceId
+          ) ? getKosModelSync(trouble.data.deviceId).model : void 0;
+          return {
+            devices: boardModel ? boardModel.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.dispense = {
+  models: registerDispenseModels(_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;
+export {
+  Assembly as A,
+  Board as B,
+  CONTEXT_ASSEMBLY_DATA as C,
+  DeviceAssembly as D,
+  ExtensionType as E,
+  getIntentVolume as F,
+  GenericPour as G,
+  Holder as H,
+  Ingredient as I,
+  sendIntent as J,
+  KosModelRegistry as K,
+  clearPourable as L,
+  getAvailability as M,
+  Nozzle as N,
+  pourNamedPourable as O,
+  PourState as P,
+  pourPourable as Q,
+  selectPourable as R,
+  pourOnTarget as S,
+  TOPIC_BOARD_LINKED as T,
+  Availability as a,
+  BoardContainer as b,
+  BoardContainerModel as c,
+  CONTEXT_ASSEMBLY_RAW_DATA as d,
+  DispenseModelType as e,
+  HolderContainer as f,
+  IngredientContainer as g,
+  Pump as h,
+  PumpContainer as i,
+  PumpIndex as j,
+  TOPIC_BOARD_UNLINKED as k,
+  TOPIC_GENERIC_POUR_CANCEL as l,
+  TOPIC_GENERIC_POUR_PROGRESS as m,
+  TOPIC_GENERIC_POUR_STARTED as n,
+  kosModels as o,
+  getIngredients as p,
+  addAssignment as q,
+  registerDispenseModels as r,
+  assignHolderIngredient as s,
+  deleteAssignment as t,
+  getAssignments as u,
+  getHolders as v,
+  replaceLine as w,
+  sendRfidOverride as x,
+  unassignHolderIngredient as y,
+  getAssembly as z
+};
+//# sourceMappingURL=dispense-registration-manager-BSKa5Oi9.js.map