@feedmepos/mf-order-setting 0.0.84 → 0.0.85

package/src/views/order-settings/auto-send-kitchen.ts

@@ -0,0 +1,92 @@
+import type { OrderSettingChannelAutoAccept } from '@entity'
+import { resolveAutoAccept } from '@entity'
+
+/**
+ * Portal-side helpers for the per-channel "Auto Send Kitchen" control.
+ *
+ * The RESOLUTION itself is not here — it lives in
+ * `@entity/order-setting/auto-send.resolve`, shared with the backend stamper so
+ * a settings page and the order it produces can never disagree. What is left
+ * here is presentation: select mapping, label keys, and when to raise the
+ * confirmation dialog.
+ *
+ * The dialog is now a teaching moment, not a safety mechanism. The backend
+ * enforces "a bill is only closed automatically if the kitchen was notified" at
+ * the point of resolution, which covers the paths no page can reach — old
+ * portal bundles, direct API writes, and pairs assembled ACROSS pages (the
+ * Queue page owns queue's auto-send while Dine In owns its auto-close). The
+ * dialog survives because offering "turn on both" is a better answer than
+ * letting a merchant save something inert.
+ */
+
+/** Tri-state select value. 'null' = unset, i.e. follow the channel's auto-accept. */
+export type AutoSendSelectValue = 'null' | 'true' | 'false'
+
+export function autoSendSelectValue(
+  autoSendKitchen: boolean | null | undefined
+): AutoSendSelectValue {
+  return autoSendKitchen === null || autoSendKitchen === undefined
+    ? 'null'
+    : (String(autoSendKitchen) as 'true' | 'false')
+}
+
+export function autoSendFromSelectValue(v: string): boolean | null {
+  return v === 'null' ? null : v === 'true'
+}
+
+/**
+ * True when turning auto-close on would have NO effect, so the merchant should
+ * be offered kitchen-send alongside it.
+ *
+ * Evaluated for a PAID order deliberately. An unpaid bill never auto-closes
+ * anyway (`closeBill` no-ops while `balance > 0`), so the only question worth
+ * asking is whether the setting does anything for the orders that CAN close.
+ * That keeps paid-only channels dialog-free — their paid orders do reach the
+ * kitchen — while still asking on a channel whose auto-accept is off entirely.
+ *
+ * An EXPLICIT choice decides on its own, before the channel is consulted. When
+ * the merchant has picked Enabled or Disabled (or dine-in has, for a channel
+ * that inherits), `resolveAutoSend` never reaches the auto-accept fallback, so
+ * the answer is fully determined and reading the channel would only be a chance
+ * to get it wrong. Checking the channel first is precisely the regression this
+ * guard shipped with: a stored `Disabled` plus an unreadable channel produced
+ * no dialog, no warning sublabel, and no reverse-clear — the merchant saved the
+ * inert pair with no feedback anywhere.
+ *
+ * Only a genuinely unresolved value falls through to the channel, and an
+ * unknown channel then fails OPEN: the backend invariant is the safety net now,
+ * so a page that cannot read the channel must not nag on a guess.
+ *
+ * `inheritFrom` carries dine-in's value for the channels that inherit it
+ * (queue, kiosk); omit it for channels that own their setting.
+ */
+export function requiresAutoSendConfirmation(
+  autoSendKitchen: boolean | null | undefined,
+  channel: OrderSettingChannelAutoAccept | null | undefined,
+  inheritFrom?: boolean | null
+): boolean {
+  const explicit = autoSendKitchen ?? inheritFrom
+  if (explicit !== null && explicit !== undefined) return !explicit
+  const autoAccept = resolveAutoAccept(channel, true)
+  if (autoAccept === null) return false
+  return !autoAccept
+}
+
+/**
+ * i18n key for the auto-close sublabel.
+ *
+ * A merchant can arrive already in the broken state — auto-close stored on,
+ * kitchen send resolving false — without ever touching a control, so the
+ * confirmation dialog never fires for them. This row is the only thing that
+ * tells them, which is why it reads the STORED pair rather than a change.
+ */
+export function autoCloseSublabelKey(
+  autoSendKitchen: boolean | null | undefined,
+  channel: OrderSettingChannelAutoAccept | null | undefined,
+  autoCloseBill: boolean | null | undefined,
+  inheritFrom?: boolean | null
+): string {
+  return autoCloseBill && requiresAutoSendConfirmation(autoSendKitchen, channel, inheritFrom)
+    ? 'order.autoCloseBillRequiresAutoSend'
+    : 'order.autoCloseBillSublabel'
+}

