@saasicat/ui-vue 0.2.0

package/src/create-super-admin-app.ts

@@ -0,0 +1,345 @@
+// createSuperAdminApp — universal bootstrap helper for SuperAdmin Vue apps.
+// Bundles the Quasar/Pinia/Router setup that every consumer app rebuilds itself
+// today, and exposes the platform contract maps (`extensions:`, `actions:`)
+// via `provide()`.
+//
+// What the helper does NOT do:
+//   - Auth stores, login flows, JWT refresh — app-specific.
+//   - CSS imports (Quasar CSS, Material Icons, app theme) — these stay in the
+//     app's own `main.ts`, because tsup does not bundle CSS.
+
+import { createApp, type App, type Component, type InjectionKey } from 'vue';
+import { Quasar, Notify, Dialog, Loading, type QuasarPluginOptions } from 'quasar';
+import { createPinia, type Pinia } from 'pinia';
+import {
+    createRouter,
+    createWebHistory,
+    type NavigationGuardWithThis,
+    type RouteLocationNormalized,
+    type RouteRecordRaw,
+    type Router,
+    type RouterHistory,
+} from 'vue-router';
+
+import type { ActionKey, AdminManifest, ComponentKey } from '@saasicat/types';
+import type { ActionHandler } from './action-registry.js';
+import { defaultHttpClient, type HttpClient } from './types.js';
+
+/**
+ * App-specific branding data that the platform `AdminLayout` and other
+ * consumers read via `useSuperAdminBrand()`.
+ */
+export interface SuperAdminBrand {
+    /** 2-letter abbreviation in the logo badge (`'ma'`, `'da'`, …). */
+    logoText: string;
+    /** Full display name (`'DemoApp'`, `'ClubApp'`, …). */
+    name: string;
+    /** Optional: tag to the right of the name, default `'SuperAdmin'`. */
+    tag?: string;
+}
+
+/**
+ * Endpoint configuration. `apiBase` is the shared prefix under which
+ * `/manifest`, `/boot` and extra routes live.
+ */
+export interface SuperAdminEndpoints {
+    /** Shared prefix, e.g. `'/api/admin'` or `'/api/v1/admin'`. */
+    apiBase: string;
+    /** Pre-login branding endpoint, default `${apiBase}/boot`. */
+    publicBootEndpoint?: string;
+    /** Post-login full-manifest endpoint, default `${apiBase}/manifest`. */
+    manifestEndpoint?: string;
+}
+
+export type ExtensionLoader = () => Promise<Component | { default: Component }>;
+export type ExtensionsMap = Record<ComponentKey, ExtensionLoader>;
+export type ActionsMap = Record<ActionKey, ActionHandler>;
+
+export interface SuperAdminAuthGuardOptions {
+    /** App provides: is the user currently logged in? */
+    isAuthenticated: () => boolean;
+    /** App provides: does the user have the SuperAdmin role? Default: only check `isAuthenticated`. */
+    isSuperAdmin?: () => boolean;
+    /** App provides: redirect path for unauthenticated calls (e.g. `'/login'`). */
+    onUnauthenticated: () => string;
+}
+
+/**
+ * Result of a login attempt. Apps pass this back from their auth store to the
+ * platform LoginPage; the page renders an appropriate error message.
+ *
+ * `ok: true` → login succeeded, page redirects to `redirectAfterLogin`.
+ * `ok: false` → page shows `message` or a translation derived from `code`.
+ *
+ * Known codes:
+ *   - `BAD_CREDENTIALS` — wrong email/password combination.
+ *   - `NOT_SUPER_ADMIN` — account does not have the SuperAdmin role.
+ *   - otherwise          — app-specific; `message` is displayed directly.
+ */
+export type SuperAdminLoginResult =
+    | { ok: true }
+    | { ok: false; code?: 'BAD_CREDENTIALS' | 'NOT_SUPER_ADMIN' | string; message?: string };
+
+/**
+ * Login adapter. The app passes its auth-store call through here. The platform
+ * LoginPage consumes it via `useSuperAdminLoginAdapter()`, without knowledge
+ * of app-specific stores (Pinia, auth API routes, MFA hooks).
+ */
+export interface SuperAdminLoginAdapter {
+    /**
+     * Performs the login. The app store encapsulates the API call, token
+     * storage, MFA hops etc.
+     */
+    login(email: string, password: string): Promise<SuperAdminLoginResult>;
+    /**
+     * Target route after a successful login. Default: `/admin/dashboard`
+     * (platform convention for the standard pages — apps with a different
+     * default mount override this here).
+     */
+    redirectAfterLogin?: string;
+    /**
+     * Optional: dev hint (test account), shown below the form. Deliberately
+     * rendered only when `environment !== 'production'`.
+     */
+    devHint?: { email: string; password: string };
+}
+
+export interface SuperAdminManifestGuardOptions {
+    /**
+     * App provides: loads the manifest into the app store. The router guard
+     * `await`s the promise before the route is resolved.
+     *
+     * **On loader error:** the promise REJECTS. The router guard catches the
+     * rejection and decides depending on `errorRoute`:
+     *   - `errorRoute` set → redirect to this route (fail-closed).
+     *   - `errorRoute` not set → `console.error` + render allowed
+     *     (defensive default behavior; the app must render the manifest gap
+     *     itself).
+     */
+    ensureLoaded: () => Promise<void>;
+    /**
+     * Optional: read accessor on the loaded manifest. When set, it is exposed
+     * via `provide(SUPER_ADMIN_MANIFEST_KEY)` — the `<ProjectPageHost>`
+     * resolves manifest `projectPages` through it against the
+     * `extensions:` map.
+     */
+    getManifest?: () => AdminManifest | null;
+    /**
+     * Optional: path that the router guard redirects to on a manifest load
+     * error (fail-closed mode). The app must register the route in `appRoutes`
+     * and mark it as `meta.public = true`, otherwise it runs through the
+     * manifest guard again and produces a redirect loop.
+     */
+    errorRoute?: string;
+}
+
+export interface CreateSuperAdminAppOptions {
+    /** App root component (`App.vue`). */
+    rootComponent: Component;
+    /** App branding (logo, name). */
+    brand: SuperAdminBrand;
+    /** Endpoint configuration. */
+    endpoints: SuperAdminEndpoints;
+    /** App's own routes (login, standard pages, bundle pages, …). */
+    appRoutes: RouteRecordRaw[];
+    /**
+     * Static `extensions:` map. Manifest `projectPages[].componentKey` is
+     * looked up in it (see Spec §4.4).
+     */
+    extensions?: ExtensionsMap;
+    /**
+     * Static `actions:` map. Manifest `tenants.actions[].actionKey` is looked
+     * up in it.
+     */
+    actions?: ActionsMap;
+    /**
+     * Optional: auth guard. When set, `router.beforeEach` is wired up
+     * automatically — `to.meta.public === true` bypasses the guard.
+     */
+    authGuard?: SuperAdminAuthGuardOptions;
+    /**
+     * Optional: manifest guard. Runs after a successful auth guard, blocks the
+     * render until the manifest is loaded (prevents sidebar flicker).
+     */
+    manifestGuard?: SuperAdminManifestGuardOptions;
+    /**
+     * Optional: login adapter. When set, it is exposed via `provide()` for the
+     * shared `<SuperAdminLoginPage>` (from `pages-standard/`) — the app no
+     * longer needs to hold its own LoginPage Vue component.
+     */
+    loginAdapter?: SuperAdminLoginAdapter;
+    /**
+     * Optional: router history variant, default `createWebHistory()`.
+     * Apps with a subpath mount override this.
+     */
+    routerHistory?: RouterHistory;
+    /**
+     * Optional: Quasar configuration. Default loads `Notify`/`Dialog`/`Loading`
+     * with the established consumer convention (`top-right`, 3 s).
+     */
+    quasarOptions?: Partial<QuasarPluginOptions>;
+    /**
+     * Optional: additional Vue plugins (e.g. an app's own NotificationCenter)
+     * that are installed after the platform setup, before the mount.
+     */
+    installPlugins?: Array<(app: App) => void>;
+    /**
+     * Optional: `HttpClient` for all pre-login calls (boot, first-run setup).
+     * Default `defaultHttpClient()` (= `fetch`). Consumers pass their own
+     * variant through (auth header, baseURL, retry) — it then applies uniformly,
+     * including for the setup wizard. Consumed via `useSuperAdminHttp()`.
+     */
+    http?: HttpClient;
+}
+
+export interface SuperAdminAppHandle {
+    app: App;
+    router: Router;
+    pinia: Pinia;
+    /** Mounts the app on a selector. Returns the root component instance. */
+    mount: (selector: string | Element) => ReturnType<App['mount']>;
+}
+
+// Vue inject keys are registered globally via `Symbol.for(...)`. Reason:
+// apps import `createSuperAdminApp` (and thus `app.provide(KEY, ...)`) from
+// the built `dist/index.js` bundle, but shared `.vue` pages in the
+// `pages-standard/` directory directly from `src/`. Both paths produce two
+// independent module instances — with local `Symbol(...)` the identity would
+// differ, and `inject()` would always throw "not found". `Symbol.for(...)`
+// resolves both imports to the same symbol.
+
+/** Vue inject key for `useSuperAdminBrand()`. */
+export const SUPER_ADMIN_BRAND_KEY: InjectionKey<SuperAdminBrand> = Symbol.for(
+    '@saasicat/ui-vue/SUPER_ADMIN_BRAND',
+);
+/** Vue inject key for `useSuperAdminEndpoints()`. */
+export const SUPER_ADMIN_ENDPOINTS_KEY: InjectionKey<Required<SuperAdminEndpoints>> = Symbol.for(
+    '@saasicat/ui-vue/SUPER_ADMIN_ENDPOINTS',
+);
+/** Vue inject key for `useSuperAdminExtensions()`. */
+export const SUPER_ADMIN_EXTENSIONS_KEY: InjectionKey<ExtensionsMap> = Symbol.for(
+    '@saasicat/ui-vue/SUPER_ADMIN_EXTENSIONS',
+);
+/** Vue inject key for `useSuperAdminActions()`. */
+export const SUPER_ADMIN_ACTIONS_KEY: InjectionKey<ActionsMap> = Symbol.for(
+    '@saasicat/ui-vue/SUPER_ADMIN_ACTIONS',
+);
+/**
+ * Vue inject key for the manifest accessor. Only provided when
+ * `manifestGuard.getManifest` was passed to `createSuperAdminApp()` — the
+ * `<ProjectPageHost>` needs it to resolve project pages.
+ */
+export const SUPER_ADMIN_MANIFEST_KEY: InjectionKey<() => AdminManifest | null> = Symbol.for(
+    '@saasicat/ui-vue/SUPER_ADMIN_MANIFEST',
+);
+/** Vue inject key for `useSuperAdminLoginAdapter()`. */
+export const SUPER_ADMIN_LOGIN_ADAPTER_KEY: InjectionKey<SuperAdminLoginAdapter> = Symbol.for(
+    '@saasicat/ui-vue/SUPER_ADMIN_LOGIN_ADAPTER',
+);
+/** Vue inject key for `useSuperAdminHttp()` (pre-login HttpClient). */
+export const SUPER_ADMIN_HTTP_KEY: InjectionKey<HttpClient> = Symbol.for(
+    '@saasicat/ui-vue/SUPER_ADMIN_HTTP',
+);
+
+const DEFAULT_QUASAR_OPTIONS: QuasarPluginOptions = {
+    plugins: { Notify, Dialog, Loading },
+    config: { notify: { position: 'top-right', timeout: 3000 } },
+};
+
+/**
+ * Universal bootstrap function for SuperAdmin apps. Replaces the `main.ts`
+ * boilerplate duplicated per app today (Quasar + Pinia + Router + manifest
+ * guard) and exposes the platform maps via `provide()` for downstream
+ * components.
+ */
+export function createSuperAdminApp(options: CreateSuperAdminAppOptions): SuperAdminAppHandle {
+    const app = createApp(options.rootComponent);
+
+    app.use(Quasar, options.quasarOptions ?? DEFAULT_QUASAR_OPTIONS);
+
+    const pinia = createPinia();
+    app.use(pinia);
+
+    const router = createRouter({
+        history: options.routerHistory ?? createWebHistory(),
+        routes: options.appRoutes,
+    });
+
+    const navGuard = buildNavigationGuard(options);
+    if (navGuard) {
+        router.beforeEach(navGuard);
+    }
+
+    app.use(router);
+
+    const endpoints: Required<SuperAdminEndpoints> = {
+        apiBase: options.endpoints.apiBase,
+        publicBootEndpoint:
+            options.endpoints.publicBootEndpoint ?? `${options.endpoints.apiBase}/boot`,
+        manifestEndpoint:
+            options.endpoints.manifestEndpoint ?? `${options.endpoints.apiBase}/manifest`,
+    };
+
+    app.provide(SUPER_ADMIN_BRAND_KEY, { tag: 'SuperAdmin', ...options.brand });
+    app.provide(SUPER_ADMIN_ENDPOINTS_KEY, endpoints);
+    app.provide(SUPER_ADMIN_EXTENSIONS_KEY, options.extensions ?? {});
+    app.provide(SUPER_ADMIN_ACTIONS_KEY, options.actions ?? {});
+    if (options.manifestGuard?.getManifest) {
+        app.provide(SUPER_ADMIN_MANIFEST_KEY, options.manifestGuard.getManifest);
+    }
+    if (options.loginAdapter) {
+        app.provide(SUPER_ADMIN_LOGIN_ADAPTER_KEY, options.loginAdapter);
+    }
+    app.provide(SUPER_ADMIN_HTTP_KEY, options.http ?? defaultHttpClient());
+
+    for (const plugin of options.installPlugins ?? []) {
+        plugin(app);
+    }
+
+    return {
+        app,
+        router,
+        pinia,
+        mount: (selector) => app.mount(selector),
+    };
+}
+
+/**
+ * Internal helper, exported for isolated unit tests of the navigation
+ * behavior (auth redirect, manifest fail-closed path). Consumers should call
+ * `createSuperAdminApp()`, not this helper directly.
+ */
+export function buildNavigationGuard(
+    options: Pick<CreateSuperAdminAppOptions, 'authGuard' | 'manifestGuard'>,
+): NavigationGuardWithThis<undefined> | null {
+    const { authGuard, manifestGuard } = options;
+    if (!authGuard && !manifestGuard) return null;
+
+    return async (to: RouteLocationNormalized) => {
+        if (to.meta?.public === true) return true;
+
+        if (authGuard) {
+            if (!authGuard.isAuthenticated()) return authGuard.onUnauthenticated();
+            if (authGuard.isSuperAdmin && !authGuard.isSuperAdmin()) {
+                return authGuard.onUnauthenticated();
+            }
+        }
+
+        if (manifestGuard) {
+            try {
+                await manifestGuard.ensureLoaded();
+            } catch (err) {
+                if (manifestGuard.errorRoute && to.path !== manifestGuard.errorRoute) {
+                    return manifestGuard.errorRoute;
+                }
+                // No errorRoute configured — defensive fallback: warn, allow
+                // render. The app can detect the error via the store
+                // (`error.value`) and render a banner/stub.
+
+                console.error('[SuperAdmin] manifest load failed', err);
+            }
+        }
+
+        return true;
+    };
+}

