@feedmepos/mf-menu-portal 0.0.0-stage → 1.0.1-dev.1

package/dist/apps/mf-menu/src/components/layout/FlatInlineSort.vue.d.ts

@@ -0,0 +1,25 @@
+interface SortItem {
+    readonly id: string;
+    readonly label: string;
+}
+type __VLS_Props = {
+    items: readonly SortItem[];
+    handle: string;
+    lockLast?: boolean;
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    reorder: (ids: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onReorder?: ((ids: string[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    item?: ((props: {
+        element: any;
+        index: any;
+    }) => any) | undefined;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/apps/mf-menu/src/components/layout/FormColumn.vue.d.ts

@@ -0,0 +1,12 @@
+interface Props {
+    shrinkable?: boolean;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: ((props: {}) => any) | undefined;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/apps/mf-menu/src/components/layout/FormItem.vue.d.ts

@@ -0,0 +1,17 @@
+interface Props {
+    label?: string;
+    description?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    append?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/apps/mf-menu/src/components/layout/FormRow.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?: ((props: {}) => any) | undefined;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/apps/mf-menu/src/components/layout/FormSection.vue.d.ts

@@ -0,0 +1,18 @@
+interface Props {
+    title?: string;
+    subTitle?: string;
+    shrinkable?: boolean;
+}
+declare var __VLS_1: {}, __VLS_6: {};
+type __VLS_Slots = {} & {
+    'append-title'?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/apps/mf-menu/src/components/layout/FullScreenForm.vue.d.ts

@@ -0,0 +1,31 @@
+interface FullScreenFormProps {
+    show: boolean;
+    title: string;
+    primaryAction: {
+        label: string;
+        disabled?: boolean;
+    };
+    secondaryActions: {
+        label: string;
+        click?: () => void;
+    }[];
+}
+declare var __VLS_20: {}, __VLS_34: {};
+type __VLS_Slots = {} & {
+    'append-title'?: (props: typeof __VLS_20) => any;
+} & {
+    default?: (props: typeof __VLS_34) => any;
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FullScreenFormProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: any;
+} & {
+    [x: string]: any;
+}, string, import("vue").PublicProps, Readonly<FullScreenFormProps> & Readonly<{
+    [x: `on${Capitalize<any>}`]: ((...args: any[] | unknown[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/apps/mf-menu/src/components/layout/FullWrapper.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?: ((props: {}) => any) | undefined;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/apps/mf-menu/src/components/layout/LabeledTextField.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    label?: string;
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<__VLS_Props, {
+    inputEl: import("vue").ComputedRef<HTMLInputElement | null>;
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    [x: string]: ((props: any) => any) | undefined;
+    [x: number]: ((props: any) => any) | undefined;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/apps/mf-menu/src/components/layout/ListCountTag.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    value: number | string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/layout/LottieAnimation.vue.d.ts

@@ -0,0 +1,39 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    link: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    json: {
+        type: ObjectConstructor;
+        default: undefined;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    link: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    json: {
+        type: ObjectConstructor;
+        default: undefined;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    link: string;
+    json: Record<string, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/layout/PageLayout.vue.d.ts

@@ -0,0 +1,19 @@
+interface Props {
+    heading: string;
+    subheading?: string;
+}
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+type __VLS_Slots = {} & {
+    'prepend-heading'?: (props: typeof __VLS_1) => any;
+} & {
+    'append-heading'?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/apps/mf-menu/src/components/layout/ProgressBar.vue.d.ts

@@ -0,0 +1,9 @@
+interface Props {
+    /** 0–100. Values outside the range are clamped. */
+    percent: number;
+    variant?: 'neutral' | 'warning' | 'success' | 'error';
+}
+declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    variant: "error" | "success" | "warning" | "neutral";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/loading/AppLoading.vue.d.ts

@@ -0,0 +1,20 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/loading/PageLoading.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/loading/index.d.ts

@@ -0,0 +1 @@
+export declare const withLoading: (loader: () => Promise<any>) => any;

package/dist/apps/mf-menu/src/components/placeholder/PlaceholderView.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    module: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/preview/MenuPreview.vue.d.ts

@@ -0,0 +1,13 @@
+import type { MenuPreviewModule } from '@feedmepos/menu-sdk';
+type MenuPreviewPageSdk = {
+    preview: Pick<MenuPreviewModule, 'open'>;
+};
+type __VLS_Props = {
+    sdk: MenuPreviewPageSdk;
+    /** The deployed simulator; null where this environment has none. */
+    simulatorUrl: string | null;
+    /** This page's origin, which the simulator posts back to. */
+    parentOrigin?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/preview/simulatorPort.d.ts

@@ -0,0 +1,23 @@
+import type { MenuPreviewSimulatorPort } from '@feedmepos/menu-sdk';
+/**
+ * Where the simulator iframe points, and the origin every message to and from
+ * it must carry.
+ *
+ * The simulator posts only to the origin named in `?parent=` and refuses one
+ * that is not on its allowlist (`feedmepos/menu-simulator` `src/lib/contract.ts`
+ * and `public/_headers`), so this page's own origin goes there.
+ */
+export declare function simulatorFrame(simulatorUrl: string, parentOrigin: string): {
+    readonly src: string;
+    readonly origin: string;
+};
+/**
+ * The host side of the simulator iframe, handed to the SDK's preview session.
+ *
+ * Only the window plumbing lives here: posting to the frame at the simulator's
+ * exact origin (never `'*'`), and passing on a `message` event only when both
+ * its origin and its source are that frame — an origin check alone would let a
+ * same-origin frame elsewhere on the page speak for it. Every message itself,
+ * handshake to acknowledgement, is the SDK's.
+ */
+export declare function createSimulatorPort(frame: () => HTMLIFrameElement | null, origin: string, host?: Pick<Window, 'addEventListener' | 'removeEventListener'>): MenuPreviewSimulatorPort;

package/dist/apps/mf-menu/src/components/publish/PublishRevertPreview.vue.d.ts

@@ -0,0 +1,6 @@
+import type { PublishRevertPreviewSession } from '@feedmepos/menu-sdk';
+type __VLS_Props = {
+    session: PublishRevertPreviewSession;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/publish/PublishScheduleDetails.vue.d.ts

@@ -0,0 +1,6 @@
+import type { PublishScheduleDetailsSession } from '@feedmepos/menu-sdk';
+type __VLS_Props = {
+    session: PublishScheduleDetailsSession;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/publish/publishStatus.d.ts

@@ -0,0 +1,15 @@
+import type { PublishJobStatus } from '@feedmepos/menu-sdk';
+/**
+ * Presentation mapping for the publish job lifecycle, shared by the progress
+ * side sheet and the publish-details dialog so the two cannot disagree.
+ *
+ * Legacy kept the same table (`portal views/Publish/PublishProgressView.vue:33-55`)
+ * but paired each token text class with a raw hex background for its progress
+ * bar (`#E0E0DE`, `#FFB800`, `#34C759`, `#FF3B30`). Those are ADR-0003 §2
+ * violations, so the bar takes a semantic `variant` and resolves its own token
+ * class instead.
+ */
+export declare const PUBLISH_STATUS_TEXT_CLASS: Record<PublishJobStatus, string>;
+export declare const PUBLISH_STATUS_BAR_VARIANT: Record<PublishJobStatus, 'neutral' | 'warning' | 'success' | 'error'>;
+export declare const PUBLISH_STATUS_LABEL_KEY: Record<PublishJobStatus, string>;
+export declare const PUBLISH_JOB_STATUSES: readonly PublishJobStatus[];

package/dist/apps/mf-menu/src/components/translation/TranslationLanguageSelector.vue.d.ts

@@ -0,0 +1,21 @@
+type __VLS_Props = {
+    selected: readonly {
+        code: string;
+        name: string;
+    }[];
+    available: readonly {
+        code: string;
+        name: string;
+    }[];
+    menuZIndex?: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    add: (code: string) => any;
+    remove: (code: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAdd?: ((code: string) => any) | undefined;
+    onRemove?: ((code: string) => any) | undefined;
+}>, {
+    menuZIndex: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/translation/TranslationViewChip.vue.d.ts

@@ -0,0 +1,12 @@
+type __VLS_Props = {
+    nameLocale: Readonly<Record<string, string>>;
+    /**
+     * How many locales badge individually before the rest collapse into one
+     * `+N` chip. Omitted — every host but the product list — keeps legacy's
+     * other branch: one chip per locale, each with its own tooltip
+     * (`portal .../translation/TranslationViewChip.vue:25-46`).
+     */
+    showNumber?: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/apps/mf-menu/src/components/translation/localeName.d.ts

@@ -0,0 +1,11 @@
+/** The display name for a locale code, or the code itself when unmapped. */
+export declare function localeFullName(code: string): string;
+/** Every locale this app can name, in legacy's table order. */
+export declare function localeVocabulary(): readonly {
+    code: string;
+    name: string;
+}[];
+export declare function defaultTranslationLocales(): readonly {
+    code: string;
+    name: string;
+}[];

package/dist/apps/mf-menu/src/components/translation/localeSymbol.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Legacy's `getLocaleIcon`: the mapped icon, else the REGION segment
+ * uppercased — `ar-AE` badges as `AE`, not `AR` and not `ar-AE`
+ * (`portal .../utils/translation.ts:62-65`, observed as
+ * `translation-editor/display/unknown-locale-fallback`).
+ *
+ * The fallback is why this is shared rather than written per surface: three
+ * surfaces had each derived it, and two of them took the LANGUAGE segment,
+ * which badges `zh-CN` as `ZH` where legacy badges it 简. The icons are the
+ * same string in every bundle — a constant table rendered as text rather than
+ * copy — but they stay in the locale files, which is where every migrated
+ * surface already reads them from, and each key is written whole so the i18n
+ * gate can see it.
+ */
+export declare function useLocaleSymbol(): (code: string) => string;

package/dist/apps/mf-menu/src/composable/elementPosition.d.ts

@@ -0,0 +1,17 @@
+import { type Ref } from 'vue';
+export declare function useElementPosition(el: Ref<HTMLElement | null>, watched?: any): Ref<{
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}, {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+} | {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}>;

package/dist/apps/mf-menu/src/composable/menuNotifier.d.ts

@@ -0,0 +1,14 @@
+import type { MenuSdk } from '@feedmepos/menu-sdk';
+/**
+ * Posts the Publish navigation badge from the app root, as legacy's notifier
+ * does (`portal App.vue:225`), so the badge is on screen — and follows every
+ * menu save — before Publish is ever opened. The SDK owns the count; this only
+ * renders it into the legacy window-message contract the sidebar listens to.
+ *
+ * Legacy's notifier also posts `menu-version-notifier` (`{ isV4 }`). That is
+ * deliberately not migrated: its only listener was legacy mf-menu's own
+ * `router/shared.ts`, which toggled the V4-only navigation items — here the
+ * router reads the SDK's `moduleRoutes` capability instead — and ADR-0002
+ * forbids `mf-menu` from receiving a menu-version value at all.
+ */
+export declare function useMenuNotifier(sdk: MenuSdk): void;

package/dist/apps/mf-menu/src/composable/navigator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Legacy window-message contract for updating route badges from menu publish state.
+ * The notifier that produces this message must reuse this constant.
+ */
+export declare const PUBLISH_NOTIFIER = "publish-notifier";
+interface NavigatorStatus {
+    [key: string]: {
+        icon?: string;
+        badge?: number;
+    };
+}
+export declare function useMenuNavigatorStatus(): {
+    navigatorStatus: import("vue").Ref<NavigatorStatus, NavigatorStatus>;
+    stop: () => void;
+};
+export {};

package/dist/apps/mf-menu/src/composable/useActionFeedback.d.ts

@@ -0,0 +1,81 @@
+import type { MenuActionOutcome } from '@feedmepos/menu-sdk';
+export interface ActionFeedbackConfig<T = unknown> {
+    /**
+     * Localized text shown in a bottom snackbar when the action succeeds.
+     *
+     * A function receives the outcome's value, for the case where the text names
+     * something only the write knows — a duplicate reports the *clone's* name,
+     * and that name is a domain rule the SDK owns. Recomputing it in the caller
+     * would put a second copy of that rule on the wrong side of the boundary
+     * (ADR-0002 §2), so the SDK hands it back and the caller only renders it.
+     */
+    successMessage?: string | ((value: T) => string);
+    /**
+     * Legacy's scheduled-publish cancellation bypasses its loading helper and
+     * writes a regular-weight snackbar message directly. Other settled writes
+     * retain the helper's semibold title convention.
+     */
+    successPresentation?: 'title' | 'message';
+    /** Localized text shown with a spinner while the action is in flight. */
+    loadingMessage?: string;
+    /**
+     * Optional semibold heading for an in-flight action. Legacy publish revert
+     * names its restaurant in this slot and keeps the generic loading copy below.
+     */
+    loadingTitle?: string;
+    /**
+     * Whether the in-flight spinner is shown at all. Defaults to `true`.
+     *
+     * Set it to `false` where an action can settle without a backend round trip —
+     * a required-field rejection is decided locally, and flashing a loading toast
+     * for it shows the user an indicator the legacy never had. Turn it off only
+     * with an approved baseline that says so; it is not a matter of taste.
+     *
+     * Pass a FUNCTION when the answer is derived from editor status. `run` calls
+     * it after the action has been started, so a `status === 'submitting'` gate
+     * reads the status the SDK published synchronously rather than the `idle` it
+     * still held when the config object was built. A plain boolean is evaluated
+     * by the caller as before and stays valid.
+     */
+    showLoading?: boolean | (() => boolean);
+    /**
+     * Render field-associated rejections through the shared snackbar as well.
+     *
+     * Most editors keep field issues next to their inputs. Legacy scheduled
+     * publish is the exception: its combined date-and-restaurants guard presents
+     * one error toast and leaves the composer otherwise unchanged.
+     */
+    toastFieldIssues?: boolean;
+    /**
+     * Overrides the client-origin rejection weight (normally `message`,
+     * regular-weight — see the `rejected` branch below). Legacy is not uniform
+     * here: most client-side guards open the snackbar directly with `message`
+     * (`portal .../manager/menu/memberPricing.ts:63-71`), but a raw caught
+     * parser exception goes through `snackbar.open({ title: err.message })`
+     * instead (`portal apps/mf-menu/src/views/Catalog/Edit/ImportProductDialog.vue:227-233`).
+     * Pass `'title'` only when the call site's own citation shows the latter
+     * shape; otherwise the origin-based default already matches legacy.
+     */
+    rejectedPresentation?: 'title' | 'message';
+    /**
+     * Some legacy actions catch server errors directly with `message`, bypassing
+     * the loading helper (ManageImageDrawer.vue runForRatio). Opt into that
+     * regular-weight, default-position presentation; other callers keep titles.
+     */
+    errorPresentation?: 'title' | 'message';
+    /** Exact approved legacy failures that settle without a snackbar. */
+    silentFailureCodes?: readonly string[];
+}
+/**
+ * Cross-cutting write feedback (ADR-0003 §1 "Toast / notification" ->
+ * `useSnackbar`). A module forwards its SDK `MenuActionOutcome` here and this
+ * composable owns the loading indicator and the success / rejected / failure
+ * snackbar. An exact approved `silentFailureCodes` entry can preserve a
+ * measured legacy failure with no settled feedback.
+ *
+ * The snackbar host is mounted once by the `FeedMeUI` plugin in `main.ts`; this
+ * composable only opens and closes toasts, it renders nothing itself.
+ */
+export declare function useActionFeedback(): {
+    run<T>(action: () => Promise<MenuActionOutcome<T>>, config?: ActionFeedbackConfig<T>): Promise<MenuActionOutcome<T>>;
+};

package/dist/apps/mf-menu/src/composable/useEditorValidation.d.ts

@@ -0,0 +1,21 @@
+import type { FieldIssues, Issue, MenuActionOutcome } from '@feedmepos/menu-sdk';
+/**
+ * When an editor's field issues are shown. The SDK derives what the draft
+ * would be rejected for on every change (`fieldIssues`); this decides only
+ * visibility, the way FmForm rules did in legacy: a field's issue appears once
+ * it has been edited or blurred, and every issue appears after a submit.
+ */
+export declare function useEditorValidation(session: () => unknown): {
+    field: <T>(name: string, update: (value: T) => void) => {
+        ref: (instance: unknown) => void;
+        'onUpdate:modelValue': (value: T) => void;
+        onFocusChanged: (focused: boolean) => void;
+    };
+    issue: <F extends string>(fieldIssues: Readonly<Partial<Record<F, readonly Issue[]>>>, name: F) => Issue | null;
+    issues: <F_1 extends string>(fieldIssues: Readonly<Partial<Record<F_1, readonly Issue[]>>>, name: F_1) => readonly Issue[];
+    removeRow: (prefix: string, index: number) => void;
+    submit: <T_1 extends MenuActionOutcome<unknown>>(action: () => Promise<T_1>) => Promise<T_1>;
+    touch: (name: string) => void;
+};
+/** The visibility layer one editor shares with the field components it renders. */
+export type EditorValidation = ReturnType<typeof useEditorValidation>;

package/dist/apps/mf-menu/src/init.d.ts

@@ -0,0 +1 @@
+export declare function initFirebase(): Promise<void>;

package/dist/apps/mf-menu/src/main.d.ts

@@ -0,0 +1,2 @@
+import './assets/main.css';
+import '@feedmepos/mf-common/style.css';

package/dist/apps/mf-menu/src/plugins.d.ts

@@ -0,0 +1,4 @@
+/** Only legacy category thumbnails still live in Firebase Storage. */
+export declare const firebaseStorage: {
+    delete(url: string, bucketUrl?: string): Promise<void>;
+};

package/dist/apps/mf-menu/src/router/index.d.ts

@@ -0,0 +1,2 @@
+declare const router: import("vue-router").Router;
+export default router;

package/dist/apps/mf-menu/src/router/shared.d.ts

@@ -0,0 +1,65 @@
+import type { RouteLocationNormalized, RouteLocationRaw, RouteRecordRaw } from 'vue-router';
+import type { Capability, MenuRouteCapabilities } from '@feedmepos/menu-sdk';
+export declare function setMenuRouteCapabilities(next: MenuRouteCapabilities): void;
+export declare function setMenuPublishCapability(next: Capability): void;
+export declare function setMenuCatalogBindingCapability(next: Capability): void;
+export declare let appReady: Promise<void>;
+export declare function resetAppReady(): void;
+export declare function signalAppReady(): void;
+/** What a shell publishes about its scope for the gated route guards. */
+export interface ShellScope {
+    routes: MenuRouteCapabilities;
+    publish: Capability;
+    catalogBinding: Capability;
+    /** The session is terminal, so a gated guard can decide on `routes`. */
+    settled: boolean;
+}
+export interface AttachedShell {
+    /**
+     * Whether this is still the latest shell (reactive). Only it may decide a
+     * route: a replaced shell would pair its own settled session with the
+     * capabilities the newer shell publishes, provisional ones included.
+     */
+    isCurrent(): boolean;
+    /** Publishes this shell's scope; ignored once a newer shell has attached. */
+    publish(scope: ShellScope): void;
+    detach(): void;
+}
+/**
+ * Called by the shell when it is set up. The latest shell owns readiness and
+ * the capabilities the guards read: one set up before an earlier shell
+ * unmounts (a transition, a keyed remount, HMR) must not have its scope
+ * overwritten by a late update from that earlier shell, nor lose its
+ * attachment or its signal to that earlier shell's detach.
+ */
+export declare function attachShell(): AttachedShell;
+/**
+ * Where the settled scope sends `route`, or `null` to stay: its `scopeRedirect`
+ * target, else Catalog when its `scopeGuard` fails. The one rule both the
+ * route guard and the shell apply to a scope-gated route.
+ */
+export declare function scopeRedirectTarget(route: Pick<RouteLocationNormalized, 'meta' | 'query'>): RouteLocationRaw | null;
+/** Keeps businessId/country on the URL so the query-state plugin need not redirect again. */
+export declare function withQuery(target: RouteLocationRaw, from: Pick<RouteLocationNormalized, 'query'>): RouteLocationRaw;
+export declare enum RouteName {
+    OVERVIEW = "$menu-overview",
+    CATALOG = "$menu-catalog",
+    EDIT_CATALOG = "$menu-catalog-edit",
+    EDIT_CATALOG_PRODUCT = "$menu-catalog-edit-product",
+    EDIT_CATALOG_CATEGORY = "$menu-catalog-edit-category",
+    EDIT_CATALOG_GROUP = "$menu-catalog-edit-group",
+    EDIT_CATALOG_TAKEAWAY = "$menu-catalog-edit-takeaway",
+    EDIT_CATALOG_SETTING = "$menu-catalog-edit-setting",
+    SCHEDULER = "$menu-scheduler",
+    VARIANT = "$menu-variant",
+    ORDER_PACING = "$menu-order-pacing",
+    COOKING_GUIDE = "$menu-cooking-guide",
+    PRINT_ROUTE = "$menu-print-route",
+    PUBLISH = "$menu-publish",
+    PREVIEW = "$menu-preview",
+    CATALOG_BINDING = "$menu-catalog-binding",
+    PRODUCT_INTERNAL_TOOLS = "$menu-product-internal-tools"
+}
+declare const routers: Array<RouteRecordRaw>;
+export { routers };
+export declare const catalogRoutes: Array<RouteRecordRaw>;