@fayz-ai/plugin-menu 0.9.0-next.1 → 0.9.1

package/src/data/platform.ts

@@ -1,429 +0,0 @@
-import { createFayzClient, type FayzClientOptions, type FayzTableFilter } from '@fayz-ai/sdk'
-import type {
-  CreateMenuCategoryInput,
-  CreateMenuItemInput,
-  MenuCategory,
-  MenuItem,
-  MenuItemQuery,
-  MenuItemStatus,
-  MenuSummary,
-  ModifierGroup,
-  PaginatedResult,
-  UpdateMenuItemInput,
-} from '../types'
-import type { MenuDataProvider } from './types'
-
-export interface FayzMenuProviderOptions extends FayzClientOptions {
-  projectId?: string
-  schema?: string
-  runtime?: boolean
-  categoriesTable?: string
-  productsTable?: string
-  categoryKind?: string
-}
-
-interface CategoryRow {
-  id: string
-  tenant_id?: string | null
-  kind?: string | null
-  name: string
-  slug?: string | null
-  parent_id?: string | null
-  icon?: string | null
-  color?: string | null
-  sort_order?: number | null
-  is_active?: boolean | null
-  metadata?: Record<string, unknown> | null
-  created_at?: string | null
-  updated_at?: string | null
-}
-
-interface ProductRow {
-  id: string
-  tenant_id?: string | null
-  category_id?: string | null
-  name: string
-  description?: string | null
-  sku?: string | null
-  price?: number | string | null
-  cost?: number | string | null
-  currency?: string | null
-  image_url?: string | null
-  status?: string | null
-  is_active?: boolean | null
-  tags?: string[] | null
-  metadata?: Record<string, unknown> | null
-  created_at?: string | null
-  updated_at?: string | null
-}
-
-const DEFAULT_CATEGORY_KIND = 'menu_category'
-const MENU_METADATA_KEY = 'fayzMenu'
-
-function nowIso(): string {
-  return new Date().toISOString()
-}
-
-function slugify(value: string): string {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
-}
-
-function numberValue(value: number | string | null | undefined): number {
-  if (typeof value === 'number') return value
-  if (typeof value === 'string') return Number(value) || 0
-  return 0
-}
-
-function menuMetadata(row: ProductRow): Record<string, unknown> {
-  const raw = row.metadata?.[MENU_METADATA_KEY]
-  return raw && typeof raw === 'object' && !Array.isArray(raw) ? raw as Record<string, unknown> : {}
-}
-
-function rowToCategory(row: CategoryRow, itemCount = 0): MenuCategory {
-  return {
-    id: row.id,
-    name: row.name,
-    parentId: row.parent_id ?? undefined,
-    icon: row.icon ?? undefined,
-    color: row.color ?? undefined,
-    sortOrder: row.sort_order ?? 0,
-    isActive: row.is_active ?? true,
-    itemCount,
-    tenantId: row.tenant_id ?? 'runtime-tenant',
-    createdAt: row.created_at ?? nowIso(),
-    updatedAt: row.updated_at ?? row.created_at ?? nowIso(),
-  }
-}
-
-function rowToItem(row: ProductRow, categoryName?: string): MenuItem {
-  const metadata = menuMetadata(row)
-  const status = (metadata.status ?? row.status ?? 'available') as MenuItemStatus
-  return {
-    id: row.id,
-    name: row.name,
-    description: row.description ?? undefined,
-    price: numberValue(row.price),
-    cost: numberValue(row.cost),
-    currency: row.currency ?? 'BRL',
-    sku: row.sku ?? undefined,
-    imageUrl: row.image_url ?? undefined,
-    categoryId: row.category_id ?? undefined,
-    categoryName,
-    status,
-    isActive: row.is_active ?? true,
-    prepTimeMinutes: typeof metadata.prepTimeMinutes === 'number' ? metadata.prepTimeMinutes : undefined,
-    allergens: Array.isArray(metadata.allergens) ? metadata.allergens as string[] : undefined,
-    dietaryTags: Array.isArray(metadata.dietaryTags) ? metadata.dietaryTags as string[] : row.tags ?? undefined,
-    availableForPos: typeof metadata.availableForPos === 'boolean' ? metadata.availableForPos : true,
-    availableForDelivery: typeof metadata.availableForDelivery === 'boolean' ? metadata.availableForDelivery : true,
-    deliveryPrice: typeof metadata.deliveryPrice === 'number' ? metadata.deliveryPrice : undefined,
-    sortOrder: typeof metadata.sortOrder === 'number' ? metadata.sortOrder : 0,
-    isFeatured: typeof metadata.isFeatured === 'boolean' ? metadata.isFeatured : false,
-    modifierGroupIds: Array.isArray(metadata.modifierGroupIds) ? metadata.modifierGroupIds as string[] : undefined,
-    metadata: row.metadata ?? {},
-    tenantId: row.tenant_id ?? 'runtime-tenant',
-    createdAt: row.created_at ?? nowIso(),
-    updatedAt: row.updated_at ?? row.created_at ?? nowIso(),
-  }
-}
-
-function categoryPayload(input: CreateMenuCategoryInput, kind: string): Record<string, unknown> {
-  return {
-    kind,
-    name: input.name,
-    slug: slugify(input.name),
-    parent_id: input.parentId ?? null,
-    icon: input.icon ?? null,
-    color: input.color ?? null,
-    sort_order: input.sortOrder ?? 0,
-    is_active: true,
-  }
-}
-
-function itemMetadata(input: Partial<CreateMenuItemInput>, existing?: Record<string, unknown>): Record<string, unknown> {
-  return {
-    ...(existing ?? {}),
-    [MENU_METADATA_KEY]: {
-      ...((existing?.[MENU_METADATA_KEY] && typeof existing[MENU_METADATA_KEY] === 'object') ? existing[MENU_METADATA_KEY] as Record<string, unknown> : {}),
-      status: input.status,
-      prepTimeMinutes: input.prepTimeMinutes,
-      allergens: input.allergens,
-      dietaryTags: input.dietaryTags,
-      availableForPos: input.availableForPos ?? true,
-      availableForDelivery: input.availableForDelivery ?? true,
-      deliveryPrice: input.deliveryPrice,
-      isFeatured: input.isFeatured ?? false,
-      modifierGroupIds: input.modifierGroupIds,
-    },
-  }
-}
-
-function itemCreatePayload(input: CreateMenuItemInput): Record<string, unknown> {
-  return {
-    name: input.name,
-    description: input.description ?? null,
-    price: input.price,
-    cost: input.cost ?? null,
-    currency: 'BRL',
-    image_url: input.imageUrl ?? null,
-    category_id: input.categoryId ?? null,
-    status: input.status === 'hidden' ? 'archived' : 'active',
-    is_active: input.status !== 'hidden',
-    tags: input.dietaryTags ?? [],
-    metadata: itemMetadata(input),
-  }
-}
-
-function itemUpdatePayload(input: UpdateMenuItemInput, existing?: MenuItem): Record<string, unknown> {
-  const payload: Record<string, unknown> = {}
-  if (input.name !== undefined) payload.name = input.name
-  if (input.description !== undefined) payload.description = input.description
-  if (input.price !== undefined) payload.price = input.price
-  if (input.cost !== undefined) payload.cost = input.cost
-  if (input.imageUrl !== undefined) payload.image_url = input.imageUrl
-  if (input.categoryId !== undefined) payload.category_id = input.categoryId
-  if (input.status !== undefined) {
-    payload.status = input.status === 'hidden' ? 'archived' : 'active'
-    payload.is_active = input.status !== 'hidden'
-  }
-  if (input.dietaryTags !== undefined) payload.tags = input.dietaryTags
-  payload.metadata = itemMetadata(input, existing?.metadata)
-  return payload
-}
-
-function filtersFromQuery(query: MenuItemQuery): FayzTableFilter[] {
-  const filters: FayzTableFilter[] = [{ column: 'is_active', operator: 'eq', value: true }]
-  if (query.categoryId) filters.push({ column: 'category_id', operator: 'eq', value: query.categoryId })
-  return filters
-}
-
-function matchesClientQuery(item: MenuItem, query: MenuItemQuery): boolean {
-  if (query.status) {
-    const statuses = Array.isArray(query.status) ? query.status : [query.status]
-    if (!statuses.includes(item.status)) return false
-  }
-  if (query.availableForPos !== undefined && item.availableForPos !== query.availableForPos) return false
-  if (query.availableForDelivery !== undefined && item.availableForDelivery !== query.availableForDelivery) return false
-  if (query.isFeatured !== undefined && item.isFeatured !== query.isFeatured) return false
-  if (query.search) {
-    const search = query.search.toLowerCase()
-    return item.name.toLowerCase().includes(search)
-      || (item.description?.toLowerCase().includes(search) ?? false)
-  }
-  return true
-}
-
-function paginate<T>(items: T[], page?: number, pageSize?: number): PaginatedResult<T> {
-  const currentPage = page ?? 1
-  const limit = pageSize ?? 50
-  const start = (currentPage - 1) * limit
-  return { data: items.slice(start, start + limit), total: items.length }
-}
-
-export function createFayzMenuProvider(options: FayzMenuProviderOptions = {}): MenuDataProvider {
-  const client = createFayzClient(options)
-  const projectId = options.projectId
-  const schema = options.schema
-  const runtime = options.runtime
-  const categoriesTable = options.categoriesTable ?? 'categories'
-  const productsTable = options.productsTable ?? 'products'
-  const categoryKind = options.categoryKind ?? DEFAULT_CATEGORY_KIND
-
-  const tableOptions = { projectId, schema, runtime }
-
-  async function getCategoriesRaw(): Promise<CategoryRow[]> {
-    const response = await client.data.listRows<CategoryRow>({
-      ...tableOptions,
-      table: categoriesTable,
-      filters: [
-        { column: 'kind', operator: 'eq', value: categoryKind },
-        { column: 'is_active', operator: 'eq', value: true },
-      ],
-      sortColumn: 'sort_order',
-      sortDirection: 'asc',
-      limit: 500,
-    })
-    return response.rows
-  }
-
-  async function getItemsRaw(): Promise<ProductRow[]> {
-    const response = await client.data.listRows<ProductRow>({
-      ...tableOptions,
-      table: productsTable,
-      filters: [{ column: 'is_active', operator: 'eq', value: true }],
-      sortColumn: 'name',
-      sortDirection: 'asc',
-      limit: 1000,
-    })
-    return response.rows.filter((row) => {
-      const metadata = menuMetadata(row)
-      return metadata.kind === 'menu_item' || metadata.status != null || row.category_id != null
-    })
-  }
-
-  async function getCategoryMap() {
-    const categories = await getCategoriesRaw()
-    return new Map(categories.map((category) => [category.id, category]))
-  }
-
-  async function getItems(): Promise<MenuItem[]> {
-    const [rows, categoryMap] = await Promise.all([getItemsRaw(), getCategoryMap()])
-    return rows.map((row) => rowToItem(row, row.category_id ? categoryMap.get(row.category_id)?.name : undefined))
-      .sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name))
-  }
-
-  return {
-    async getCategories() {
-      const [categories, items] = await Promise.all([getCategoriesRaw(), getItemsRaw()])
-      const counts = new Map<string, number>()
-      for (const item of items) {
-        if (item.category_id) counts.set(item.category_id, (counts.get(item.category_id) ?? 0) + 1)
-      }
-      return categories.map((category) => rowToCategory(category, counts.get(category.id) ?? 0))
-    },
-
-    async getCategoryById(id: string) {
-      const response = await client.data.listRows<CategoryRow>({
-        ...tableOptions,
-        table: categoriesTable,
-        filters: [{ column: 'id', operator: 'eq', value: id }],
-        limit: 1,
-      })
-      return response.rows[0] ? rowToCategory(response.rows[0]) : null
-    },
-
-    async createCategory(input: CreateMenuCategoryInput) {
-      const row = await client.data.createRow<CategoryRow>({
-        ...tableOptions,
-        table: categoriesTable,
-        row: categoryPayload(input, categoryKind),
-      })
-      return rowToCategory(row)
-    },
-
-    async updateCategory(id: string, data: Partial<MenuCategory>) {
-      const row = await client.data.updateRow<CategoryRow>({
-        ...tableOptions,
-        table: categoriesTable,
-        primaryKeys: { id },
-        row: {
-          name: data.name,
-          parent_id: data.parentId,
-          icon: data.icon,
-          color: data.color,
-          sort_order: data.sortOrder,
-          is_active: data.isActive,
-        },
-      })
-      return rowToCategory(row)
-    },
-
-    async deleteCategory(id: string) {
-      await client.data.updateRow<CategoryRow>({
-        ...tableOptions,
-        table: categoriesTable,
-        primaryKeys: { id },
-        row: { is_active: false },
-      })
-    },
-
-    async reorderCategories(ids: string[]) {
-      await Promise.all(ids.map((id, sortOrder) => this.updateCategory(id, { sortOrder })))
-    },
-
-    async getMenuItems(query: MenuItemQuery) {
-      const items = (await getItems()).filter((item) => matchesClientQuery(item, query))
-      return paginate(items, query.page, query.pageSize)
-    },
-
-    async getMenuItemById(id: string) {
-      const response = await client.data.listRows<ProductRow>({
-        ...tableOptions,
-        table: productsTable,
-        filters: [{ column: 'id', operator: 'eq', value: id }],
-        limit: 1,
-      })
-      if (!response.rows[0]) return null
-      const categoryMap = await getCategoryMap()
-      const row = response.rows[0]
-      return rowToItem(row, row.category_id ? categoryMap.get(row.category_id)?.name : undefined)
-    },
-
-    async createMenuItem(input: CreateMenuItemInput) {
-      const row = await client.data.createRow<ProductRow>({
-        ...tableOptions,
-        table: productsTable,
-        row: itemCreatePayload(input),
-      })
-      const categoryMap = await getCategoryMap()
-      return rowToItem(row, row.category_id ? categoryMap.get(row.category_id)?.name : undefined)
-    },
-
-    async updateMenuItem(id: string, data: UpdateMenuItemInput) {
-      const existing = await this.getMenuItemById(id)
-      const row = await client.data.updateRow<ProductRow>({
-        ...tableOptions,
-        table: productsTable,
-        primaryKeys: { id },
-        row: itemUpdatePayload(data, existing ?? undefined),
-      })
-      const categoryMap = await getCategoryMap()
-      return rowToItem(row, row.category_id ? categoryMap.get(row.category_id)?.name : undefined)
-    },
-
-    async deleteMenuItem(id: string) {
-      await client.data.updateRow<ProductRow>({
-        ...tableOptions,
-        table: productsTable,
-        primaryKeys: { id },
-        row: { is_active: false },
-      })
-    },
-
-    async toggleAvailability(id: string, field: 'status' | 'availableForPos' | 'availableForDelivery', value: unknown) {
-      return this.updateMenuItem(id, { [field]: value } as UpdateMenuItemInput)
-    },
-
-    async reorderItems(categoryId: string, ids: string[]) {
-      await Promise.all(ids.map(async (id, sortOrder) => {
-        const existing = await this.getMenuItemById(id)
-        await client.data.updateRow<ProductRow>({
-          ...tableOptions,
-          table: productsTable,
-          primaryKeys: { id },
-          row: { metadata: itemMetadata({ categoryId }, { ...existing?.metadata, [MENU_METADATA_KEY]: { ...existing?.metadata?.[MENU_METADATA_KEY] as Record<string, unknown>, sortOrder } }) },
-        })
-      }))
-    },
-
-    async getModifierGroups(): Promise<ModifierGroup[]> {
-      return []
-    },
-
-    async createModifierGroup(): Promise<ModifierGroup> {
-      throw new Error('Menu modifier groups require a dedicated Fayz table/broker contract.')
-    },
-
-    async updateModifierGroup(): Promise<ModifierGroup> {
-      throw new Error('Menu modifier groups require a dedicated Fayz table/broker contract.')
-    },
-
-    async deleteModifierGroup(): Promise<void> {
-      throw new Error('Menu modifier groups require a dedicated Fayz table/broker contract.')
-    },
-
-    async getSummary(): Promise<MenuSummary> {
-      const [items, categories] = await Promise.all([getItems(), this.getCategories()])
-      const prices = items.filter((item) => item.price > 0).map((item) => item.price)
-      return {
-        totalItems: items.length,
-        availableItems: items.filter((item) => item.status === 'available').length,
-        soldOutItems: items.filter((item) => item.status === 'sold_out').length,
-        hiddenItems: items.filter((item) => item.status === 'hidden').length,
-        categoryCount: categories.length,
-        averagePrice: prices.length ? prices.reduce((sum, price) => sum + price, 0) / prices.length : 0,
-        featuredCount: items.filter((item) => item.isFeatured).length,
-      }
-    },
-  }
-}