package/src/entitlement-provider.ts

@@ -0,0 +1,36 @@
+// Entitlement provider — app-wide inject key for FeatureGate / router guard.
+//
+// Consumers call `provideEntitlement(app, ent)` once at app bootstrap,
+// where `ent` is the result of `useEntitlement({...})`. Afterwards
+// <FeatureGate> components and the router guard can access it without
+// reconfiguring the endpoint.
+//
+// `Symbol.for(...)` so that multi-bundle setups (app bundle + pages bundle)
+// resolve to the same identity — analogous to the inject keys in
+// create-super-admin-app.
+//
+// Spec: handoff/superadmin/QUICKSTART_SIMPLIFICATIONS.md §P8.
+
+import { inject, type App, type InjectionKey } from 'vue';
+import type { UseEntitlementResult } from './use-entitlement.js';
+
+export const ENTITLEMENT_INJECTION_KEY: InjectionKey<UseEntitlementResult> = Symbol.for(
+    '@saasicat/ui-vue/ENTITLEMENT',
+);
+
+/**
+ * Binds a `useEntitlement(...)` result for the whole app so that
+ * `<FeatureGate>` and router guards can inject it.
+ */
+export function provideEntitlement(app: App, entitlement: UseEntitlementResult): void {
+    app.provide(ENTITLEMENT_INJECTION_KEY, entitlement);
+}
+
+/**
+ * Fetches the bound entitlement result. Returns `null` when the
+ * consumer did not call `provideEntitlement(...)` — `<FeatureGate>`
+ * then falls back to "everything allowed" (with a dev warning).
+ */
+export function useInjectedEntitlement(): UseEntitlementResult | null {
+    return inject(ENTITLEMENT_INJECTION_KEY, null);
+}

