@saasicat/ui-vue 0.2.0

package/dist/index.js

@@ -0,0 +1,3659 @@
+// src/version.ts
+var ADMIN_UI_VERSION = "1.2.0";
+
+// src/types.ts
+function defaultKvStore() {
+  if (typeof globalThis.localStorage === "undefined") {
+    return {
+      get: () => null,
+      set: () => {
+      },
+      remove: () => {
+      }
+    };
+  }
+  const ls = globalThis.localStorage;
+  return {
+    get: (k) => ls.getItem(k),
+    set: (k, v) => ls.setItem(k, v),
+    remove: (k) => ls.removeItem(k)
+  };
+}
+function defaultHttpClient() {
+  return (url, init) => fetch(url, init);
+}
+
+// src/http-json.ts
+var HttpJsonError = class extends Error {
+  constructor(status, code) {
+    super(code ?? `HTTP ${status}`);
+    this.status = status;
+    this.code = code;
+    this.name = "HttpJsonError";
+  }
+  status;
+  code;
+};
+async function extractCode(res) {
+  try {
+    const body = await res.json();
+    return typeof body?.code === "string" ? body.code : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function trimTrailingSlashes(url) {
+  let end = url.length;
+  while (end > 0 && url[end - 1] === "/") end--;
+  return url.slice(0, end);
+}
+async function getJson(http, url) {
+  const res = await http(url);
+  if (res.status < 200 || res.status >= 300) {
+    throw new HttpJsonError(res.status, await extractCode(res));
+  }
+  return await res.json();
+}
+async function postJson(http, url, body) {
+  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();
+}
+
+// src/project-page-host.ts
+import { computed, defineAsyncComponent, defineComponent, h, inject } from "vue";
+import { useRoute } from "vue-router";
+
+// src/create-super-admin-app.ts
+import { createApp } from "vue";
+import { Quasar, Notify, Dialog, Loading } from "quasar";
+import { createPinia } from "pinia";
+import {
+  createRouter,
+  createWebHistory
+} from "vue-router";
+var SUPER_ADMIN_BRAND_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/SUPER_ADMIN_BRAND"
+);
+var SUPER_ADMIN_ENDPOINTS_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/SUPER_ADMIN_ENDPOINTS"
+);
+var SUPER_ADMIN_EXTENSIONS_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/SUPER_ADMIN_EXTENSIONS"
+);
+var SUPER_ADMIN_ACTIONS_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/SUPER_ADMIN_ACTIONS"
+);
+var SUPER_ADMIN_MANIFEST_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/SUPER_ADMIN_MANIFEST"
+);
+var SUPER_ADMIN_LOGIN_ADAPTER_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/SUPER_ADMIN_LOGIN_ADAPTER"
+);
+var SUPER_ADMIN_HTTP_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/SUPER_ADMIN_HTTP"
+);
+var DEFAULT_QUASAR_OPTIONS = {
+  plugins: { Notify, Dialog, Loading },
+  config: { notify: { position: "top-right", timeout: 3e3 } }
+};
+function createSuperAdminApp(options) {
+  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 = {
+    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)
+  };
+}
+function buildNavigationGuard(options) {
+  const { authGuard, manifestGuard } = options;
+  if (!authGuard && !manifestGuard) return null;
+  return async (to) => {
+    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;
+        }
+        console.error("[SuperAdmin] manifest load failed", err);
+      }
+    }
+    return true;
+  };
+}
+
+// src/project-page-host.ts
+var asyncComponentCache = /* @__PURE__ */ new WeakMap();
+function resolveAsync(extensions, key) {
+  let bucket = asyncComponentCache.get(extensions);
+  if (!bucket) {
+    bucket = /* @__PURE__ */ new Map();
+    asyncComponentCache.set(extensions, bucket);
+  }
+  const cached = bucket.get(key);
+  if (cached) return cached;
+  const loader = extensions[key];
+  if (!loader) return null;
+  const cmp = defineAsyncComponent(loader);
+  bucket.set(key, cmp);
+  return cmp;
+}
+var ProjectPageHost = defineComponent({
+  name: "ProjectPageHost",
+  setup() {
+    const route = useRoute();
+    const extensions = inject(SUPER_ADMIN_EXTENSIONS_KEY, {});
+    const manifestAccessor = inject(SUPER_ADMIN_MANIFEST_KEY, null);
+    const matchingPage = computed(() => {
+      const manifest = manifestAccessor ? manifestAccessor() : null;
+      if (!manifest) return null;
+      const pages = manifest.navigation?.projectPages ?? [];
+      return pages.find((p) => p.route === route.path) ?? null;
+    });
+    const resolvedComponent = computed(() => {
+      const page = matchingPage.value;
+      if (!page) return null;
+      return resolveAsync(extensions, page.componentKey);
+    });
+    return () => {
+      const page = matchingPage.value;
+      const cmp = resolvedComponent.value;
+      if (page && cmp) return h(cmp);
+      return h("div", { class: "sa-project-page-host__missing", role: "alert" }, [
+        h("h2", "Seite nicht verf\xFCgbar"),
+        h(
+          "p",
+          page ? `componentKey "${page.componentKey}" ist nicht in der extensions:-Map registriert. Apps m\xFCssen die Komponente in createSuperAdminApp({ extensions }) eintragen.` : `Keine Manifest-Definition f\xFCr ${route.path}. Entweder fehlt die ProjectPage im Manifest, oder die Capability ist nicht aktiv.`
+        )
+      ]);
+    };
+  }
+});
+function createProjectPageHostRoute(options) {
+  return {
+    path: options?.path ?? ":projectPagePath(.+)",
+    component: ProjectPageHost,
+    meta: { isProjectPageHost: true }
+  };
+}
+
+// src/create-admin-routes.ts
+function createAdminRoutes(options) {
+  return [
+    {
+      path: "/login",
+      name: "login",
+      component: options.loginPage,
+      meta: { public: true }
+    },
+    {
+      // `meta.public: true` MUST be set, otherwise the route runs through
+      // the manifest guard again → redirect loop.
+      path: "/admin-error",
+      name: "admin-error",
+      component: options.adminErrorPage,
+      meta: { public: true }
+    },
+    {
+      path: "/admin",
+      component: options.adminLayout,
+      children: [
+        { path: "", redirect: options.dashboardPath ?? "/admin/dashboard" },
+        ...options.children,
+        // Catch-all for manifest ProjectPages — Vue Router 4 matches
+        // more specific children first; the host only steps in when
+        // no static page matches. MUST come last.
+        createProjectPageHostRoute()
+      ]
+    },
+    { path: "/", redirect: "/admin" },
+    { path: "/:pathMatch(.*)*", redirect: "/admin" }
+  ];
+}
+
+// src/boot-loader.ts
+var BootLoadError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "BootLoadError";
+  }
+  status;
+};
+var BootLoader = class {
+  endpoint;
+  http;
+  constructor(options) {
+    if (!options?.endpoint) {
+      throw new Error(
+        'BootLoader: `endpoint` ist Pflicht (z. B. "/api/admin/boot" oder "/api/v1/admin/boot"). Plattform hat keinen Default, weil Apps unterschiedliche globalPrefix-Konventionen haben.'
+      );
+    }
+    this.endpoint = options.endpoint;
+    this.http = options.http ?? defaultHttpClient();
+  }
+  async load() {
+    const res = await this.http(this.endpoint);
+    if (res.status !== 200) {
+      throw new BootLoadError(res.status, `Boot-Endpunkt antwortete HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+};
+
+// src/manifest-loader.ts
+var ManifestLoadError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ManifestLoadError";
+  }
+  status;
+};
+var ManifestLoader = class {
+  endpoint;
+  http;
+  storage;
+  bodyKey;
+  etagKey;
+  getAuthToken;
+  constructor(options) {
+    if (!options?.endpoint) {
+      throw new Error(
+        'ManifestLoader: `endpoint` ist Pflicht (z. B. "/api/admin/manifest" oder "/api/v1/admin/manifest"). Plattform hat keinen Default, weil Apps unterschiedliche globalPrefix-Konventionen haben.'
+      );
+    }
+    this.endpoint = options.endpoint;
+    this.http = options.http ?? defaultHttpClient();
+    this.storage = options.storage ?? defaultKvStore();
+    const prefix = options.storageKeyPrefix ?? "";
+    this.bodyKey = `${prefix}manifest:body`;
+    this.etagKey = `${prefix}manifest:etag`;
+    this.getAuthToken = options.getAuthToken;
+  }
+  /**
+   * Loads the current manifest. On a cache hit (304) the cached
+   * body is returned — otherwise the fresh server body.
+   */
+  async load() {
+    const cachedEtag = this.storage.get(this.etagKey);
+    const headers = {};
+    const token = this.getAuthToken?.();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    if (cachedEtag) headers["If-None-Match"] = cachedEtag;
+    const res = await this.http(this.endpoint, { method: "GET", headers });
+    if (res.status === 304) {
+      const cachedBody = this.readCachedBody();
+      if (!cachedBody) {
+        throw new ManifestLoadError(
+          304,
+          "Server lieferte 304, aber Cache-Body fehlt \u2014 bitte clearCache() + reload"
+        );
+      }
+      return cachedBody.body;
+    }
+    if (res.status !== 200) {
+      throw new ManifestLoadError(
+        res.status,
+        `Manifest-Endpunkt antwortete HTTP ${res.status}`
+      );
+    }
+    const body = await res.json();
+    const etag = res.headers.get("ETag") ?? res.headers.get("etag");
+    if (etag) {
+      this.storage.set(this.etagKey, etag);
+      this.storage.set(this.bodyKey, JSON.stringify(body));
+    }
+    return body;
+  }
+  /** Reads the cached manifest body from storage; null if absent. */
+  readCachedBody() {
+    const etag = this.storage.get(this.etagKey);
+    const bodyStr = this.storage.get(this.bodyKey);
+    if (!etag || !bodyStr) return null;
+    try {
+      return { etag, body: JSON.parse(bodyStr) };
+    } catch {
+      return null;
+    }
+  }
+  /** Clears the cache — e.g. on logout or after `manifest reload`. */
+  clearCache() {
+    this.storage.remove(this.etagKey);
+    this.storage.remove(this.bodyKey);
+  }
+};
+
+// src/nav-builder.ts
+var DEFAULT_STANDARD_PAGE_ROUTES = {
+  dashboard: "/admin/dashboard",
+  tenants: "/admin/tenants",
+  subscriptions: "/admin/subscriptions",
+  promoCodes: "/admin/promo-codes",
+  plans: "/admin/plans",
+  planVersions: "/admin/plan-versions",
+  audit: "/admin/audit",
+  users: "/admin/users",
+  pilots: "/admin/pilots",
+  discovery: "/admin/discovery",
+  bundles: "/admin/bundles",
+  businessTypes: "/admin/business-types",
+  marketingCatalog: "/admin/marketing-catalog",
+  platformEmail: "/admin/platform-email",
+  platformEmailHistory: "/admin/platform-email-history"
+};
+var DEFAULT_LABELS = {
+  dashboard: "Dashboard",
+  tenants: "Mandanten",
+  subscriptions: "Abonnements",
+  promoCodes: "Promo-Codes",
+  plans: "Pl\xE4ne & Versionen",
+  planVersions: "Plan-Versionen",
+  audit: "Audit-Log",
+  users: "Benutzer",
+  pilots: "Piloten",
+  discovery: "Discovery",
+  bundles: "Bundles",
+  businessTypes: "Gesch\xE4ftstypen",
+  marketingCatalog: "Marketing-Catalog",
+  platformEmail: "Plattform-E-Mail",
+  platformEmailHistory: "E-Mail-Verlauf"
+};
+var DEFAULT_ICONS = {
+  dashboard: "dashboard",
+  tenants: "business",
+  subscriptions: "card_membership",
+  promoCodes: "local_activity",
+  plans: "workspace_premium",
+  planVersions: "history_edu",
+  audit: "history",
+  users: "people",
+  pilots: "flight_takeoff",
+  discovery: "travel_explore",
+  bundles: "inventory_2",
+  businessTypes: "category",
+  marketingCatalog: "campaign",
+  platformEmail: "mail",
+  platformEmailHistory: "mark_email_read"
+};
+var DEFAULT_NAV_SECTIONS = {
+  dashboard: "\xDCbersicht",
+  discovery: "Produktkatalog",
+  businessTypes: "Produktkatalog",
+  bundles: "Produktkatalog",
+  plans: "Produktkatalog",
+  planVersions: "Produktkatalog",
+  marketingCatalog: "Produktkatalog",
+  promoCodes: "Produktkatalog",
+  tenants: "Kunden",
+  subscriptions: "Kunden",
+  users: "Kunden",
+  pilots: "Kunden",
+  audit: "System",
+  platformEmail: "System",
+  platformEmailHistory: "System"
+};
+var DEFAULT_SECTION_ORDER = [
+  "\xDCbersicht",
+  "Produktkatalog",
+  "Kunden",
+  "System"
+];
+function buildRoutes(manifest, options = {}) {
+  const routes = [];
+  const capabilities = manifest.capabilities ?? {};
+  const standard = manifest.navigation?.standardPages ?? {};
+  const overrideRoutes = { ...DEFAULT_STANDARD_PAGE_ROUTES, ...options.standardPageRoutes };
+  const overrideLabels = { ...DEFAULT_LABELS, ...options.standardPageLabels };
+  const overrideIcons = { ...DEFAULT_ICONS, ...options.standardPageIcons };
+  const overrideNavSection = { ...DEFAULT_NAV_SECTIONS, ...options.standardPageNavSection };
+  for (const key of Object.keys(standard)) {
+    const def = standard[key];
+    if (!def?.enabled) continue;
+    const cap = def.requiredCapability ?? null;
+    if (cap && capabilities[cap] !== true) continue;
+    routes.push({
+      id: key,
+      path: overrideRoutes[key],
+      label: overrideLabels[key],
+      icon: overrideIcons[key],
+      navSection: overrideNavSection[key],
+      componentKey: `platform-${key}`,
+      requiredCapability: cap,
+      isStandard: true
+    });
+  }
+  const projectPages = manifest.navigation?.projectPages ?? [];
+  const exts = options.availableExtensions;
+  for (const p of projectPages) {
+    const cap = p.requiredCapability ?? null;
+    if (cap && capabilities[cap] !== true) continue;
+    if (exts && !exts.has(p.componentKey)) continue;
+    routes.push({
+      id: p.id,
+      path: p.route,
+      label: p.label,
+      icon: p.icon,
+      navSection: p.navSection,
+      componentKey: p.componentKey,
+      requiredCapability: cap,
+      isStandard: false,
+      prefetchOnIdle: p.prefetchOnIdle
+    });
+  }
+  return routes;
+}
+function buildSidebar(routes, sectionOrder = DEFAULT_SECTION_ORDER) {
+  const bySection = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    const section = r.navSection ?? null;
+    const list = bySection.get(section) ?? [];
+    list.push({ id: r.id, path: r.path, label: r.label, icon: r.icon });
+    bySection.set(section, list);
+  }
+  const sections = [];
+  if (bySection.has(null)) {
+    sections.push({ section: null, items: bySection.get(null) });
+  }
+  const ordered = /* @__PURE__ */ new Set();
+  for (const name of sectionOrder) {
+    if (bySection.has(name)) {
+      sections.push({ section: name, items: bySection.get(name) });
+      ordered.add(name);
+    }
+  }
+  const remaining = [...bySection.entries()].filter(([s]) => s !== null && !ordered.has(s)).sort((a, b) => a[0].localeCompare(b[0]));
+  for (const [section, items] of remaining) {
+    sections.push({ section, items });
+  }
+  return sections;
+}
+function resolveExtension(componentKey, extensions) {
+  return extensions[componentKey] ?? null;
+}
+
+// src/action-registry.ts
+var MissingHandlerError = class extends Error {
+  constructor(actionKey) {
+    super(
+      `Kein Handler f\xFCr actionKey "${actionKey}" registriert. Konsument-Shell muss \`actions["${actionKey}"]\` bereitstellen.`
+    );
+    this.name = "MissingHandlerError";
+  }
+};
+var ActionDefNotInManifestError = class extends Error {
+  constructor(actionKey) {
+    super(
+      `actionKey "${actionKey}" ist im Manifest nicht deklariert. Bitte als TenantAction in einer ManifestContribution registrieren.`
+    );
+    this.name = "ActionDefNotInManifestError";
+  }
+};
+var ActionRegistry = class {
+  defs = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  constructor(manifest, handlers = {}) {
+    for (const def of manifest.tenants?.actions ?? []) {
+      this.defs.set(def.actionKey, def);
+    }
+    for (const [key, handler] of Object.entries(handlers)) {
+      this.handlers.set(key, handler);
+    }
+  }
+  /**
+   * Registers a handler after the fact (e.g. when consumer code loads
+   * lazily). Throws `ActionDefNotInManifestError` if the `actionKey` is not
+   * declared in the manifest — prevents dead registrations.
+   */
+  register(actionKey, handler) {
+    if (!this.defs.has(actionKey)) {
+      throw new ActionDefNotInManifestError(actionKey);
+    }
+    this.handlers.set(actionKey, handler);
+  }
+  /**
+   * Returns the `{def, handler}` pair. Throws if the key is missing from
+   * the manifest or no handler is registered. The shell's UI layer calls
+   * the method, checks `def.requiresMfa` / `def.confirmType` for the
+   * pre-flow, and then calls `handler(input)`.
+   */
+  get(actionKey) {
+    const def = this.defs.get(actionKey);
+    if (!def) throw new ActionDefNotInManifestError(actionKey);
+    const handler = this.handlers.get(actionKey);
+    if (!handler) throw new MissingHandlerError(actionKey);
+    return { def, handler };
+  }
+  /**
+   * Convenience: `get(key).handler(input)`. UI convenience for actions
+   * that need neither MFA nor confirm.
+   */
+  async dispatch(actionKey, input) {
+    return this.get(actionKey).handler(input);
+  }
+  /**
+   * List of actionKeys that are declared in the manifest but have no
+   * handler. Consumers use this in a doctor check to detect drift between
+   * the manifest and the shell build.
+   */
+  listOrphanedDefs() {
+    return [...this.defs.keys()].filter((k) => !this.handlers.has(k));
+  }
+  /**
+   * List of registered handlers that are missing from the manifest. Drift
+   * in the other direction.
+   */
+  listOrphanedHandlers() {
+    return [...this.handlers.keys()].filter((k) => !this.defs.has(k));
+  }
+};
+
+// src/batch-column-fetcher.ts
+var BatchColumnDriftError = class extends Error {
+  constructor(column, reason) {
+    super(`Spalte "${column.key}": ${reason}`);
+    this.column = column;
+    this.name = "BatchColumnDriftError";
+  }
+  column;
+};
+var BatchColumnFetcher = class {
+  http;
+  paramStyle;
+  getAuthToken;
+  constructor(options = {}) {
+    this.http = options.http ?? defaultHttpClient();
+    this.paramStyle = options.paramStyle ?? "comma";
+    this.getAuthToken = options.getAuthToken;
+  }
+  /**
+   * Loads the data for all columns declared in the manifest in parallel
+   * (one request per column, all `tenantIds` in the batch). Columns without
+   * a satisfied capability are ignored.
+   */
+  async fetchAll(manifest, tenantIds) {
+    if (tenantIds.length === 0) return {};
+    const cols = this.eligibleColumns(manifest);
+    const results = await Promise.all(
+      cols.map(
+        (col) => this.fetchOne(col, tenantIds).then((data) => [col.key, data])
+      )
+    );
+    const out = {};
+    for (const [key, data] of results) out[key] = data;
+    return out;
+  }
+  /** Fetch a single column (consumers may also use this directly). */
+  async fetchOne(column, tenantIds) {
+    this.validateBatchEndpoint(column);
+    if (tenantIds.length === 0) return {};
+    const url = this.buildUrl(column.endpoint, tenantIds);
+    const headers = {};
+    const token = this.getAuthToken?.();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const res = await this.http(url, { method: "GET", headers });
+    if (res.status !== 200) {
+      throw new Error(
+        `Spalte "${column.key}" \u2014 Endpoint ${column.endpoint} antwortete HTTP ${res.status}`
+      );
+    }
+    const body = await res.json();
+    return body;
+  }
+  /**
+   * Column drift against the manifest. Consumers use this for CI smoke
+   * tests of the manifest-vs-shell build.
+   */
+  listDriftIssues(manifest) {
+    const issues = [];
+    for (const col of manifest.tenants?.columns ?? []) {
+      try {
+        this.validateBatchEndpoint(col);
+      } catch (err) {
+        if (err instanceof BatchColumnDriftError) issues.push(err);
+      }
+    }
+    return issues;
+  }
+  /**
+   * Which columns have a satisfied `requiredCapability`? Manifest =
+   * discovery, so a local check is enough.
+   */
+  eligibleColumns(manifest) {
+    const caps = manifest.capabilities ?? {};
+    return (manifest.tenants?.columns ?? []).filter((col) => {
+      if (!col.requiredCapability) return true;
+      return caps[col.requiredCapability] === true;
+    });
+  }
+  validateBatchEndpoint(col) {
+    if (!col.endpoint || col.endpoint.trim().length === 0) {
+      throw new BatchColumnDriftError(col, "endpoint ist leer");
+    }
+    if (col.endpoint.includes("{slug}") || col.endpoint.includes("{tenantId}")) {
+      throw new BatchColumnDriftError(
+        col,
+        "endpoint enth\xE4lt per-Tenant-Placeholder ({slug}/{tenantId}). Spalten-Endpoints m\xFCssen batchf\xE4hig sein \u2014 bitte Backend auf `?tenantIds=...`-Parameter umstellen."
+      );
+    }
+  }
+  buildUrl(endpoint, tenantIds) {
+    const sep = endpoint.includes("?") ? "&" : "?";
+    if (this.paramStyle === "comma") {
+      const enc = tenantIds.map(encodeURIComponent).join(",");
+      return `${endpoint}${sep}tenantIds=${enc}`;
+    }
+    const params = tenantIds.map((id) => `tenantIds=${encodeURIComponent(id)}`).join("&");
+    return `${endpoint}${sep}${params}`;
+  }
+};
+
+// src/use-api-list.ts
+import { ref, watch } from "vue";
+function useApiList(options) {
+  const http = options.http ?? defaultHttpClient();
+  const items = ref([]);
+  const page = ref(1);
+  const pageSize = ref(50);
+  const total = ref(0);
+  const loading = ref(false);
+  const error = ref(null);
+  function buildUrl() {
+    const params = new URLSearchParams();
+    params.set("page", String(page.value));
+    params.set("pageSize", String(pageSize.value));
+    const f = options.filter?.value ?? {};
+    for (const [k, v] of Object.entries(f)) {
+      if (v === void 0 || v === null || v === "") continue;
+      params.set(k, String(v));
+    }
+    const sep = options.endpoint.includes("?") ? "&" : "?";
+    return `${options.endpoint}${sep}${params.toString()}`;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const headers = {};
+      const token = options.getAuthToken?.();
+      if (token) headers.Authorization = `Bearer ${token}`;
+      const res = await http(buildUrl(), { method: "GET", headers });
+      if (res.status !== 200) {
+        throw new Error(`Endpoint ${options.endpoint} \u2192 HTTP ${res.status}`);
+      }
+      const raw = await res.json();
+      if (Array.isArray(raw)) {
+        items.value = raw;
+        total.value = raw.length;
+      } else if (raw !== null && typeof raw === "object") {
+        const body = raw;
+        items.value = body.items ?? [];
+        if (typeof body.page === "number") page.value = body.page;
+        if (typeof body.pageSize === "number") pageSize.value = body.pageSize;
+        if (typeof body.total === "number") total.value = body.total;
+      } else {
+        items.value = [];
+        total.value = 0;
+      }
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      items.value = [];
+      total.value = 0;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function goToPage(p) {
+    page.value = Math.max(1, Math.floor(p));
+    await load();
+  }
+  async function setPageSize(size) {
+    pageSize.value = Math.max(1, Math.floor(size));
+    page.value = 1;
+    await load();
+  }
+  if (options.filter) {
+    watch(
+      options.filter,
+      () => {
+        page.value = 1;
+        void load();
+      },
+      { deep: true }
+    );
+  }
+  if (options.autoLoad !== false) {
+    Promise.resolve().then(() => void load());
+  }
+  return {
+    items,
+    page,
+    pageSize,
+    total,
+    loading,
+    error,
+    reload: load,
+    goToPage,
+    setPageSize
+  };
+}
+
+// src/use-tenants.ts
+import { ref as ref2 } from "vue";
+function useTenants(options) {
+  if (!options?.endpoint) {
+    throw new Error(
+      'useTenants: `endpoint` ist Pflicht (z. B. "/api/v1/admin/tenants" oder "/api/admin/tenants"). Plattform hat keinen Default, weil Apps unterschiedliche globalPrefix-Konventionen haben.'
+    );
+  }
+  const filter = options.filter ?? ref2({});
+  const list = useApiList({
+    endpoint: options.endpoint,
+    filter,
+    http: options.http,
+    getAuthToken: options.getAuthToken,
+    autoLoad: options.autoLoad
+  });
+  return { ...list, filter };
+}
+
+// src/use-audit-entries.ts
+import { ref as ref3 } from "vue";
+function useAuditEntries(options) {
+  if (!options?.endpoint) {
+    throw new Error(
+      'useAuditEntries: `endpoint` ist Pflicht (z. B. "/api/admin/audit" oder "/api/v1/admin/audit"). Plattform hat keinen Default, weil Apps unterschiedliche globalPrefix-Konventionen haben.'
+    );
+  }
+  const filter = options.filter ?? ref3({});
+  const list = useApiList({
+    endpoint: options.endpoint,
+    filter,
+    http: options.http,
+    getAuthToken: options.getAuthToken,
+    autoLoad: options.autoLoad
+  });
+  return { ...list, filter };
+}
+
+// src/use-entitlement.ts
+import { ref as ref4 } from "vue";
+function useEntitlement(options) {
+  if (!options?.endpoint) {
+    throw new Error(
+      'useEntitlement: `endpoint` ist Pflicht (z. B. "/api/billing/entitlement" oder "/api/v1/billing/entitlement"). Plattform hat keinen Default, weil Apps unterschiedliche globalPrefix-Konventionen haben.'
+    );
+  }
+  const endpoint = options.endpoint;
+  const http = options.http ?? defaultHttpClient();
+  const entitlement = ref4(null);
+  const loading = ref4(false);
+  const error = ref4(null);
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const headers = {};
+      const token = options.getAuthToken?.();
+      if (token) headers.Authorization = `Bearer ${token}`;
+      const res = await http(endpoint, { method: "GET", headers });
+      if (res.status !== 200) {
+        throw new Error(`Entitlement-Endpoint \u2192 HTTP ${res.status}`);
+      }
+      entitlement.value = await res.json();
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      entitlement.value = null;
+    } finally {
+      loading.value = false;
+    }
+  }
+  function hasFeature(key) {
+    return entitlement.value?.features.includes(key) ?? false;
+  }
+  if (options.autoLoad !== false) {
+    Promise.resolve().then(() => void load());
+  }
+  return { entitlement, loading, error, load, hasFeature };
+}
+
+// src/use-tenant-manifest.ts
+import { ref as ref5 } from "vue";
+function useTenantManifest(options) {
+  if (!options?.endpoint) {
+    throw new Error(
+      'useTenantManifest: `endpoint` ist Pflicht (z. B. "/api/tenant/manifest").'
+    );
+  }
+  const http = options.http ?? defaultHttpClient();
+  const manifest = ref5(null);
+  const loading = ref5(false);
+  const error = ref5(null);
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const headers = {};
+      const token = options.getAuthToken?.();
+      if (token) headers.Authorization = `Bearer ${token}`;
+      const res = await http(options.endpoint, { method: "GET", headers });
+      if (res.status !== 200) {
+        throw new Error(`Tenant-Manifest-Endpoint \u2192 HTTP ${res.status}`);
+      }
+      manifest.value = await res.json();
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      manifest.value = null;
+    } finally {
+      loading.value = false;
+    }
+  }
+  function hasFeature(key) {
+    return manifest.value?.features.includes(key) ?? false;
+  }
+  function quotaLimit(key) {
+    const v = manifest.value?.quotas[key];
+    return v === void 0 ? null : v;
+  }
+  if (options.autoLoad !== false) {
+    Promise.resolve().then(() => void load());
+  }
+  return { manifest, loading, error, load, hasFeature, quotaLimit };
+}
+
+// src/entitlement-provider.ts
+import { inject as inject2 } from "vue";
+var ENTITLEMENT_INJECTION_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/ENTITLEMENT"
+);
+function provideEntitlement(app, entitlement) {
+  app.provide(ENTITLEMENT_INJECTION_KEY, entitlement);
+}
+function useInjectedEntitlement() {
+  return inject2(ENTITLEMENT_INJECTION_KEY, null);
+}
+
+// src/feature-router-guard.ts
+function extractRequired(to) {
+  const raw = to.meta?.requiresFeature;
+  if (!raw) return [];
+  return Array.isArray(raw) ? raw : [raw];
+}
+function buildFeatureRouterGuard(options) {
+  return function featureGuard(to, _from, next) {
+    const required = extractRequired(to);
+    if (required.length === 0) return next();
+    const ent = options.getEntitlement();
+    if (!ent) {
+      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);
+  };
+}
+
+// src/use-tenant-billing-catalog.ts
+import { ref as ref6 } from "vue";
+function useTenantBillingCatalog(options = {}) {
+  const apiPrefix = trimTrailingSlashes(options.apiPrefix ?? "/billing");
+  const http = options.http ?? defaultHttpClient();
+  const plans = ref6(null);
+  const featureRegistry = ref6(null);
+  const bundles = ref6(null);
+  const loading = ref6(false);
+  const error = ref6(null);
+  async function fetchJson(path) {
+    const res = await http(`${apiPrefix}${path}`, { method: "GET" });
+    if (res.status !== 200) {
+      throw new Error(`${apiPrefix}${path} \u2192 HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const [plansResult, registryResult] = await Promise.all([
+        fetchJson("/plans"),
+        fetchJson("/feature-registry")
+      ]);
+      plans.value = plansResult;
+      featureRegistry.value = registryResult;
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      plans.value = null;
+      featureRegistry.value = null;
+    } finally {
+      loading.value = false;
+    }
+    try {
+      const raw = await fetchJson("/bundles");
+      bundles.value = (raw ?? []).map((b) => ({
+        bundleVersionId: b.bundleVersionId,
+        bundleKey: b.bundleKey,
+        label: b.label,
+        description: b.description,
+        features: b.features ?? [],
+        quotas: b.quotas ?? {},
+        monthlyNet: b.monthlyNet !== null ? parseFloat(b.monthlyNet) : null,
+        yearlyNet: b.yearlyNet !== null ? parseFloat(b.yearlyNet) : null,
+        requiresFeatures: b.requiresFeatures ?? [],
+        priceTag: b.marketing?.priceTag ?? null
+      }));
+    } catch {
+      bundles.value = [];
+    }
+  }
+  if (options.autoLoad !== false) {
+    Promise.resolve().then(() => void load());
+  }
+  return { plans, featureRegistry, bundles, loading, error, load };
+}
+
+// src/use-tenant-billing.ts
+import { ref as ref7 } from "vue";
+function useTenantBilling(options = {}) {
+  const apiPrefix = trimTrailingSlashes(options.apiPrefix ?? "/billing");
+  const http = options.http ?? defaultHttpClient();
+  const usage = ref7(null);
+  const loading = ref7(false);
+  const error = ref7(null);
+  const subscriptionBundles = ref7([]);
+  function authHeaders() {
+    const headers = {};
+    const token = options.getAuthToken?.();
+    if (token) headers.Authorization = `Bearer ${token}`;
+    return headers;
+  }
+  async function fetchOrThrow(path, init) {
+    const res = await http(`${apiPrefix}${path}`, {
+      method: init?.method ?? "GET",
+      headers: { ...authHeaders(), "Content-Type": "application/json" },
+      body: init?.body !== void 0 ? JSON.stringify(init.body) : void 0
+    });
+    if (res.status >= 400) {
+      let body;
+      try {
+        body = await res.json();
+      } catch {
+        body = await res.text();
+      }
+      const err = new Error(
+        `${apiPrefix}${path} \u2192 HTTP ${res.status}: ${typeof body === "string" ? body : JSON.stringify(body)}`
+      );
+      err.status = res.status;
+      err.body = body;
+      throw err;
+    }
+    if (res.status === 204) return void 0;
+    return await res.json();
+  }
+  async function reload() {
+    loading.value = true;
+    error.value = null;
+    try {
+      usage.value = await fetchOrThrow("/usage");
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      usage.value = null;
+    } finally {
+      loading.value = false;
+    }
+    await loadBundles();
+  }
+  async function loadBundles() {
+    try {
+      subscriptionBundles.value = await fetchOrThrow("/subscription-bundles") ?? [];
+    } catch {
+      subscriptionBundles.value = [];
+    }
+  }
+  async function addBundle(bundleVersionId, minimumTermMonths) {
+    await fetchOrThrow("/subscription-bundles", {
+      method: "POST",
+      body: minimumTermMonths !== void 0 ? { bundleVersionId, minimumTermMonths } : { bundleVersionId }
+    });
+    await loadBundles();
+  }
+  async function cancelBundle(subscriptionBundleId) {
+    await fetchOrThrow(`/subscription-bundles/${subscriptionBundleId}`, {
+      method: "DELETE",
+      body: {}
+    });
+    await loadBundles();
+  }
+  async function reactivateBundle(subscriptionBundleId) {
+    await fetchOrThrow(`/subscription-bundles/${subscriptionBundleId}/reactivate`, {
+      method: "POST",
+      body: {}
+    });
+    await loadBundles();
+  }
+  async function previewAddBundle(bundleVersionId, minimumTermMonths) {
+    return fetchOrThrow("/subscription-bundles/preview", {
+      method: "POST",
+      body: minimumTermMonths !== void 0 ? { bundleVersionId, minimumTermMonths } : { bundleVersionId }
+    });
+  }
+  async function previewCancelBundle(subscriptionBundleId) {
+    return fetchOrThrow("/subscription-bundles/preview", {
+      method: "POST",
+      body: { subscriptionBundleId }
+    });
+  }
+  async function previewPlanChange(plan, billingCycle) {
+    return fetchOrThrow("/plan/preview", {
+      method: "POST",
+      body: { plan, billingCycle }
+    });
+  }
+  async function changePlan(plan, billingCycle, effectiveImmediately) {
+    await fetchOrThrow("/plan", {
+      method: "POST",
+      body: { plan, billingCycle, effectiveImmediately }
+    });
+    await reload();
+  }
+  async function acceptPendingPlanVersion() {
+    await fetchOrThrow("/subscription/accept-pending-version", { method: "POST" });
+    await reload();
+  }
+  async function cancelSubscription(immediately) {
+    await fetchOrThrow("/cancel", {
+      method: "POST",
+      body: { immediately }
+    });
+    await reload();
+  }
+  function hasFeature(key) {
+    return usage.value?.limits.features.includes(key) ?? false;
+  }
+  if (options.autoLoad !== false) {
+    Promise.resolve().then(() => void reload());
+  }
+  return {
+    usage,
+    loading,
+    error,
+    reload,
+    previewPlanChange,
+    changePlan,
+    acceptPendingPlanVersion,
+    cancelSubscription,
+    hasFeature,
+    subscriptionBundles,
+    loadBundles,
+    addBundle,
+    cancelBundle,
+    reactivateBundle,
+    previewAddBundle,
+    previewCancelBundle
+  };
+}
+
+// src/use-subscription-draft.ts
+import { computed as computed2, ref as ref8 } from "vue";
+import {
+  selectChargeableBundles
+} from "@saasicat/types";
+var DEFAULT_YEARLY_FACTOR = 10;
+function unwrap(source) {
+  if (source && typeof source === "object" && "value" in source) {
+    return source.value;
+  }
+  return source;
+}
+function priceForCycle(monthlyNet, yearlyNet, cycle, yearlyFactor) {
+  if (cycle === "YEARLY") {
+    return yearlyNet != null ? yearlyNet : monthlyNet * yearlyFactor;
+  }
+  return monthlyNet;
+}
+function useSubscriptionDraft(options) {
+  const yearlyFactor = options.yearlyFactor ?? DEFAULT_YEARLY_FACTOR;
+  const plansRef = computed2(() => unwrap(options.plans) ?? []);
+  const subscriptionBundlesRef = computed2(
+    () => unwrap(options.subscriptionBundles ?? null) ?? []
+  );
+  const plan = ref8(options.initialPlan ?? null);
+  const cycle = ref8(options.initialCycle ?? "MONTHLY");
+  const selectedBundleVersionIds = ref8(
+    new Set(options.initialBundleVersionIds ?? [])
+  );
+  const promoCode = ref8("");
+  const promoState = ref8({ status: "idle", preview: null, message: "" });
+  const selectedPlan = computed2(() => {
+    if (!plan.value) return null;
+    return plansRef.value.find((p) => p.id === plan.value) ?? null;
+  });
+  const selectedBundles = computed2(
+    () => subscriptionBundlesRef.value.filter(
+      (b) => selectedBundleVersionIds.value.has(b.bundleVersionId)
+    )
+  );
+  const chargeableBundles = computed2(() => {
+    const planFeatures = selectedPlan.value?.features ?? [];
+    const selected = selectedBundles.value;
+    const keptIds = new Set(
+      selectChargeableBundles(planFeatures, selected).map((b) => b.bundleVersionId)
+    );
+    return selected.filter((b) => keptIds.has(b.bundleVersionId));
+  });
+  const activeFeatures = computed2(() => {
+    const result = /* @__PURE__ */ new Set();
+    const planObj = selectedPlan.value;
+    if (planObj) {
+      for (const f of planObj.features) result.add(f);
+    }
+    for (const bundle of selectedBundles.value) {
+      for (const f of bundle.features) result.add(f);
+    }
+    return result;
+  });
+  const pricing = computed2(() => {
+    const cyc = cycle.value;
+    const planObj = selectedPlan.value;
+    const planNet = planObj ? priceForCycle(planObj.monthlyNet ?? 0, planObj.yearlyNet, cyc, yearlyFactor) : 0;
+    const bundleItems = [];
+    let bundlesNet = 0;
+    for (const b of chargeableBundles.value) {
+      const net = priceForCycle(b.monthlyNet ?? 0, b.yearlyNet, cyc, yearlyFactor);
+      bundlesNet += net;
+      bundleItems.push({
+        key: `subscription-bundle:${b.bundleVersionId}`,
+        label: b.label,
+        net
+      });
+    }
+    const subtotalNet = planNet + bundlesNet;
+    let discountNet = 0;
+    const preview = promoState.value.preview;
+    if (preview && preview.valid && promoState.value.status === "valid") {
+      const valid = preview;
+      const value = Number(valid.discount.value);
+      if (Number.isFinite(value) && value > 0) {
+        if (valid.discount.valueType === "PERCENT") {
+          discountNet = subtotalNet * value / 100;
+        } else {
+          discountNet = Math.min(value, subtotalNet);
+        }
+      }
+    }
+    const totalNet = Math.max(0, subtotalNet - discountNet);
+    let yearSavings = 0;
+    if (planObj) {
+      const monthlyTotal = priceForCycle(planObj.monthlyNet ?? 0, planObj.yearlyNet, "MONTHLY", yearlyFactor) * 12;
+      const yearlyTotal = priceForCycle(
+        planObj.monthlyNet ?? 0,
+        planObj.yearlyNet,
+        "YEARLY",
+        yearlyFactor
+      );
+      yearSavings = Math.max(0, monthlyTotal - yearlyTotal);
+    }
+    return {
+      cycle: cyc,
+      planNet,
+      bundlesNet,
+      subtotalNet,
+      discountNet,
+      totalNet,
+      yearSavings,
+      breakdown: {
+        plan: planObj ? {
+          key: `plan:${planObj.id}`,
+          label: planObj.name,
+          net: planNet,
+          sublabel: `${planObj.features.length} Basis-Module`
+        } : null,
+        bundles: bundleItems
+      }
+    };
+  });
+  const isDirty = computed2(() => {
+    return selectedBundleVersionIds.value.size > 0 || promoState.value.status === "valid";
+  });
+  function setPlan(planId) {
+    if (plan.value === planId) return;
+    plan.value = planId;
+    const compatibleBundleVersions = /* @__PURE__ */ new Set();
+    for (const bundle of subscriptionBundlesRef.value) {
+      if (bundle.compatiblePlanKeys.length === 0 || bundle.compatiblePlanKeys.includes(planId)) {
+        compatibleBundleVersions.add(bundle.bundleVersionId);
+      }
+    }
+    selectedBundleVersionIds.value = new Set(
+      [...selectedBundleVersionIds.value].filter((id) => compatibleBundleVersions.has(id))
+    );
+  }
+  function setCycle(c) {
+    cycle.value = c;
+  }
+  function toggleSubscriptionBundle(bundleVersionId) {
+    const next = new Set(selectedBundleVersionIds.value);
+    if (next.has(bundleVersionId)) next.delete(bundleVersionId);
+    else next.add(bundleVersionId);
+    selectedBundleVersionIds.value = next;
+  }
+  function setPromoCode(code) {
+    promoCode.value = code.toUpperCase();
+    if (promoState.value.status !== "idle") {
+      promoState.value = { status: "idle", preview: null, message: "" };
+    }
+  }
+  function setPromoState(state) {
+    promoState.value = state;
+  }
+  function clearPromo() {
+    promoCode.value = "";
+    promoState.value = { status: "idle", preview: null, message: "" };
+  }
+  function toApiPayload() {
+    if (!plan.value) {
+      throw new Error("useSubscriptionDraft: plan ist nicht gesetzt");
+    }
+    const payload = {
+      plan: plan.value,
+      billingCycle: cycle.value
+    };
+    if (promoState.value.status === "valid" && promoCode.value) {
+      payload.promoCode = promoCode.value;
+    }
+    const chargeableIds = chargeableBundles.value.map((b) => b.bundleVersionId);
+    if (chargeableIds.length > 0) {
+      payload.bundleVersionIds = chargeableIds;
+    }
+    return payload;
+  }
+  return {
+    plan,
+    cycle,
+    selectedBundleVersionIds,
+    promoCode,
+    promoState,
+    selectedPlan,
+    activeFeatures,
+    pricing,
+    isDirty,
+    setPlan,
+    setCycle,
+    toggleSubscriptionBundle,
+    setPromoCode,
+    setPromoState,
+    clearPromo,
+    toApiPayload
+  };
+}
+
+// src/pages-tenant/default-i18n.ts
+var DEFAULT_I18N_DE = {
+  sectionTitle: "Paket & Verbrauch",
+  sectionSubtitle: "Aktuelles Paket, Verbrauch und Bundles.",
+  loading: "Lade \u2026",
+  noSubscription: "Keine Subscription f\xFCr diesen Mandanten gefunden.",
+  activePlan: "Aktuelles Paket",
+  cycleMonthly: "Monatlich",
+  cycleYearly: "J\xE4hrlich",
+  statusActive: "Aktiv",
+  statusTrial: "Testphase",
+  statusPastDue: "Zahlung \xFCberf\xE4llig",
+  statusCanceled: "Gek\xFCndigt",
+  statusPendingSales: "Vertrieb-Kl\xE4rung",
+  trialEndsAt: "Testphase endet am",
+  pilotEndsAt: "Pilot endet am",
+  nextBillingDate: "N\xE4chste Abrechnung",
+  pendingChange: "Ausstehender Plan-Wechsel",
+  changeFromTo: "Wechsel zu",
+  changeEffectiveAt: "wirksam ab",
+  changePlanButton: "Paket wechseln",
+  cancelSubscriptionButton: "Abonnement k\xFCndigen",
+  usageTitle: "Verbrauch",
+  featuresOverviewTitle: "Leistungsumfang",
+  featuresActive: "Enthalten",
+  featuresLocked: "Nicht enthalten",
+  bundlesStoreTitle: "Bundles",
+  bundlesBookedTitle: "Gebuchte Bundles",
+  bundlesAvailableTitle: "Verf\xFCgbare Bundles",
+  bundlesAvailableEmpty: "Aktuell sind keine zus\xE4tzlichen Bundles verf\xFCgbar.",
+  bundlesPerMonth: "netto/Monat",
+  bundleBookAction: "Bundle buchen",
+  bundleBookInProgress: "Buchung l\xE4uft \u2026",
+  bundleCancelAction: "K\xFCndigen",
+  bundleReactivateAction: "Reaktivieren",
+  bundleReactivateConfirmTitle: "Bundle reaktivieren",
+  bundleReactivateConfirmBody: "Die K\xFCndigung wird r\xFCckg\xE4ngig gemacht. Das Bundle bleibt gebucht, l\xE4uft regul\xE4r weiter und wird wieder abgerechnet.",
+  bundleCanceledAt: "Gek\xFCndigt zum",
+  bundleMinimumTermUntil: "Mindestlaufzeit bis",
+  bundleIncludesLabel: "Enth\xE4lt",
+  bundleAlreadyBooked: "Bereits gebucht",
+  bundleIncompatible: "Nicht kompatibel mit aktuellem Paket",
+  bundleMissingRequires: "Ben\xF6tigt",
+  bundlePreviewAddTitle: "Bundle buchen",
+  bundlePreviewCancelTitle: "Bundle k\xFCndigen",
+  bundlePreviewLoading: "Vorschau wird berechnet \u2026",
+  bundlePreviewProrationTitle: "Anteilige Abrechnung",
+  bundlePreviewProratedNow: "Heute anteilig f\xE4llig",
+  bundlePreviewProrationDays: "Tage",
+  bundlePreviewNextPeriod: "Regul\xE4r ab n\xE4chster Periode",
+  bundlePreviewTrialNote: "W\xE4hrend der Testphase f\xE4llt nichts an \u2014 die Abrechnung beginnt mit der ersten bezahlten Periode.",
+  bundlePreviewNoPrice: "F\xFCr den aktuellen Abrechnungszyklus ist kein Listenpreis gepflegt.",
+  bundlePreviewMinimumTermLabel: "Mindestlaufzeit",
+  bundlePreviewMinimumTermMonths: "Monate, bis",
+  bundlePreviewMinimumTermNone: "Keine Mindestlaufzeit",
+  bundlePreviewRedundantTitle: "Bereits enthaltene Features (w\xFCrden doppelt bezahlt)",
+  bundlePreviewRedundantCoveredByPlan: "bereits im Plan",
+  bundlePreviewRedundantCoveredByBundle: "bereits im Bundle",
+  bundlePreviewMissingRequiresTitle: "Fehlende Voraussetzungen",
+  bundlePreviewBlockersTitle: "Buchung nicht m\xF6glich",
+  bundlePreviewWarningsTitle: "Hinweise",
+  bundlePreviewEffectiveAt: "K\xFCndigung wirksam zum",
+  bundlePreviewSavings: "Ersparnis pro Periode ab Wirksamkeit",
+  bundlePreviewConfirmAdd: "Kostenpflichtig buchen",
+  bundlePreviewConfirmCancel: "K\xFCndigung best\xE4tigen",
+  bundlePreviewInProgress: "Wird ausgef\xFChrt \u2026",
+  bundlePreviewClose: "Abbrechen",
+  pendingVersionTitle: "Anstehende Plan-\xC4nderung",
+  pendingVersionChipNonRegressive: "Verbessernd",
+  pendingVersionChipRegressive: "Best\xE4tigung erforderlich",
+  pendingVersionEffectiveAt: "Wirksam ab",
+  pendingVersionAcceptAction: "\xC4nderungen akzeptieren",
+  pendingVersionAcceptInProgress: "Akzeptiere \u2026",
+  pendingVersionAcceptedAt: "Akzeptiert am",
+  wizardTitle: "Paket wechseln",
+  wizardClose: "Schlie\xDFen",
+  wizardCurrent: "Aktuell",
+  wizardBadgeCurrent: "aktiv",
+  wizardBadgePopular: "beliebt",
+  wizardPriceUnitMonthly: "netto/Monat",
+  wizardPriceUnitYearly: "netto/Jahr",
+  wizardPriceOnRequest: "auf Anfrage",
+  wizardStepChoose: "Paket w\xE4hlen",
+  wizardStepChooseIntro: "W\xE4hle dein Ziel-Paket und den Abrechnungszyklus. Im n\xE4chsten Schritt zeigen wir Verbrauchs-Check und Feature-Diff.",
+  wizardStepPreview: "Vorschau",
+  wizardStepConfirm: "Best\xE4tigen",
+  wizardNext: "Weiter",
+  wizardBack: "Zur\xFCck",
+  wizardPreviewLoading: "Vorschau wird berechnet \u2026",
+  wizardEffectiveAtLabel: "Wirksam ab",
+  wizardEffectiveImmediate: "Wirksam sofort",
+  wizardProrationTitle: "Anteilige Abrechnung",
+  wizardProrationLine: "Mehrbetrag bis Periodenende:",
+  wizardProrationDays: "Tage",
+  wizardLimitsTitle: "Limit-Vergleich",
+  wizardLimitsUsed: "Verbrauch",
+  wizardLimitsCurrent: "Aktuell",
+  wizardLimitsTarget: "Ziel",
+  wizardFeaturesGained: "Neu freigeschaltet",
+  wizardFeaturesLost: "Wegfallende Features",
+  wizardBlockersTitle: "Verhinderungs-Gr\xFCnde",
+  wizardConfirmImmediate: "Der Wechsel wird sofort wirksam.",
+  wizardConfirmScheduled: "Der Wechsel wird wirksam zum",
+  wizardConfirmAction: "Wechsel best\xE4tigen",
+  wizardConfirmInProgress: "Wechsel l\xE4uft \u2026",
+  wizardConfirmPriceTitle: "Preis\xFCbersicht",
+  wizardConfirmProratedNow: "Heute anteilig f\xE4llig",
+  wizardConfirmRecurringNext: "Regul\xE4r ab n\xE4chster Periode",
+  wizardConfirmRecurringFrom: "Regul\xE4r f\xE4llig ab",
+  wizardConfirmPerCycleMonthly: "pro Monat",
+  wizardConfirmPerCycleYearly: "pro Jahr",
+  wizardConfirmTrialNote: "W\xE4hrend der Testphase f\xE4llt nichts an.",
+  wizardConfirmRecurringTrialEnd: "Regul\xE4r ab Ende der Testphase",
+  wizardChangeTypeUpgrade: "Upgrade",
+  wizardChangeTypeDowngrade: "Downgrade",
+  wizardChangeTypeCycle: "Zyklus-Wechsel",
+  wizardChangeTypeNoop: "Keine \xC4nderung",
+  packageSnapshotTitle: "Gebuchtes Paket (Snapshot)",
+  packageSnapshotSubtitle: "Schreibgesch\xFCtzte Kopie des Pakets, wie es beim Abschluss vermarktet wurde.",
+  packageSnapshotCapturedAt: "Erfasst am",
+  packageSnapshotOfferRef: "Angebots-Referenz",
+  packageSnapshotPlanLabel: "Plan",
+  packageSnapshotPlanVersionLabel: "Plan-Version",
+  packageSnapshotCycleLabel: "Abrechnungszyklus",
+  packageSnapshotBundlesLabel: "Enthaltene Bundles",
+  packageSnapshotBundlesEmpty: "Keine Bundles im Paket.",
+  packageSnapshotPriceMonthly: "Preis monatlich",
+  packageSnapshotPriceYearly: "Preis j\xE4hrlich",
+  packageSnapshotPriceTotal: "Gesamtpreis",
+  packageSnapshotNone: "Diese Subscription wurde nicht \xFCber ein Webseiten-Angebot abgeschlossen.",
+  packageSnapshotShowRaw: "Rohdaten anzeigen",
+  packageSnapshotHideRaw: "Rohdaten ausblenden"
+};
+
+// src/use-plan-versions.ts
+import { ref as ref9 } from "vue";
+function buildVersionsComposable(label) {
+  return function(options) {
+    if (!options?.endpoint) {
+      throw new Error(
+        `${label}: \`endpoint\` ist Pflicht (z. B. "/api/admin/${label}" oder "/api/v1/admin/${label}"). Plattform hat keinen Default, weil Apps unterschiedliche globalPrefix-Konventionen haben.`
+      );
+    }
+    const filter = options.filter ?? ref9({});
+    const list = useApiList({
+      endpoint: options.endpoint,
+      filter,
+      http: options.http,
+      getAuthToken: options.getAuthToken,
+      autoLoad: options.autoLoad
+    });
+    return { ...list, filter };
+  };
+}
+var usePlanVersionsCatalog = buildVersionsComposable("plan-versions");
+
+// src/use-bulk-publish.ts
+import { computed as computed3, ref as ref10 } from "vue";
+function useBulkPublish(options) {
+  if (!options?.endpoints) {
+    throw new Error(
+      "useBulkPublish: `endpoints` ist Pflicht (Mapping plan \u2192 URL-Builder). Plattform hat keinen Default, weil Apps unterschiedliche globalPrefix-Konventionen haben."
+    );
+  }
+  const http = options.http ?? defaultHttpClient();
+  const endpoints = options.endpoints;
+  const items = ref10([]);
+  const successCount = computed3(() => items.value.filter((i) => i.status === "published").length);
+  const failureCount = computed3(() => items.value.filter((i) => i.status === "failed").length);
+  const progress = computed3(() => {
+    if (items.value.length === 0) return 0;
+    const done2 = successCount.value + failureCount.value;
+    return done2 / items.value.length;
+  });
+  const done = computed3(
+    () => items.value.length > 0 && items.value.every((i) => i.status === "published" || i.status === "failed")
+  );
+  function setItems(next) {
+    items.value = next.map((i) => ({ ...i, status: "pending" }));
+  }
+  async function publishOne(item, body, mfaCode) {
+    item.status = "publishing";
+    try {
+      const url = endpoints[item.kind](item.draftId);
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      const token = options.getAuthToken?.();
+      if (token) headers.Authorization = `Bearer ${token}`;
+      if (mfaCode) headers["X-Mfa-Code"] = mfaCode;
+      const res = await http(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (res.status >= 200 && res.status < 300) {
+        item.result = await res.json();
+        item.status = "published";
+      } else {
+        item.error = `HTTP ${res.status}: ${await res.text()}`;
+        item.status = "failed";
+      }
+    } catch (err) {
+      item.error = err instanceof Error ? err.message : String(err);
+      item.status = "failed";
+    }
+  }
+  async function run(input) {
+    const note = input.changeNote.trim();
+    if (note.length === 0) {
+      for (const item of items.value) {
+        item.status = "failed";
+        item.error = "changeNote ist Pflicht beim Publish.";
+      }
+      return;
+    }
+    await Promise.all(
+      items.value.map((item) => publishOne(item, { changeNote: note }, input.mfaCode))
+    );
+  }
+  return {
+    items,
+    progress,
+    done,
+    successCount,
+    failureCount,
+    setItems,
+    run
+  };
+}
+
+// src/use-plan-editor.ts
+import { computed as computed4, ref as ref11 } from "vue";
+var PlannedOnlyFeatureError = class extends Error {
+  constructor(violations) {
+    super(
+      `Folgende Features sind im Catalog als plannedOnly markiert und d\xFCrfen nicht in einer Plan-Version stehen: ${violations.sort().join(", ")}.`
+    );
+    this.violations = violations;
+    this.name = "PlannedOnlyFeatureError";
+  }
+  violations;
+};
+var TIER_ORDER = ["CORE", "ADVANCED", "PRO", "BUSINESS", "ENTERPRISE_ONLY"];
+function tierWeight(tier) {
+  if (!tier) return TIER_ORDER.length;
+  const i = TIER_ORDER.indexOf(tier);
+  return i === -1 ? TIER_ORDER.length : i;
+}
+function usePlanEditor(manifest, options = {}) {
+  const baseSet = new Set(options.baseFeatures ?? []);
+  const nonRegressive = options.nonRegressive ?? true;
+  const selectedFeatures = ref11(new Set(options.initialFeatures ?? []));
+  const catalogFeatures = manifest.planCatalogSnapshot.features ?? [];
+  const plannedOnlySet = new Set(catalogFeatures.filter((f) => f.plannedOnly).map((f) => f.key));
+  const availableFeatures = computed4(() => {
+    return catalogFeatures.map((def) => {
+      const isSelected = selectedFeatures.value.has(def.key);
+      const isPlannedOnly = !!def.plannedOnly;
+      const isInherited = baseSet.has(def.key);
+      const canToggle = !isPlannedOnly && (!nonRegressive || !isInherited || !isSelected);
+      return { def, isSelected, isPlannedOnly, isInherited, canToggle };
+    });
+  });
+  const featuresByTier = computed4(() => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const row of availableFeatures.value) {
+      const tier = row.def.tier ?? "OTHER";
+      const list = groups.get(tier) ?? [];
+      list.push(row);
+      groups.set(tier, list);
+    }
+    return [...groups.entries()].sort((a, b) => {
+      const wa = tierWeight(a[0]);
+      const wb = tierWeight(b[0]);
+      return wa !== wb ? wa - wb : a[0].localeCompare(b[0]);
+    }).map(([tier, rows]) => ({ tier, rows }));
+  });
+  function toggleFeature(key) {
+    if (plannedOnlySet.has(key)) return;
+    const next = new Set(selectedFeatures.value);
+    if (next.has(key)) {
+      if (nonRegressive && baseSet.has(key)) return;
+      next.delete(key);
+    } else {
+      next.add(key);
+    }
+    selectedFeatures.value = next;
+  }
+  function validateDraft() {
+    const violations = [...selectedFeatures.value].filter((k) => plannedOnlySet.has(k));
+    if (violations.length > 0) {
+      throw new PlannedOnlyFeatureError(violations);
+    }
+  }
+  function snapshot() {
+    return [...selectedFeatures.value].sort();
+  }
+  return {
+    selectedFeatures,
+    availableFeatures,
+    featuresByTier,
+    toggleFeature,
+    validateDraft,
+    snapshot
+  };
+}
+
+// src/use-public-boot.ts
+import { ref as ref12 } from "vue";
+function usePublicBoot(options) {
+  const loader = new BootLoader(options);
+  const boot = ref12(null);
+  const loading = ref12(false);
+  const error = ref12(null);
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      boot.value = await loader.load();
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      boot.value = null;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return { boot, loading, error, load };
+}
+
+// src/use-discovery.ts
+import { ref as ref13 } from "vue";
+var DiscoveryLoadError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "DiscoveryLoadError";
+  }
+  status;
+};
+function useDiscovery(options) {
+  if (!options?.endpoint) {
+    throw new Error(
+      'useDiscovery: `endpoint` ist Pflicht (z. B. "/api/admin/discovery" oder "/api/v1/admin/discovery"). Plattform hat keinen Default, weil Apps unterschiedliche globalPrefix-Konventionen haben.'
+    );
+  }
+  const http = options.http ?? defaultHttpClient();
+  const snapshot = ref13(null);
+  const etag = ref13(null);
+  const loading = ref13(false);
+  const error = ref13(null);
+  async function fetchSnapshot(includeEtag) {
+    loading.value = true;
+    error.value = null;
+    try {
+      const headers = {};
+      const token = options.getAuthToken?.();
+      if (token) headers.Authorization = `Bearer ${token}`;
+      if (includeEtag && etag.value) {
+        headers["If-None-Match"] = etag.value;
+      }
+      const res = await http(options.endpoint, { method: "GET", headers });
+      if (res.status === 304) {
+        return;
+      }
+      if (res.status !== 200) {
+        throw new DiscoveryLoadError(
+          res.status,
+          `Discovery-Endpoint antwortete mit HTTP ${res.status}`
+        );
+      }
+      const body = await res.json();
+      snapshot.value = body;
+      etag.value = res.headers.get("ETag");
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function load() {
+    await fetchSnapshot(true);
+  }
+  async function reload() {
+    etag.value = null;
+    await fetchSnapshot(false);
+  }
+  async function rescan() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const headers = { "content-type": "application/json" };
+      const token = options.getAuthToken?.();
+      if (token) headers.Authorization = `Bearer ${token}`;
+      const res = await http(`${options.endpoint}/rescan`, { method: "POST", headers });
+      if (res.status !== 200 && res.status !== 201) {
+        throw new DiscoveryLoadError(
+          res.status,
+          `Discovery-Rescan antwortete mit HTTP ${res.status}`
+        );
+      }
+      const body = await res.json();
+      snapshot.value = body;
+      etag.value = res.headers.get("ETag");
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return { snapshot, etag, loading, error, load, reload, rescan };
+}
+
+// src/use-catalog-entries.ts
+import { ref as ref14 } from "vue";
+var CatalogEntriesApiError = class extends Error {
+  constructor(status, body, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "CatalogEntriesApiError";
+  }
+  status;
+  body;
+};
+function useCatalogEntries(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error("useCatalogEntries: `adminEndpoint` ist Pflicht.");
+  }
+  if (!options?.projectKey) {
+    throw new Error("useCatalogEntries: `projectKey` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const capabilities = ref14([]);
+  const features = ref14([]);
+  const quotas = ref14([]);
+  const loading = ref14(false);
+  const error = ref14(null);
+  const base = `${options.adminEndpoint}/catalog`;
+  const pk = encodeURIComponent(options.projectKey);
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new CatalogEntriesApiError(
+        res.status,
+        body,
+        `Catalog-Entries-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const [caps, feats, qs] = await Promise.all([
+        fetchJson(`${base}/capabilities?projectKey=${pk}`),
+        fetchJson(`${base}/features?projectKey=${pk}`),
+        fetchJson(`${base}/quotas?projectKey=${pk}`)
+      ]);
+      capabilities.value = caps ?? [];
+      features.value = feats ?? [];
+      quotas.value = qs ?? [];
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function reviewFeature(featureKey, data) {
+    const updated = await fetchJson(
+      `${base}/features/${encodeURIComponent(featureKey)}/review?projectKey=${pk}`,
+      { method: "PATCH", body: JSON.stringify(data) }
+    );
+    if (!updated) throw new CatalogEntriesApiError(0, null, "Review gab keinen Body zur\xFCck");
+    features.value = features.value.map((f) => f.featureKey === featureKey ? updated : f);
+    return updated;
+  }
+  async function reviewQuota(quotaKey, data) {
+    const updated = await fetchJson(
+      `${base}/quotas/${encodeURIComponent(quotaKey)}/review?projectKey=${pk}`,
+      { method: "PATCH", body: JSON.stringify(data) }
+    );
+    if (!updated) throw new CatalogEntriesApiError(0, null, "Review gab keinen Body zur\xFCck");
+    quotas.value = quotas.value.map((q) => q.quotaKey === quotaKey ? updated : q);
+    return updated;
+  }
+  async function setFeatureI18n(featureKey, i18n) {
+    const updated = await fetchJson(
+      `${base}/features/${encodeURIComponent(featureKey)}/i18n?projectKey=${pk}`,
+      { method: "PATCH", body: JSON.stringify({ i18n }) }
+    );
+    if (!updated) throw new CatalogEntriesApiError(0, null, "i18n gab keinen Body zur\xFCck");
+    features.value = features.value.map((f) => f.featureKey === featureKey ? updated : f);
+    return updated;
+  }
+  async function setQuotaI18n(quotaKey, i18n) {
+    const updated = await fetchJson(
+      `${base}/quotas/${encodeURIComponent(quotaKey)}/i18n?projectKey=${pk}`,
+      { method: "PATCH", body: JSON.stringify({ i18n }) }
+    );
+    if (!updated) throw new CatalogEntriesApiError(0, null, "i18n gab keinen Body zur\xFCck");
+    quotas.value = quotas.value.map((q) => q.quotaKey === quotaKey ? updated : q);
+    return updated;
+  }
+  async function setFeatureBase(featureKey, data) {
+    const updated = await fetchJson(
+      `${base}/features/${encodeURIComponent(featureKey)}?projectKey=${pk}`,
+      { method: "PATCH", body: JSON.stringify(data) }
+    );
+    if (!updated) throw new CatalogEntriesApiError(0, null, "Base gab keinen Body zur\xFCck");
+    features.value = features.value.map((f) => f.featureKey === featureKey ? updated : f);
+    return updated;
+  }
+  async function setQuotaBase(quotaKey, data) {
+    const updated = await fetchJson(
+      `${base}/quotas/${encodeURIComponent(quotaKey)}?projectKey=${pk}`,
+      { method: "PATCH", body: JSON.stringify(data) }
+    );
+    if (!updated) throw new CatalogEntriesApiError(0, null, "Base gab keinen Body zur\xFCck");
+    quotas.value = quotas.value.map((q) => q.quotaKey === quotaKey ? updated : q);
+    return updated;
+  }
+  async function syncDiscovery(snapshot) {
+    const result = await fetchJson(`${base}/discovery/sync`, {
+      method: "POST",
+      body: JSON.stringify({ snapshot })
+    });
+    if (!result) throw new CatalogEntriesApiError(0, null, "Sync gab keinen Body zur\xFCck");
+    await load();
+    return result;
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return {
+    capabilities,
+    features,
+    quotas,
+    loading,
+    error,
+    load,
+    reviewFeature,
+    reviewQuota,
+    setFeatureI18n,
+    setQuotaI18n,
+    setFeatureBase,
+    setQuotaBase,
+    syncDiscovery
+  };
+}
+
+// src/use-bundles.ts
+import { ref as ref15 } from "vue";
+var BundlesApiError = class extends Error {
+  constructor(status, body, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "BundlesApiError";
+  }
+  status;
+  body;
+};
+function useBundles(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error(
+      'useBundles: `adminEndpoint` ist Pflicht (z. B. "/api/admin" oder "/api/v1/admin"). Plattform hat keinen Default, weil Apps unterschiedliche globalPrefix-Konventionen haben.'
+    );
+  }
+  if (!options?.projectKey) {
+    throw new Error("useBundles: `projectKey` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const bundles = ref15([]);
+  const loading = ref15(false);
+  const error = ref15(null);
+  const baseUrl = `${options.adminEndpoint}/catalog/bundles`;
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new BundlesApiError(
+        res.status,
+        body,
+        `Bundles-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(
+        `${baseUrl}?projectKey=${encodeURIComponent(options.projectKey)}`
+      );
+      bundles.value = data ?? [];
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function create(data) {
+    const created = await fetchJson(baseUrl, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (!created) throw new BundlesApiError(0, null, "Create gab keinen Body zur\xFCck");
+    bundles.value = [...bundles.value, created];
+    return created;
+  }
+  async function update(bundleId, data) {
+    const updated = await fetchJson(`${baseUrl}/${bundleId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    if (!updated) throw new BundlesApiError(0, null, "Update gab keinen Body zur\xFCck");
+    bundles.value = bundles.value.map((b) => b.id === bundleId ? updated : b);
+    return updated;
+  }
+  async function softDelete(bundleId) {
+    await fetchJson(`${baseUrl}/${bundleId}`, { method: "DELETE" });
+    bundles.value = bundles.value.filter((b) => b.id !== bundleId);
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return { bundles, loading, error, load, create, update, softDelete };
+}
+function useBundleVersions(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error("useBundleVersions: `adminEndpoint` ist Pflicht.");
+  }
+  if (!options?.bundleId) {
+    throw new Error("useBundleVersions: `bundleId` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const versions = ref15([]);
+  const loading = ref15(false);
+  const error = ref15(null);
+  const bundleVersionsUrl = `${options.adminEndpoint}/catalog/bundles/${options.bundleId}/versions`;
+  const versionUrlBase = `${options.adminEndpoint}/catalog/bundle-versions`;
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new BundlesApiError(
+        res.status,
+        body,
+        `BundleVersions-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(bundleVersionsUrl);
+      versions.value = data ?? [];
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function createDraft(data) {
+    const result = await fetchJson(bundleVersionsUrl, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (!result) throw new BundlesApiError(0, null, "CreateDraft gab keinen Body zur\xFCck");
+    versions.value = [...versions.value, result.bundleVersion];
+    return result;
+  }
+  async function updateDraft(versionId, data) {
+    const result = await fetchJson(
+      `${versionUrlBase}/${versionId}`,
+      { method: "PATCH", body: JSON.stringify(data) }
+    );
+    if (!result) throw new BundlesApiError(0, null, "UpdateDraft gab keinen Body zur\xFCck");
+    versions.value = versions.value.map((v) => v.id === versionId ? result.bundleVersion : v);
+    return result;
+  }
+  async function publish(versionId, opts = {}) {
+    const result = await fetchJson(
+      `${versionUrlBase}/${versionId}/publish`,
+      { method: "POST", body: JSON.stringify(opts) }
+    );
+    if (!result) throw new BundlesApiError(0, null, "Publish gab keinen Body zur\xFCck");
+    await load();
+    return result;
+  }
+  async function discardDraft(versionId) {
+    await fetchJson(`${versionUrlBase}/${versionId}`, { method: "DELETE" });
+    versions.value = versions.value.filter((v) => v.id !== versionId);
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return { versions, loading, error, load, createDraft, updateDraft, publish, discardDraft };
+}
+
+// src/use-bundle-versions-map.ts
+import { ref as ref16, watch as watch2 } from "vue";
+function useBundleVersionsMap(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error("useBundleVersionsMap: `adminEndpoint` ist Pflicht.");
+  }
+  if (!options?.bundles) {
+    throw new Error("useBundleVersionsMap: `bundles` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const versionsByBundle = ref16({});
+  const loading = ref16(false);
+  const error = ref16(null);
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function loadForBundle(bundleId) {
+    const res = await http(`${options.adminEndpoint}/catalog/bundles/${bundleId}/versions`, {
+      method: "GET",
+      headers: { "content-type": "application/json", ...authHeaders() }
+    });
+    if (res.status >= 400) {
+      throw new Error(`HTTP ${res.status} beim Laden der Versionen f\xFCr Bundle '${bundleId}'`);
+    }
+    return await res.json().catch(() => null) ?? [];
+  }
+  async function refresh() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const entries = await Promise.all(
+        options.bundles.value.map(async (b) => {
+          try {
+            const versions = await loadForBundle(b.id);
+            return [b.id, versions];
+          } catch (err) {
+            console.warn(
+              `useBundleVersionsMap: Bundle '${b.bundleKey}' Versions-Load failed`,
+              err
+            );
+            return [b.id, []];
+          }
+        })
+      );
+      versionsByBundle.value = Object.fromEntries(entries);
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function refreshOne(bundleId) {
+    try {
+      const versions = await loadForBundle(bundleId);
+      versionsByBundle.value = { ...versionsByBundle.value, [bundleId]: versions };
+    } catch (err) {
+      console.warn(`useBundleVersionsMap: refreshOne('${bundleId}') failed`, err);
+    }
+  }
+  watch2(
+    () => options.bundles.value.map((b) => b.id).join(","),
+    () => {
+      if (options.bundles.value.length > 0) void refresh();
+      else versionsByBundle.value = {};
+    },
+    { immediate: true }
+  );
+  return { versionsByBundle, loading, error, refresh, refreshOne };
+}
+
+// src/use-tenant-subscription-bundles.ts
+import { ref as ref17 } from "vue";
+var TenantSubscriptionBundlesApiError = class extends Error {
+  constructor(status, body, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "TenantSubscriptionBundlesApiError";
+  }
+  status;
+  body;
+};
+function useTenantSubscriptionBundles(options) {
+  if (!options?.billingEndpoint) {
+    throw new Error(
+      'useTenantSubscriptionBundles: `billingEndpoint` ist Pflicht (z. B. "/api/v1").'
+    );
+  }
+  const http = options.http ?? defaultHttpClient();
+  const baseUrl = `${options.billingEndpoint}/billing/subscription-bundles`;
+  const bundles = ref17([]);
+  const loading = ref17(false);
+  const error = ref17(null);
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new TenantSubscriptionBundlesApiError(
+        res.status,
+        body,
+        `SubscriptionBundle-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(baseUrl);
+      bundles.value = (data ?? []).map(rehydrateDates);
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function add(data) {
+    const result = await fetchJson(baseUrl, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (!result) {
+      throw new TenantSubscriptionBundlesApiError(0, null, "add gab keinen Body zur\xFCck");
+    }
+    const hydrated = rehydrateDates(result);
+    bundles.value = [hydrated, ...bundles.value];
+    return hydrated;
+  }
+  async function cancel(subscriptionBundleId, opts = {}) {
+    const result = await fetchJson(
+      `${baseUrl}/${subscriptionBundleId}`,
+      { method: "DELETE", body: JSON.stringify(opts) }
+    );
+    if (!result) {
+      throw new TenantSubscriptionBundlesApiError(0, null, "cancel gab keinen Body zur\xFCck");
+    }
+    const hydrated = rehydrateDates(result);
+    bundles.value = bundles.value.map((b) => b.id === subscriptionBundleId ? hydrated : b);
+    return hydrated;
+  }
+  if (options.autoLoad) void load();
+  return { bundles, loading, error, load, add, cancel };
+}
+function rehydrateDates(raw) {
+  return {
+    ...raw,
+    startedAt: new Date(raw.startedAt),
+    minimumTermEndsAt: raw.minimumTermEndsAt ? new Date(raw.minimumTermEndsAt) : null,
+    canceledAt: raw.canceledAt ? new Date(raw.canceledAt) : null,
+    canceledEffectiveAt: raw.canceledEffectiveAt ? new Date(raw.canceledEffectiveAt) : null,
+    createdAt: new Date(raw.createdAt),
+    updatedAt: new Date(raw.updatedAt)
+  };
+}
+
+// src/use-business-types.ts
+import { ref as ref18 } from "vue";
+var BusinessTypesApiError = class extends Error {
+  constructor(status, body, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "BusinessTypesApiError";
+  }
+  status;
+  body;
+};
+function useBusinessTypes(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error("useBusinessTypes: `adminEndpoint` ist Pflicht.");
+  }
+  if (!options?.projectKey) {
+    throw new Error("useBusinessTypes: `projectKey` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const businessTypes = ref18([]);
+  const loading = ref18(false);
+  const error = ref18(null);
+  const baseUrl = `${options.adminEndpoint}/catalog/business-types`;
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new BusinessTypesApiError(
+        res.status,
+        body,
+        `BusinessTypes-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(
+        `${baseUrl}?projectKey=${encodeURIComponent(options.projectKey)}`
+      );
+      businessTypes.value = data ?? [];
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function create(data) {
+    const created = await fetchJson(baseUrl, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (!created) throw new BusinessTypesApiError(0, null, "Create gab keinen Body zur\xFCck");
+    businessTypes.value = [...businessTypes.value, created];
+    return created;
+  }
+  async function update(businessTypeId, data) {
+    const updated = await fetchJson(`${baseUrl}/${businessTypeId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    if (!updated) throw new BusinessTypesApiError(0, null, "Update gab keinen Body zur\xFCck");
+    businessTypes.value = businessTypes.value.map(
+      (b) => b.id === businessTypeId ? updated : b
+    );
+    return updated;
+  }
+  async function softDelete(businessTypeId) {
+    await fetchJson(`${baseUrl}/${businessTypeId}`, { method: "DELETE" });
+    businessTypes.value = businessTypes.value.filter((b) => b.id !== businessTypeId);
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return { businessTypes, loading, error, load, create, update, softDelete };
+}
+function useBusinessTypeVersions(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error("useBusinessTypeVersions: `adminEndpoint` ist Pflicht.");
+  }
+  if (!options?.businessTypeId) {
+    throw new Error("useBusinessTypeVersions: `businessTypeId` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const versions = ref18([]);
+  const loading = ref18(false);
+  const error = ref18(null);
+  const versionsUrl = `${options.adminEndpoint}/catalog/business-types/${options.businessTypeId}/versions`;
+  const versionUrlBase = `${options.adminEndpoint}/catalog/business-type-versions`;
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new BusinessTypesApiError(
+        res.status,
+        body,
+        `BusinessTypeVersions-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(versionsUrl);
+      versions.value = data ?? [];
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function createDraft(data) {
+    const result = await fetchJson(versionsUrl, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (!result) throw new BusinessTypesApiError(0, null, "CreateDraft gab keinen Body zur\xFCck");
+    versions.value = [...versions.value, result.businessTypeVersion];
+    return result;
+  }
+  async function updateDraft(versionId, data) {
+    const result = await fetchJson(
+      `${versionUrlBase}/${versionId}`,
+      { method: "PATCH", body: JSON.stringify(data) }
+    );
+    if (!result) throw new BusinessTypesApiError(0, null, "UpdateDraft gab keinen Body zur\xFCck");
+    versions.value = versions.value.map(
+      (v) => v.id === versionId ? result.businessTypeVersion : v
+    );
+    return result;
+  }
+  async function publish(versionId, opts = {}) {
+    const result = await fetchJson(
+      `${versionUrlBase}/${versionId}/publish`,
+      { method: "POST", body: JSON.stringify(opts) }
+    );
+    if (!result) throw new BusinessTypesApiError(0, null, "Publish gab keinen Body zur\xFCck");
+    await load();
+    return result;
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return { versions, loading, error, load, createDraft, updateDraft, publish };
+}
+
+// src/use-marketing-projections.ts
+import { ref as ref19 } from "vue";
+var MarketingProjectionsApiError = class extends Error {
+  constructor(status, body, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "MarketingProjectionsApiError";
+  }
+  status;
+  body;
+};
+function useMarketingProjections(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error("useMarketingProjections: `adminEndpoint` ist Pflicht.");
+  }
+  if (!options?.filter?.projectKey) {
+    throw new Error("useMarketingProjections: `filter.projectKey` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const projections = ref19([]);
+  const filter = ref19({ ...options.filter });
+  const loading = ref19(false);
+  const error = ref19(null);
+  const baseUrl = `${options.adminEndpoint}/catalog/marketing-projections`;
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  function buildListUrl() {
+    const params = new URLSearchParams();
+    params.set("projectKey", filter.value.projectKey);
+    if (filter.value.targetType) params.set("targetType", filter.value.targetType);
+    if (filter.value.targetVersionId)
+      params.set("targetVersionId", filter.value.targetVersionId);
+    if (filter.value.locale) params.set("locale", filter.value.locale);
+    return `${baseUrl}?${params.toString()}`;
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new MarketingProjectionsApiError(
+        res.status,
+        body,
+        `MarketingProjections-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(buildListUrl());
+      projections.value = data ?? [];
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function setFilter(next) {
+    filter.value = { ...next };
+    await load();
+  }
+  async function create(data) {
+    const created = await fetchJson(baseUrl, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (!created) {
+      throw new MarketingProjectionsApiError(0, null, "Create gab keinen Body zur\xFCck");
+    }
+    await load();
+    return created;
+  }
+  async function update(id, data) {
+    const updated = await fetchJson(`${baseUrl}/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    if (!updated) {
+      throw new MarketingProjectionsApiError(0, null, "Update gab keinen Body zur\xFCck");
+    }
+    projections.value = projections.value.map((p) => p.id === id ? updated : p);
+    return updated;
+  }
+  async function remove(id) {
+    await fetchJson(`${baseUrl}/${id}`, { method: "DELETE" });
+    projections.value = projections.value.filter((p) => p.id !== id);
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return { projections, filter, loading, error, setFilter, load, create, update, remove };
+}
+
+// src/use-promotions.ts
+import { ref as ref20 } from "vue";
+var PromotionsApiError = class extends Error {
+  constructor(status, body, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "PromotionsApiError";
+  }
+  status;
+  body;
+};
+function usePromotions(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error("usePromotions: `adminEndpoint` ist Pflicht.");
+  }
+  if (!options?.projectKey) {
+    throw new Error("usePromotions: `projectKey` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const promotions = ref20([]);
+  const loading = ref20(false);
+  const error = ref20(null);
+  const baseUrl = `${options.adminEndpoint}/catalog/promotions`;
+  const pk = encodeURIComponent(options.projectKey);
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new PromotionsApiError(
+        res.status,
+        body,
+        `Promotions-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(`${baseUrl}?projectKey=${pk}`);
+      promotions.value = data ?? [];
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function create(data) {
+    const created = await fetchJson(baseUrl, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (!created) throw new PromotionsApiError(0, null, "Create gab keinen Body zur\xFCck");
+    promotions.value = [...promotions.value, created];
+    return created;
+  }
+  async function update(id, data) {
+    const updated = await fetchJson(`${baseUrl}/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    if (!updated) throw new PromotionsApiError(0, null, "Update gab keinen Body zur\xFCck");
+    promotions.value = promotions.value.map((p) => p.id === id ? updated : p);
+    return updated;
+  }
+  async function remove(id) {
+    await fetchJson(`${baseUrl}/${id}`, { method: "DELETE" });
+    promotions.value = promotions.value.filter((p) => p.id !== id);
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return { promotions, loading, error, load, create, update, remove };
+}
+
+// src/use-plans.ts
+import { ref as ref21 } from "vue";
+var PlansApiError = class extends Error {
+  constructor(status, body, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "PlansApiError";
+  }
+  status;
+  body;
+};
+function usePlans(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error(
+      'usePlans: `adminEndpoint` ist Pflicht (z. B. "/api/admin" oder "/api/v1/admin").'
+    );
+  }
+  if (!options?.projectKey) {
+    throw new Error("usePlans: `projectKey` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const plans = ref21([]);
+  const loading = ref21(false);
+  const error = ref21(null);
+  const tenantCountsByPlanKey = ref21({});
+  const baseUrl = `${options.adminEndpoint}/catalog/plans`;
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: {
+        "content-type": "application/json",
+        ...authHeaders(),
+        ...init?.headers
+      },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new PlansApiError(
+        res.status,
+        body,
+        `Plans-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(
+        `${baseUrl}?projectKey=${encodeURIComponent(options.projectKey)}`
+      );
+      plans.value = data ?? [];
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function loadTenantCounts() {
+    try {
+      const data = await fetchJson(
+        `${baseUrl}/tenant-counts?projectKey=${encodeURIComponent(options.projectKey)}`
+      );
+      tenantCountsByPlanKey.value = data ?? {};
+    } catch {
+      tenantCountsByPlanKey.value = {};
+    }
+  }
+  async function create(data) {
+    const created = await fetchJson(baseUrl, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (!created) throw new PlansApiError(0, null, "Create gab keinen Body zur\xFCck");
+    plans.value = [...plans.value, created];
+    return created;
+  }
+  async function update(planId, data) {
+    const updated = await fetchJson(`${baseUrl}/${planId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    if (!updated) throw new PlansApiError(0, null, "Update gab keinen Body zur\xFCck");
+    plans.value = plans.value.map((p) => p.id === planId ? updated : p);
+    return updated;
+  }
+  async function softDelete(planId) {
+    await fetchJson(`${baseUrl}/${planId}`, { method: "DELETE" });
+    plans.value = plans.value.filter((p) => p.id !== planId);
+  }
+  async function hardDelete(planId) {
+    await fetchJson(`${baseUrl}/${planId}/purge`, { method: "DELETE" });
+    plans.value = plans.value.filter((p) => p.id !== planId);
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return {
+    plans,
+    loading,
+    error,
+    tenantCountsByPlanKey,
+    load,
+    loadTenantCounts,
+    create,
+    update,
+    softDelete,
+    hardDelete
+  };
+}
+function usePlanVersions(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error("usePlanVersions: `adminEndpoint` ist Pflicht.");
+  }
+  if (!options?.planId) {
+    throw new Error("usePlanVersions: `planId` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const versions = ref21([]);
+  const loading = ref21(false);
+  const error = ref21(null);
+  const planVersionsUrl = `${options.adminEndpoint}/catalog/plans/${options.planId}/versions`;
+  const versionUrlBase = `${options.adminEndpoint}/catalog/plan-versions`;
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function fetchJson(url, init) {
+    const res = await http(url, {
+      method: init?.method ?? "GET",
+      headers: {
+        "content-type": "application/json",
+        ...authHeaders(),
+        ...init?.headers
+      },
+      body: init?.body
+    });
+    if (res.status === 204) return null;
+    const body = await res.json().catch(() => null);
+    if (res.status >= 400) {
+      throw new PlansApiError(
+        res.status,
+        body,
+        `PlanVersions-API antwortete mit HTTP ${res.status}`
+      );
+    }
+    return body;
+  }
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await fetchJson(planVersionsUrl);
+      versions.value = data ?? [];
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function createDraft(data) {
+    const result = await fetchJson(planVersionsUrl, {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    if (!result) throw new PlansApiError(0, null, "CreateDraft gab keinen Body zur\xFCck");
+    versions.value = [...versions.value, result.planVersion];
+    return result;
+  }
+  async function updateDraft(versionId, data) {
+    const result = await fetchJson(
+      `${versionUrlBase}/${versionId}`,
+      { method: "PATCH", body: JSON.stringify(data) }
+    );
+    if (!result) throw new PlansApiError(0, null, "UpdateDraft gab keinen Body zur\xFCck");
+    versions.value = versions.value.map((v) => v.id === versionId ? result.planVersion : v);
+    return result;
+  }
+  async function publish(versionId, opts = {}) {
+    const result = await fetchJson(
+      `${versionUrlBase}/${versionId}/publish`,
+      { method: "POST", body: JSON.stringify(opts) }
+    );
+    if (!result) throw new PlansApiError(0, null, "Publish gab keinen Body zur\xFCck");
+    versions.value = versions.value.map((v) => v.id === versionId ? result.planVersion : v);
+    return result;
+  }
+  async function discardDraft(versionId) {
+    await fetchJson(`${versionUrlBase}/${versionId}`, { method: "DELETE" });
+    versions.value = versions.value.filter((v) => v.id !== versionId);
+  }
+  async function terminateVersion(versionId, endsAt) {
+    const updated = await fetchJson(
+      `${versionUrlBase}/${versionId}/terminate`,
+      { method: "POST", body: JSON.stringify({ endsAt }) }
+    );
+    if (!updated) throw new PlansApiError(0, null, "Terminate gab keinen Body zur\xFCck");
+    versions.value = versions.value.map((v) => v.id === versionId ? updated : v);
+    return updated;
+  }
+  if (options.autoLoad) {
+    void load();
+  }
+  return {
+    versions,
+    loading,
+    error,
+    load,
+    createDraft,
+    updateDraft,
+    publish,
+    discardDraft,
+    terminateVersion
+  };
+}
+
+// src/use-live-plan-versions.ts
+import { ref as ref22, watch as watch3 } from "vue";
+function useLivePlanVersions(options) {
+  if (!options?.adminEndpoint) {
+    throw new Error("useLivePlanVersions: `adminEndpoint` ist Pflicht.");
+  }
+  if (!options?.plans) {
+    throw new Error("useLivePlanVersions: `plans` ist Pflicht.");
+  }
+  const http = options.http ?? defaultHttpClient();
+  const livePlanVersions = ref22({});
+  const loading = ref22(false);
+  const error = ref22(null);
+  function authHeaders() {
+    const token = options.getAuthToken?.();
+    return token ? { Authorization: `Bearer ${token}` } : {};
+  }
+  async function loadForPlan(planId) {
+    const res = await http(`${options.adminEndpoint}/catalog/plans/${planId}/versions`, {
+      method: "GET",
+      headers: { "content-type": "application/json", ...authHeaders() }
+    });
+    if (res.status >= 400) {
+      throw new Error(`HTTP ${res.status} beim Laden der Versionen f\xFCr Plan '${planId}'`);
+    }
+    const versions = await res.json().catch(() => null);
+    if (!versions || versions.length === 0) return null;
+    return findLatestLive(versions);
+  }
+  async function refresh() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const entries = await Promise.all(
+        options.plans.value.map(async (plan) => {
+          try {
+            const live = await loadForPlan(plan.id);
+            return [plan.planKey, live];
+          } catch (err) {
+            console.warn(
+              `useLivePlanVersions: Plan '${plan.planKey}' Versions-Load failed`,
+              err
+            );
+            return [plan.planKey, null];
+          }
+        })
+      );
+      livePlanVersions.value = Object.fromEntries(entries);
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      loading.value = false;
+    }
+  }
+  watch3(
+    () => options.plans.value.map((p) => p.id).join(","),
+    () => {
+      if (options.plans.value.length > 0) void refresh();
+      else livePlanVersions.value = {};
+    },
+    { immediate: true }
+  );
+  return { livePlanVersions, loading, error, refresh };
+}
+function findLatestLive(versions) {
+  const candidates = versions.filter((v) => v.publishedAt !== null && v.supersededAt === null);
+  if (candidates.length === 0) return null;
+  return [...candidates].sort((a, b) => {
+    const av = a.validFrom ?? "";
+    const bv = b.validFrom ?? "";
+    if (av === bv) return b.version - a.version;
+    return bv.localeCompare(av);
+  })[0];
+}
+
+// src/use-manifest.ts
+import { ref as ref23 } from "vue";
+function useManifest(options) {
+  const loader = new ManifestLoader(options);
+  const manifest = ref23(null);
+  const loading = ref23(false);
+  const error = ref23(null);
+  async function load() {
+    loading.value = true;
+    error.value = null;
+    try {
+      manifest.value = await loader.load();
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      manifest.value = null;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function reload() {
+    loader.clearCache();
+    manifest.value = null;
+    await load();
+  }
+  function clearCache() {
+    loader.clearCache();
+    manifest.value = null;
+  }
+  return { manifest, loading, error, load, reload, clearCache };
+}
+
+// src/use-nav.ts
+import { computed as computed5 } from "vue";
+function useNav(manifest, options = {}) {
+  const routes = computed5(() => {
+    if (!manifest.value) return [];
+    return buildRoutes(manifest.value, options);
+  });
+  const sidebar = computed5(() => buildSidebar(routes.value));
+  return { routes, sidebar };
+}
+
+// src/use-actions.ts
+import { computed as computed6 } from "vue";
+function useActions(manifest, actions) {
+  const registry = computed6(() => {
+    if (!manifest.value) return null;
+    return new ActionRegistry(manifest.value, actions);
+  });
+  return { registry };
+}
+
+// src/use-tenant-action-flow.ts
+import { computed as computed7 } from "vue";
+
+// src/use-super-admin-context.ts
+import { inject as inject3 } from "vue";
+function useSuperAdminExtensions() {
+  return inject3(SUPER_ADMIN_EXTENSIONS_KEY, {});
+}
+function useSuperAdminActions() {
+  return inject3(SUPER_ADMIN_ACTIONS_KEY, {});
+}
+function useSuperAdminBrand() {
+  const brand = inject3(SUPER_ADMIN_BRAND_KEY);
+  if (!brand) {
+    throw new Error(
+      "useSuperAdminBrand(): kein SuperAdmin-Branding im Inject-Scope. Wurde die Komponente innerhalb createSuperAdminApp() gemounted?"
+    );
+  }
+  return brand;
+}
+function useSuperAdminEndpoints() {
+  const endpoints = inject3(SUPER_ADMIN_ENDPOINTS_KEY);
+  if (!endpoints) {
+    throw new Error(
+      "useSuperAdminEndpoints(): keine Endpoints im Inject-Scope. Wurde die Komponente innerhalb createSuperAdminApp() gemounted?"
+    );
+  }
+  return endpoints;
+}
+function useSuperAdminManifest() {
+  const accessor = inject3(SUPER_ADMIN_MANIFEST_KEY, null);
+  return accessor ? accessor() : null;
+}
+function useSuperAdminLoginAdapter() {
+  const adapter = inject3(SUPER_ADMIN_LOGIN_ADAPTER_KEY);
+  if (!adapter) {
+    throw new Error(
+      "useSuperAdminLoginAdapter(): kein Login-Adapter registriert. Reiche ihn via createSuperAdminApp({ loginAdapter }) ein."
+    );
+  }
+  return adapter;
+}
+function useSuperAdminHttp() {
+  return inject3(SUPER_ADMIN_HTTP_KEY, defaultHttpClient());
+}
+
+// src/use-tenant-action-flow.ts
+function useTenantActionFlow(manifest, providers = {}) {
+  const handlers = useSuperAdminActions();
+  const registry = computed7(() => {
+    if (!manifest.value) return null;
+    return new ActionRegistry(manifest.value, handlers);
+  });
+  const orphanedDefs = computed7(
+    () => registry.value ? registry.value.listOrphanedDefs() : []
+  );
+  const availableActions = computed7(() => {
+    const m = manifest.value;
+    const reg = registry.value;
+    if (!m || !reg) return [];
+    const defs = m.tenants?.actions ?? [];
+    const caps = m.capabilities ?? {};
+    const orphans = new Set(reg.listOrphanedDefs());
+    return defs.filter((def) => passesStaticGates(def, caps, orphans));
+  });
+  function actionsForRow(row) {
+    const reg = registry.value;
+    if (!reg) return [];
+    return availableActions.value.filter((def) => !providers.visibleForRow || providers.visibleForRow(def, row)).map((def) => ({
+      def,
+      invoke: (r) => runFlow(def, r ?? row, reg, providers)
+    }));
+  }
+  return { registry, availableActions, actionsForRow, orphanedDefs };
+}
+function passesStaticGates(def, capabilities, orphanedKeys) {
+  if (def.requiredCapability && capabilities[def.requiredCapability] === false) {
+    return false;
+  }
+  if (orphanedKeys.has(def.actionKey)) {
+    return false;
+  }
+  return true;
+}
+async function runFlow(def, row, registry, providers) {
+  let reason = null;
+  let extras = {};
+  if (def.confirmType && def.confirmType !== "none") {
+    if (!providers.confirm) {
+      throw new Error(
+        `useTenantActionFlow: Action "${def.id}" verlangt confirmType="${def.confirmType}", aber kein \`confirm\`-Provider \xFCbergeben.`
+      );
+    }
+    const c = await providers.confirm(def, { row });
+    if (!c.ok) return void 0;
+    reason = c.reason ?? null;
+    if (c.extras) extras = c.extras;
+  }
+  let mfaCode = null;
+  if (def.requiresMfa) {
+    if (!providers.mfa) {
+      throw new Error(
+        `useTenantActionFlow: Action "${def.id}" verlangt MFA, aber kein \`mfa\`-Provider \xFCbergeben.`
+      );
+    }
+    mfaCode = await providers.mfa(def, { row });
+    if (mfaCode === null) return void 0;
+  }
+  let resolved;
+  try {
+    resolved = registry.get(def.actionKey);
+  } catch (err) {
+    providers.notify?.("negative", err instanceof Error ? err.message : String(err));
+    throw err;
+  }
+  try {
+    const input = { row, mfaCode, reason, extras };
+    const result = await resolved.handler(input);
+    providers.notify?.("positive", `${def.label}: erfolgreich.`);
+    providers.onSuccess?.(def, { row });
+    return result;
+  } catch (err) {
+    const message = err?.response?.data?.message ?? (err instanceof Error ? err.message : String(err));
+    providers.notify?.("negative", message);
+    throw err;
+  }
+}
+
+// src/use-platform-tenant-actions.ts
+import { computed as computed8, ref as ref24 } from "vue";
+var DEFAULT_VISIBLE_FOR_ROW = (def, row) => {
+  if (def.actionKey === "tenants.suspend") return row.isActive;
+  if (def.actionKey === "tenants.reactivate") return !row.isActive;
+  return true;
+};
+var DEFAULT_MFA_DESCRIPTION = (def, row) => `${def.label} \u2014 Tenant \u201E${row.name}". TOTP-Code aus Authenticator eingeben.`;
+var DEFAULT_ICON_FOR_ACTION_KEY = (actionKey) => {
+  if (actionKey.endsWith(".suspend")) return "block";
+  if (actionKey.endsWith(".reactivate")) return "play_arrow";
+  if (actionKey.endsWith(".grant")) return "star";
+  if (actionKey.endsWith(".revoke")) return "star_outline";
+  if (actionKey.endsWith(".impersonate")) return "switch_account";
+  if (actionKey.endsWith(".export")) return "download";
+  return "bolt";
+};
+var DEFAULT_TONE_FOR_ACTION_KEY = (actionKey) => {
+  if (actionKey.endsWith(".suspend") || actionKey.endsWith(".revoke")) return "negative";
+  if (actionKey.endsWith(".reactivate") || actionKey.endsWith(".grant")) return "positive";
+  return "primary";
+};
+function defaultIconForActionKey(actionKey) {
+  return DEFAULT_ICON_FOR_ACTION_KEY(actionKey);
+}
+function defaultToneForActionKey(actionKey) {
+  return DEFAULT_TONE_FOR_ACTION_KEY(actionKey);
+}
+function usePlatformTenantActions(options) {
+  const mfaDescription = options.mfaDescription ?? DEFAULT_MFA_DESCRIPTION;
+  const iconForActionKey = options.iconForActionKey ?? DEFAULT_ICON_FOR_ACTION_KEY;
+  const toneForActionKey = options.toneForActionKey ?? DEFAULT_TONE_FOR_ACTION_KEY;
+  const visibleForRow = options.visibleForRow ?? DEFAULT_VISIBLE_FOR_ROW;
+  const mfa = ref24({ show: false, description: "", error: "" });
+  let pendingMfaResolve = null;
+  function showMfaDialog(def, ctx) {
+    return new Promise((resolve) => {
+      mfa.value = {
+        show: true,
+        description: mfaDescription(def, ctx.row),
+        error: ""
+      };
+      pendingMfaResolve = (code) => {
+        pendingMfaResolve = null;
+        resolve(code);
+      };
+    });
+  }
+  function onMfaConfirm(code) {
+    pendingMfaResolve?.(code);
+    mfa.value.show = false;
+  }
+  function onMfaDialogVisibility(open) {
+    mfa.value.show = open;
+    if (!open && pendingMfaResolve) {
+      pendingMfaResolve(null);
+    }
+  }
+  const confirmDialog = ref24({
+    show: false,
+    def: null,
+    row: null
+  });
+  let pendingConfirmResolve = null;
+  function showConfirmDialog(def, ctx) {
+    return new Promise((resolve) => {
+      confirmDialog.value = { show: true, def, row: ctx.row };
+      pendingConfirmResolve = (result) => {
+        pendingConfirmResolve = null;
+        resolve(result);
+      };
+    });
+  }
+  function onConfirmSubmit(payload) {
+    pendingConfirmResolve?.({
+      ok: true,
+      reason: payload.reason,
+      extras: payload.extras
+    });
+    confirmDialog.value.show = false;
+  }
+  function onConfirmCancel() {
+    pendingConfirmResolve?.({ ok: false });
+    confirmDialog.value.show = false;
+  }
+  function onConfirmDialogVisibility(open) {
+    confirmDialog.value.show = open;
+    if (!open && pendingConfirmResolve) {
+      pendingConfirmResolve({ ok: false });
+    }
+  }
+  const flow = useTenantActionFlow(options.manifest, {
+    confirm: showConfirmDialog,
+    mfa: showMfaDialog,
+    notify: options.notify,
+    onSuccess: () => {
+      void options.onSuccess();
+    },
+    visibleForRow
+  });
+  const manifestActions = computed8(
+    () => flow.availableActions.value.map((def) => ({
+      id: def.id,
+      label: def.label,
+      icon: iconForActionKey(def.actionKey),
+      tone: toneForActionKey(def.actionKey),
+      actionKey: def.actionKey,
+      condition: (row) => flow.actionsForRow(row).some((a) => a.def.actionKey === def.actionKey),
+      handler: (row) => {
+        const resolved = flow.actionsForRow(row).find((a) => a.def.actionKey === def.actionKey);
+        void resolved?.invoke(row);
+      }
+    }))
+  );
+  const realOrphans = computed8(() => {
+    const caps = options.manifest.value?.capabilities ?? {};
+    const defs = options.manifest.value?.tenants?.actions ?? [];
+    const defByActionKey = new Map(defs.map((d) => [d.actionKey, d]));
+    return flow.orphanedDefs.value.filter((actionKey) => {
+      const def = defByActionKey.get(actionKey);
+      const requiredCap = def?.requiredCapability;
+      if (!requiredCap) return true;
+      return caps[requiredCap] === true;
+    });
+  });
+  return {
+    manifestActions,
+    realOrphans,
+    mfa,
+    onMfaConfirm,
+    onMfaDialogVisibility,
+    confirmDialog,
+    onConfirmSubmit,
+    onConfirmCancel,
+    onConfirmDialogVisibility
+  };
+}
+
+// src/use-batch-columns.ts
+import { ref as ref25, watch as watch4 } from "vue";
+function useBatchColumns(manifest, tenantIds, options = {}) {
+  const fetcher = new BatchColumnFetcher(options);
+  const data = ref25({});
+  const loading = ref25(false);
+  const error = ref25(null);
+  async function load() {
+    if (!manifest.value || tenantIds.value.length === 0) {
+      data.value = {};
+      return;
+    }
+    loading.value = true;
+    error.value = null;
+    try {
+      data.value = await fetcher.fetchAll(manifest.value, tenantIds.value);
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      data.value = {};
+    } finally {
+      loading.value = false;
+    }
+  }
+  watch4([manifest, tenantIds], () => {
+    void load();
+  });
+  return { data, loading, error, reload: load };
+}
+
+// src/plan-versions-catalog.ts
+var dec = (s) => Number(s);
+function extractQuotas(p) {
+  if (p.quotas && Object.keys(p.quotas).length > 0) {
+    return { ...p.quotas };
+  }
+  const out = {};
+  if (typeof p.maxUsers === "number") out.users = p.maxUsers;
+  if (typeof p.maxVehicles === "number") out.vehicles = p.maxVehicles;
+  if (typeof p.maxStorageGb === "number") out.storageGb = p.maxStorageGb;
+  return out;
+}
+var sortByPublishedDesc = (rows) => [...rows].sort((a, b) => {
+  const at = a.publishedAt ? Date.parse(a.publishedAt) : Number.POSITIVE_INFINITY;
+  const bt = b.publishedAt ? Date.parse(b.publishedAt) : Number.POSITIVE_INFINITY;
+  if (at !== bt) return bt - at;
+  return b.version - a.version;
+});
+function findLiveAt(rows, asOfMs) {
+  const candidates = rows.filter((r) => {
+    if (r.publishedAt === null) return false;
+    if (Date.parse(r.publishedAt) > asOfMs) return false;
+    if (r.supersededAt !== null && Date.parse(r.supersededAt) <= asOfMs) return false;
+    return true;
+  });
+  if (candidates.length === 0) return null;
+  return [...candidates].sort((a, b) => b.version - a.version)[0] ?? null;
+}
+function findCurrentLive(rows) {
+  return rows.find((r) => r.publishedAt !== null && r.supersededAt === null) ?? null;
+}
+function findDraft(rows) {
+  return rows.find((r) => r.publishedAt === null) ?? null;
+}
+function groupBy(rows, keyOf) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const k = keyOf(r);
+    const list = out.get(k) ?? [];
+    list.push(r);
+    out.set(k, list);
+  }
+  return out;
+}
+function resolvePlan(source, liveBase) {
+  const quotas = extractQuotas(source);
+  return {
+    source,
+    liveBase,
+    isDraft: source.publishedAt === null,
+    planId: source.planId,
+    features: source.features,
+    quotas,
+    monthlyNet: dec(source.monthlyNet),
+    yearlyNet: dec(source.yearlyNet),
+    marketed: source.marketed,
+    version: source.version,
+    maxUsers: quotas.users,
+    maxVehicles: quotas.vehicles,
+    maxStorageGb: quotas.storageGb
+  };
+}
+function dateLabelDe(iso) {
+  return new Date(iso).toLocaleDateString("de-DE", {
+    day: "2-digit",
+    month: "short",
+    year: "numeric"
+  });
+}
+function buildDraftsSnapshot(data, sortPlansFn) {
+  const planByKey = groupBy(data.planVersions, (r) => r.planId);
+  const plans = [];
+  for (const [, rows] of planByKey) {
+    const draft = findDraft(rows);
+    const live = findCurrentLive(rows);
+    if (draft) plans.push(resolvePlan(draft, live));
+    else if (live) plans.push(resolvePlan(live, null));
+  }
+  const draftCount = plans.filter((p) => p.isDraft).length;
+  return {
+    id: "drafts",
+    kind: "drafts",
+    status: "DRAFT",
+    label: "Arbeitsstand",
+    title: draftCount === 0 ? "Keine offenen Drafts" : `${draftCount} offene${draftCount === 1 ? "r" : ""} Draft${draftCount === 1 ? "" : "s"} bereit f\xFCr Publish`,
+    description: draftCount === 0 ? "Lege einen Draft an, um Limits, Preise oder Features zu \xE4ndern. Drafts sind ohne MFA editierbar und werden erst beim Publish wirksam." : "Diese Tabelle zeigt, wie der Catalog nach Publish aller Drafts aussehen w\xFCrde. Bestehende Mandanten bleiben auf der vorherigen Version, bis sie aktiv migriert werden.",
+    asOf: null,
+    createdAt: null,
+    publishedAt: null,
+    authorEmail: null,
+    plans: sortPlansFn(plans),
+    draftCount,
+    regressionCount: 0
+  };
+}
+function buildActiveSnapshot(data, sortPlansFn) {
+  const planByKey = groupBy(data.planVersions, (r) => r.planId);
+  const plans = [];
+  for (const [, rows] of planByKey) {
+    const live = findCurrentLive(rows);
+    if (live) plans.push(resolvePlan(live, null));
+  }
+  if (plans.length === 0) return null;
+  const publishedDates = plans.map((p) => p.source.publishedAt).filter((t) => t !== null).sort();
+  const latestPublished = publishedDates[publishedDates.length - 1];
+  return {
+    id: "active",
+    kind: "active",
+    status: "ACTIVE",
+    label: "Aktuell",
+    title: "Live-Catalog",
+    description: "Diese Plan-Versionen sind aktuell f\xFCr neue Onboardings und f\xFCr Renewals nach Stichtag aktiv.",
+    asOf: latestPublished ?? null,
+    createdAt: null,
+    publishedAt: latestPublished ?? null,
+    authorEmail: null,
+    plans: sortPlansFn(plans),
+    draftCount: 0,
+    regressionCount: 0
+  };
+}
+function buildHistoricalSnapshots(data, sortPlansFn) {
+  const allPublishedAt = /* @__PURE__ */ new Set();
+  for (const r of data.planVersions) if (r.publishedAt) allPublishedAt.add(r.publishedAt);
+  if (allPublishedAt.size === 0) return [];
+  const planByKey = groupBy(data.planVersions, (r) => r.planId);
+  const liveTimestamps = /* @__PURE__ */ new Set();
+  for (const rows of planByKey.values()) {
+    const live = findCurrentLive(rows);
+    if (live?.publishedAt) liveTimestamps.add(live.publishedAt);
+  }
+  const liveSorted = [...liveTimestamps].sort();
+  const latestLive = liveSorted[liveSorted.length - 1];
+  const sortedDesc = [...allPublishedAt].sort((a, b) => Date.parse(b) - Date.parse(a));
+  const out = [];
+  for (const ts of sortedDesc) {
+    if (latestLive && Date.parse(ts) >= Date.parse(latestLive)) continue;
+    const tMs = Date.parse(ts) + 1;
+    const plans = [];
+    for (const [, rows] of planByKey) {
+      const live = findLiveAt(rows, tMs);
+      if (live) plans.push(resolvePlan(live, null));
+    }
+    if (plans.length === 0) continue;
+    const publishedAtThisEvent = data.planVersions.filter((r) => r.publishedAt === ts);
+    const regressionCount = publishedAtThisEvent.filter((r) => !r.nonRegressive).length;
+    const author = publishedAtThisEvent[0]?.publishedByUserId ?? null;
+    out.push({
+      id: `hist-${ts}`,
+      kind: "historical",
+      status: "ARCHIVED",
+      label: dateLabelDe(ts),
+      title: summarizeEvent(publishedAtThisEvent),
+      description: detailEvent(publishedAtThisEvent),
+      asOf: ts,
+      createdAt: ts,
+      publishedAt: ts,
+      authorEmail: author,
+      plans: sortPlansFn(plans),
+      draftCount: 0,
+      regressionCount
+    });
+  }
+  return out;
+}
+function summarizeEvent(rows) {
+  if (rows.length === 0) return "Publish-Event";
+  if (rows.length === 1) {
+    const r = rows[0];
+    return `${r.planId} v${r.version} publiziert`;
+  }
+  return `${rows.length} Versionen publiziert`;
+}
+function detailEvent(rows) {
+  if (rows.length === 0) return "";
+  const note = rows[0]?.changeNote ?? "";
+  return note.length > 0 ? note : "Snapshot rekonstruiert aus per-Entity-Versionen.";
+}
+function sortPlansBy(order) {
+  if (!order || order.length === 0) {
+    return (rows) => [...rows].sort((a, b) => a.planId.localeCompare(b.planId));
+  }
+  const idx = {};
+  for (let i = 0; i < order.length; i++) idx[order[i]] = i;
+  return (rows) => [...rows].sort((a, b) => {
+    const ai = idx[a.planId] ?? Number.POSITIVE_INFINITY;
+    const bi = idx[b.planId] ?? Number.POSITIVE_INFINITY;
+    if (ai !== bi) return ai - bi;
+    return a.planId.localeCompare(b.planId);
+  });
+}
+function buildSnapshots(data, options = {}) {
+  const sortPlansFn = sortPlansBy(options.planSortOrder);
+  const drafts = buildDraftsSnapshot(data, sortPlansFn);
+  const active = buildActiveSnapshot(data, sortPlansFn);
+  const historical = buildHistoricalSnapshots(data, sortPlansFn);
+  const out = [drafts];
+  if (active) out.push(active);
+  out.push(...historical);
+  return out;
+}
+function listOpenDrafts(data) {
+  return {
+    plans: sortByPublishedDesc(data.planVersions).filter((r) => r.publishedAt === null)
+  };
+}
+
+// src/components/dialogs/types.ts
+var DEFAULT_PILOT_COPY = {
+  tenantSubtitle: "Stammdaten des Mandanten",
+  tenantNameLabel: "Name des Mandanten",
+  tenantNamePlaceholder: "z. B. Muster GmbH",
+  slugPlaceholder: "muster-mandant",
+  adminEmailPlaceholder: "admin@example.com",
+  notePlaceholder: "z. B. Sales-Pilot \xB7 Demo-Zugang"
+};
+
+// src/components/bundle-editor/catalog-i18n.ts
+var CATALOG_DEFAULT_LOCALE = "de";
+function localized(i18n, locale, field) {
+  if (locale === CATALOG_DEFAULT_LOCALE) return void 0;
+  const value = i18n?.[locale]?.[field];
+  return value && value.trim().length > 0 ? value : void 0;
+}
+function resolveLabel(baseLabel, i18n, locale) {
+  return localized(i18n, locale, "label") ?? (baseLabel || void 0);
+}
+function buildFeatureRegistry(featureCatalog, locale) {
+  const registry = {};
+  for (const feature of featureCatalog) {
+    const label = resolveLabel(feature.label, feature.i18n, locale);
+    if (label) registry[feature.featureKey] = { label, core: feature.core };
+  }
+  return registry;
+}
+function buildQuotaRegistry(quotaCatalog, locale) {
+  const registry = {};
+  for (const quota of quotaCatalog) {
+    registry[quota.quotaKey] = {
+      label: resolveLabel(quota.label, quota.i18n, locale),
+      unit: localized(quota.i18n, locale, "unit") ?? (quota.unit || void 0)
+    };
+  }
+  return registry;
+}
+
+// src/platform-loaders.ts
+function resolveEndpoints(endpoints) {
+  return {
+    apiBase: endpoints.apiBase,
+    publicBootEndpoint: endpoints.publicBootEndpoint ?? `${endpoints.apiBase}/boot`,
+    manifestEndpoint: endpoints.manifestEndpoint ?? `${endpoints.apiBase}/manifest`
+  };
+}
+function createPlatformLoaders(options) {
+  const resolved = resolveEndpoints(options.endpoints);
+  const bootLoader = new BootLoader({
+    endpoint: resolved.publicBootEndpoint,
+    http: options.http
+  });
+  const manifestLoader = new ManifestLoader({
+    endpoint: resolved.manifestEndpoint,
+    http: options.http,
+    storage: options.storage,
+    storageKeyPrefix: options.storageKeyPrefix,
+    getAuthToken: options.getAuthToken
+  });
+  return { bootLoader, manifestLoader };
+}
+
+// src/manifest-store-factory.ts
+import { defineStore } from "pinia";
+import { ref as ref26 } from "vue";
+function createManifestStore(options) {
+  return defineStore(options.id ?? "admin-manifest", () => {
+    const manifest = ref26(null);
+    const loading = ref26(false);
+    const error = ref26(null);
+    const loaded = ref26(false);
+    let inflight = null;
+    async function load() {
+      loading.value = true;
+      error.value = null;
+      try {
+        manifest.value = await options.loader.load();
+        loaded.value = true;
+      } catch (err) {
+        const wrapped = err instanceof Error ? err : new Error(String(err));
+        error.value = wrapped;
+        manifest.value = null;
+        loaded.value = false;
+        throw wrapped;
+      } finally {
+        loading.value = false;
+        inflight = null;
+      }
+    }
+    function ensureLoaded() {
+      if (loaded.value) return Promise.resolve();
+      if (inflight) return inflight;
+      inflight = load();
+      return inflight;
+    }
+    function clearCache() {
+      options.loader.clearCache();
+      manifest.value = null;
+      loaded.value = false;
+      inflight = null;
+    }
+    async function reload() {
+      clearCache();
+      await ensureLoaded();
+    }
+    return { manifest, loading, error, loaded, ensureLoaded, clearCache, reload };
+  });
+}
+export {
+  ADMIN_UI_VERSION,
+  ActionDefNotInManifestError,
+  ActionRegistry,
+  BatchColumnDriftError,
+  BatchColumnFetcher,
+  BootLoadError,
+  BootLoader,
+  BundlesApiError,
+  BusinessTypesApiError,
+  CATALOG_DEFAULT_LOCALE,
+  CatalogEntriesApiError,
+  DEFAULT_I18N_DE,
+  DEFAULT_PILOT_COPY,
+  DEFAULT_SECTION_ORDER,
+  DEFAULT_STANDARD_PAGE_ROUTES,
+  DEFAULT_YEARLY_FACTOR,
+  DiscoveryLoadError,
+  ENTITLEMENT_INJECTION_KEY,
+  HttpJsonError,
+  ManifestLoadError,
+  ManifestLoader,
+  MarketingProjectionsApiError,
+  MissingHandlerError,
+  PlannedOnlyFeatureError,
+  PlansApiError,
+  ProjectPageHost,
+  PromotionsApiError,
+  SUPER_ADMIN_ACTIONS_KEY,
+  SUPER_ADMIN_BRAND_KEY,
+  SUPER_ADMIN_ENDPOINTS_KEY,
+  SUPER_ADMIN_EXTENSIONS_KEY,
+  SUPER_ADMIN_HTTP_KEY,
+  SUPER_ADMIN_LOGIN_ADAPTER_KEY,
+  SUPER_ADMIN_MANIFEST_KEY,
+  TenantSubscriptionBundlesApiError,
+  buildFeatureRegistry,
+  buildFeatureRouterGuard,
+  buildNavigationGuard,
+  buildQuotaRegistry,
+  buildRoutes,
+  buildSidebar,
+  buildSnapshots,
+  createAdminRoutes,
+  createManifestStore,
+  createPlatformLoaders,
+  createProjectPageHostRoute,
+  createSuperAdminApp,
+  defaultHttpClient,
+  defaultIconForActionKey,
+  defaultKvStore,
+  defaultToneForActionKey,
+  getJson,
+  listOpenDrafts,
+  postJson,
+  provideEntitlement,
+  resolveExtension,
+  trimTrailingSlashes,
+  useActions,
+  useApiList,
+  useAuditEntries,
+  useBatchColumns,
+  useBulkPublish,
+  useBundleVersions,
+  useBundleVersionsMap,
+  useBundles,
+  useBusinessTypeVersions,
+  useBusinessTypes,
+  useCatalogEntries,
+  useDiscovery,
+  useEntitlement,
+  useInjectedEntitlement,
+  useLivePlanVersions,
+  useManifest,
+  useMarketingProjections,
+  useNav,
+  usePlanEditor,
+  usePlanVersions,
+  usePlanVersionsCatalog,
+  usePlans,
+  usePlatformTenantActions,
+  usePromotions,
+  usePublicBoot,
+  useSubscriptionDraft,
+  useSuperAdminActions,
+  useSuperAdminBrand,
+  useSuperAdminEndpoints,
+  useSuperAdminExtensions,
+  useSuperAdminHttp,
+  useSuperAdminLoginAdapter,
+  useSuperAdminManifest,
+  useTenantActionFlow,
+  useTenantBilling,
+  useTenantBillingCatalog,
+  useTenantManifest,
+  useTenantSubscriptionBundles,
+  useTenants
+};