package/src/data/types.ts

@@ -1,33 +0,0 @@
-import type {
-  MenuCategory, MenuItem, ModifierGroup,
-  CreateMenuItemInput, UpdateMenuItemInput, CreateMenuCategoryInput,
-  MenuItemQuery, PaginatedResult, MenuSummary,
-} from '../types'
-
-export interface MenuDataProvider {
-  // Categories
-  getCategories(): Promise<MenuCategory[]>
-  getCategoryById(id: string): Promise<MenuCategory | null>
-  createCategory(input: CreateMenuCategoryInput): Promise<MenuCategory>
-  updateCategory(id: string, data: Partial<MenuCategory>): Promise<MenuCategory>
-  deleteCategory(id: string): Promise<void>
-  reorderCategories(ids: string[]): Promise<void>
-
-  // Menu Items
-  getMenuItems(query: MenuItemQuery): Promise<PaginatedResult<MenuItem>>
-  getMenuItemById(id: string): Promise<MenuItem | null>
-  createMenuItem(input: CreateMenuItemInput): Promise<MenuItem>
-  updateMenuItem(id: string, data: UpdateMenuItemInput): Promise<MenuItem>
-  deleteMenuItem(id: string): Promise<void>
-  toggleAvailability(id: string, field: 'status' | 'availableForPos' | 'availableForDelivery', value: any): Promise<MenuItem>
-  reorderItems(categoryId: string, ids: string[]): Promise<void>
-
-  // Modifier Groups
-  getModifierGroups(): Promise<ModifierGroup[]>
-  createModifierGroup(input: Partial<ModifierGroup>): Promise<ModifierGroup>
-  updateModifierGroup(id: string, data: Partial<ModifierGroup>): Promise<ModifierGroup>
-  deleteModifierGroup(id: string): Promise<void>
-
-  // Summary
-  getSummary(): Promise<MenuSummary>
-}