package/src/feature-router-guard.ts

@@ -0,0 +1,77 @@
+// Feature router guard — Vue Router `beforeEach` that checks routes with
+// `meta.requiresFeature` against the entitlement source of truth.
+//
+// Usage (in the app router setup, alternatively via createSuperAdminApp):
+//
+// ```ts
+// import { useEntitlement, buildFeatureRouterGuard } from '@saasicat/ui-vue';
+// const ent = useEntitlement({ endpoint: '/api/billing/entitlement' });
+// router.beforeEach(buildFeatureRouterGuard({
+//     getEntitlement: () => ent,
+//     redirectTo: '/upgrade',
+// }));
+// ```
+//
+// Route meta:
+//
+// ```ts
+// { path: '/dms', component: DmsPage, meta: { requiresFeature: 'DMS' } }
+// { path: '/x',   component: XPage,   meta: { requiresFeature: ['DMS', 'STORAGE_PRO'] } }
+// ```
+//
+// Spec: handoff/superadmin/QUICKSTART_SIMPLIFICATIONS.md §P8.
+
+import type { NavigationGuardWithThis, RouteLocationNormalized } from 'vue-router';
+import type { UseEntitlementResult } from './use-entitlement.js';
+
+export interface FeatureRouterGuardOptions {
+    /**
+     * Returns the current entitlement. Deliberately a factory (instead of
+     * passing a ref directly), so the app can lazy-load the entitlement and
+     * re-bind it — e.g. after a plan change or logout/re-login.
+     */
+    getEntitlement: () => UseEntitlementResult | null;
+    /**
+     * Where to redirect when a feature is missing. Default: no redirect, but
+     * `next(false)` (route blocks). Apps with an upgrade page set
+     * `'/upgrade'`.
+     */
+    redirectTo?: string;
+    /**
+     * `true` (default): entitlement not yet loaded → let through,
+     * so the first render doesn't hang. `false`: blocks until the entitlement
+     * is there (user sees a white screen if the endpoint is slow — only
+     * sensible in apps with pre-login load).
+     */
+    allowWhileLoading?: boolean;
+}
+
+function extractRequired(to: RouteLocationNormalized): string[] {
+    const raw = (to.meta as { requiresFeature?: string | string[] } | undefined)?.requiresFeature;
+    if (!raw) return [];
+    return Array.isArray(raw) ? raw : [raw];
+}
+
+export function buildFeatureRouterGuard(
+    options: FeatureRouterGuardOptions,
+): NavigationGuardWithThis<undefined> {
+    return function featureGuard(to, _from, next) {
+        const required = extractRequired(to);
+        if (required.length === 0) return next();
+        const ent = options.getEntitlement();
+        if (!ent) {
+            // No provider — let through (this prevents the whole app
+            // from stalling if the app registered the guard but the
+            // entitlement isn't there yet).
+            return next();
+        }
+        const allowLoading = options.allowWhileLoading !== false;
+        if (allowLoading && ent.loading.value && ent.entitlement.value === null) {
+            return next();
+        }
+        const allowed = required.some((f) => ent.hasFeature(f));
+        if (allowed) return next();
+        if (options.redirectTo) return next(options.redirectTo);
+        return next(false);
+    };
+}