package/src/views/order-settings/auto-send-resolve.spec.ts

@@ -0,0 +1,123 @@
+import { describe, expect, it } from 'vitest'
+import type { OrderSettingChannelAutoAccept } from '@entity'
+import { resolveAutoAccept, resolveAutoCloseBill, resolveAutoSend } from '@entity'
+
+/**
+ * The resolver is the ONLY definition of what a channel does to an order, and
+ * every producer of an IncomingOrder config calls it, so these are the rules the
+ * stamped config is held to.
+ *
+ * Ground truth for the auto-accept column is `isAutoAcceptable`
+ * (backend/libs/incoming-order/incoming-order.service.ts): paid-only returns
+ * `hasSucceedPayment(order)`, so an UNPAID order on a paid-only channel is
+ * accepted by hand, not automatically.
+ */
+const OFF: OrderSettingChannelAutoAccept = { autoAccept: false, autoAcceptPaidOnly: false }
+const ON: OrderSettingChannelAutoAccept = { autoAccept: true, autoAcceptPaidOnly: false }
+const PAID_ONLY: OrderSettingChannelAutoAccept = { autoAccept: true, autoAcceptPaidOnly: true }
+
+describe('resolveAutoAccept', () => {
+  it('is unknown, never false, when the channel could not be read', () => {
+    // Failing OPEN matters: a restaurant whose CouchDB documents do not exist
+    // yet must not have its settings page claim auto-accept is off.
+    expect(resolveAutoAccept(null, true)).toBeNull()
+    expect(resolveAutoAccept(undefined, false)).toBeNull()
+  })
+
+  it('ignores payment unless the channel is paid-only', () => {
+    expect(resolveAutoAccept(OFF, true)).toBe(false)
+    expect(resolveAutoAccept(OFF, false)).toBe(false)
+    expect(resolveAutoAccept(ON, true)).toBe(true)
+    expect(resolveAutoAccept(ON, false)).toBe(true)
+  })
+
+  it('makes paid-only a per-ORDER verdict', () => {
+    expect(resolveAutoAccept(PAID_ONLY, true)).toBe(true)
+    expect(resolveAutoAccept(PAID_ONLY, false)).toBe(false)
+  })
+
+  it('ignores a stranded paidOnly when auto-accept is off', () => {
+    // `{autoAccept: false, autoAcceptPaidOnly: true}` is a real stored shape —
+    // the two POS checkboxes project one pair, so turning paid-only on and then
+    // auto-accept off leaves paidOnly behind. `isAutoAcceptable` gates on
+    // `?.autoAccept` before it ever reads paidOnly and falls through to
+    // `return false`, so the stranded flag is dead there; this must agree, or
+    // the preview would promise auto-accept for prepaid orders that get none.
+    const STRANDED = { autoAccept: false, autoAcceptPaidOnly: true }
+    expect(resolveAutoAccept(STRANDED, true)).toBe(false)
+    expect(resolveAutoAccept(STRANDED, false)).toBe(false)
+    // i.e. indistinguishable from plain "off" for every order.
+    expect(resolveAutoAccept(STRANDED, true)).toBe(resolveAutoAccept(OFF, true))
+    expect(resolveAutoAccept(STRANDED, false)).toBe(resolveAutoAccept(OFF, false))
+  })
+})
+
+describe('resolveAutoSend', () => {
+  it('falls back to auto-accept when unset — the legacy binding, unchanged', () => {
+    expect(resolveAutoSend(null, true)).toBe(true)
+    expect(resolveAutoSend(undefined, false)).toBe(false)
+  })
+
+  it('lets an explicit false WIN over a channel that auto-accepts', () => {
+    // `||` here would silently discard the merchant's choice; `??` is load-bearing.
+    expect(resolveAutoSend(false, true)).toBe(false)
+  })
+
+  it('lets an explicit true decouple the kitchen from manual accept', () => {
+    // The workflow this branch exists to enable: a human accepts each order,
+    // the kitchen still fires automatically.
+    expect(resolveAutoSend(true, false)).toBe(true)
+  })
+
+  it('consults inheritFrom before auto-accept, and only when unset', () => {
+    expect(resolveAutoSend(null, true, false)).toBe(false)
+    expect(resolveAutoSend(null, false, true)).toBe(true)
+    expect(resolveAutoSend(false, true, true)).toBe(false)
+    expect(resolveAutoSend(true, false, false)).toBe(true)
+    // A null inheritFrom must fall through rather than pin anything.
+    expect(resolveAutoSend(null, true, null)).toBe(true)
+  })
+})
+
+describe('resolveAutoCloseBill — the invariant', () => {
+  it('never closes a bill the kitchen was not told about', () => {
+    expect(resolveAutoCloseBill(true, false)).toBe(false)
+  })
+
+  it('leaves every coherent combination alone', () => {
+    expect(resolveAutoCloseBill(true, true)).toBe(true)
+    expect(resolveAutoCloseBill(false, true)).toBe(false)
+    expect(resolveAutoCloseBill(null, true)).toBe(false)
+    expect(resolveAutoCloseBill(undefined, false)).toBe(false)
+  })
+})
+
+
+describe('the reported bug and its fix, end to end through the chain', () => {
+  it('suppresses the close that used to happen with the kitchen never notified', () => {
+    // Auto-accept off, merchant turned auto-close on: the exact merchant report.
+    // Before the invariant this stamped `autoCloseBill: true` and POS closed the
+    // paid bill without ever sending it.
+    const autoAccept = resolveAutoAccept(OFF, true) as boolean
+    const autoSend = resolveAutoSend(null, autoAccept)
+    expect(autoSend).toBe(false)
+    expect(resolveAutoCloseBill(true, autoSend)).toBe(false)
+  })
+
+  it('gives the merchant the workflow they asked for once kitchen send is on', () => {
+    // Manual accept, auto send, auto complete.
+    const autoAccept = resolveAutoAccept(OFF, true) as boolean
+    const autoSend = resolveAutoSend(true, autoAccept)
+    expect(autoAccept).toBe(false)
+    expect(autoSend).toBe(true)
+    expect(resolveAutoCloseBill(true, autoSend)).toBe(true)
+  })
+
+  it('closes the queue hole: an explicit queue false cannot outlive the invariant', () => {
+    // queueSettings.autoSendKitchen = false beats the pinned dine-in true, which
+    // is how the Queue page reopened the bug — but the close is suppressed now.
+    const autoSend = resolveAutoSend(false, true, true)
+    expect(autoSend).toBe(false)
+    expect(resolveAutoCloseBill(true, autoSend)).toBe(false)
+  })
+})

