@innertia-solutions/innertia-nuxt 0.1.11 → 0.1.13

package/docs/superpowers/specs/2026-05-27-nuxt-apps-to-contexts-rename-design.md

@@ -0,0 +1,113 @@
+# innertia-nuxt: Rename apps → contexts
+
+**Fecha:** 2026-05-27
+**Estado:** Aprobado para implementación
+**Tipo:** Refactor — rename puro, sin cambios de comportamiento
+**Scope:** innertia-nuxt library
+
+## Problema
+
+El concepto de "apps" (áreas del sistema a las que un usuario tiene acceso) colisiona semánticamente con "apps" en el contexto de frontend (aplicaciones, secciones de front). Renombrar a "contexts" elimina la ambigüedad y alinea la librería con el rename ya realizado en innertia-laravel (donde `user_apps`, `HasApps`, `appKeys()` etc. ya se renombraron a `user_contexts`, `HasContexts`, `contextKeys()`).
+
+El backend ya devuelve `availableContexts` y `currentContext` — el frontend ya usaba esos nombres en el store. Este rename hace que la **capa de configuración y composables** sea consistente con la API que ya consume.
+
+## Alcance
+
+Rename puro. **Cero cambios de comportamiento.** Todo lo que hoy funciona, sigue funcionando igual — solo cambian los nombres.
+
+**Fuera de scope:**
+- `menuApps` en `app.config.ts` y `backoffice.vue` — semánticamente correcto como "secciones del menú", no relacionado con el sistema de user contexts. Se mantiene intacto.
+- Lógica de organizations, mobile guard, o cualquier otra feature.
+
+## Mapa de renombrado
+
+### `app.config.ts` — config key + tipos
+
+| Antes | Después |
+|-------|---------|
+| `innertia.apps: {}` | `innertia.contexts: {}` |
+| `AppDefinition` interface | `ContextDefinition` |
+| `AppMobileMode` type | `ContextMobileMode` |
+
+`menuApps` **no se toca**.
+
+### `composables/useContext.js` — fusión de useApp + useContext
+
+`useApp.ts` se elimina. `useContext.js` absorbe su lógica y expone la unión completa:
+
+```ts
+const {
+  // — absorbido de useApp —
+  current,            // ContextDefinition | null  (contexto según URL actual)
+  all,                // ContextDefinition[]        (todos los declarados en config)
+  accessible,         // ContextDefinition[]        (filtrados por availableContexts del user)
+  canAccess,          // (key: string) => boolean
+  contexts,           // Record<string, ContextDefinition>  (dict raw del config)
+
+  // — ya existía en useContext —
+  currentContext,     // string | null
+  availableContexts,  // string[]
+  switchContext,      // (target: string) => Promise<{success, reason?}>
+  confirmSwitch,      // (target: string) => Promise<{success}>
+  hasAccessToContext, // (context: string) => boolean
+} = useContext()
+```
+
+**Regla de resolución de la parte absorbida:** lee de `appConfig.innertia.contexts` (antes `appConfig.innertia.apps`). La lógica interna es idéntica a la de `useApp.ts` actual.
+
+### `composables/useApp.ts`
+
+**Eliminado.** Toda su funcionalidad vive en `useContext.js`.
+
+### `composables/useAuth.js`
+
+Login POST body:
+
+```js
+// Antes
+api.post(`${context}/auth/login`, { email, password, app: context })
+
+// Después
+api.post(`${context}/auth/login`, { email, password, context })
+```
+
+El backend (innertia-laravel) ya espera el campo `context`. Este fix cierra la inconsistencia.
+
+### `middleware/03.apps.global.ts` → `middleware/03.contexts.global.ts`
+
+- Renombrar el archivo.
+- Internamente: `apps` variables → `contexts`, `AppDefinition` import → `ContextDefinition`, `appConfig.innertia.apps` → `appConfig.innertia.contexts`.
+- La lógica de los 6 escenarios (ruta pública, login path, sin auth, sin contextos, sin acceso, sync) no cambia.
+
+### `composables/useOrganization.ts`
+
+- `useApp()` → `useContext()`
+- Las propiedades que consume (`current`, referenciada internamente como `currentApp`) siguen existiendo con el mismo nombre en el composable fusionado.
+
+### `composables/useMobileGuard.ts`
+
+- `useApp()` → `useContext()`
+- Propiedades consumidas: `all`, `current`, `accessible` — todas disponibles en el composable fusionado sin cambios de nombre.
+
+### `CHANGELOG.md`
+
+Agregar entrada `[Unreleased]` con sección `### BREAKING CHANGES`.
+
+## Archivos a modificar (8)
+
+1. `app.config.ts` — config key + tipos
+2. `composables/useContext.js` — absorber useApp + actualizar internals
+3. `composables/useApp.ts` — **eliminar**
+4. `composables/useAuth.js` — fix body del login
+5. `middleware/03.apps.global.ts` → **renombrar** a `03.contexts.global.ts` + editar internals
+6. `composables/useOrganization.ts` — `useApp()` → `useContext()`
+7. `composables/useMobileGuard.ts` — `useApp()` → `useContext()`
+8. `CHANGELOG.md` — BREAKING CHANGE entry
+
+## BREAKING CHANGES para productos consumidores
+
+- Config `innertia.contexts` en vez de `innertia.apps`
+- Tipo `ContextDefinition` en vez de `AppDefinition`
+- Tipo `ContextMobileMode` en vez de `AppMobileMode`
+- `useApp()` eliminado → usar `useContext()` (que ahora expone también `current`, `all`, `accessible`, `canAccess`, `contexts`)
+- `performLogin` body: campo `context` en vez de `app`