package/src/http-json.ts

@@ -0,0 +1,62 @@
+// Shared JSON helpers over the injectable `HttpClient`. A single
+// request/error path for all pre-login calls (boot, setup status, setup),
+// instead of raw `fetch` with divergent error handling per component. A
+// consumer `HttpClient` (auth header, baseURL, retry) then applies everywhere.
+
+import type { HttpClient } from './types.js';
+
+/**
+ * Error for non-2xx responses. `code` is the machine-readable error code
+ * from the JSON body (`{ code }`), if present — callers map it to
+ * a message (e.g. via `SETUP_ERROR_CODES`).
+ */
+export class HttpJsonError extends Error {
+    constructor(
+        readonly status: number,
+        readonly code?: string,
+    ) {
+        super(code ?? `HTTP ${status}`);
+        this.name = 'HttpJsonError';
+    }
+}
+
+async function extractCode(res: { json(): Promise<unknown> }): Promise<string | undefined> {
+    try {
+        const body = (await res.json()) as { code?: unknown } | null;
+        return typeof body?.code === 'string' ? body.code : undefined;
+    } catch {
+        return undefined;
+    }
+}
+
+/**
+ * Removes trailing slashes so an API prefix can be concatenated with paths
+ * that start with `/`. Deliberately index-based instead of
+ * `replace(/\/+$/, '')`: the regex backtracks quadratically on inputs that
+ * end in many slashes.
+ */
+export function trimTrailingSlashes(url: string): string {
+    let end = url.length;
+    while (end > 0 && url[end - 1] === '/') end--;
+    return url.slice(0, end);
+}
+
+export async function getJson<T>(http: HttpClient, url: string): Promise<T> {
+    const res = await http(url);
+    if (res.status < 200 || res.status >= 300) {
+        throw new HttpJsonError(res.status, await extractCode(res));
+    }
+    return (await res.json()) as T;
+}
+
+export async function postJson<T>(http: HttpClient, url: string, body: unknown): Promise<T> {
+    const res = await http(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (res.status < 200 || res.status >= 300) {
+        throw new HttpJsonError(res.status, await extractCode(res));
+    }
+    return (await res.json()) as T;
+}

package/src/index.ts

@@ -0,0 +1,98 @@
+// @saasicat/ui-vue — Vue 3 components + composables for the
+// SuperAdmin UI shell.
+//
+// P4.1 (Phase 30): public boot loader + manifest loader (ETag cache).
+// P4.2 (Phase 31): nav builder + extension host + action registry.
+// P4.3 (Phase 32): batch column fetcher.
+// P4.4 (Phase 33): composables for standard pages (Tenants, Audit, Entitlement).
+// P4.5 (Phase 34): plan-versions list composables + bulk-publish orchestration.
+//
+// Contents:
+//   - types:                HttpClient, KvStore, defaultHttpClient, defaultKvStore
+//   - boot-loader:          BootLoader (framework-agnostic) + BootLoadError
+//   - manifest-loader:      ManifestLoader with ETag cache + ManifestLoadError
+//   - nav-builder:          buildRoutes, buildSidebar, resolveExtension
+//   - action-registry:      ActionRegistry, MissingHandlerError, ActionDefNotInManifestError
+//   - batch-column-fetcher: BatchColumnFetcher + BatchColumnDriftError
+//   - use-api-list:         useApiList<T> generic list composable
+//   - use-tenants:          useTenants typed wrapper
+//   - use-audit-entries:    useAuditEntries typed wrapper
+//   - use-entitlement:      useEntitlement composable
+//   - use-plan-versions:    usePlanVersionsCatalog
+//   - use-bulk-publish:     useBulkPublish (parallel publishes with status tracking)
+//   - use-plan-editor:      usePlanEditor composable (feature discovery, plannedOnly filter)
+//   - use-public-boot:      usePublicBoot composable
+//   - use-manifest:         useManifest composable
+//   - use-nav:              useNav composable
+//   - use-actions:          useActions composable
+//   - use-batch-columns:    useBatchColumns composable
+
+export * from './version.js';
+export * from './types.js';
+export * from './http-json.js';
+export * from './create-admin-routes.js';
+export * from './boot-loader.js';
+export * from './manifest-loader.js';
+export * from './nav-builder.js';
+export * from './action-registry.js';
+export * from './batch-column-fetcher.js';
+export * from './use-api-list.js';
+export * from './use-tenants.js';
+export * from './use-audit-entries.js';
+export * from './use-entitlement.js';
+export * from './use-tenant-manifest.js';
+export * from './entitlement-provider.js';
+export * from './feature-router-guard.js';
+// FeatureGate.vue is not bundled — consumers import it directly:
+//   import FeatureGate from '@saasicat/ui-vue/components/FeatureGate.vue';
+export * from './use-tenant-billing-catalog.js';
+export * from './use-tenant-billing.js';
+export * from './use-subscription-draft.js';
+export * from './pages-tenant/default-i18n.js';
+export * from './use-plan-versions.js';
+export * from './use-bulk-publish.js';
+export * from './use-plan-editor.js';
+export * from './use-public-boot.js';
+export * from './use-discovery.js';
+export * from './use-catalog-entries.js';
+export * from './use-bundles.js';
+export * from './use-bundle-versions-map.js';
+export * from './use-tenant-subscription-bundles.js';
+export * from './use-business-types.js';
+export * from './use-marketing-projections.js';
+export * from './use-promotions.js';
+export * from './use-plans.js';
+export * from './use-live-plan-versions.js';
+export * from './use-manifest.js';
+export * from './use-nav.js';
+export * from './use-actions.js';
+export * from './use-tenant-action-flow.js';
+export * from './use-platform-tenant-actions.js';
+export * from './use-batch-columns.js';
+export * from './plan-versions-catalog.js';
+// Platform dialog types for app wrappers that type submit handlers.
+export * from './components/dialogs/types.js';
+// Pure resolvers for translated feature/quota labels in the bundle editors.
+export * from './components/bundle-editor/catalog-i18n.js';
+// Types of the shared PlatformEmailPage (platform email sender).
+export * from './pages-standard/platform-email.types.js';
+// Types of the shared EmailHistoryPage (platform email history).
+export * from './pages-standard/email-history.types.js';
+// Universal bootstrap helper for SuperAdmin apps + associated composables.
+export * from './create-super-admin-app.js';
+export * from './use-super-admin-context.js';
+// Loader factory that builds BootLoader + ManifestLoader from the same
+// endpoint configuration as createSuperAdminApp() — so that endpoints live
+// in a single place per app.
+export * from './platform-loaders.js';
+// ProjectPageHost: resolves manifest projectPages dynamically against the
+// extensions: map — replaces static route duplication in the apps.
+export * from './project-page-host.js';
+// Manifest Pinia store factory — standardizes ensureLoaded/reload/clearCache.
+export * from './manifest-store-factory.js';
+
+// The shared SuperAdmin LoginPage lives at
+// `@saasicat/ui-vue/pages-standard/SuperAdminLoginPage.vue` —
+// not via bundle (tsup ignores .vue), but directly from src/ through the
+// subpath export. Apps pass a `loginAdapter` via createSuperAdminApp()
+// and route `/login` to this component.