package/src/index.ts

@@ -1,191 +0,0 @@
-import React from 'react'
-import type { PluginManifest, PluginScope, VerticalId } from '@fayz-ai/core'
-import { registerTranslations } from '@fayz-ai/core'
-import type { EntityLookup } from '@fayz-ai/saas'
-import type { MenuDataProvider } from './data/types'
-import { createMockMenuProvider } from './data/mock'
-import { createMenuStore } from './store'
-import { menuRegistries } from './registries'
-import { menuLocales } from './locales'
-import { PluginSettingsPanel } from '@fayz-ai/saas'
-
-// Lazy import page to avoid circular dependency issues
-const MenuPage = React.lazy(() => import('./MenuPage').then((m) => ({ default: m.MenuPage })))
-
-// ---------------------------------------------------------------------------
-// Labels
-// ---------------------------------------------------------------------------
-
-export interface MenuPluginLabels {
-  pageTitle: string
-  menuManager: string
-  categories: string
-  newItem: string
-}
-
-const DEFAULT_LABELS: MenuPluginLabels = {
-  pageTitle: 'Menu',
-  menuManager: 'Menu Manager',
-  categories: 'Categories',
-  newItem: 'New Item',
-}
-
-// ---------------------------------------------------------------------------
-// Currency
-// ---------------------------------------------------------------------------
-
-const DEFAULT_CURRENCY = { code: 'BRL', locale: 'pt-BR', symbol: 'R$' }
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface MenuPluginOptions {
-  modules?: {
-    modifiers?: boolean
-    deliveryPricing?: boolean
-  }
-  labels?: Partial<MenuPluginLabels>
-  currency?: { code?: string; locale?: string; symbol?: string }
-  navPosition?: number
-  navSection?: 'main' | 'secondary' | 'settings'
-  scope?: PluginScope
-  verticalId?: VerticalId
-  dataProvider?: MenuDataProvider
-  menuItemLookup?: EntityLookup
-}
-
-// ---------------------------------------------------------------------------
-// Config resolver
-// ---------------------------------------------------------------------------
-
-function resolveConfig(options?: MenuPluginOptions) {
-  return {
-    modules: {
-      modifiers: options?.modules?.modifiers !== false,
-      deliveryPricing: options?.modules?.deliveryPricing === true,
-    },
-    labels: { ...DEFAULT_LABELS, ...options?.labels },
-    currency: { ...DEFAULT_CURRENCY, ...options?.currency },
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function createMenuPlugin(options?: MenuPluginOptions): PluginManifest {
-  const config = resolveConfig(options)
-  registerTranslations(menuLocales)
-  const provider = options?.dataProvider ?? createMockMenuProvider()
-  const store = createMenuStore(provider)
-
-  const PageComponent: React.FC<any> = () =>
-    React.createElement(React.Suspense, { fallback: null },
-      React.createElement(MenuPage, { config, provider, store, registries: menuRegistries })
-    )
-
-  return {
-    id: 'menu',
-    name: config.labels.pageTitle,
-    icon: 'UtensilsCrossed',
-    version: '1.0.0',
-    scope: options?.scope ?? 'vertical',
-    verticalId: options?.verticalId,
-    // Digital menu serves both internal ops (saas) and online ordering
-    // (ecommerce) — genuinely dual-surface, low confidence, revisit if a
-    // real host disagrees.
-    scaffolds: ['saas', 'ecommerce'],
-    defaultEnabled: true,
-    dependencies: [],
-    declaredLimits: [
-      { key: 'menu_items', label: 'Menu items', table: 'menu_items' },
-    ],
-    navigation: [
-      {
-        section: options?.navSection ?? 'main',
-        position: options?.navPosition ?? 5,
-        label: config.labels.pageTitle,
-        route: '/menu',
-        icon: 'UtensilsCrossed',
-        permission: { feature: 'menu', action: 'read' as const },
-      },
-    ],
-    routes: [
-      {
-        path: '/menu',
-        component: PageComponent,
-        permission: { feature: 'menu', action: 'read' as const },
-      },
-    ],
-    widgets: [],
-    aiTools: [
-      {
-        id: 'menu.list-items',
-        name: 'listMenuItems',
-        description: 'Lists menu items, optionally filtered by category or status.',
-        icon: 'UtensilsCrossed',
-        mode: 'read' as const,
-        category: 'Menu',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            category: { type: 'string' as const, description: 'Category name to filter by' },
-            status: { type: 'string' as const, enum: ['available', 'sold_out', 'hidden'] },
-          },
-        },
-        suggestions: [
-          { label: 'What items are on the menu?' },
-          { label: 'Which items are sold out right now?' },
-        ],
-      },
-      {
-        id: 'menu.toggle-availability',
-        name: 'toggleMenuItemAvailability',
-        description: 'Marks a menu item as available or sold out.',
-        icon: 'ToggleLeft',
-        mode: 'persist' as const,
-        category: 'Menu',
-        parameters: {
-          type: 'object' as const,
-          properties: {
-            itemName: { type: 'string' as const, description: 'Menu item name' },
-            status: { type: 'string' as const, enum: ['available', 'sold_out'] },
-          },
-          required: ['itemName', 'status'],
-        },
-        permission: { feature: 'menu', action: 'edit' as const },
-      },
-    ],
-    registries: menuRegistries,
-    settings: [
-      {
-        id: 'menu',
-        label: config.labels.pageTitle,
-        icon: 'UtensilsCrossed',
-        component: (() => {
-          const MenuSettingsTab: React.ComponentType<unknown> = () =>
-            React.createElement(PluginSettingsPanel, {
-              title: 'Menu Settings',
-              subtitle: 'Categories, allergens, and modifiers',
-              registries: menuRegistries,
-              routeBase: '/settings/menu',
-            })
-          MenuSettingsTab.displayName = 'MenuSettingsTab'
-          return MenuSettingsTab
-        })(),
-        order: 20,
-        permission: { feature: 'menu', action: 'read' as const },
-      },
-    ],
-    locales: menuLocales,
-  }
-}
-
-export type { MenuDataProvider } from './data/types'
-export { createFayzMenuProvider } from './data/platform'
-export type { FayzMenuProviderOptions } from './data/platform'
-export type { ResolvedMenuConfig } from './MenuContext'
-// Domain types — public so any host can implement a MenuDataProvider (e.g. an
-// app-local Supabase provider during plugin incubation).
-export type * from './types'