package/middleware/{03.apps.global.ts → 03.contexts.global.ts}

@@ -1,45 +1,45 @@
 /**
  * Middleware global que se ejecuta en cada navegación.
  *
- * Lee la declaración de apps desde `appConfig.innertia.apps`. Si el producto
- * no declara apps, este middleware no hace nada (feature inactivo).
+ * Lee la declaración de contextos desde `appConfig.innertia.contexts`. Si el
+ * producto no declara contextos, este middleware no hace nada (feature inactivo).
  *
- * Cuando hay apps declaradas, resuelve qué "app" (contexto) está intentando
- * acceder el usuario según el prefijo de URL y:
- *   1. Si la URL no cae en ningún app declarado → pasa (deja seguir)
- *   2. Si la URL es la ruta de login del app → pasa (sin chequeo de permisos)
+ * Cuando hay contextos declarados, resuelve qué contexto está intentando acceder
+ * el usuario según el prefijo de URL y:
+ *   1. Si la URL no cae en ningún contexto declarado → pasa (deja seguir)
+ *   2. Si la URL es la ruta de login del contexto → pasa (sin chequeo de permisos)
  *   3. Si el usuario no está autenticado → deja que el middleware `auth` redirija
  *   4. Si `availableContexts` está vacío (SSR sin hidratar) → intenta fetchMe()
  *      y si falla, pasa sin redirigir (mejor renderizar que redirigir mal)
- *   5. Si el usuario está autenticado pero NO tiene acceso al contexto del app →
- *      redirige al primer app accesible (o a su loginPath si no tiene ninguno)
- *   6. Si todo OK pero `currentContext !== app.context` → sincroniza el contexto
- *      en el authStore y recarga permisos vía fetchMe()
+ *   5. Si el usuario está autenticado pero NO tiene acceso al contexto →
+ *      redirige al primer contexto accesible (o a su loginPath si no tiene ninguno)
+ *   6. Si todo OK pero `currentContext !== targetContext.context` → sincroniza el
+ *      contexto en el authStore y recarga permisos vía fetchMe()
  *
  * Esto es lo que permite el "cambio de contexto implícito por URL" sin botón.
  *
  * Numeración 03. para correr DESPUÉS de los middlewares saas
  * (01.detect-subdomain, 02.validate-tenant).
  */