package/src/views/order-settings/delivery/DeliverySetting.vue

@@ -105,6 +105,7 @@
       :initial-value="inHouseComponentProps.initialValue"
       :address="formatAddress((currentRestaurant as any).profile.address)"
       :order-inhouse-delivery-settings="orderInhouseDeliverySettings"
+      :channel-auto-accept="orderSetting?.channelAutoAccept?.inhouseDelivery ?? null"
       @update:model-value="handleModelValueUpdateInHouse"
       @update:order-settings="handleOrderInhouseDeliverySettingsUpdate"
     />
@@ -487,6 +488,15 @@ async function updateFeedmeExpress({ key, setting }: IntegratedDeliveryRow) {
 async function updateInHouse({ key, setting }: IntegratedDeliveryRow) {
   clearComponentProps()
 
+  // Drop the previous restaurant's settings BEFORE mounting the side sheet.
+  // The mount below is synchronous while the GET at the end of this function is
+  // not, so a stale value here would be read by `InHouseDelivery`'s auto-send
+  // guard — which reads `channelAutoAccept` — and it would decide whether to
+  // raise the auto-close dialog against the restaurant the merchant just
+  // navigated away from. Undefined means "unknown", which fails open and claims
+  // nothing until the real data lands.
+  orderSetting.value = undefined
+
   const inhouseSetting = setting as FdoRestaurantInHouseDelivery
 
   inHouseComponentProps.value = {

package/src/views/order-settings/delivery/inhouse/InHouseDelivery.vue

@@ -9,7 +9,8 @@ import type {
   FdoOfflinePaymentMethod,
   FdoRestaurantInHouseDelivery
 } from '@feedmepos/core/entity'
-import type { OrderInhouseDeliverySettingsDto } from '@entity'
+import type { OrderInhouseDeliverySettingsDto, OrderSettingChannelAutoAccept } from '@entity'
+import { useAutoSendGuard } from '../../useAutoSendGuard'
 import { F_FEATURE } from '@feedmepos/core/entity'
 import { FdoProductTaxSetting } from '@feedmepos/entity'
 import { computed, reactive, watch, type PropType } from 'vue'
@@ -81,12 +82,33 @@ const props = defineProps({
   orderInhouseDeliverySettings: {
     type: Object as PropType<OrderInhouseDeliverySettingsDto>,
     default: () => ({})
+  },
+  // Read-only projection of `setting.inHouseDelivery`'s auto-accept pair,
+  // injected on the order-settings read. null = the backend could not resolve
+  // it; the auto-close guard then fails OPEN rather than disabling on a guess.
+  channelAutoAccept: {
+    type: Object as PropType<OrderSettingChannelAutoAccept | null>,
+    default: null
   }
 })
 
-function updateAutoCloseBill(autoCloseBill: boolean) {
-  emits('update:order-settings', { ...props.orderInhouseDeliverySettings, autoCloseBill })
-}
+// Select + auto-close coupling live in one shared implementation; this view only
+// says how to PERSIST a change. `null` stays unset so the backend keeps
+// inheriting `setting.inHouseDelivery`'s auto-accept — `false` would pin it.
+const {
+  autoSendKitchenValue,
+  selectItems: autoSendSelectItems,
+  autoCloseSublabel,
+  autoCloseSwitchKey,
+  updateAutoSendKitchen,
+  updateAutoCloseBill
+} = useAutoSendGuard({
+  channel: () => props.channelAutoAccept,
+  autoSendKitchen: () => props.orderInhouseDeliverySettings.autoSendKitchen,
+  autoCloseBill: () => props.orderInhouseDeliverySettings.autoCloseBill,
+  apply: (patch) =>
+    emits('update:order-settings', { ...props.orderInhouseDeliverySettings, ...patch })
+})
 
 function updatePrintReceiptAfterClose(printReceiptAfterClose: boolean) {
   emits('update:order-settings', { ...props.orderInhouseDeliverySettings, printReceiptAfterClose })
@@ -269,12 +291,25 @@ const actualDeliveryTime = computed({
         />
       </div>
 
+      <div class="mb-5 flex flex-col gap-2">
+        <span class="fm-typo-en-body-md-600">{{ t('order.autoSendKitchen') }}</span>
+        <span class="fm-typo-en-body-sm-400 text-fm-color-typo-secondary">
+          {{ t('order.autoSendKitchenChannelSublabel') }}
+        </span>
+        <FmSelect
+          :model-value="autoSendKitchenValue"
+          :items="autoSendSelectItems"
+          @update:model-value="updateAutoSendKitchen"
+        />
+      </div>
+
       <div class="mb-5">
         <FmSwitch
+          :key="autoCloseSwitchKey"
           :model-value="orderInhouseDeliverySettings.autoCloseBill ?? false"
           value="autoCloseBill"
           :label="t('order.autoCloseBill')"
-          :sublabel="t('order.autoCloseBillSublabel')"
+          :sublabel="autoCloseSublabel"
           label-placement="right"
           @update:model-value="updateAutoCloseBill"
         />

package/src/views/order-settings/dine-in/DineInSetting.vue

@@ -115,10 +115,23 @@
         @update:model-value="updateOverridePax"
       ></FmSwitch>
 
+      <div class="flex flex-col gap-2">
+        <span class="fm-typo-en-body-md-600">{{ t('order.autoSendKitchen') }}</span>
+        <span class="fm-typo-en-body-sm-400 text-fm-color-typo-secondary">
+          {{ t('order.autoSendKitchenChannelSublabel') }}
+        </span>
+        <FmSelect
+          :model-value="autoSendKitchenValue"
+          :items="autoSendSelectItems"
+          @update:model-value="updateAutoSendKitchen"
+        />
+      </div>
+
       <FmSwitch
+        :key="autoCloseSwitchKey"
         :model-value="orderSetting?.dineInSettings?.autoCloseBill ?? false"
         :label="t('order.autoCloseBill')"
-        :sublabel="t('order.autoCloseBillSublabel')"
+        :sublabel="autoCloseSublabel"
         label-placement="right"
         @update:model-value="updateAutoCloseBill"
       ></FmSwitch>
@@ -173,6 +186,7 @@ import semver from 'semver'
 import { useI18n } from '@feedmepos/mf-common'
 import { OrderSettingApi } from '@/api/order-setting'
 import { type OrderSettingsDto } from '@entity'
+import { useAutoSendGuard } from '../useAutoSendGuard'
 import { useSnackbarFunctions } from '@/components/snackbar'
 
 const { t } = useI18n()
@@ -270,10 +284,29 @@ function updateOverridePax(v: boolean) {
   if (dineInSettings) dineInSettings.overridePax = v
 }
 
-function updateAutoCloseBill(v: boolean) {
-  const dineInSettings = ensureOrderDineInSettings()
-  if (dineInSettings) dineInSettings.autoCloseBill = v
-}
+const dineInAutoAccept = computed(() => orderSetting.value?.channelAutoAccept?.dineIn ?? null)
+
+// Select + auto-close coupling live in one shared implementation; this view only
+// says how to PERSIST a change. `null` stays unset so the backend keeps
+// inheriting the channel's auto-accept — writing `false` would pin it.
+const {
+  autoSendKitchenValue,
+  selectItems: autoSendSelectItems,
+  autoCloseSublabel,
+  autoCloseSwitchKey,
+  updateAutoSendKitchen,
+  updateAutoCloseBill
+} = useAutoSendGuard({
+  channel: () => dineInAutoAccept.value,
+  autoSendKitchen: () => orderSetting.value?.dineInSettings?.autoSendKitchen,
+  autoCloseBill: () => orderSetting.value?.dineInSettings?.autoCloseBill,
+  apply: (patch) => {
+    const settings = ensureOrderDineInSettings()
+    if (!settings) return
+    if ('autoSendKitchen' in patch) settings.autoSendKitchen = patch.autoSendKitchen ?? null
+    if ('autoCloseBill' in patch) settings.autoCloseBill = patch.autoCloseBill ?? false
+  }
+})
 
 function updatePrintReceiptAfterClose(v: boolean) {
   const dineInSettings = ensureOrderDineInSettings()

package/src/views/order-settings/pickup/PickUpSetting.vue

@@ -7,6 +7,7 @@
       <PickUpSettingDialogContent
         :pickup="pickupSetting"
         :order-pickup-settings="orderPickupSettings"
+        :channel-auto-accept="orderSetting?.channelAutoAccept?.pickup ?? null"
         :accept-pickup="acceptPickup"
         @update-pickup="updatePickupSetting"
         @update-order-settings="updateOrderPickupSettings"

package/src/views/order-settings/pickup/PickUpSettingDialogContent.vue

@@ -19,12 +19,24 @@
     label-placement="right"
     @update:model-value="updateIgnoreStock"
   />
+  <div class="flex flex-col gap-2 mt-5">
+    <span class="fm-typo-en-body-md-600">{{ t('order.autoSendKitchen') }}</span>
+    <span class="fm-typo-en-body-sm-400 text-fm-color-typo-secondary">
+      {{ t('order.autoSendKitchenChannelSublabel') }}
+    </span>
+    <FmSelect
+      :model-value="autoSendKitchenValue"
+      :items="autoSendSelectItems"
+      @update:model-value="updateAutoSendKitchen"
+    />
+  </div>
   <FmSwitch
     class="mt-5"
+    :key="autoCloseSwitchKey"
     :model-value="orderPickupSettings.autoCloseBill ?? false"
     value="autoCloseBill"
     :label="t('order.autoCloseBill')"
-    :sublabel="t('order.autoCloseBillSublabel')"
+    :sublabel="autoCloseSublabel"
     label-placement="right"
     @update:model-value="updateAutoCloseBill"
   />
@@ -89,7 +101,8 @@ import {
   FdoPickupPoint,
   FdoRestaurantPickup
 } from '@feedmepos/core/entity'
-import type { OrderPickupSettingsDto } from '@entity'
+import type { OrderPickupSettingsDto, OrderSettingChannelAutoAccept } from '@entity'
+import { useAutoSendGuard } from '../useAutoSendGuard'
 
 import { computed, ref, watch, type PropType } from 'vue'
 import PickUpPointDialog from './PickUpPointDialog.vue'
@@ -119,6 +132,13 @@ const props = defineProps({
     type: Object as PropType<OrderPickupSettingsDto>,
     default: () => ({})
   },
+  // Read-only projection of `setting.pickup`'s auto-accept pair, injected on the
+  // order-settings read. null = the backend could not resolve it; the auto-close
+  // guard then fails OPEN rather than disabling the toggle on a guess.
+  channelAutoAccept: {
+    type: Object as PropType<OrderSettingChannelAutoAccept | null>,
+    default: null
+  },
   // Read-only pickup online status (restaurant-level `acceptPickup`); shown as a
   // labeled row at the top of this section, not editable here.
   acceptPickup: {
@@ -133,9 +153,22 @@ const getClassForOnline = (enabled: boolean) => {
     : 'bg-fm-color-neutral-gray-100 text-fm-color-typo-neutral fm-typo-en-body-md-600 border fm-corner-radius-lg w-max p-4'
 }
 
-function updateAutoCloseBill(autoCloseBill: boolean) {
-  emits('update-order-settings', { ...props.orderPickupSettings, autoCloseBill })
-}
+// Select + auto-close coupling live in one shared implementation; this view only
+// says how to PERSIST a change. `null` stays unset so the backend keeps
+// inheriting `setting.pickup`'s auto-accept — writing `false` would pin it.
+const {
+  autoSendKitchenValue,
+  selectItems: autoSendSelectItems,
+  autoCloseSublabel,
+  autoCloseSwitchKey,
+  updateAutoSendKitchen,
+  updateAutoCloseBill
+} = useAutoSendGuard({
+  channel: () => props.channelAutoAccept,
+  autoSendKitchen: () => props.orderPickupSettings.autoSendKitchen,
+  autoCloseBill: () => props.orderPickupSettings.autoCloseBill,
+  apply: (patch) => emits('update-order-settings', { ...props.orderPickupSettings, ...patch })
+})
 
 function updatePrintReceiptAfterClose(printReceiptAfterClose: boolean) {
   emits('update-order-settings', { ...props.orderPickupSettings, printReceiptAfterClose })

package/src/views/order-settings/queue/QueueSetting.vue

@@ -4,7 +4,6 @@ import { OrderSettingApi } from '@/api/order-setting'
 import { restaurantApi, type RestaurantSettingDoc } from '@/api/restaurant-setting'
 import { useLoading } from '@/composables/loading'
 import {
-  type FdoOrderSettings,
   type FdoOrderQueueSettings,
   defaultQueueSetting,
   OrderSettingsDto,
@@ -16,13 +15,16 @@ import { useSnackbarFunctions } from '@/components/snackbar'
 import { useDialog } from '@feedmepos/ui-library'
 import PresetRemarksSheet from './PresetRemarksSheet.vue'
 import { nextCodeSettingBand } from './code-setting-band'
+import { autoSendFromSelectValue, autoSendSelectValue } from '../auto-send-kitchen'
 
 const { t } = useI18n()
 const { showSuccess, showError } = useSnackbarFunctions()
 const { currentRestaurant } = useCoreStore()
 const { isLoading, startAsyncCallWithErr, startLoading } = useLoading()
 
-const orderSettingDefault = ref<FdoOrderSettings | undefined>(undefined)
+// The DTO, not the stored document. `OrderSettingUpdateDto` omits the injected
+// read-only `channelAutoAccept`, so it can never be echoed back into Mongo.
+const orderSettingDefault = ref<OrderSettingsDto | undefined>(undefined)
 const queueSettings = ref<FdoOrderQueueSettings>({ ...defaultQueueSetting })
 const restaurantSetting = ref<RestaurantSettingDoc | undefined>(undefined)
 const presetRemarks = ref<string[]>([])
@@ -444,14 +446,9 @@ async function saveAllowOverrideQueueCode(value: boolean) {
         <div class="flex flex-col gap-2">
           <span class="fm-typo-en-body-md-600">{{ t('order.autoSendKitchen') }}</span>
           <FmSelect
-            :model-value="
-              queueSettings.autoSendKitchen === null
-                ? 'null'
-                : String(queueSettings.autoSendKitchen)
-            "
+            :model-value="autoSendSelectValue(queueSettings.autoSendKitchen)"
             @update:model-value="
-              (v: string) =>
-                updateQueueSetting('autoSendKitchen', v === 'null' ? null : v === 'true')
+              (v: string) => updateQueueSetting('autoSendKitchen', autoSendFromSelectValue(v))
             "
             :items="[
               { label: t('order.followDineIn'), value: 'null' },

package/src/views/order-settings/useAutoSendGuard.ts

@@ -0,0 +1,142 @@
+import { computed, ref } from 'vue'
+import type { OrderSettingChannelAutoAccept } from '@entity'
+import { useDialog } from '@feedmepos/ui-library'
+import { useI18n } from '@feedmepos/mf-common'
+import {
+  autoCloseSublabelKey,
+  autoSendFromSelectValue,
+  autoSendSelectValue,
+  requiresAutoSendConfirmation
+} from './auto-send-kitchen'
+
+/**
+ * The Auto Send Kitchen select and its coupling to Auto close bill, as ONE
+ * implementation.
+ *
+ * This used to be copy-pasted into every channel view, and the copies drifted:
+ * review caught one path bumping the switch-remount key and another not, which
+ * is precisely the class of bug the remount exists to prevent.
+ *
+ * Used by the three views that own BOTH controls: dine-in, pickup and in-house
+ * delivery. Queue deliberately does not — it has no auto-close toggle of its own
+ * (queue orders take `autoCloseBill` from `dineInSettings`), so there is no
+ * event to hang the dialog on, and wiring it would mean this page writing to
+ * another page's settings. Kiosk owns both flags and SHOULD use this, but its
+ * settings block is still behind `v-if="false"` — wire it here when that block
+ * is unhidden rather than growing a fourth copy.
+ *
+ * This is guidance only. The backend enforces "a bill is only closed
+ * automatically if the kitchen was notified" at the point of resolution, so
+ * nothing here is load-bearing: a merchant who never opens this page, an old
+ * portal bundle, or a direct API write is covered regardless.
+ *
+ * Views differ only in HOW they persist, so that is the one thing they pass in:
+ * `apply` receives a partial patch and the view maps it onto its own state
+ * (a reactive settings object, or an emit).
+ */
+export function useAutoSendGuard(opts: {
+  /** The channel's auto-accept pair, or null when it could not be read. */
+  channel: () => OrderSettingChannelAutoAccept | null | undefined
+  autoSendKitchen: () => boolean | null | undefined
+  autoCloseBill: () => boolean | null | undefined
+  /** Dine-in's value, for the channels that inherit it (queue, kiosk). */
+  inheritFrom?: () => boolean | null | undefined
+  apply: (patch: { autoSendKitchen?: boolean | null; autoCloseBill?: boolean }) => void
+}) {
+  const { t } = useI18n()
+  const Dialog = useDialog()
+
+  const inheritFrom = () => opts.inheritFrom?.() ?? null
+
+  /**
+   * Remounts the auto-close switch so it re-reads the STORED value. FmSwitch's
+   * internal state after a click we decline to apply is not something we
+   * control, and a switch left visually on while nothing was saved is the worst
+   * outcome here.
+   */
+  const autoCloseSwitchKey = ref(0)
+
+  const autoSendKitchenValue = computed(() => autoSendSelectValue(opts.autoSendKitchen()))
+
+  const autoCloseSublabel = computed(() =>
+    t(
+      autoCloseSublabelKey(
+        opts.autoSendKitchen(),
+        opts.channel(),
+        opts.autoCloseBill(),
+        inheritFrom()
+      )
+    )
+  )
+
+  // Static labels: the unset option says what it INHERITS from, not what that
+  // currently evaluates to. Resolving it here meant the label depended on the
+  // async settings GET, which is why the select needed a remount key to repaint
+  // — and the resolved suffix was the thing that made a simple control look
+  // complicated. The backend is what guarantees the outcome now.
+  const selectItems = computed(() => [
+    { label: t('order.followAutoAccept'), value: 'null' },
+    { label: t('order.enabled'), value: 'true' },
+    { label: t('order.disabled'), value: 'false' }
+  ])
+
+  function updateAutoSendKitchen(v: string) {
+    const autoSendKitchen = autoSendFromSelectValue(v)
+    // Reverse direction: turning kitchen send off while auto-close is ON would
+    // leave auto-close inert, so it visibly follows off. No dialog — this
+    // direction only REMOVES behaviour, it never starts printing tickets.
+    //
+    // Gated on auto-close actually being on. Without that check this wrote an
+    // explicit `autoCloseBill: false` over an UNSET value on every such change,
+    // turning "inherit" into "pinned off" — the same hazard the kiosk mapper
+    // avoids by sending `?? undefined` — and remounted the switch to show a
+    // change that had not happened.
+    const clearsAutoClose =
+      opts.autoCloseBill() === true &&
+      requiresAutoSendConfirmation(autoSendKitchen, opts.channel(), inheritFrom())
+    if (clearsAutoClose) autoCloseSwitchKey.value++
+    opts.apply(
+      clearsAutoClose ? { autoSendKitchen, autoCloseBill: false } : { autoSendKitchen }
+    )
+  }
+
+  function updateAutoCloseBill(autoCloseBill: boolean) {
+    // Turning auto-close ON while the kitchen would not be notified is the one
+    // case worth interrupting: the setting would do nothing, and confirming is
+    // the one-click fix. The backend suppresses the close either way, so this
+    // is guidance rather than the guard it used to be.
+    if (
+      autoCloseBill &&
+      requiresAutoSendConfirmation(opts.autoSendKitchen(), opts.channel(), inheritFrom())
+    ) {
+      autoCloseSwitchKey.value++
+      Dialog.open({
+        title: t('order.autoCloseBillEnableKitchenTitle'),
+        message: t('order.autoCloseBillEnableKitchenMessage'),
+        dismissAway: false,
+        primaryActions: {
+          text: t('order.autoCloseBillEnableKitchenConfirm'),
+          variant: 'primary',
+          close: true
+        },
+        secondaryActions: { text: t('order.cancel'), variant: 'tertiary', close: true }
+      }).onPrimary(() => {
+        // Pin `true` rather than leave it inherited: otherwise turning
+        // auto-accept off later would silently make auto-close inert again.
+        opts.apply({ autoSendKitchen: true, autoCloseBill: true })
+      })
+      return
+    }
+
+    opts.apply({ autoCloseBill })
+  }
+
+  return {
+    autoSendKitchenValue,
+    selectItems,
+    autoCloseSublabel,
+    autoCloseSwitchKey,
+    updateAutoSendKitchen,
+    updateAutoCloseBill
+  }
+}

package/tsconfig.app.json

@@ -8,7 +8,16 @@
     "../../common/**/*",
     "src/**/*.json"
   ],
-  "exclude": ["src/**/__tests__/*", "src/**/*.spec.ts"],
+  "exclude": [
+    "src/**/__tests__/*",
+    "src/**/*.spec.ts",
+    // `include` pulls in all of `../../common` for the shared helpers, which
+    // also sweeps up the jest compatibility suites that live there. This is a
+    // Vue app: its `types` array is ["googlemaps"], so jest globals are not
+    // loaded and every `describe` / `it` / `expect` in those files is an error.
+    // They are backend tests and are type-checked by the backend gate.
+    "../../common/**/*.test.ts"
+  ],
   "compilerOptions": {
     "rootDir": "./../..",
     "composite": true,