-import type { AppDefinition } from '../app.config'
+import type { ContextDefinition } from '../app.config'
 
 export default defineNuxtRouteMiddleware(async (to) => {
   const appConfig = useAppConfig()
-  const apps = (appConfig.innertia?.apps ?? {}) as Record<string, AppDefinition>
-  const list = Object.values(apps)
+  const contexts = (appConfig.innertia?.contexts ?? {}) as Record<string, ContextDefinition>
+  const list = Object.values(contexts)
 
-  // Si el producto no declaró apps, el feature está inactivo
+  // Si el producto no declaró contextos, el feature está inactivo
   if (list.length === 0) return
 
-  // ¿La ruta cae bajo algún app?
-  const targetApp = list.find(app =>
-    to.path === app.path || to.path.startsWith(app.path + '/')
+  // ¿La ruta cae bajo algún contexto?
+  const targetContext = list.find(ctx =>
+    to.path === ctx.path || to.path.startsWith(ctx.path + '/')
   )
 
-  if (!targetApp) return  // ruta pública / fuera de apps
+  if (!targetContext) return  // ruta pública / fuera de contextos
 
-  // La ruta de login del propio app no requiere permisos del contexto
-  if (to.path === targetApp.loginPath) return
+  // La ruta de login del propio contexto no requiere permisos
+  if (to.path === targetContext.loginPath) return
 
   const authStore = useAuthStore()
 
@@ -66,9 +66,9 @@ export default defineNuxtRouteMiddleware(async (to) => {
   // Si tras hidratar seguimos sin contextos, NO redirigimos.
   if (userContexts.length === 0) return
 
-  // ¿Tiene acceso al contexto del app?
-  if (!userContexts.includes(targetApp.context)) {
-    const fallback = list.find(app => userContexts.includes(app.context))
+  // ¿Tiene acceso al contexto?
+  if (!userContexts.includes(targetContext.context)) {
+    const fallback = list.find(ctx => userContexts.includes(ctx.context))
     if (fallback) {
       return navigateTo(fallback.home, { replace: true })
     }
@@ -76,8 +76,8 @@ export default defineNuxtRouteMiddleware(async (to) => {
   }
 
   // Sincronizar currentContext silenciosamente si cambia
-  if (authStore.currentContext !== targetApp.context) {
-    authStore.setCurrentContext(targetApp.context)
+  if (authStore.currentContext !== targetContext.context) {
+    authStore.setCurrentContext(targetContext.context)
     try {
       const { fetchMe } = useAuth()
       await fetchMe()

package/nuxt.config.ts

@@ -13,7 +13,7 @@ export default defineNuxtConfig({
     { path: './components', pathPrefix: true, prefix: '' },
   ],
   imports: {
-    dirs: ['stores', 'composables'],
+    dirs: ['stores', 'composables', 'composables/useWorkflow'],
     presets: [
       {
         from: '@tanstack/vue-query',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@innertia-solutions/innertia-nuxt",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Innertia Solutions — Nuxt layer unificada: core, auth, multitenancy, theme y app contexts",
   "keywords": [
     "nuxt",
@@ -24,11 +24,11 @@
     "./theme.css": "./theme.css"
   },
   "peerDependencies": {
+    "@pinia/nuxt": ">=0.11.0",
     "nuxt": ">=4.0.0",
-    "vue": ">=3.5.0",
     "pinia": ">=3.0.0",
-    "@pinia/nuxt": ">=0.11.0",
-    "pinia-plugin-persistedstate": ">=4.0.0"
+    "pinia-plugin-persistedstate": ">=4.0.0",
+    "vue": ">=3.5.0"
   },
   "dependencies": {
     "@nuxtjs/seo": "^3.4.0",
@@ -39,7 +39,11 @@
     "@tailwindcss/vite": "^4.0.0",
     "@tanstack/vue-query": "^5.100.10",
     "@tanstack/vue-table": "^8.21.3",
+    "@vue-flow/background": "^1.3.2",
+    "@vue-flow/controls": "^1.1.3",
+    "@vue-flow/core": "^1.48.2",
     "@vueuse/core": "^14.3.0",
+    "apexcharts": "^5.13.0",
     "date-fns": "^4.1.0",
     "date-fns-tz": "^3.2.0",
     "dayjs": "^1.11.0",
@@ -48,13 +52,14 @@
     "pusher-js": "^8.5.0",
     "tailwindcss": "^4.0.0",
     "uuid": "^13.0.0",
-    "vanilla-calendar-pro": "^3.1.0"
+    "vanilla-calendar-pro": "^3.1.0",
+    "vue3-apexcharts": "^1.11.1"
   },
   "devDependencies": {
-    "nuxt": "^4.4.2",
-    "vue": "^3.5.0",
     "@pinia/nuxt": "^0.11.3",
+    "nuxt": "^4.4.2",
     "pinia": "^3.0.4",
-    "pinia-plugin-persistedstate": "^4.7.1"
+    "pinia-plugin-persistedstate": "^4.7.1",
+    "vue": "^3.5.0"
   }
 }

package/stores/modal.js

@@ -0,0 +1,48 @@
+// stores/modal.js
+import { defineStore } from 'pinia'
+import { markRaw } from 'vue'
+
+/**
+ * Cola de modales programáticos. Renderizada por <ModalHost />.
+ *
+ * Cada entry: { id, kind: 'confirm'|'alert'|'prompt'|'component',
+ *               props: object, component?: Component, resolve: fn }
+ *
+ * `component` se guarda con markRaw para que Pinia no lo reactivee.
+ */
+let _id = 0
+const nextId = () => `m${++_id}`
+
+export const useModalStore = defineStore('modal', {
+  state: () => ({
+    queue: [],
+  }),
+  actions: {
+    push(entry) {
+      this.queue.push(entry)
+      return entry.id
+    },
+    remove(id) {
+      const idx = this.queue.findIndex(e => e.id === id)
+      if (idx !== -1) this.queue.splice(idx, 1)
+    },
+    resolve(id, value) {
+      const entry = this.queue.find(e => e.id === id)
+      if (!entry) return
+      entry.resolve(value)
+      this.remove(id)
+    },
+    /** Crea entry + devuelve Promise que se resuelve con .resolve(id, value) */
+    open({ kind, props = {}, component = null }) {
+      return new Promise((resolve) => {
+        this.push({
+          id: nextId(),
+          kind,
+          props,
+          component: component ? markRaw(component) : null,
+          resolve,
+        })
+      })
+    },
+  },
+})

package/stores/toast.js

@@ -1,129 +1,168 @@
 // stores/toast.js
 import { defineStore } from 'pinia'
-import { v4 as uuid } from 'uuid'
+import { markRaw } from 'vue'
 
-const toastConfig = {
-    severity: 'info',
-    title: null,
-    message: null,
-    duration: 5000,
-    progress: true,
-    position: 'top-right',
-    icon: null,
+/**
+ * Store unificado de toasts. Soporta tres variants:
+ *
+ *  - 'alert'  → toast simple con severity + título opcional + mensaje
+ *  - 'notification' → más prominente, soporta acción y no auto-dismiss
+ *  - 'process' → con barra de progreso, no auto-dismiss
+ *
+ * Y 6 posiciones: top-left|center|right · bottom-left|center|right
+ *
+ * Action opcional para cualquier variant:
+ *   action: { label: 'Deshacer', onClick: () => { ... } }
+ */
+
+const POSITIONS = ['top-left','top-center','top-right','bottom-left','bottom-center','bottom-right']
+const SEVERITIES = ['success','error','warning','info']
+
+const DEFAULTS = {
+  variant: 'alert',
+  severity: 'info',
+  position: 'top-right',
+  duration: 5000,
+  closable: true,
+}
+
+let _id = 0
+const nextId = () => `t${++_id}`
+
+function normalize(input, override = {}) {
+  const cfg = typeof input === 'string' ? { message: input } : { ...input }
+  const merged = { ...DEFAULTS, ...cfg, ...override }
+  if (!POSITIONS.includes(merged.position)) merged.position = 'top-right'
+  if (merged.action && typeof merged.action.onClick === 'function') {
+    // Pinia evita reactivear funciones — markRaw el objeto
+    merged.action = markRaw(merged.action)
+  }
+  return { ...merged, id: nextId(), createdAt: Date.now() }
 }
 
 export const useToastStore = defineStore('toast', {
-    state: () => ({
-        toasts: {
-            'top-left': [],
-            'top-center': [],
-            'top-right': [],
-            'bottom-left': [],
-            'bottom-center': [],
-            'bottom-right': [],
-        },
-        timeouts: {}, // id → timeoutId (plain object, JSON-safe)
-    }),
-    actions: {
-        success(config) {
-            const normalizedConfig = typeof config === 'string' ? { message: config } : config
-            const toast = {
-                ...toastConfig,
-                id: uuid(),
-                severity: 'success',
-                icon: 'ti ti-circle-check text-green-500',
-                position: 'top-center',
-                ...normalizedConfig,
-            }
-            this.toasts[toast.position].push(toast)
-            this._scheduleRemoval(toast)
-        },
-        info(config) {
-            const normalizedConfig = typeof config === 'string' ? { message: config } : config
-            const toast = {
-                ...toastConfig,
-                id: uuid(),
-                severity: 'info',
-                icon: 'ti ti-info-circle',
-                title: 'Info',
-                position: 'top-right',
-                ...normalizedConfig,
-            }
-            this.toasts[toast.position].push(toast)
-            this._scheduleRemoval(toast)
-        },
-        error(config) {
-            const normalizedConfig = typeof config === 'string' ? { message: config } : config
-            const toast = {
-                ...toastConfig,
-                id: uuid(),
-                severity: 'danger',
-                icon: 'ti ti-exclamation-circle',
-                title: 'Atención',
-                position: 'top-right',
-                ...normalizedConfig,
-            }
-            this.toasts[toast.position].push(toast)
-            this._scheduleRemoval(toast)
-        },
-        show(config) {
-            const toast = {
-                id: uuid(),
-                severity: 'info',
-                position: 'top-right',
-                ...toastConfig,
-                ...config,
-            }
-            this.toasts[toast.position].push(toast)
-            this._scheduleRemoval(toast)
-        },
-        update(id, data) {
-            for (const key in this.toasts) {
-                const idx = this.toasts[key].findIndex(t => t.id === id)
-                if (idx !== -1) {
-                    this.toasts[key][idx] = { ...this.toasts[key][idx], ...data }
-                    break
-                }
-            }
-        },
-        remove(id) {
-            if (this.timeouts[id] !== undefined) {
-                clearTimeout(this.timeouts[id])
-                delete this.timeouts[id]
-            }
+  state: () => ({
+    toasts: Object.fromEntries(POSITIONS.map(p => [p, []])),
+    timeouts: {},
+  }),
+  getters: {
+    flat(state) {
+      return POSITIONS.flatMap(p => state.toasts[p])
+    },
+  },
+  actions: {
+    _push(toast) {
+      this.toasts[toast.position].push(toast)
+      this._scheduleRemoval(toast)
+      return toast.id
+    },
+    _scheduleRemoval(toast) {
+      if (!toast.duration || toast.duration <= 0) return
+      const tid = setTimeout(() => this.dismiss(toast.id), toast.duration)
+      this.timeouts[toast.id] = tid
+    },
+
+    // ── API pública ──────────────────────────────────────────────────
+    show(config) {
+      return this._push(normalize(config))
+    },
+    success(input, config = {}) {
+      return this._push(normalize(input, { ...config, severity: 'success' }))
+    },
+    error(input, config = {}) {
+      return this._push(normalize(input, { ...config, severity: 'error', duration: config.duration ?? 7000 }))
+    },
+    warning(input, config = {}) {
+      return this._push(normalize(input, { ...config, severity: 'warning' }))
+    },
+    info(input, config = {}) {
+      return this._push(normalize(input, { ...config, severity: 'info' }))
+    },
 
-            for (const key in this.toasts) {
-                this.toasts[key] = this.toasts[key].filter(t => t.id !== id)
-            }
-        },
-        _scheduleRemoval(toast) {
-            if (toast.duration && toast.duration > 0) {
-                const timeoutId = setTimeout(() => {
-                    this.remove(toast.id)
-                }, toast.duration)
+    /** Notification — variant prominente, NO auto-dismiss por defecto. */
+    notify(config = {}) {
+      return this._push(normalize({ ...config, variant: 'notification', duration: config.duration ?? 0 }))
+    },
 
-                this.timeouts[toast.id] = timeoutId
-            }
-        },
+    /** Process — toast con barra de progreso. Devuelve id para actualizar. */
+    process(title, config = {}) {
+      return this._push(normalize({
+        ...config,
+        variant: 'process',
+        title,
+        progress: 0,
+        progressLabel: config.progressLabel ?? 'Iniciando…',
+        duration: 0,
+        closable: config.closable ?? false,
+      }))
+    },
 
-        // Método específico para actualizar progreso de un toast tipo process
-        updateProgress(id, progress, progressLabel = null) {
-            const updateData = { progress }
-            if (progressLabel) {
-                updateData.progressLabel = progressLabel
-            }
-            this.update(id, updateData)
-        },
+    update(id, patch) {
+      for (const p of POSITIONS) {
+        const idx = this.toasts[p].findIndex(t => t.id === id)
+        if (idx !== -1) {
+          this.toasts[p][idx] = { ...this.toasts[p][idx], ...patch }
+          return
+        }
+      }
+    },
+    updateProgress(id, progress, progressLabel) {
+      const patch = { progress: Math.min(100, Math.max(0, progress)) }
+      if (progressLabel != null) patch.progressLabel = progressLabel
+      this.update(id, patch)
+    },
+    completeProcess(id, message = 'Completado') {
+      this.update(id, {
+        progress: 100,
+        progressLabel: message,
+        severity: 'success',
+        closable: true,
+      })
+      // Auto-dismiss después de 2.5s
+      const tid = setTimeout(() => this.dismiss(id), 2500)
+      this.timeouts[id] = tid
+    },
+    failProcess(id, message = 'Error') {
+      this.update(id, {
+        progressLabel: message,
+        severity: 'error',
+        closable: true,
+        duration: 7000,
+      })
+      const tid = setTimeout(() => this.dismiss(id), 7000)
+      this.timeouts[id] = tid
+    },
 
-        // Método para completar un proceso
-        completeProcess(id, message = 'Completado') {
-            this.update(id, {
-                progress: 100,
-                progressLabel: message,
-                duration: 3000, // Auto-remove después de completar
-            })
-            // Programar removal para el proceso completado
-            this._scheduleRemoval({ id, duration: 3000 })
-        },
+    dismiss(id) {
+      if (this.timeouts[id] != null) {
+        clearTimeout(this.timeouts[id])
+        delete this.timeouts[id]
+      }
+      for (const p of POSITIONS) {
+        const idx = this.toasts[p].findIndex(t => t.id === id)
+        if (idx !== -1) {
+          this.toasts[p].splice(idx, 1)
+          return
+        }
+      }
     },
+    clear(position) {
+      if (position && this.toasts[position]) {
+        for (const t of this.toasts[position]) {
+          if (this.timeouts[t.id]) { clearTimeout(this.timeouts[t.id]); delete this.timeouts[t.id] }
+        }
+        this.toasts[position] = []
+      } else {
+        for (const p of POSITIONS) {
+          for (const t of this.toasts[p]) {
+            if (this.timeouts[t.id]) { clearTimeout(this.timeouts[t.id]); delete this.timeouts[t.id] }
+          }
+          this.toasts[p] = []
+        }
+      }
+    },
+
+    // ── Compat (deprecated) ────────────────────────────────────────
+    remove(id) { this.dismiss(id) },
+  },
 })

package/composables/useApp.ts

@@ -1,46 +0,0 @@
-import type { AppDefinition } from '../app.config'
-
-/**
- * Devuelve metadata del app actual + listas filtradas por permisos del usuario.
- * Lee la declaración de apps desde `appConfig.innertia.apps` (configurable por
- * el producto en su `nuxt.config.ts`).
- *
- * Uso típico:
- *   const { current, accessible } = useApp()
- *   <h1>Estás en: {{ current?.label }}</h1>
- */
-export function useApp() {
-  const route = useRoute()
-  const authStore = useAuthStore()
-  const appConfig = useAppConfig()
-
-  /** Diccionario de apps declarados por el producto. */
-  const apps = computed<Record<string, AppDefinition>>(() =>
-    (appConfig.innertia?.apps ?? {}) as Record<string, AppDefinition>
-  )
-
-  /** Todos los apps declarados, en orden de declaración. */
-  const all = computed<AppDefinition[]>(() => Object.values(apps.value))
-
-  /** App actual, determinado por el prefijo de la ruta. `null` si la URL no cae en ningún app. */
-  const current = computed<AppDefinition | null>(() => {
-    return all.value.find(app =>
-      route.path === app.path || route.path.startsWith(app.path + '/')
-    ) ?? null
-  })
-
-  /** Apps a los que el usuario autenticado tiene acceso (filtrado por `availableContexts`). */
-  const accessible = computed<AppDefinition[]>(() => {
-    const ctxs = (authStore.availableContexts ?? []) as string[]
-    return all.value.filter(app => ctxs.includes(app.context))
-  })
-
-  /** Helper: ¿el usuario puede acceder a este app? */
-  function canAccess(appKey: string): boolean {
-    const app = apps.value[appKey]
-    if (!app) return false
-    return ((authStore.availableContexts ?? []) as string[]).includes(app.context)
-  }
-
-  return { current, all, accessible, canAccess, apps }
-}