@saasicat/ui-vue 0.25.0 → 0.26.1

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(src_exports, {
   ALL_ROWS: () => ALL_ROWS,
   ActionDefNotInManifestError: () => ActionDefNotInManifestError,
   ActionRegistry: () => ActionRegistry,
+  AdminError: () => AdminError,
   BatchColumnDriftError: () => BatchColumnDriftError,
   BatchColumnFetcher: () => BatchColumnFetcher,
   BootLoadError: () => BootLoadError,
@@ -44,6 +45,10 @@ __export(src_exports, {
   IDENTITY_ACCENT_VALUES: () => IDENTITY_ACCENT_VALUES,
   IDENTITY_NEUTRAL: () => IDENTITY_NEUTRAL,
   IDENTITY_NEUTRAL_VALUE: () => IDENTITY_NEUTRAL_VALUE,
+  LIST_FIRST_PAGE: () => LIST_FIRST_PAGE,
+  LIST_PAGE_SIZE_DEFAULT: () => LIST_PAGE_SIZE_DEFAULT,
+  LIST_PAGE_SIZE_MAX: () => LIST_PAGE_SIZE_MAX,
+  LIST_PAGINATION_PARAMS: () => LIST_PAGINATION_PARAMS,
   ManifestLoadError: () => ManifestLoadError,
   ManifestLoader: () => ManifestLoader,
   MarketingProjectionsApiError: () => MarketingProjectionsApiError,
@@ -53,15 +58,18 @@ __export(src_exports, {
   PlansApiError: () => PlansApiError,
   ProjectPageHost: () => ProjectPageHost,
   PromotionsApiError: () => PromotionsApiError,
+  SA_COLOR_SCHEMES: () => SA_COLOR_SCHEMES,
   SA_INTL_LOCALES: () => SA_INTL_LOCALES,
   SA_LOCALES: () => SA_LOCALES,
   SA_LOCALE_LABELS: () => SA_LOCALE_LABELS,
   SA_LOCALE_STORAGE_KEY: () => SA_LOCALE_STORAGE_KEY,
   SA_MESSAGES: () => SA_MESSAGES,
   SA_THEME_KEY: () => SA_THEME_KEY,
+  SA_THEME_STORAGE_KEY: () => SA_THEME_STORAGE_KEY,
   SERVER_PAGE_SIZE_OPTIONS: () => SERVER_PAGE_SIZE_OPTIONS,
   SUPER_ADMIN_ACTIONS_KEY: () => SUPER_ADMIN_ACTIONS_KEY,
   SUPER_ADMIN_BRAND_KEY: () => SUPER_ADMIN_BRAND_KEY,
+  SUPER_ADMIN_CONFIRM_KEY: () => SUPER_ADMIN_CONFIRM_KEY,
   SUPER_ADMIN_ENDPOINTS_KEY: () => SUPER_ADMIN_ENDPOINTS_KEY,
   SUPER_ADMIN_EXTENSIONS_KEY: () => SUPER_ADMIN_EXTENSIONS_KEY,
   SUPER_ADMIN_HTTP_KEY: () => SUPER_ADMIN_HTTP_KEY,
@@ -70,19 +78,28 @@ __export(src_exports, {
   SUPER_ADMIN_MANIFEST_CLEAR_CACHE_KEY: () => SUPER_ADMIN_MANIFEST_CLEAR_CACHE_KEY,
   SUPER_ADMIN_MANIFEST_KEY: () => SUPER_ADMIN_MANIFEST_KEY,
   SUPER_ADMIN_NOTIFY_KEY: () => SUPER_ADMIN_NOTIFY_KEY,
+  SUPER_ADMIN_RESOURCES_KEY: () => SUPER_ADMIN_RESOURCES_KEY,
   TenantSubscriptionBundlesApiError: () => TenantSubscriptionBundlesApiError,
+  adminErrorMessage: () => adminErrorMessage,
+  auditResource: () => auditResource,
+  bindResource: () => bindResource,
   buildFeatureRegistry: () => buildFeatureRegistry,
   buildFeatureRouterGuard: () => buildFeatureRouterGuard,
   buildNavigationGuard: () => buildNavigationGuard,
   buildQuotaRegistry: () => buildQuotaRegistry,
   buildRoutes: () => buildRoutes,
   buildSidebar: () => buildSidebar,
+  clampListPage: () => clampListPage,
+  clampListPageSize: () => clampListPageSize,
   countPlans: () => countPlans,
   createAdminResourceClient: () => createAdminResourceClient,
   createAdminRoutes: () => createAdminRoutes,
+  createAxiosHttpClient: () => createAxiosHttpClient,
+  createFetchHttpClient: () => createFetchHttpClient,
   createManifestStore: () => createManifestStore,
   createPlatformLoaders: () => createPlatformLoaders,
   createProjectPageHostRoute: () => createProjectPageHostRoute,
+  createResourceRegistry: () => createResourceRegistry,
   createSaCatalog: () => createSaCatalog,
   createSaTheme: () => createSaTheme,
   createSuperAdminI18n: () => createSuperAdminI18n,
@@ -92,30 +109,57 @@ __export(src_exports, {
   defaultSectionOrder: () => defaultSectionOrder,
   defaultTenantPlanSectionI18n: () => defaultTenantPlanSectionI18n,
   defaultToneForActionKey: () => defaultToneForActionKey,
+  defineListOp: () => defineListOp,
   defineMessages: () => defineMessages,
+  defineResource: () => defineResource,
+  filterQueryString: () => filterQueryString,
   formatCurrency: () => formatCurrency,
   formatMessage: () => formatMessage,
   getJson: () => getJson,
   identityAccentAt: () => identityAccentAt,
   identityAccentFor: () => identityAccentFor,
   identityChipStyle: () => identityChipStyle,
+  isAdminError: () => isAdminError,
+  isAxiosNoResponseError: () => isAxiosNoResponseError,
   isCurrentlyValid: () => isCurrentlyValid,
+  isEmptyResponse: () => isEmptyResponse,
   isExpired: () => isExpired,
   isFutureScheduled: () => isFutureScheduled,
+  isPlatformError: () => isPlatformError,
   isProductionBoot: () => isProductionBoot,
   isSaBuiltinLocale: () => isSaBuiltinLocale,
+  isSentInQuery: () => isSentInQuery,
+  isTransportFailure: () => isTransportFailure,
+  listUrl: () => listUrl,
+  markEmptyResponse: () => markEmptyResponse,
+  markPlatformError: () => markPlatformError,
+  markTransportFailure: () => markTransportFailure,
   mergeMessages: () => mergeMessages,
   planChangeWizardI18n: () => planChangeWizardI18n,
+  planVersionsResource: () => planVersionsResource,
+  plansResource: () => plansResource,
+  platformResources: () => platformResources,
   postJson: () => postJson,
   provideEntitlement: () => provideEntitlement,
+  readErrorCode: () => readErrorCode,
+  readErrorDetail: () => readErrorDetail,
+  readListPage: () => readListPage,
+  requestJson: () => requestJson,
+  requestJsonBody: () => requestJsonBody,
+  requireServerAnswer: () => requireServerAnswer,
   resolveExtension: () => resolveExtension,
   resolveLoginBranding: () => resolveLoginBranding,
   resolveMessages: () => resolveMessages,
   resolvePlans: () => resolvePlans,
+  resolveSuperAdminEndpoints: () => resolveSuperAdminEndpoints,
+  tenantsResource: () => tenantsResource,
+  toAdminError: () => toAdminError,
   todayIsoDate: () => todayIsoDate,
   trimTrailingSlashes: () => trimTrailingSlashes,
   useActions: () => useActions,
   useApiList: () => useApiList,
+  useAsyncAction: () => useAsyncAction,
+  useAsyncData: () => useAsyncData,
   useAuditEntries: () => useAuditEntries,
   useBatchColumns: () => useBatchColumns,
   useBulkPublish: () => useBulkPublish,
@@ -137,6 +181,8 @@ __export(src_exports, {
   usePlatformTenantActions: () => usePlatformTenantActions,
   usePromotions: () => usePromotions,
   usePublicBoot: () => usePublicBoot,
+  useResource: () => useResource,
+  useResourceList: () => useResourceList,
   useSaMessages: () => useSaMessages,
   useSaTheme: () => useSaTheme,
   useSubscriptionDraft: () => useSubscriptionDraft,
@@ -160,6 +206,298 @@ module.exports = __toCommonJS(src_exports);
 // src/client/version.ts
 var ADMIN_UI_VERSION = "1.2.0";
 
+// src/client/attach-cause.ts
+function attachCause(error, cause) {
+  Object.defineProperty(error, "cause", {
+    value: cause,
+    configurable: true,
+    writable: true
+  });
+  return error;
+}
+
+// src/client/i18n/format.ts
+var import_types = require("@saasicat/types");
+function formatMessage(template, params) {
+  return (0, import_types.formatErrorMessage)(template, params);
+}
+
+// src/client/admin-error.ts
+var ADMIN_ERROR = /* @__PURE__ */ Symbol.for("@saasicat/ui-vue/AdminError");
+var PLATFORM_ERROR = /* @__PURE__ */ Symbol.for("@saasicat/ui-vue/PlatformError");
+function markPlatformError(error) {
+  Object.defineProperty(error, PLATFORM_ERROR, { value: true });
+}
+function isPlatformError(value) {
+  return typeof value === "object" && value !== null && PLATFORM_ERROR in value;
+}
+var EMPTY_RESPONSE = /* @__PURE__ */ Symbol.for("@saasicat/ui-vue/EmptyResponse");
+function markEmptyResponse(error) {
+  Object.defineProperty(error, EMPTY_RESPONSE, { value: true });
+  return error;
+}
+function isEmptyResponse(value) {
+  return typeof value === "object" && value !== null && EMPTY_RESPONSE in value;
+}
+var TRANSPORT_FAILURE = /* @__PURE__ */ Symbol.for("@saasicat/ui-vue/TransportFailure");
+function markTransportFailure(error) {
+  if (typeof error === "object" && error !== null) {
+    try {
+      Object.defineProperty(error, TRANSPORT_FAILURE, { value: true });
+    } catch {
+    }
+  }
+  return error;
+}
+function isTransportFailure(value) {
+  return typeof value === "object" && value !== null && TRANSPORT_FAILURE in value;
+}
+function describe(init) {
+  const status = init.status ?? 0;
+  const where = [init.method, init.url].filter(Boolean).join(" ");
+  const what = status > 0 ? `HTTP ${status}` : "request failed";
+  const head = where ? `${where} \u2192 ${what}` : what;
+  const code = init.code ? ` (${init.code})` : "";
+  return init.detail ? `${head}${code}: ${init.detail}` : `${head}${code}`;
+}
+var AdminError = class extends Error {
+  /** HTTP status. `0` means the request never produced one. */
+  status;
+  /** Machine-readable code from the response body, when it carried one. */
+  code;
+  /** Parsed response body, when there was one. */
+  body;
+  /** Requested URL, when known. */
+  url;
+  /** Request method, when known. */
+  method;
+  /**
+   * Text the failing side supplied — the only candidate for user-facing
+   * output. `undefined` when nothing was supplied.
+   */
+  detail;
+  /** The request completed but the answer was unusable. See `AdminErrorInit`. */
+  emptyResponse;
+  /** The request never reached the server. See `AdminErrorInit`. */
+  transportFailure;
+  constructor(init = {}) {
+    super(init.message ?? describe(init));
+    if (init.cause !== void 0) attachCause(this, init.cause);
+    this.name = "AdminError";
+    this.status = init.status ?? 0;
+    this.code = init.code;
+    this.body = init.body;
+    this.url = init.url;
+    this.method = init.method;
+    this.detail = init.detail;
+    this.emptyResponse = init.emptyResponse ?? false;
+    this.transportFailure = init.transportFailure ?? false;
+    Object.defineProperty(this, ADMIN_ERROR, { value: true });
+    markPlatformError(this);
+  }
+};
+function isAdminError(err) {
+  return typeof err === "object" && err !== null && ADMIN_ERROR in err;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function isAxiosNoResponseError(value) {
+  const record = asRecord(value);
+  if (!record) return false;
+  return record.isAxiosError === true && record.request != null && record.response == null;
+}
+function readErrorDetail(body) {
+  const record = asRecord(body);
+  if (!record) return asString(body);
+  const message = record.message;
+  if (Array.isArray(message)) {
+    const parts = message.filter((part) => typeof part === "string");
+    return parts.length > 0 ? parts.join(", ") : void 0;
+  }
+  return asString(message) ?? asString(record.error) ?? asString(record.reason);
+}
+function readErrorCode(body) {
+  return asString(asRecord(body)?.code);
+}
+function toAdminError(err) {
+  if (isAdminError(err)) return err;
+  const record = asRecord(err);
+  const response = asRecord(record?.response);
+  if (response && typeof response.status === "number") {
+    const config = asRecord(record?.config);
+    const body = response.data;
+    return new AdminError({
+      status: response.status,
+      code: readErrorCode(body),
+      body,
+      url: asString(config?.url),
+      method: asString(config?.method)?.toUpperCase(),
+      // Only what the response actually said. `err.message` here is
+      // axios's own generated line ("Request failed with status code
+      // 401") — English, untranslated, and about the transport rather
+      // than about what went wrong. Letting it through as `detail` would
+      // make `adminErrorMessage` return it in preference to the
+      // localized wording, which is the whole point of that wording.
+      detail: readErrorDetail(body),
+      cause: err
+    });
+  }
+  if (record && typeof record.status === "number") {
+    const ours = isPlatformError(err);
+    return new AdminError({
+      status: record.status,
+      code: readErrorCode(record.body) ?? asString(record.code),
+      body: record.body,
+      // Same reasoning as above: `BundlesApiError`'s message is
+      // "Bundles API responded with HTTP 403", a diagnostic. It stays on
+      // `message`, where logs read it.
+      detail: readErrorDetail(record.body) ?? (ours ? void 0 : asString(record.message)),
+      // Asked of the throw site, not of the class: only the site that
+      // read the response knows whether one arrived. `status === 0 &&
+      // ours` was the same question put to the wrong witness — the
+      // loaders raise branded errors from a status the client chose, so
+      // a client that resolves a transport failure as `0` turned a
+      // failed GET into "the change may have been applied".
+      emptyResponse: isEmptyResponse(err),
+      transportFailure: isTransportFailure(err),
+      message: asString(record.message),
+      cause: err
+    });
+  }
+  if (err instanceof Error) {
+    const transport = isTransportFailure(err) || isAxiosNoResponseError(err);
+    const saidSomethingReadable = !transport && !(err instanceof TypeError);
+    return new AdminError({
+      detail: saidSomethingReadable ? asString(err.message) : void 0,
+      transportFailure: transport,
+      message: err.message,
+      cause: err
+    });
+  }
+  const text = asString(err) ?? asString(record?.message);
+  return new AdminError({
+    code: asString(record?.code),
+    detail: text,
+    message: text,
+    cause: err
+  });
+}
+function statusKey(status) {
+  if (status === 400 || status === 422) return "validation";
+  if (status === 401) return "unauthorized";
+  if (status === 403) return "forbidden";
+  if (status === 404) return "notFound";
+  if (status === 409) return "conflict";
+  if (status === 429) return "rateLimited";
+  if (status >= 500) return "server";
+  return void 0;
+}
+function adminErrorMessage(err, msgs) {
+  const error = toAdminError(err);
+  if (error.detail) return error.detail;
+  if (error.emptyResponse) return msgs.emptyResponse;
+  if (error.transportFailure) return msgs.network;
+  if (error.status > 0) {
+    const key = statusKey(error.status);
+    return key ? msgs[key] : formatMessage(msgs.httpStatus, { status: error.status });
+  }
+  return msgs.unexpected;
+}
+
+// src/client/http-json.ts
+function serverAnswered(status) {
+  return status > 0;
+}
+function requireServerAnswer(status, method, url, raise) {
+  if (serverAnswered(status)) return;
+  throw markTransportFailure(
+    raise(`${method} ${url} produced no HTTP status \u2014 the request did not reach the server`)
+  );
+}
+var HttpJsonError = AdminError;
+async function readErrorBody(res) {
+  try {
+    return await res.json();
+  } catch {
+    return void 0;
+  }
+}
+async function failed(res, method, url) {
+  const body = await readErrorBody(res);
+  return new AdminError({
+    status: res.status,
+    // Read here rather than left to the status: `status: 0` reaches
+    // `adminErrorMessage` as "nothing is known about this failure", and
+    // this seam knows better — it held the response.
+    transportFailure: !serverAnswered(res.status),
+    code: readErrorCode(body),
+    body,
+    url,
+    method,
+    // Shared with `toAdminError` on purpose: a NestJS `ValidationPipe`
+    // rejection carries `message` as an array, and reading it here in a
+    // second, narrower way is how those constraints went missing.
+    detail: readErrorDetail(body)
+  });
+}
+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 await failed(res, "GET", url);
+  }
+  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 await failed(res, "POST", url);
+  }
+  return await res.json();
+}
+
+// src/client/http/fetch-http-client.ts
+var ABSOLUTE_URL = /^[a-z][a-z0-9+.-]*:|^\/\//i;
+function resolveUrl(url, baseUrl) {
+  if (!baseUrl || ABSOLUTE_URL.test(url)) return url;
+  return `${trimTrailingSlashes(baseUrl)}${url.startsWith("/") ? "" : "/"}${url}`;
+}
+function createFetchHttpClient(options = {}) {
+  return async (url, init) => {
+    const headers = new Headers(await options.headers?.());
+    if (!headers.has("Accept")) headers.set("Accept", "application/json");
+    for (const [name, value] of Object.entries(init?.headers ?? {})) {
+      headers.set(name, value);
+    }
+    if (init?.body !== void 0 && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    let response;
+    try {
+      response = await fetch(resolveUrl(url, options.baseUrl), {
+        method: init?.method ?? "GET",
+        headers,
+        body: init?.body
+      });
+    } catch (err) {
+      throw markTransportFailure(err);
+    }
+    return response;
+  };
+}
+
 // src/client/types.ts
 var NOOP_KV_STORE = {
   get: () => null,
@@ -201,51 +539,326 @@ function resolveLocalStorage() {
   }
 }
 function defaultHttpClient() {
-  return (url, init) => fetch(url, init);
+  return createFetchHttpClient();
 }
 
-// src/client/http-json.ts
-var HttpJsonError = class extends Error {
-  constructor(status, code) {
-    super(code ?? `HTTP ${status}`);
-    this.status = status;
-    this.code = code;
-    this.name = "HttpJsonError";
+// src/client/http/axios-http-client.ts
+function stripped(url, prefixes) {
+  for (const prefix of prefixes) {
+    const trimmed = trimTrailingSlashes(prefix);
+    if (!trimmed || !url.startsWith(trimmed)) continue;
+    const rest = url.slice(trimmed.length);
+    if (rest === "") return "/";
+    if (rest.startsWith("/")) return rest;
+    if (rest.startsWith("?") || rest.startsWith("#")) return `/${rest}`;
+  }
+  return url;
+}
+function headerReader(headers) {
+  const record = typeof headers === "object" && headers !== null ? headers : {};
+  const lowered = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(record)) lowered.set(key.toLowerCase(), value);
+  return (name) => {
+    const value = lowered.get(name.toLowerCase());
+    return value == null ? null : String(value);
+  };
+}
+function bodyIsRaw(response, declared) {
+  if (declared !== "auto") return declared === "raw";
+  if (response.data === "") return true;
+  const config = response.config;
+  if (config?.transformResponse === null) return true;
+  if (Array.isArray(config?.transformResponse) && config.transformResponse.length === 0) {
+    return true;
   }
-  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;
+  const responseType = config?.responseType;
+  if (responseType === "json") return false;
+  if (typeof responseType === "string" && responseType !== "") return true;
+  const transitional = config?.transitional;
+  return typeof transitional === "object" && transitional !== null && transitional.forcedJSONParsing === false;
+}
+async function readBody(data) {
+  if (typeof data === "string" || data === null || data === void 0) return data;
+  if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+  if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data);
+  const maybe = data;
+  if (typeof maybe.pipe === "function" || typeof maybe.getReader === "function") {
+    throw new TypeError(
+      "createAxiosHttpClient cannot read a streamed body: responseType 'stream' can be consumed only once, and never synchronously. Use 'arraybuffer' or the default for the instance the platform receives."
+    );
   }
+  if (typeof maybe.text === "function") return maybe.text.call(data);
+  return data;
 }
-function trimTrailingSlashes(url) {
-  let end = url.length;
-  while (end > 0 && url[end - 1] === "/") end--;
-  return url.slice(0, end);
+function adapt(response, declared) {
+  return {
+    status: response.status,
+    headers: { get: headerReader(response.headers) },
+    json: async () => {
+      const data = await readBody(response.data);
+      if (typeof data !== "string") return data;
+      return bodyIsRaw({ ...response, data }, declared) ? JSON.parse(data) : data;
+    },
+    text: async () => {
+      const data = await readBody(response.data);
+      return typeof data === "string" ? data : JSON.stringify(data);
+    }
+  };
 }
-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));
+function createAxiosHttpClient(instance, options = {}) {
+  const prefixes = typeof options.stripPrefix === "string" ? [options.stripPrefix] : options.stripPrefix ?? [];
+  const responseBody = options.responseBody ?? "auto";
+  return async (url, init) => {
+    try {
+      return adapt(
+        await instance.request({
+          url: stripped(url, prefixes),
+          method: (init?.method ?? "GET").toUpperCase(),
+          headers: init?.headers,
+          data: init?.body
+        }),
+        responseBody
+      );
+    } catch (err) {
+      const response = err?.response;
+      if (response && typeof response.status === "number") {
+        return adapt(response, responseBody);
+      }
+      throw isAxiosNoResponseError(err) ? markTransportFailure(err) : err;
+    }
+  };
+}
+
+// src/client/resources/define-resource.ts
+function defineResource(key, ops, options = {}) {
+  return { key, ops, projectScoped: options.projectScoped ?? false };
+}
+function requireProjectKey(def, ctx) {
+  if (!def.projectScoped) return;
+  if (typeof ctx.projectKey === "string" && ctx.projectKey.trim() !== "") return;
+  throw new Error(
+    `Resource "${def.key}" is project-scoped, but the context it is bound to names no project. Its requests would go out as \`?projectKey=\`, which the admin API answers for no project at all: the catalogue reads as empty and the first create fails validation instead. Name the project this admin administers \u2014 \`endpoints.projectKey\` for createSuperAdminApp(), \`context.projectKey\` for createResourceRegistry().`
+  );
+}
+function bindResource(def, http, ctx) {
+  const readContext = typeof ctx === "function" ? ctx : () => ctx;
+  if (def.projectScoped) requireProjectKey(def, readContext());
+  const bound = {};
+  for (const [name, op] of Object.entries(def.ops)) {
+    bound[name] = async (...args) => {
+      const context = readContext();
+      requireProjectKey(def, context);
+      return op(http, context, ...args);
+    };
   }
-  return await res.json();
+  return bound;
 }
-async function postJson(http, url, body) {
-  const res = await http(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
+
+// src/client/resources/resource-request.ts
+async function requestJson(http, url, init = {}) {
+  const method = init.method ?? "GET";
+  const response = await http(url, {
+    method,
+    headers: { "content-type": "application/json", ...init.headers },
+    body: init.body === void 0 ? void 0 : JSON.stringify(init.body)
   });
-  if (res.status < 200 || res.status >= 300) {
-    throw new HttpJsonError(res.status, await extractCode(res));
+  requireServerAnswer(
+    response.status,
+    method,
+    url,
+    (diagnostic) => new AdminError({ status: response.status, url, method, message: diagnostic })
+  );
+  if (response.status === 204) return null;
+  const body = await response.json().catch(() => null);
+  if (response.status >= 400) {
+    throw new AdminError({
+      status: response.status,
+      code: readErrorCode(body),
+      body,
+      // The third place this had to be read, and the second time it was
+      // read a narrower way: without `detail` a page migrating onto these
+      // resources loses "Plan already exists" and shows the generic
+      // status sentence instead. One decision, one function.
+      detail: readErrorDetail(body),
+      url,
+      method
+    });
   }
-  return await res.json();
+  return body;
+}
+async function requestJsonBody(http, url, what, init = {}) {
+  const body = await requestJson(http, url, init);
+  if (body === null || body === void 0) {
+    throw new AdminError({
+      status: 0,
+      url,
+      method: init.method ?? "GET",
+      // `what` is a diagnostic — "Create returned no body" — so it goes
+      // on `message`, not `detail`. As `detail` it out-ranked the
+      // localized wording and the operator read an English internal
+      // string instead of being told the change may already have landed.
+      message: what,
+      emptyResponse: true
+    });
+  }
+  return body;
+}
+
+// src/client/resources/list-resource.ts
+var LIST_FIRST_PAGE = 1;
+var LIST_PAGE_SIZE_DEFAULT = 50;
+var LIST_PAGE_SIZE_MAX = 200;
+var LIST_PAGINATION_PARAMS = ["page", "pageSize"];
+function isSentInQuery(value) {
+  return value !== void 0 && value !== null && value !== "";
+}
+function appendFilter(params, filter) {
+  for (const [key, value] of Object.entries(filter ?? {})) {
+    if (!isSentInQuery(value)) continue;
+    params.set(key, String(value));
+  }
+}
+function filterQueryString(filter) {
+  const params = new URLSearchParams();
+  appendFilter(params, filter);
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+function listUrl(endpoint, query = {}) {
+  const params = new URLSearchParams();
+  params.set("page", String(query.page ?? LIST_FIRST_PAGE));
+  params.set("pageSize", String(query.pageSize ?? LIST_PAGE_SIZE_DEFAULT));
+  appendFilter(params, query.filter);
+  return `${endpoint}${endpoint.includes("?") ? "&" : "?"}${params.toString()}`;
+}
+function readListPage(raw) {
+  if (Array.isArray(raw)) return { items: raw, total: raw.length };
+  if (raw === null || typeof raw !== "object") return { items: [], total: 0 };
+  const body = raw;
+  const page = {
+    items: Array.isArray(body.items) ? body.items : []
+  };
+  if (typeof body.total === "number") page.total = body.total;
+  if (typeof body.page === "number") page.page = body.page;
+  if (typeof body.pageSize === "number") page.pageSize = body.pageSize;
+  return page;
 }
+function clampListPage(page) {
+  return Math.max(LIST_FIRST_PAGE, Math.floor(page));
+}
+function clampListPageSize(size) {
+  return Math.min(LIST_PAGE_SIZE_MAX, Math.max(1, Math.floor(size)));
+}
+function defineListOp(endpoint) {
+  return async (http, ctx, query) => readListPage(await requestJson(http, listUrl(endpoint(ctx), query)));
+}
+
+// src/client/resources/plans.resource.ts
+function plansUrl(ctx) {
+  return `${ctx.apiBase}/catalog/plans`;
+}
+function versionsUrl(ctx) {
+  return `${ctx.apiBase}/catalog/plan-versions`;
+}
+function scoped(url, ctx) {
+  return `${url}?projectKey=${encodeURIComponent(ctx.projectKey)}`;
+}
+var plansResource = defineResource(
+  "plans",
+  {
+    list: async (http, ctx) => await requestJson(http, scoped(plansUrl(ctx), ctx)) ?? [],
+    tenantCounts: async (http, ctx) => await requestJson(
+      http,
+      scoped(`${plansUrl(ctx)}/tenant-counts`, ctx)
+    ) ?? {},
+    /**
+     * The project comes from the context, not from the caller.
+     *
+     * The endpoint takes it in the body, and the composable this replaces
+     * made that the caller's job — so a page had to keep hold of the
+     * project it was administering just to create in it, and `list()` and
+     * `create()` read two different sources for one value. A stale one
+     * creates a plan outside the project the list is showing.
+     */
+    create: (http, ctx, data) => requestJsonBody(http, plansUrl(ctx), "Create returned no body", {
+      method: "POST",
+      body: { ...data, projectKey: ctx.projectKey }
+    }),
+    update: (http, ctx, planId, data) => requestJsonBody(
+      http,
+      `${plansUrl(ctx)}/${planId}`,
+      "Update returned no body",
+      {
+        method: "PATCH",
+        body: data
+      }
+    ),
+    /** Marks the plan deleted. Fails while it still has versions. */
+    softDelete: async (http, ctx, planId) => {
+      await requestJson(http, `${plansUrl(ctx)}/${planId}`, { method: "DELETE" });
+    },
+    /** Removes the plan for good. 422 `PLAN_HAS_VERSIONS` when it cannot. */
+    hardDelete: async (http, ctx, planId) => {
+      await requestJson(http, `${plansUrl(ctx)}/${planId}/purge`, { method: "DELETE" });
+    }
+  },
+  { projectScoped: true }
+);
+var planVersionsResource = defineResource("planVersions", {
+  listForPlan: async (http, ctx, planId) => await requestJson(http, `${plansUrl(ctx)}/${planId}/versions`) ?? [],
+  createDraft: (http, ctx, planId, data) => requestJsonBody(
+    http,
+    `${plansUrl(ctx)}/${planId}/versions`,
+    "CreateDraft returned no body",
+    { method: "POST", body: data }
+  ),
+  updateDraft: (http, ctx, versionId, data) => requestJsonBody(
+    http,
+    `${versionsUrl(ctx)}/${versionId}`,
+    "UpdateDraft returned no body",
+    { method: "PATCH", body: data }
+  ),
+  publish: (http, ctx, versionId, options = {}) => requestJsonBody(
+    http,
+    `${versionsUrl(ctx)}/${versionId}/publish`,
+    "Publish returned no body",
+    { method: "POST", body: options }
+  ),
+  discardDraft: async (http, ctx, versionId) => {
+    await requestJson(http, `${versionsUrl(ctx)}/${versionId}`, { method: "DELETE" });
+  },
+  /**
+   * Ends a live version on `endsAt`, with no successor. Idempotent — a
+   * second call with another date overwrites the first.
+   *
+   * `endsAt` is the date itself, not a payload: the endpoint's body is
+   * `{ endsAt }` and wrapping it is this operation's job, not the caller's.
+   */
+  terminate: (http, ctx, versionId, endsAt) => requestJsonBody(
+    http,
+    `${versionsUrl(ctx)}/${versionId}/terminate`,
+    "Terminate returned no body",
+    { method: "POST", body: { endsAt } }
+  )
+});
+
+// src/client/resources/tenants.resource.ts
+var tenantsResource = defineResource("tenants", {
+  list: defineListOp((ctx) => `${ctx.apiBase}/tenants`)
+});
+
+// src/client/resources/audit.resource.ts
+var auditResource = defineResource("audit", {
+  list: defineListOp((ctx) => `${ctx.apiBase}/audit`)
+});
+
+// src/client/resources/index.ts
+var platformResources = {
+  plans: plansResource,
+  planVersions: planVersionsResource,
+  tenants: tenantsResource,
+  audit: auditResource
+};
 
 // src/client/boot-loader.ts
 var BootLoadError = class extends Error {
@@ -253,6 +866,7 @@ var BootLoadError = class extends Error {
     super(message);
     this.status = status;
     this.name = "BootLoadError";
+    markPlatformError(this);
   }
   status;
 };
@@ -270,19 +884,27 @@ var BootLoader = class {
   }
   async load() {
     const res = await this.http(this.endpoint);
+    requireServerAnswer(
+      res.status,
+      "GET",
+      this.endpoint,
+      (diagnostic) => new BootLoadError(res.status, diagnostic)
+    );
     if (res.status !== 200) {
-      throw new BootLoadError(res.status, `Boot-Endpunkt antwortete HTTP ${res.status}`);
+      throw new BootLoadError(res.status, `Boot endpoint responded with HTTP ${res.status}`);
     }
     return await res.json();
   }
 };
 
 // src/client/manifest-loader.ts
+var NOT_MODIFIED = 304;
 var ManifestLoadError = class extends Error {
   constructor(status, message) {
     super(message);
     this.status = status;
     this.name = "ManifestLoadError";
+    markPlatformError(this);
   }
   status;
 };
@@ -310,24 +932,48 @@ var ManifestLoader = class {
   /**
    * Loads the current manifest. On a cache hit (304) the cached
    * body is returned — otherwise the fresh server body.
+   *
+   * A 304 with no usable cached body is not a failure to report but one to
+   * undo: the request only carried `If-None-Match` because this loader put
+   * the ETag there, and the cache it validated against is this loader's own.
+   * So it drops the pair and asks once more without the header, which is the
+   * same recovery a person would have had to trigger by hand — except that
+   * the person reading an admin screen has neither this loader nor a
+   * console. Exactly one retry: a 304 to a request that asked nothing
+   * conditional is a server fault, and no repetition fixes it.
    */
   async load() {
     const cachedEtag = this.storage.get(this.etagKey);
+    const res = await this.request(cachedEtag);
+    if (res.status !== NOT_MODIFIED) return this.acceptFresh(res);
+    const cached = this.readCachedBody();
+    if (cached) return cached.body;
+    if (cachedEtag) {
+      this.clearCache();
+      const fresh = await this.request(null);
+      if (fresh.status !== NOT_MODIFIED) return this.acceptFresh(fresh);
+    }
+    throw new ManifestLoadError(
+      NOT_MODIFIED,
+      "Manifest endpoint answered HTTP 304 to a request without If-None-Match"
+    );
+  }
+  /** Sends the manifest GET, conditional when an ETag is supplied. */
+  request(etag) {
     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 returned 304 but the cache body is missing \u2014 call clearCache() and reload"
-        );
-      }
-      return cachedBody.body;
-    }
+    if (etag) headers["If-None-Match"] = etag;
+    return this.http(this.endpoint, { method: "GET", headers });
+  }
+  /** Takes a non-304 response as the current manifest and caches it. */
+  async acceptFresh(res) {
+    requireServerAnswer(
+      res.status,
+      "GET",
+      this.endpoint,
+      (diagnostic) => new ManifestLoadError(res.status, diagnostic)
+    );
     if (res.status !== 200) {
       throw new ManifestLoadError(
         res.status,
@@ -463,7 +1109,7 @@ var DEFAULT_STANDARD_PAGE_ROUTES = {
   platformEmailHistory: "/admin/platform-email-history"
 };
 function isSupportedStandardPageKey(key) {
-  return Object.hasOwn(DEFAULT_STANDARD_PAGE_ROUTES, key);
+  return Object.prototype.hasOwnProperty.call(DEFAULT_STANDARD_PAGE_ROUTES, key);
 }
 var DEFAULT_ICONS = {
   dashboard: "dashboard",
@@ -662,7 +1308,7 @@ var ActionRegistry = class {
 // src/client/batch-column-fetcher.ts
 var BatchColumnDriftError = class extends Error {
   constructor(column, reason) {
-    super(`Spalte "${column.key}": ${reason}`);
+    super(`Column "${column.key}": ${reason}`);
     this.column = column;
     this.name = "BatchColumnDriftError";
   }
@@ -705,7 +1351,7 @@ var BatchColumnFetcher = class {
     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}`
+        `Column "${column.key}" \u2014 endpoint ${column.endpoint} responded with HTTP ${res.status}`
       );
     }
     const body = await res.json();
@@ -781,10 +1427,10 @@ function createAdminResourceClient(options) {
     tenantsEndpoint,
     loadTenantDetail: (slug) => getJson2(`${tenantsEndpoint}/${encodeURIComponent(slug)}`),
     loadUsers: (filter) => getJson2(
-      `${base}/users${queryString({ q: filter.q, tenant: filter.tenant })}`
+      `${base}/users${filterQueryString({ q: filter.q, tenant: filter.tenant })}`
     ),
     loadAudit: (filter) => getJson2(
-      `${base}/audit${queryString({
+      `${base}/audit${filterQueryString({
         actor: filter.actor,
         action: filter.action,
         entity: filter.entity,
@@ -794,7 +1440,7 @@ function createAdminResourceClient(options) {
     ),
     loadSubscriptions: () => getJson2(`${base}/subscriptions`),
     loadPromos: (filter) => getJson2(
-      `${base}/promo-codes${queryString({
+      `${base}/promo-codes${filterQueryString({
         search: filter.search,
         status: filter.status
       })}`
@@ -819,21 +1465,6 @@ function assertSuccess(status, method, url) {
     throw new Error(`${method} ${url} \u2192 HTTP ${status}`);
   }
 }
-function queryString(params) {
-  const search = new URLSearchParams();
-  for (const [key, value2] of Object.entries(params)) {
-    if (value2 === void 0 || value2 === null || value2 === "") continue;
-    search.set(key, String(value2));
-  }
-  const value = search.toString();
-  return value ? `?${value}` : "";
-}
-
-// src/client/i18n/format.ts
-var import_types4 = require("@saasicat/types");
-function formatMessage(template, params) {
-  return (0, import_types4.formatErrorMessage)(template, params);
-}
 
 // src/client/i18n/currency.ts
 var DEFAULT_CURRENCY = "EUR";
@@ -1532,9 +2163,6 @@ var discoveryMessages = defineMessages(
     replacedBy: "ersetzt durch {key}",
     replaces: "ersetzt: {keys}",
     reapproveEmphasis: "erneut freigeben",
-    errorDiscoveryHttp: "Discovery-Endpoint antwortete mit HTTP {status}",
-    errorRescanHttp: "Discovery-Rescan antwortete mit HTTP {status}",
-    errorCatalogHttp: "Catalog-Entries-API antwortete mit HTTP {status}",
     capList: {
       orphanFeature: "Feature im Katalog ohne implementierende Capability \u2014 blockiert im blocking-Strict-Mode das Plan-Publish.",
       removedFromCode: "aus Code entfernt"
@@ -1636,9 +2264,6 @@ var discoveryMessages = defineMessages(
     replacedBy: "replaced by {key}",
     replaces: "replaces: {keys}",
     reapproveEmphasis: "approve again",
-    errorDiscoveryHttp: "Discovery endpoint responded with HTTP {status}",
-    errorRescanHttp: "Discovery rescan responded with HTTP {status}",
-    errorCatalogHttp: "Catalog entries API responded with HTTP {status}",
     capList: {
       orphanFeature: "Feature in the catalog without an implementing capability \u2014 blocks plan publishing in blocking strict mode.",
       removedFromCode: "removed from code"
@@ -1843,6 +2468,36 @@ var emailMessages = defineMessages(
   }
 );
 
+// src/client/i18n/messages/errors.ts
+var errorsMessages = defineMessages(
+  {
+    network: "Die Anfrage konnte nicht abgeschlossen werden. Bitte Verbindung pr\xFCfen.",
+    emptyResponse: "Der Server hat nichts zur\xFCckgegeben. Bitte pr\xFCfen, ob die \xC4nderung angekommen ist.",
+    unauthorized: "Die Sitzung ist abgelaufen. Bitte erneut anmelden.",
+    forbidden: "F\xFCr diese Aktion fehlt die Berechtigung.",
+    notFound: "Der angeforderte Eintrag existiert nicht mehr.",
+    conflict: "Der Eintrag wurde zwischenzeitlich ge\xE4ndert. Bitte neu laden.",
+    validation: "Die Eingaben wurden nicht akzeptiert.",
+    rateLimited: "Zu viele Anfragen. Bitte kurz warten und erneut versuchen.",
+    server: "Der Server konnte die Anfrage nicht verarbeiten.",
+    httpStatus: "Die Anfrage ist fehlgeschlagen (HTTP {status}).",
+    unexpected: "Es ist ein unerwarteter Fehler aufgetreten. Bitte erneut versuchen."
+  },
+  {
+    network: "The request could not be completed. Please check your connection.",
+    emptyResponse: "The server returned nothing. Please check whether the change was applied.",
+    unauthorized: "Your session has expired. Please sign in again.",
+    forbidden: "You do not have permission for this action.",
+    notFound: "The requested entry no longer exists.",
+    conflict: "The entry changed in the meantime. Please reload.",
+    validation: "The input was not accepted.",
+    rateLimited: "Too many requests. Please wait a moment and try again.",
+    server: "The server could not process the request.",
+    httpStatus: "The request failed (HTTP {status}).",
+    unexpected: "Something went wrong. Please try again."
+  }
+);
+
 // src/client/i18n/messages/marketing.ts
 var marketingMessages = defineMessages(
   {
@@ -1967,9 +2622,6 @@ var marketingMessages = defineMessages(
       colorLabel: "Farbe",
       delete: "Aktion l\xF6schen",
       deleteConfirm: "Aktion \u201E{label}\u201C wirklich l\xF6schen?"
-    },
-    errors: {
-      projectionsApi: "MarketingProjections-API antwortete mit HTTP {status}"
     }
   },
   {
@@ -2094,9 +2746,6 @@ var marketingMessages = defineMessages(
       colorLabel: "Color",
       delete: "Delete promotion",
       deleteConfirm: 'Really delete promotion "{label}"?'
-    },
-    errors: {
-      projectionsApi: "MarketingProjections API responded with HTTP {status}"
     }
   }
 );
@@ -3290,7 +3939,6 @@ var promosMessages = defineMessages(
   {
     title: "Promo-Codes",
     createAction: "Promo-Code anlegen",
-    apiErrorHttpStatus: "Promotions-API antwortete mit HTTP {status}",
     list: {
       searchLabel: "Suche (Code)",
       tileScheduled: "Geplant",
@@ -3388,7 +4036,6 @@ var promosMessages = defineMessages(
   {
     title: "Promo codes",
     createAction: "Create promo code",
-    apiErrorHttpStatus: "Promotions API responded with HTTP {status}",
     list: {
       searchLabel: "Search (code)",
       tileScheduled: "Scheduled",
@@ -3496,7 +4143,13 @@ var shellMessages = defineMessages(
       subtitle: "SuperAdmin \xB7 Plattform-Verwaltung",
       roleBadge: "SUPER ADMIN",
       logout: "Abmelden",
-      language: "Sprache"
+      language: "Sprache",
+      theme: {
+        label: "Darstellung",
+        light: "Hell",
+        dark: "Dunkel",
+        system: "System"
+      }
     },
     drawer: {
       docs: "Doku \xF6ffnen"
@@ -3565,7 +4218,13 @@ var shellMessages = defineMessages(
       subtitle: "SuperAdmin \xB7 Platform administration",
       roleBadge: "SUPER ADMIN",
       logout: "Sign out",
-      language: "Language"
+      language: "Language",
+      theme: {
+        label: "Appearance",
+        light: "Light",
+        dark: "Dark",
+        system: "System"
+      }
     },
     drawer: {
       docs: "Open documentation"
@@ -3809,6 +4468,7 @@ var usersMessages = defineMessages(
 function catalogFor(locale) {
   return {
     common: commonMessages[locale],
+    errors: errorsMessages[locale],
     nav: navMessages[locale],
     shell: shellMessages[locale],
     dashboard: dashboardMessages[locale],
@@ -4063,6 +4723,11 @@ var SUPER_ADMIN_NOTIFY_KEY = /* @__PURE__ */ Symbol.for(
   "@saasicat/ui-vue/SUPER_ADMIN_NOTIFY"
 );
 
+// src/vue/ui-confirm.ts
+var SUPER_ADMIN_CONFIRM_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/SUPER_ADMIN_CONFIRM"
+);
+
 // src/vue/use-super-admin-context.ts
 var import_vue = require("vue");
 function useSuperAdminExtensions() {
@@ -4153,10 +4818,10 @@ function useSaMessages(namespace) {
 
 // src/vue/use-sa-theme.ts
 var import_vue3 = require("vue");
-var SCHEMES = ["light", "dark", "system"];
-var STORAGE_KEY = "saasicat.theme.scheme";
+var SA_COLOR_SCHEMES = ["light", "dark", "system"];
+var SA_THEME_STORAGE_KEY = "saasicat.theme.scheme";
 function isScheme(value) {
-  return typeof value === "string" && SCHEMES.includes(value);
+  return typeof value === "string" && SA_COLOR_SCHEMES.includes(value);
 }
 function systemScheme() {
   const value = (0, import_vue3.ref)("light");
@@ -4177,13 +4842,19 @@ function createSaTheme(options = {}) {
   const persist = options.persist !== false;
   const provided = options.scheme;
   const appOwnsIt = (0, import_vue3.isRef)(provided);
-  const stored = persist && !appOwnsIt ? storage.get(STORAGE_KEY) : null;
+  const key = `${options.storageKeyPrefix ?? ""}${SA_THEME_STORAGE_KEY}`;
+  const stored = persist && !appOwnsIt ? storage.get(key) : null;
   const scheme = (0, import_vue3.isRef)(provided) ? provided : (0, import_vue3.ref)(isScheme(stored) ? stored : provided ?? "system");
   const { value: system, unsubscribe } = systemScheme();
-  const stopPersisting = persist && !appOwnsIt ? (0, import_vue3.watch)(scheme, (next) => storage.set(STORAGE_KEY, next)) : null;
+  const stopPersisting = persist && !appOwnsIt ? (0, import_vue3.watch)(scheme, (next) => storage.set(key, next)) : null;
   return {
     scheme,
     resolved: (0, import_vue3.computed)(() => scheme.value === "system" ? system.value : scheme.value),
+    // A readonly ref (typically a `computed` derived from a profile
+    // setting) silently swallows writes, so the switcher would be a dead
+    // control. TypeScript ignores `readonly` when checking assignability,
+    // so the guard has to be a runtime one — same as the locale next door.
+    switcherEnabled: (options.switcher ?? true) && !(0, import_vue3.isReadonly)(scheme),
     dispose: () => {
       unsubscribe();
       stopPersisting?.();
@@ -4295,22 +4966,17 @@ var import_vue5 = require("vue");
 function useApiList(options) {
   const http = options.http ?? defaultHttpClient();
   const items = (0, import_vue5.ref)([]);
-  const page = (0, import_vue5.ref)(1);
-  const pageSize = (0, import_vue5.ref)(50);
+  const page = (0, import_vue5.ref)(LIST_FIRST_PAGE);
+  const pageSize = (0, import_vue5.ref)(LIST_PAGE_SIZE_DEFAULT);
   const total = (0, import_vue5.ref)(0);
   const loading = (0, import_vue5.ref)(false);
   const error = (0, import_vue5.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()}`;
+    return listUrl(options.endpoint, {
+      page: page.value,
+      pageSize: pageSize.value,
+      filter: options.filter?.value
+    });
   }
   async function load() {
     loading.value = true;
@@ -4323,20 +4989,11 @@ function useApiList(options) {
       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;
-      }
+      const body = readListPage(await res.json());
+      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;
     } catch (err) {
       error.value = err instanceof Error ? err : new Error(String(err));
       items.value = [];
@@ -4346,19 +5003,19 @@ function useApiList(options) {
     }
   }
   async function goToPage(p) {
-    page.value = Math.max(1, Math.floor(p));
+    page.value = clampListPage(p);
     await load();
   }
   async function setPageSize(size) {
-    pageSize.value = Math.min(200, Math.max(1, Math.floor(size)));
-    page.value = 1;
+    pageSize.value = clampListPageSize(size);
+    page.value = LIST_FIRST_PAGE;
     await load();
   }
   if (options.filter) {
     (0, import_vue5.watch)(
       options.filter,
       () => {
-        page.value = 1;
+        page.value = LIST_FIRST_PAGE;
         void load();
       },
       { deep: true }
@@ -4404,15 +5061,253 @@ function usePagination(rows, initialRowsPerPage = DEFAULT_ROWS_PER_PAGE) {
   return { page, rowsPerPage, total, pagedRows };
 }
 
-// src/vue/use-tenants.ts
+// src/vue/use-async-action.ts
 var import_vue7 = require("vue");
+function report(announce) {
+  try {
+    announce();
+  } catch (err) {
+    queueMicrotask(() => {
+      throw err;
+    });
+  }
+}
+function useAsyncAction(fn, options = {}) {
+  const pending = (0, import_vue7.ref)(false);
+  const error = (0, import_vue7.ref)(null);
+  const notify = options.notify ?? (0, import_vue7.inject)(SUPER_ADMIN_NOTIFY_KEY, void 0);
+  const messages = useSaMessages("errors");
+  const notifyOn = options.notifyOn ?? "error";
+  let inFlight = 0;
+  let generation = 0;
+  async function run(...args) {
+    const mine = ++generation;
+    inFlight++;
+    pending.value = true;
+    error.value = null;
+    try {
+      const result = await fn(...args);
+      await options.onSuccess?.(result);
+      if (notifyOn === "both") {
+        report(() => {
+          const message = typeof options.successMessage === "function" ? options.successMessage() : options.successMessage;
+          if (message) notify?.("positive", message);
+        });
+      }
+      return { ok: true, value: result };
+    } catch (err) {
+      const adminError = toAdminError(err);
+      if (mine === generation) error.value = adminError;
+      if (notifyOn !== "none") {
+        report(
+          () => notify?.(
+            "negative",
+            options.errorMessage?.(adminError) ?? adminErrorMessage(adminError, messages.value)
+          )
+        );
+      }
+      return { ok: false, error: adminError };
+    } finally {
+      if (--inFlight === 0) pending.value = false;
+    }
+  }
+  return {
+    run,
+    pending,
+    error,
+    reset: () => {
+      error.value = null;
+    }
+  };
+}
+
+// src/vue/use-async-data.ts
+var import_vue8 = require("vue");
+function useAsyncData(fn, options) {
+  const data = (0, import_vue8.ref)(options.initial);
+  const pending = (0, import_vue8.ref)(false);
+  const error = (0, import_vue8.ref)(null);
+  let generation = 0;
+  async function reload() {
+    const mine = ++generation;
+    pending.value = true;
+    error.value = null;
+    try {
+      const result = await fn();
+      if (mine !== generation) return;
+      data.value = result;
+    } catch (err) {
+      if (mine !== generation) return;
+      error.value = toAdminError(err);
+      data.value = options.initial;
+    } finally {
+      if (mine === generation) pending.value = false;
+    }
+  }
+  if (options.watch?.length) {
+    (0, import_vue8.watch)(options.watch, () => void reload());
+  }
+  if (options.immediate !== false) {
+    void Promise.resolve().then(() => reload());
+  }
+  return { data, pending, error, reload };
+}
+
+// src/vue/resource-registry.ts
+var import_vue9 = require("vue");
+function boundWithOverride(def, http, readContext, override) {
+  const context = override?.context ? () => ({ ...readContext(), ...override.context }) : readContext;
+  const platform = bindResource(def, override?.http ?? http, context);
+  if (!override?.ops) return platform;
+  const result = { ...platform };
+  for (const [name, wrap] of Object.entries(override.ops)) {
+    if (typeof wrap !== "function") continue;
+    if (!Object.hasOwn(platform, name)) {
+      throw new Error(
+        `createResourceRegistry: resource "${def.key}" has no operation "${name}" to override. It offers: ${Object.keys(platform).join(", ")}.`
+      );
+    }
+    const next = platform[name];
+    result[name] = (...args) => wrap(next, ...args);
+  }
+  return result;
+}
+function createResourceRegistry(options) {
+  if (!options?.http) {
+    throw new Error(
+      "createResourceRegistry: `http` is required. Pass the HttpClient your app already uses \u2014 createAxiosHttpClient(instance) or createFetchHttpClient({ headers }) \u2014 so every platform request carries its auth."
+    );
+  }
+  const readContext = typeof options.context === "function" ? options.context : () => options.context;
+  const unknown = Object.keys(options.overrides ?? {}).filter(
+    (key) => !Object.hasOwn(options.resources, key)
+  );
+  if (unknown.length > 0) {
+    throw new Error(
+      `createResourceRegistry: no resource named ${unknown.map((k) => `"${k}"`).join(", ")} to override. The registry holds: ${Object.keys(options.resources).join(", ")}.`
+    );
+  }
+  const bound = /* @__PURE__ */ new Map();
+  for (const [key, def] of Object.entries(options.resources)) {
+    bound.set(key, boundWithOverride(def, options.http, readContext, options.overrides?.[key]));
+  }
+  return {
+    get(key) {
+      const ops = bound.get(key);
+      if (!ops) {
+        throw new Error(
+          `useResource("${String(key)}"): no such resource. The registry offers: ${[...bound.keys()].join(", ")}.`
+        );
+      }
+      return ops;
+    },
+    keys: () => [...bound.keys()]
+  };
+}
+var SUPER_ADMIN_RESOURCES_KEY = /* @__PURE__ */ Symbol.for(
+  "@saasicat/ui-vue/SUPER_ADMIN_RESOURCES"
+);
+function useResource(key) {
+  const registry = (0, import_vue9.inject)(SUPER_ADMIN_RESOURCES_KEY, null);
+  if (!registry) {
+    throw new Error(
+      `useResource("${key}"): no resource registry in scope. Either the component was not mounted inside createSuperAdminApp(), or the app did not pass an \`http\` client \u2014 the registry is not installed without one, because a bare fetch would send every request without your Authorization header and fail silently.`
+    );
+  }
+  return registry.get(key);
+}
+
+// src/vue/use-resource-list.ts
+var import_vue10 = require("vue");
+var DEFAULT_LIST_OP = "list";
+var EMPTY_PAGE = Object.freeze({
+  items: Object.freeze([]),
+  total: 0
+});
+function paginationCollision(key, op, claimed) {
+  return new AdminError({
+    message: `useResourceList("${key}", { op: "${op}" }): the filter carries ${claimed.join(" and ")}, which the list already sends. The filter is serialised after the pagination, so its value wins on the wire while page.value keeps the one goToPage() set \u2014 the list would report a page it is not showing. Drive the page with goToPage()/setPageSize() and leave those keys out of the filter.`
+  });
+}
+function paginationKeysIn(filter) {
+  return LIST_PAGINATION_PARAMS.filter((param) => isSentInQuery(filter[param]));
+}
+function readListOp(key, ops, name) {
+  const op = Object.hasOwn(ops, name) ? ops[name] : void 0;
+  if (typeof op !== "function") {
+    throw new Error(
+      `useResourceList("${key}", { op: "${name}" }): that resource has no such operation. It offers: ${Object.keys(ops).join(", ")}.`
+    );
+  }
+  return op;
+}
+function useResourceList(key, opts) {
+  const ops = useResource(key);
+  const opName = opts?.op ?? DEFAULT_LIST_OP;
+  const load = readListOp(key, ops, opName);
+  if (opts?.filter) {
+    const claimed = paginationKeysIn(opts.filter.value);
+    if (claimed.length > 0) throw paginationCollision(key, opName, claimed);
+  }
+  const page = (0, import_vue10.ref)(LIST_FIRST_PAGE);
+  const pageSize = (0, import_vue10.ref)(clampListPageSize(opts?.pageSize ?? LIST_PAGE_SIZE_DEFAULT));
+  function query() {
+    const filter = opts?.filter?.value;
+    if (filter) {
+      const claimed = paginationKeysIn(filter);
+      if (claimed.length > 0) throw paginationCollision(key, opName, claimed);
+    }
+    return { page: page.value, pageSize: pageSize.value, filter };
+  }
+  const state = useAsyncData(() => load(query()), {
+    initial: EMPTY_PAGE,
+    immediate: opts?.immediate
+  });
+  (0, import_vue10.watch)(state.data, (answer) => {
+    if (typeof answer.page === "number") page.value = answer.page;
+    if (typeof answer.pageSize === "number") pageSize.value = answer.pageSize;
+  });
+  async function goToPage(next) {
+    page.value = clampListPage(next);
+    await state.reload();
+  }
+  async function setPageSize(size) {
+    pageSize.value = clampListPageSize(size);
+    page.value = LIST_FIRST_PAGE;
+    await state.reload();
+  }
+  if (opts?.filter) {
+    (0, import_vue10.watch)(
+      opts.filter,
+      () => {
+        page.value = LIST_FIRST_PAGE;
+        void state.reload();
+      },
+      { deep: true }
+    );
+  }
+  return {
+    items: (0, import_vue10.computed)(() => state.data.value.items),
+    total: (0, import_vue10.computed)(() => state.data.value.total ?? state.data.value.items.length),
+    page,
+    pageSize,
+    pending: state.pending,
+    error: state.error,
+    reload: state.reload,
+    goToPage,
+    setPageSize
+  };
+}
+
+// src/vue/use-tenants.ts
+var import_vue11 = require("vue");
 function useTenants(options) {
   if (!options?.endpoint) {
     throw new Error(
       'useTenants: `endpoint` is required (e.g. "/api/v1/admin/tenants" or "/api/admin/tenants"). The platform has no default because apps use different globalPrefix conventions.'
     );
   }
-  const filter = options.filter ?? (0, import_vue7.ref)({});
+  const filter = options.filter ?? (0, import_vue11.ref)({});
   const list = useApiList({
     endpoint: options.endpoint,
     filter,
@@ -4424,14 +5319,14 @@ function useTenants(options) {
 }
 
 // src/vue/use-audit-entries.ts
-var import_vue8 = require("vue");
+var import_vue12 = require("vue");
 function useAuditEntries(options) {
   if (!options?.endpoint) {
     throw new Error(
       'useAuditEntries: `endpoint` is required (e.g. "/api/admin/audit" or "/api/v1/admin/audit"). The platform has no default because apps use different globalPrefix conventions.'
     );
   }
-  const filter = options.filter ?? (0, import_vue8.ref)({});
+  const filter = options.filter ?? (0, import_vue12.ref)({});
   const list = useApiList({
     endpoint: options.endpoint,
     filter,
@@ -4443,7 +5338,7 @@ function useAuditEntries(options) {
 }
 
 // src/vue/use-entitlement.ts
-var import_vue9 = require("vue");
+var import_vue13 = require("vue");
 function useEntitlement(options) {
   if (!options?.endpoint) {
     throw new Error(
@@ -4452,9 +5347,9 @@ function useEntitlement(options) {
   }
   const endpoint = options.endpoint;
   const http = options.http ?? defaultHttpClient();
-  const entitlement = (0, import_vue9.ref)(null);
-  const loading = (0, import_vue9.ref)(false);
-  const error = (0, import_vue9.ref)(null);
+  const entitlement = (0, import_vue13.ref)(null);
+  const loading = (0, import_vue13.ref)(false);
+  const error = (0, import_vue13.ref)(null);
   async function load() {
     loading.value = true;
     error.value = null;
@@ -4484,15 +5379,15 @@ function useEntitlement(options) {
 }
 
 // src/vue/use-tenant-manifest.ts
-var import_vue10 = require("vue");
+var import_vue14 = require("vue");
 function useTenantManifest(options) {
   if (!options?.endpoint) {
     throw new Error('useTenantManifest: `endpoint` is required (e.g. "/api/tenant/manifest").');
   }
   const http = options.http ?? defaultHttpClient();
-  const manifest = (0, import_vue10.ref)(null);
-  const loading = (0, import_vue10.ref)(false);
-  const error = (0, import_vue10.ref)(null);
+  const manifest = (0, import_vue14.ref)(null);
+  const loading = (0, import_vue14.ref)(false);
+  const error = (0, import_vue14.ref)(null);
   async function load() {
     loading.value = true;
     error.value = null;
@@ -4526,7 +5421,7 @@ function useTenantManifest(options) {
 }
 
 // src/vue/entitlement-provider.ts
-var import_vue11 = require("vue");
+var import_vue15 = require("vue");
 var ENTITLEMENT_INJECTION_KEY = /* @__PURE__ */ Symbol.for(
   "@saasicat/ui-vue/ENTITLEMENT"
 );
@@ -4534,7 +5429,7 @@ function provideEntitlement(app, entitlement) {
   app.provide(ENTITLEMENT_INJECTION_KEY, entitlement);
 }
 function useInjectedEntitlement() {
-  return (0, import_vue11.inject)(ENTITLEMENT_INJECTION_KEY, null);
+  return (0, import_vue15.inject)(ENTITLEMENT_INJECTION_KEY, null);
 }
 
 // src/vue/feature-router-guard.ts
@@ -4563,15 +5458,15 @@ function buildFeatureRouterGuard(options) {
 }
 
 // src/vue/use-tenant-billing-catalog.ts
-var import_vue12 = require("vue");
+var import_vue16 = require("vue");
 function useTenantBillingCatalog(options = {}) {
   const apiPrefix = trimTrailingSlashes(options.apiPrefix ?? "/billing");
   const http = options.http ?? defaultHttpClient();
-  const plans = (0, import_vue12.ref)(null);
-  const featureRegistry = (0, import_vue12.ref)(null);
-  const bundles = (0, import_vue12.ref)(null);
-  const loading = (0, import_vue12.ref)(false);
-  const error = (0, import_vue12.ref)(null);
+  const plans = (0, import_vue16.ref)(null);
+  const featureRegistry = (0, import_vue16.ref)(null);
+  const bundles = (0, import_vue16.ref)(null);
+  const loading = (0, import_vue16.ref)(false);
+  const error = (0, import_vue16.ref)(null);
   async function fetchJson(path) {
     const res = await http(`${apiPrefix}${path}`, { method: "GET" });
     if (res.status !== 200) {
@@ -4621,14 +5516,14 @@ function useTenantBillingCatalog(options = {}) {
 }
 
 // src/vue/use-tenant-billing.ts
-var import_vue13 = require("vue");
+var import_vue17 = require("vue");
 function useTenantBilling(options = {}) {
   const apiPrefix = trimTrailingSlashes(options.apiPrefix ?? "/billing");
   const http = options.http ?? defaultHttpClient();
-  const usage = (0, import_vue13.ref)(null);
-  const loading = (0, import_vue13.ref)(false);
-  const error = (0, import_vue13.ref)(null);
-  const subscriptionBundles = (0, import_vue13.ref)([]);
+  const usage = (0, import_vue17.ref)(null);
+  const loading = (0, import_vue17.ref)(false);
+  const error = (0, import_vue17.ref)(null);
+  const subscriptionBundles = (0, import_vue17.ref)([]);
   function authHeaders() {
     const headers = {};
     const token = options.getAuthToken?.();
@@ -4762,7 +5657,7 @@ function useTenantBilling(options = {}) {
 }
 
 // src/vue/use-subscription-draft.ts
-var import_vue14 = require("vue");
+var import_vue18 = require("vue");
 var import_types13 = require("@saasicat/types");
 var DEFAULT_YEARLY_FACTOR = 10;
 function unwrap(source) {
@@ -4779,27 +5674,27 @@ function priceForCycle(monthlyNet, yearlyNet, cycle, yearlyFactor) {
 }
 function useSubscriptionDraft(options) {
   const yearlyFactor = options.yearlyFactor ?? DEFAULT_YEARLY_FACTOR;
-  const plansRef = (0, import_vue14.computed)(() => unwrap(options.plans) ?? []);
-  const subscriptionBundlesRef = (0, import_vue14.computed)(
+  const plansRef = (0, import_vue18.computed)(() => unwrap(options.plans) ?? []);
+  const subscriptionBundlesRef = (0, import_vue18.computed)(
     () => unwrap(options.subscriptionBundles ?? null) ?? []
   );
-  const plan = (0, import_vue14.ref)(options.initialPlan ?? null);
-  const cycle = (0, import_vue14.ref)(options.initialCycle ?? "MONTHLY");
-  const selectedBundleVersionIds = (0, import_vue14.ref)(
+  const plan = (0, import_vue18.ref)(options.initialPlan ?? null);
+  const cycle = (0, import_vue18.ref)(options.initialCycle ?? "MONTHLY");
+  const selectedBundleVersionIds = (0, import_vue18.ref)(
     new Set(options.initialBundleVersionIds ?? [])
   );
-  const promoCode = (0, import_vue14.ref)("");
-  const promoState = (0, import_vue14.ref)({ status: "idle", preview: null, message: "" });
-  const selectedPlan = (0, import_vue14.computed)(() => {
+  const promoCode = (0, import_vue18.ref)("");
+  const promoState = (0, import_vue18.ref)({ status: "idle", preview: null, message: "" });
+  const selectedPlan = (0, import_vue18.computed)(() => {
     if (!plan.value) return null;
     return plansRef.value.find((p) => p.id === plan.value) ?? null;
   });
-  const selectedBundles = (0, import_vue14.computed)(
+  const selectedBundles = (0, import_vue18.computed)(
     () => subscriptionBundlesRef.value.filter(
       (b) => selectedBundleVersionIds.value.has(b.bundleVersionId)
     )
   );
-  const chargeableBundles = (0, import_vue14.computed)(() => {
+  const chargeableBundles = (0, import_vue18.computed)(() => {
     const planFeatures = selectedPlan.value?.features ?? [];
     const selected = selectedBundles.value;
     const keptIds = new Set(
@@ -4807,7 +5702,7 @@ function useSubscriptionDraft(options) {
     );
     return selected.filter((b) => keptIds.has(b.bundleVersionId));
   });
-  const activeFeatures = (0, import_vue14.computed)(() => {
+  const activeFeatures = (0, import_vue18.computed)(() => {
     const result = /* @__PURE__ */ new Set();
     const planObj = selectedPlan.value;
     if (planObj) {
@@ -4818,7 +5713,7 @@ function useSubscriptionDraft(options) {
     }
     return result;
   });
-  const pricing = (0, import_vue14.computed)(() => {
+  const pricing = (0, import_vue18.computed)(() => {
     const cyc = cycle.value;
     const planObj = selectedPlan.value;
     const planNet = planObj ? priceForCycle(planObj.monthlyNet ?? 0, planObj.yearlyNet, cyc, yearlyFactor) : 0;
@@ -4878,7 +5773,7 @@ function useSubscriptionDraft(options) {
       }
     };
   });
-  const isDirty = (0, import_vue14.computed)(() => {
+  const isDirty = (0, import_vue18.computed)(() => {
     return selectedBundleVersionIds.value.size > 0 || promoState.value.status === "valid";
   });
   function setPlan(planId) {
@@ -4954,7 +5849,7 @@ function useSubscriptionDraft(options) {
 }
 
 // src/vue/use-bulk-publish.ts
-var import_vue15 = require("vue");
+var import_vue19 = require("vue");
 function useBulkPublish(options) {
   const msg = useSaMessages("planVersions");
   if (!options?.endpoints) {
@@ -4964,15 +5859,15 @@ function useBulkPublish(options) {
   }
   const http = options.http ?? defaultHttpClient();
   const endpoints = options.endpoints;
-  const items = (0, import_vue15.ref)([]);
-  const successCount = (0, import_vue15.computed)(() => items.value.filter((i) => i.status === "published").length);
-  const failureCount = (0, import_vue15.computed)(() => items.value.filter((i) => i.status === "failed").length);
-  const progress = (0, import_vue15.computed)(() => {
+  const items = (0, import_vue19.ref)([]);
+  const successCount = (0, import_vue19.computed)(() => items.value.filter((i) => i.status === "published").length);
+  const failureCount = (0, import_vue19.computed)(() => items.value.filter((i) => i.status === "failed").length);
+  const progress = (0, import_vue19.computed)(() => {
     if (items.value.length === 0) return 0;
     const done2 = successCount.value + failureCount.value;
     return done2 / items.value.length;
   });
-  const done = (0, import_vue15.computed)(
+  const done = (0, import_vue19.computed)(
     () => items.value.length > 0 && items.value.every((i) => i.status === "published" || i.status === "failed")
   );
   function setItems(next) {
@@ -5030,7 +5925,7 @@ function useBulkPublish(options) {
 }
 
 // src/vue/use-plan-editor.ts
-var import_vue16 = require("vue");
+var import_vue20 = require("vue");
 var PlannedOnlyFeatureError = class extends Error {
   constructor(violations) {
     super(
@@ -5050,10 +5945,10 @@ function tierWeight(tier) {
 function usePlanEditor(manifest, options = {}) {
   const baseSet = new Set(options.baseFeatures ?? []);
   const nonRegressive = options.nonRegressive ?? true;
-  const selectedFeatures = (0, import_vue16.ref)(new Set(options.initialFeatures ?? []));
+  const selectedFeatures = (0, import_vue20.ref)(new Set(options.initialFeatures ?? []));
   const catalogFeatures = manifest.planCatalogSnapshot.features ?? [];
   const plannedOnlySet = new Set(catalogFeatures.filter((f) => f.plannedOnly).map((f) => f.key));
-  const availableFeatures = (0, import_vue16.computed)(() => {
+  const availableFeatures = (0, import_vue20.computed)(() => {
     return catalogFeatures.map((def) => {
       const isSelected = selectedFeatures.value.has(def.key);
       const isPlannedOnly = !!def.plannedOnly;
@@ -5062,7 +5957,7 @@ function usePlanEditor(manifest, options = {}) {
       return { def, isSelected, isPlannedOnly, isInherited, canToggle };
     });
   });
-  const featuresByTier = (0, import_vue16.computed)(() => {
+  const featuresByTier = (0, import_vue20.computed)(() => {
     const groups = /* @__PURE__ */ new Map();
     for (const row of availableFeatures.value) {
       const tier = row.def.tier ?? "OTHER";
@@ -5107,12 +6002,12 @@ function usePlanEditor(manifest, options = {}) {
 }
 
 // src/vue/use-public-boot.ts
-var import_vue17 = require("vue");
+var import_vue21 = require("vue");
 function usePublicBoot(options) {
   const loader = new BootLoader(options);
-  const boot = (0, import_vue17.ref)(null);
-  const loading = (0, import_vue17.ref)(false);
-  const error = (0, import_vue17.ref)(null);
+  const boot = (0, import_vue21.ref)(null);
+  const loading = (0, import_vue21.ref)(false);
+  const error = (0, import_vue21.ref)(null);
   async function load() {
     loading.value = true;
     error.value = null;
@@ -5129,27 +6024,27 @@ function usePublicBoot(options) {
 }
 
 // src/vue/use-discovery.ts
-var import_vue18 = require("vue");
+var import_vue22 = require("vue");
 var DiscoveryLoadError = class extends Error {
   constructor(status, message) {
     super(message);
     this.status = status;
     this.name = "DiscoveryLoadError";
+    markPlatformError(this);
   }
   status;
 };
 function useDiscovery(options) {
-  const msg = useSaMessages("discovery");
   if (!options?.endpoint) {
     throw new Error(
       'useDiscovery: `endpoint` is required (e.g. "/api/admin/discovery" or "/api/v1/admin/discovery"). The platform has no default because apps use different globalPrefix conventions.'
     );
   }
   const http = options.http ?? defaultHttpClient();
-  const snapshot = (0, import_vue18.ref)(null);
-  const etag = (0, import_vue18.ref)(null);
-  const loading = (0, import_vue18.ref)(false);
-  const error = (0, import_vue18.ref)(null);
+  const snapshot = (0, import_vue22.ref)(null);
+  const etag = (0, import_vue22.ref)(null);
+  const loading = (0, import_vue22.ref)(false);
+  const error = (0, import_vue22.ref)(null);
   async function fetchSnapshot(includeEtag) {
     loading.value = true;
     error.value = null;
@@ -5161,13 +6056,19 @@ function useDiscovery(options) {
         headers["If-None-Match"] = etag.value;
       }
       const res = await http(options.endpoint, { method: "GET", headers });
+      requireServerAnswer(
+        res.status,
+        "GET",
+        options.endpoint,
+        (diagnostic) => new DiscoveryLoadError(res.status, diagnostic)
+      );
       if (res.status === 304) {
         return;
       }
       if (res.status !== 200) {
         throw new DiscoveryLoadError(
           res.status,
-          formatMessage(msg.value.errorDiscoveryHttp, { status: res.status })
+          `Discovery endpoint responded with HTTP ${res.status}`
         );
       }
       const body = await res.json();
@@ -5193,11 +6094,18 @@ function useDiscovery(options) {
       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 });
+      const rescanUrl = `${options.endpoint}/rescan`;
+      const res = await http(rescanUrl, { method: "POST", headers });
+      requireServerAnswer(
+        res.status,
+        "POST",
+        rescanUrl,
+        (diagnostic) => new DiscoveryLoadError(res.status, diagnostic)
+      );
       if (res.status !== 200 && res.status !== 201) {
         throw new DiscoveryLoadError(
           res.status,
-          formatMessage(msg.value.errorRescanHttp, { status: res.status })
+          `Discovery rescan responded with HTTP ${res.status}`
         );
       }
       const body = await res.json();
@@ -5216,13 +6124,14 @@ function useDiscovery(options) {
 }
 
 // src/vue/use-catalog-entries.ts
-var import_vue19 = require("vue");
+var import_vue23 = require("vue");
 var CatalogEntriesApiError = class extends Error {
   constructor(status, body, message) {
     super(message);
     this.status = status;
     this.body = body;
     this.name = "CatalogEntriesApiError";
+    markPlatformError(this);
   }
   status;
   body;
@@ -5234,13 +6143,12 @@ function useCatalogEntries(options) {
   if (!options?.projectKey) {
     throw new Error("useCatalogEntries: `projectKey` is required.");
   }
-  const msg = useSaMessages("discovery");
   const http = options.http ?? defaultHttpClient();
-  const capabilities = (0, import_vue19.ref)([]);
-  const features = (0, import_vue19.ref)([]);
-  const quotas = (0, import_vue19.ref)([]);
-  const loading = (0, import_vue19.ref)(false);
-  const error = (0, import_vue19.ref)(null);
+  const capabilities = (0, import_vue23.ref)([]);
+  const features = (0, import_vue23.ref)([]);
+  const quotas = (0, import_vue23.ref)([]);
+  const loading = (0, import_vue23.ref)(false);
+  const error = (0, import_vue23.ref)(null);
   const base = `${options.adminEndpoint}/catalog`;
   const pk = encodeURIComponent(options.projectKey);
   function authHeaders() {
@@ -5248,18 +6156,25 @@ function useCatalogEntries(options) {
     return token ? { Authorization: `Bearer ${token}` } : {};
   }
   async function fetchJson(url, init) {
+    const method = init?.method ?? "GET";
     const res = await http(url, {
-      method: init?.method ?? "GET",
+      method,
       headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
       body: init?.body
     });
+    requireServerAnswer(
+      res.status,
+      method,
+      url,
+      (diagnostic) => new CatalogEntriesApiError(res.status, null, diagnostic)
+    );
     if (res.status === 204) return null;
     const body = await res.json().catch(() => null);
     if (res.status >= 400) {
       throw new CatalogEntriesApiError(
         res.status,
         body,
-        formatMessage(msg.value.errorCatalogHttp, { status: res.status })
+        `Catalog entries API responded with HTTP ${res.status}`
       );
     }
     return body;
@@ -5287,7 +6202,8 @@ function useCatalogEntries(options) {
       `${base}/features/${encodeURIComponent(featureKey)}/review?projectKey=${pk}`,
       { method: "PATCH", body: JSON.stringify(data) }
     );
-    if (!updated) throw new CatalogEntriesApiError(0, null, "Review returned no body");
+    if (!updated)
+      throw markEmptyResponse(new CatalogEntriesApiError(0, null, "Review returned no body"));
     features.value = features.value.map((f) => f.featureKey === featureKey ? updated : f);
     return updated;
   }
@@ -5296,7 +6212,8 @@ function useCatalogEntries(options) {
       `${base}/quotas/${encodeURIComponent(quotaKey)}/review?projectKey=${pk}`,
       { method: "PATCH", body: JSON.stringify(data) }
     );
-    if (!updated) throw new CatalogEntriesApiError(0, null, "Review returned no body");
+    if (!updated)
+      throw markEmptyResponse(new CatalogEntriesApiError(0, null, "Review returned no body"));
     quotas.value = quotas.value.map((q) => q.quotaKey === quotaKey ? updated : q);
     return updated;
   }
@@ -5305,7 +6222,8 @@ function useCatalogEntries(options) {
       `${base}/features/${encodeURIComponent(featureKey)}/i18n?projectKey=${pk}`,
       { method: "PATCH", body: JSON.stringify({ i18n }) }
     );
-    if (!updated) throw new CatalogEntriesApiError(0, null, "i18n returned no body");
+    if (!updated)
+      throw markEmptyResponse(new CatalogEntriesApiError(0, null, "i18n returned no body"));
     features.value = features.value.map((f) => f.featureKey === featureKey ? updated : f);
     return updated;
   }
@@ -5314,7 +6232,8 @@ function useCatalogEntries(options) {
       `${base}/quotas/${encodeURIComponent(quotaKey)}/i18n?projectKey=${pk}`,
       { method: "PATCH", body: JSON.stringify({ i18n }) }
     );
-    if (!updated) throw new CatalogEntriesApiError(0, null, "i18n returned no body");
+    if (!updated)
+      throw markEmptyResponse(new CatalogEntriesApiError(0, null, "i18n returned no body"));
     quotas.value = quotas.value.map((q) => q.quotaKey === quotaKey ? updated : q);
     return updated;
   }
@@ -5323,7 +6242,8 @@ function useCatalogEntries(options) {
       `${base}/features/${encodeURIComponent(featureKey)}?projectKey=${pk}`,
       { method: "PATCH", body: JSON.stringify(data) }
     );
-    if (!updated) throw new CatalogEntriesApiError(0, null, "Base returned no body");
+    if (!updated)
+      throw markEmptyResponse(new CatalogEntriesApiError(0, null, "Base returned no body"));
     features.value = features.value.map((f) => f.featureKey === featureKey ? updated : f);
     return updated;
   }
@@ -5332,7 +6252,8 @@ function useCatalogEntries(options) {
       `${base}/quotas/${encodeURIComponent(quotaKey)}?projectKey=${pk}`,
       { method: "PATCH", body: JSON.stringify(data) }
     );
-    if (!updated) throw new CatalogEntriesApiError(0, null, "Base returned no body");
+    if (!updated)
+      throw markEmptyResponse(new CatalogEntriesApiError(0, null, "Base returned no body"));
     quotas.value = quotas.value.map((q) => q.quotaKey === quotaKey ? updated : q);
     return updated;
   }
@@ -5341,7 +6262,8 @@ function useCatalogEntries(options) {
       method: "POST",
       body: JSON.stringify({ snapshot })
     });
-    if (!result) throw new CatalogEntriesApiError(0, null, "Sync returned no body");
+    if (!result)
+      throw markEmptyResponse(new CatalogEntriesApiError(0, null, "Sync returned no body"));
     await load();
     return result;
   }
@@ -5366,13 +6288,14 @@ function useCatalogEntries(options) {
 }
 
 // src/vue/use-bundles.ts
-var import_vue20 = require("vue");
+var import_vue24 = require("vue");
 var BundlesApiError = class extends Error {
   constructor(status, body, message) {
     super(message);
     this.status = status;
     this.body = body;
     this.name = "BundlesApiError";
+    markPlatformError(this);
   }
   status;
   body;
@@ -5387,20 +6310,27 @@ function useBundles(options) {
     throw new Error("useBundles: `projectKey` is required.");
   }
   const http = options.http ?? defaultHttpClient();
-  const bundles = (0, import_vue20.ref)([]);
-  const loading = (0, import_vue20.ref)(false);
-  const error = (0, import_vue20.ref)(null);
+  const bundles = (0, import_vue24.ref)([]);
+  const loading = (0, import_vue24.ref)(false);
+  const error = (0, import_vue24.ref)(null);
   const baseUrl = `${options.adminEndpoint}/catalog/bundles`;
   function authHeaders() {
     const token = options.getAuthToken?.();
     return token ? { Authorization: `Bearer ${token}` } : {};
   }
   async function fetchJson(url, init) {
+    const method = init?.method ?? "GET";
     const res = await http(url, {
-      method: init?.method ?? "GET",
+      method,
       headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
       body: init?.body
     });
+    requireServerAnswer(
+      res.status,
+      method,
+      url,
+      (diagnostic) => new BundlesApiError(res.status, null, diagnostic)
+    );
     if (res.status === 204) return null;
     const body = await res.json().catch(() => null);
     if (res.status >= 400) {
@@ -5431,7 +6361,8 @@ function useBundles(options) {
       method: "POST",
       body: JSON.stringify(data)
     });
-    if (!created) throw new BundlesApiError(0, null, "Create returned no body");
+    if (!created)
+      throw markEmptyResponse(new BundlesApiError(0, null, "Create returned no body"));
     bundles.value = [...bundles.value, created];
     return created;
   }
@@ -5440,7 +6371,8 @@ function useBundles(options) {
       method: "PATCH",
       body: JSON.stringify(data)
     });
-    if (!updated) throw new BundlesApiError(0, null, "Update returned no body");
+    if (!updated)
+      throw markEmptyResponse(new BundlesApiError(0, null, "Update returned no body"));
     bundles.value = bundles.value.map((b) => b.id === bundleId ? updated : b);
     return updated;
   }
@@ -5461,9 +6393,9 @@ function useBundleVersions(options) {
     throw new Error("useBundleVersions: `bundleId` is required.");
   }
   const http = options.http ?? defaultHttpClient();
-  const versions = (0, import_vue20.ref)([]);
-  const loading = (0, import_vue20.ref)(false);
-  const error = (0, import_vue20.ref)(null);
+  const versions = (0, import_vue24.ref)([]);
+  const loading = (0, import_vue24.ref)(false);
+  const error = (0, import_vue24.ref)(null);
   const bundleVersionsUrl = `${options.adminEndpoint}/catalog/bundles/${options.bundleId}/versions`;
   const versionUrlBase = `${options.adminEndpoint}/catalog/bundle-versions`;
   function authHeaders() {
@@ -5471,11 +6403,18 @@ function useBundleVersions(options) {
     return token ? { Authorization: `Bearer ${token}` } : {};
   }
   async function fetchJson(url, init) {
+    const method = init?.method ?? "GET";
     const res = await http(url, {
-      method: init?.method ?? "GET",
+      method,
       headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
       body: init?.body
     });
+    requireServerAnswer(
+      res.status,
+      method,
+      url,
+      (diagnostic) => new BundlesApiError(res.status, null, diagnostic)
+    );
     if (res.status === 204) return null;
     const body = await res.json().catch(() => null);
     if (res.status >= 400) {
@@ -5504,7 +6443,8 @@ function useBundleVersions(options) {
       method: "POST",
       body: JSON.stringify(data)
     });
-    if (!result) throw new BundlesApiError(0, null, "CreateDraft returned no body");
+    if (!result)
+      throw markEmptyResponse(new BundlesApiError(0, null, "CreateDraft returned no body"));
     versions.value = [...versions.value, result.bundleVersion];
     return result;
   }
@@ -5513,7 +6453,8 @@ function useBundleVersions(options) {
       `${versionUrlBase}/${versionId}`,
       { method: "PATCH", body: JSON.stringify(data) }
     );
-    if (!result) throw new BundlesApiError(0, null, "UpdateDraft returned no body");
+    if (!result)
+      throw markEmptyResponse(new BundlesApiError(0, null, "UpdateDraft returned no body"));
     versions.value = versions.value.map((v) => v.id === versionId ? result.bundleVersion : v);
     return result;
   }
@@ -5522,7 +6463,8 @@ function useBundleVersions(options) {
       `${versionUrlBase}/${versionId}/publish`,
       { method: "POST", body: JSON.stringify(opts) }
     );
-    if (!result) throw new BundlesApiError(0, null, "Publish returned no body");
+    if (!result)
+      throw markEmptyResponse(new BundlesApiError(0, null, "Publish returned no body"));
     await load();
     return result;
   }
@@ -5537,7 +6479,7 @@ function useBundleVersions(options) {
 }
 
 // src/vue/use-bundle-versions-map.ts
-var import_vue21 = require("vue");
+var import_vue25 = require("vue");
 function useBundleVersionsMap(options) {
   if (!options?.adminEndpoint) {
     throw new Error("useBundleVersionsMap: `adminEndpoint` is required.");
@@ -5546,9 +6488,9 @@ function useBundleVersionsMap(options) {
     throw new Error("useBundleVersionsMap: `bundles` is required.");
   }
   const http = options.http ?? defaultHttpClient();
-  const versionsByBundle = (0, import_vue21.ref)({});
-  const loading = (0, import_vue21.ref)(false);
-  const error = (0, import_vue21.ref)(null);
+  const versionsByBundle = (0, import_vue25.ref)({});
+  const loading = (0, import_vue25.ref)(false);
+  const error = (0, import_vue25.ref)(null);
   function authHeaders() {
     const token = options.getAuthToken?.();
     return token ? { Authorization: `Bearer ${token}` } : {};
@@ -5598,7 +6540,7 @@ function useBundleVersionsMap(options) {
       console.warn(`useBundleVersionsMap: refreshOne('${bundleId}') failed`, err);
     }
   }
-  (0, import_vue21.watch)(
+  (0, import_vue25.watch)(
     () => options.bundles.value.map((b) => b.id).join(","),
     () => {
       if (options.bundles.value.length > 0) void refresh();
@@ -5610,13 +6552,14 @@ function useBundleVersionsMap(options) {
 }
 
 // src/vue/use-tenant-subscription-bundles.ts
-var import_vue22 = require("vue");
+var import_vue26 = require("vue");
 var TenantSubscriptionBundlesApiError = class extends Error {
   constructor(status, body, message) {
     super(message);
     this.status = status;
     this.body = body;
     this.name = "TenantSubscriptionBundlesApiError";
+    markPlatformError(this);
   }
   status;
   body;
@@ -5629,19 +6572,26 @@ function useTenantSubscriptionBundles(options) {
   }
   const http = options.http ?? defaultHttpClient();
   const baseUrl = `${options.billingEndpoint}/billing/subscription-bundles`;
-  const bundles = (0, import_vue22.ref)([]);
-  const loading = (0, import_vue22.ref)(false);
-  const error = (0, import_vue22.ref)(null);
+  const bundles = (0, import_vue26.ref)([]);
+  const loading = (0, import_vue26.ref)(false);
+  const error = (0, import_vue26.ref)(null);
   function authHeaders() {
     const token = options.getAuthToken?.();
     return token ? { Authorization: `Bearer ${token}` } : {};
   }
   async function fetchJson(url, init) {
+    const method = init?.method ?? "GET";
     const res = await http(url, {
-      method: init?.method ?? "GET",
+      method,
       headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
       body: init?.body
     });
+    requireServerAnswer(
+      res.status,
+      method,
+      url,
+      (diagnostic) => new TenantSubscriptionBundlesApiError(res.status, null, diagnostic)
+    );
     if (res.status === 204) return null;
     const body = await res.json().catch(() => null);
     if (res.status >= 400) {
@@ -5671,7 +6621,9 @@ function useTenantSubscriptionBundles(options) {
       body: JSON.stringify(data)
     });
     if (!result) {
-      throw new TenantSubscriptionBundlesApiError(0, null, "add returned no body");
+      throw markEmptyResponse(
+        new TenantSubscriptionBundlesApiError(0, null, "add returned no body")
+      );
     }
     const hydrated = rehydrateDates(result);
     bundles.value = [hydrated, ...bundles.value];
@@ -5683,7 +6635,9 @@ function useTenantSubscriptionBundles(options) {
       { method: "DELETE", body: JSON.stringify(opts) }
     );
     if (!result) {
-      throw new TenantSubscriptionBundlesApiError(0, null, "cancel returned no body");
+      throw markEmptyResponse(
+        new TenantSubscriptionBundlesApiError(0, null, "cancel returned no body")
+      );
     }
     const hydrated = rehydrateDates(result);
     bundles.value = bundles.value.map((b) => b.id === subscriptionBundleId ? hydrated : b);
@@ -5705,13 +6659,14 @@ function rehydrateDates(raw) {
 }
 
 // src/vue/use-marketing-projections.ts
-var import_vue23 = require("vue");
+var import_vue27 = require("vue");
 var MarketingProjectionsApiError = class extends Error {
   constructor(status, body, message) {
     super(message);
     this.status = status;
     this.body = body;
     this.name = "MarketingProjectionsApiError";
+    markPlatformError(this);
   }
   status;
   body;
@@ -5723,12 +6678,11 @@ function useMarketingProjections(options) {
   if (!options?.filter?.projectKey) {
     throw new Error("useMarketingProjections: `filter.projectKey` is required.");
   }
-  const msg = useSaMessages("marketing");
   const http = options.http ?? defaultHttpClient();
-  const projections = (0, import_vue23.ref)([]);
-  const filter = (0, import_vue23.ref)({ ...options.filter });
-  const loading = (0, import_vue23.ref)(false);
-  const error = (0, import_vue23.ref)(null);
+  const projections = (0, import_vue27.ref)([]);
+  const filter = (0, import_vue27.ref)({ ...options.filter });
+  const loading = (0, import_vue27.ref)(false);
+  const error = (0, import_vue27.ref)(null);
   const baseUrl = `${options.adminEndpoint}/catalog/marketing-projections`;
   function authHeaders() {
     const token = options.getAuthToken?.();
@@ -5744,18 +6698,25 @@ function useMarketingProjections(options) {
     return `${baseUrl}?${params.toString()}`;
   }
   async function fetchJson(url, init) {
+    const method = init?.method ?? "GET";
     const res = await http(url, {
-      method: init?.method ?? "GET",
+      method,
       headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
       body: init?.body
     });
+    requireServerAnswer(
+      res.status,
+      method,
+      url,
+      (diagnostic) => new MarketingProjectionsApiError(res.status, null, diagnostic)
+    );
     if (res.status === 204) return null;
     const body = await res.json().catch(() => null);
     if (res.status >= 400) {
       throw new MarketingProjectionsApiError(
         res.status,
         body,
-        formatMessage(msg.value.errors.projectionsApi, { status: res.status })
+        `Marketing projections API responded with HTTP ${res.status}`
       );
     }
     return body;
@@ -5782,7 +6743,9 @@ function useMarketingProjections(options) {
       body: JSON.stringify(data)
     });
     if (!created) {
-      throw new MarketingProjectionsApiError(0, null, "Create returned no body");
+      throw markEmptyResponse(
+        new MarketingProjectionsApiError(0, null, "Create returned no body")
+      );
     }
     await load();
     return created;
@@ -5793,7 +6756,9 @@ function useMarketingProjections(options) {
       body: JSON.stringify(data)
     });
     if (!updated) {
-      throw new MarketingProjectionsApiError(0, null, "Update returned no body");
+      throw markEmptyResponse(
+        new MarketingProjectionsApiError(0, null, "Update returned no body")
+      );
     }
     projections.value = projections.value.map((p) => p.id === id ? updated : p);
     return updated;
@@ -5809,13 +6774,14 @@ function useMarketingProjections(options) {
 }
 
 // src/vue/use-promotions.ts
-var import_vue24 = require("vue");
+var import_vue28 = require("vue");
 var PromotionsApiError = class extends Error {
   constructor(status, body, message) {
     super(message);
     this.status = status;
     this.body = body;
     this.name = "PromotionsApiError";
+    markPlatformError(this);
   }
   status;
   body;
@@ -5827,11 +6793,10 @@ function usePromotions(options) {
   if (!options?.projectKey) {
     throw new Error("usePromotions: `projectKey` is required.");
   }
-  const msg = useSaMessages("promos");
   const http = options.http ?? defaultHttpClient();
-  const promotions = (0, import_vue24.ref)([]);
-  const loading = (0, import_vue24.ref)(false);
-  const error = (0, import_vue24.ref)(null);
+  const promotions = (0, import_vue28.ref)([]);
+  const loading = (0, import_vue28.ref)(false);
+  const error = (0, import_vue28.ref)(null);
   const baseUrl = `${options.adminEndpoint}/catalog/promotions`;
   const pk = encodeURIComponent(options.projectKey);
   function authHeaders() {
@@ -5839,18 +6804,25 @@ function usePromotions(options) {
     return token ? { Authorization: `Bearer ${token}` } : {};
   }
   async function fetchJson(url, init) {
+    const method = init?.method ?? "GET";
     const res = await http(url, {
-      method: init?.method ?? "GET",
+      method,
       headers: { "content-type": "application/json", ...authHeaders(), ...init?.headers },
       body: init?.body
     });
+    requireServerAnswer(
+      res.status,
+      method,
+      url,
+      (diagnostic) => new PromotionsApiError(res.status, null, diagnostic)
+    );
     if (res.status === 204) return null;
     const body = await res.json().catch(() => null);
     if (res.status >= 400) {
       throw new PromotionsApiError(
         res.status,
         body,
-        formatMessage(msg.value.apiErrorHttpStatus, { status: res.status })
+        `Promotions API responded with HTTP ${res.status}`
       );
     }
     return body;
@@ -5872,7 +6844,8 @@ function usePromotions(options) {
       method: "POST",
       body: JSON.stringify(data)
     });
-    if (!created) throw new PromotionsApiError(0, null, "Create returned no body");
+    if (!created)
+      throw markEmptyResponse(new PromotionsApiError(0, null, "Create returned no body"));
     promotions.value = [...promotions.value, created];
     return created;
   }
@@ -5881,7 +6854,8 @@ function usePromotions(options) {
       method: "PATCH",
       body: JSON.stringify(data)
     });
-    if (!updated) throw new PromotionsApiError(0, null, "Update returned no body");
+    if (!updated)
+      throw markEmptyResponse(new PromotionsApiError(0, null, "Update returned no body"));
     promotions.value = promotions.value.map((p) => p.id === id ? updated : p);
     return updated;
   }
@@ -5896,13 +6870,14 @@ function usePromotions(options) {
 }
 
 // src/vue/use-plans.ts
-var import_vue25 = require("vue");
+var import_vue29 = require("vue");
 var PlansApiError = class extends Error {
   constructor(status, body, message) {
     super(message);
     this.status = status;
     this.body = body;
     this.name = "PlansApiError";
+    markPlatformError(this);
   }
   status;
   body;
@@ -5917,18 +6892,19 @@ function usePlans(options) {
     throw new Error("usePlans: `projectKey` is required.");
   }
   const http = options.http ?? defaultHttpClient();
-  const plans = (0, import_vue25.ref)([]);
-  const loading = (0, import_vue25.ref)(false);
-  const error = (0, import_vue25.ref)(null);
-  const tenantCountsByPlanKey = (0, import_vue25.ref)({});
+  const plans = (0, import_vue29.ref)([]);
+  const loading = (0, import_vue29.ref)(false);
+  const error = (0, import_vue29.ref)(null);
+  const tenantCountsByPlanKey = (0, import_vue29.ref)({});
   const baseUrl = `${options.adminEndpoint}/catalog/plans`;
   function authHeaders() {
     const token = options.getAuthToken?.();
     return token ? { Authorization: `Bearer ${token}` } : {};
   }
   async function fetchJson(url, init) {
+    const method = init?.method ?? "GET";
     const res = await http(url, {
-      method: init?.method ?? "GET",
+      method,
       headers: {
         "content-type": "application/json",
         ...authHeaders(),
@@ -5936,6 +6912,12 @@ function usePlans(options) {
       },
       body: init?.body
     });
+    requireServerAnswer(
+      res.status,
+      method,
+      url,
+      (diagnostic) => new PlansApiError(res.status, null, diagnostic)
+    );
     if (res.status === 204) return null;
     const body = await res.json().catch(() => null);
     if (res.status >= 400) {
@@ -5976,7 +6958,8 @@ function usePlans(options) {
       method: "POST",
       body: JSON.stringify(data)
     });
-    if (!created) throw new PlansApiError(0, null, "Create returned no body");
+    if (!created)
+      throw markEmptyResponse(new PlansApiError(0, null, "Create returned no body"));
     plans.value = [...plans.value, created];
     return created;
   }
@@ -5985,7 +6968,8 @@ function usePlans(options) {
       method: "PATCH",
       body: JSON.stringify(data)
     });
-    if (!updated) throw new PlansApiError(0, null, "Update returned no body");
+    if (!updated)
+      throw markEmptyResponse(new PlansApiError(0, null, "Update returned no body"));
     plans.value = plans.value.map((p) => p.id === planId ? updated : p);
     return updated;
   }
@@ -6021,9 +7005,9 @@ function usePlanVersions(options) {
     throw new Error("usePlanVersions: `planId` is required.");
   }
   const http = options.http ?? defaultHttpClient();
-  const versions = (0, import_vue25.ref)([]);
-  const loading = (0, import_vue25.ref)(false);
-  const error = (0, import_vue25.ref)(null);
+  const versions = (0, import_vue29.ref)([]);
+  const loading = (0, import_vue29.ref)(false);
+  const error = (0, import_vue29.ref)(null);
   const planVersionsUrl = `${options.adminEndpoint}/catalog/plans/${options.planId}/versions`;
   const versionUrlBase = `${options.adminEndpoint}/catalog/plan-versions`;
   function authHeaders() {
@@ -6031,8 +7015,9 @@ function usePlanVersions(options) {
     return token ? { Authorization: `Bearer ${token}` } : {};
   }
   async function fetchJson(url, init) {
+    const method = init?.method ?? "GET";
     const res = await http(url, {
-      method: init?.method ?? "GET",
+      method,
       headers: {
         "content-type": "application/json",
         ...authHeaders(),
@@ -6040,6 +7025,12 @@ function usePlanVersions(options) {
       },
       body: init?.body
     });
+    requireServerAnswer(
+      res.status,
+      method,
+      url,
+      (diagnostic) => new PlansApiError(res.status, null, diagnostic)
+    );
     if (res.status === 204) return null;
     const body = await res.json().catch(() => null);
     if (res.status >= 400) {
@@ -6068,7 +7059,8 @@ function usePlanVersions(options) {
       method: "POST",
       body: JSON.stringify(data)
     });
-    if (!result) throw new PlansApiError(0, null, "CreateDraft returned no body");
+    if (!result)
+      throw markEmptyResponse(new PlansApiError(0, null, "CreateDraft returned no body"));
     versions.value = [...versions.value, result.planVersion];
     return result;
   }
@@ -6077,7 +7069,8 @@ function usePlanVersions(options) {
       `${versionUrlBase}/${versionId}`,
       { method: "PATCH", body: JSON.stringify(data) }
     );
-    if (!result) throw new PlansApiError(0, null, "UpdateDraft returned no body");
+    if (!result)
+      throw markEmptyResponse(new PlansApiError(0, null, "UpdateDraft returned no body"));
     versions.value = versions.value.map((v) => v.id === versionId ? result.planVersion : v);
     return result;
   }
@@ -6086,7 +7079,8 @@ function usePlanVersions(options) {
       `${versionUrlBase}/${versionId}/publish`,
       { method: "POST", body: JSON.stringify(opts) }
     );
-    if (!result) throw new PlansApiError(0, null, "Publish returned no body");
+    if (!result)
+      throw markEmptyResponse(new PlansApiError(0, null, "Publish returned no body"));
     versions.value = versions.value.map((v) => v.id === versionId ? result.planVersion : v);
     return result;
   }
@@ -6099,7 +7093,8 @@ function usePlanVersions(options) {
       `${versionUrlBase}/${versionId}/terminate`,
       { method: "POST", body: JSON.stringify({ endsAt }) }
     );
-    if (!updated) throw new PlansApiError(0, null, "Terminate returned no body");
+    if (!updated)
+      throw markEmptyResponse(new PlansApiError(0, null, "Terminate returned no body"));
     versions.value = versions.value.map((v) => v.id === versionId ? updated : v);
     return updated;
   }
@@ -6120,7 +7115,7 @@ function usePlanVersions(options) {
 }
 
 // src/vue/use-live-plan-versions.ts
-var import_vue26 = require("vue");
+var import_vue30 = require("vue");
 function useLivePlanVersions(options) {
   if (!options?.adminEndpoint) {
     throw new Error("useLivePlanVersions: `adminEndpoint` is required.");
@@ -6129,9 +7124,9 @@ function useLivePlanVersions(options) {
     throw new Error("useLivePlanVersions: `plans` is required.");
   }
   const http = options.http ?? defaultHttpClient();
-  const livePlanVersions = (0, import_vue26.ref)({});
-  const loading = (0, import_vue26.ref)(false);
-  const error = (0, import_vue26.ref)(null);
+  const livePlanVersions = (0, import_vue30.ref)({});
+  const loading = (0, import_vue30.ref)(false);
+  const error = (0, import_vue30.ref)(null);
   function authHeaders() {
     const token = options.getAuthToken?.();
     return token ? { Authorization: `Bearer ${token}` } : {};
@@ -6173,7 +7168,7 @@ function useLivePlanVersions(options) {
       loading.value = false;
     }
   }
-  (0, import_vue26.watch)(
+  (0, import_vue30.watch)(
     () => options.plans.value.map((p) => p.id).join(","),
     () => {
       if (options.plans.value.length > 0) void refresh();
@@ -6195,12 +7190,12 @@ function findLatestLive(versions) {
 }
 
 // src/vue/use-manifest.ts
-var import_vue27 = require("vue");
+var import_vue31 = require("vue");
 function useManifest(options) {
   const loader = new ManifestLoader(options);
-  const manifest = (0, import_vue27.ref)(null);
-  const loading = (0, import_vue27.ref)(false);
-  const error = (0, import_vue27.ref)(null);
+  const manifest = (0, import_vue31.ref)(null);
+  const loading = (0, import_vue31.ref)(false);
+  const error = (0, import_vue31.ref)(null);
   async function load() {
     loading.value = true;
     error.value = null;
@@ -6226,24 +7221,24 @@ function useManifest(options) {
 }
 
 // src/vue/use-nav.ts
-var import_vue28 = require("vue");
+var import_vue32 = require("vue");
 function useNav(manifest, options = {}) {
   const { locale } = useSuperAdminI18n();
-  const activeLocale = (0, import_vue28.computed)(() => options.locale ?? locale.value);
-  const routes = (0, import_vue28.computed)(() => {
+  const activeLocale = (0, import_vue32.computed)(() => options.locale ?? locale.value);
+  const routes = (0, import_vue32.computed)(() => {
     if (!manifest.value) return [];
     return buildRoutes(manifest.value, { ...options, locale: activeLocale.value });
   });
-  const sidebar = (0, import_vue28.computed)(
+  const sidebar = (0, import_vue32.computed)(
     () => buildSidebar(routes.value, defaultSectionOrder(activeLocale.value))
   );
   return { routes, sidebar };
 }
 
 // src/vue/use-actions.ts
-var import_vue29 = require("vue");
+var import_vue33 = require("vue");
 function useActions(manifest, actions) {
-  const registry = (0, import_vue29.computed)(() => {
+  const registry = (0, import_vue33.computed)(() => {
     if (!manifest.value) return null;
     return new ActionRegistry(manifest.value, actions);
   });
@@ -6251,18 +7246,18 @@ function useActions(manifest, actions) {
 }
 
 // src/vue/use-tenant-action-flow.ts
-var import_vue30 = require("vue");
+var import_vue34 = require("vue");
 function useTenantActionFlow(manifest, providers = {}) {
   const handlers = useSuperAdminActions();
   const msg = useSaMessages("tenants");
-  const registry = (0, import_vue30.computed)(() => {
+  const registry = (0, import_vue34.computed)(() => {
     if (!manifest.value) return null;
     return new ActionRegistry(manifest.value, handlers);
   });
-  const orphanedDefs = (0, import_vue30.computed)(
+  const orphanedDefs = (0, import_vue34.computed)(
     () => registry.value ? registry.value.listOrphanedDefs() : []
   );
-  const availableActions = (0, import_vue30.computed)(() => {
+  const availableActions = (0, import_vue34.computed)(() => {
     const m = manifest.value;
     const reg = registry.value;
     if (!m || !reg) return [];
@@ -6335,7 +7330,7 @@ async function runFlow(def, row, registry, providers, successTemplate) {
 }
 
 // src/vue/use-platform-tenant-actions.ts
-var import_vue31 = require("vue");
+var import_vue35 = require("vue");
 var DEFAULT_VISIBLE_FOR_ROW = (def, row) => {
   if (def.actionKey === "tenants.suspend") return row.isActive;
   if (def.actionKey === "tenants.reactivate") return !row.isActive;
@@ -6371,7 +7366,7 @@ function usePlatformTenantActions(options) {
   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 = (0, import_vue31.ref)({ show: false, description: "", error: "" });
+  const mfa = (0, import_vue35.ref)({ show: false, description: "", error: "" });
   let pendingMfaResolve = null;
   function showMfaDialog(def, ctx) {
     return new Promise((resolve) => {
@@ -6396,7 +7391,7 @@ function usePlatformTenantActions(options) {
       pendingMfaResolve(null);
     }
   }
-  const confirmDialog = (0, import_vue31.ref)({
+  const confirmDialog = (0, import_vue35.ref)({
     show: false,
     def: null,
     row: null
@@ -6438,7 +7433,7 @@ function usePlatformTenantActions(options) {
     },
     visibleForRow
   });
-  const manifestActions = (0, import_vue31.computed)(
+  const manifestActions = (0, import_vue35.computed)(
     () => flow.availableActions.value.map((def) => ({
       id: def.id,
       label: def.label,
@@ -6452,7 +7447,7 @@ function usePlatformTenantActions(options) {
       }
     }))
   );
-  const realOrphans = (0, import_vue31.computed)(() => {
+  const realOrphans = (0, import_vue35.computed)(() => {
     const caps = options.manifest.value?.capabilities ?? {};
     const defs = options.manifest.value?.tenants?.actions ?? [];
     const defByActionKey = new Map(defs.map((d) => [d.actionKey, d]));
@@ -6477,12 +7472,12 @@ function usePlatformTenantActions(options) {
 }
 
 // src/vue/use-batch-columns.ts
-var import_vue32 = require("vue");
+var import_vue36 = require("vue");
 function useBatchColumns(manifest, tenantIds, options = {}) {
   const fetcher = new BatchColumnFetcher(options);
-  const data = (0, import_vue32.ref)({});
-  const loading = (0, import_vue32.ref)(false);
-  const error = (0, import_vue32.ref)(null);
+  const data = (0, import_vue36.ref)({});
+  const loading = (0, import_vue36.ref)(false);
+  const error = (0, import_vue36.ref)(null);
   async function load() {
     if (!manifest.value || tenantIds.value.length === 0) {
       data.value = {};
@@ -6499,22 +7494,23 @@ function useBatchColumns(manifest, tenantIds, options = {}) {
       loading.value = false;
     }
   }
-  (0, import_vue32.watch)([manifest, tenantIds], () => {
+  (0, import_vue36.watch)([manifest, tenantIds], () => {
     void load();
   });
   return { data, loading, error, reload: load };
 }
 
 // src/vue/platform-loaders.ts
-function resolveEndpoints(endpoints) {
+function resolveSuperAdminEndpoints(endpoints) {
   return {
     apiBase: endpoints.apiBase,
     publicBootEndpoint: endpoints.publicBootEndpoint ?? `${endpoints.apiBase}/boot`,
-    manifestEndpoint: endpoints.manifestEndpoint ?? `${endpoints.apiBase}/manifest`
+    manifestEndpoint: endpoints.manifestEndpoint ?? `${endpoints.apiBase}/manifest`,
+    projectKey: endpoints.projectKey ?? ""
   };
 }
 function createPlatformLoaders(options) {
-  const resolved = resolveEndpoints(options.endpoints);
+  const resolved = resolveSuperAdminEndpoints(options.endpoints);
   const bootLoader = new BootLoader({
     endpoint: resolved.publicBootEndpoint,
     http: options.http
@@ -6531,13 +7527,13 @@ function createPlatformLoaders(options) {
 
 // src/vue/manifest-store-factory.ts
 var import_pinia = require("pinia");
-var import_vue33 = require("vue");
+var import_vue37 = require("vue");
 function createManifestStore(options) {
   return (0, import_pinia.defineStore)(options.id ?? "admin-manifest", () => {
-    const manifest = (0, import_vue33.ref)(null);
-    const loading = (0, import_vue33.ref)(false);
-    const error = (0, import_vue33.ref)(null);
-    const loaded = (0, import_vue33.ref)(false);
+    const manifest = (0, import_vue37.ref)(null);
+    const loading = (0, import_vue37.ref)(false);
+    const error = (0, import_vue37.ref)(null);
+    const loaded = (0, import_vue37.ref)(false);
     let inflight = null;
     async function load() {
       loading.value = true;
@@ -6970,6 +7966,7 @@ function planChangeWizardI18n(i18n) {
   ALL_ROWS,
   ActionDefNotInManifestError,
   ActionRegistry,
+  AdminError,
   BatchColumnDriftError,
   BatchColumnFetcher,
   BootLoadError,
@@ -6990,6 +7987,10 @@ function planChangeWizardI18n(i18n) {
   IDENTITY_ACCENT_VALUES,
   IDENTITY_NEUTRAL,
   IDENTITY_NEUTRAL_VALUE,
+  LIST_FIRST_PAGE,
+  LIST_PAGE_SIZE_DEFAULT,
+  LIST_PAGE_SIZE_MAX,
+  LIST_PAGINATION_PARAMS,
   ManifestLoadError,
   ManifestLoader,
   MarketingProjectionsApiError,
@@ -6999,15 +8000,18 @@ function planChangeWizardI18n(i18n) {
   PlansApiError,
   ProjectPageHost,
   PromotionsApiError,
+  SA_COLOR_SCHEMES,
   SA_INTL_LOCALES,
   SA_LOCALES,
   SA_LOCALE_LABELS,
   SA_LOCALE_STORAGE_KEY,
   SA_MESSAGES,
   SA_THEME_KEY,
+  SA_THEME_STORAGE_KEY,
   SERVER_PAGE_SIZE_OPTIONS,
   SUPER_ADMIN_ACTIONS_KEY,
   SUPER_ADMIN_BRAND_KEY,
+  SUPER_ADMIN_CONFIRM_KEY,
   SUPER_ADMIN_ENDPOINTS_KEY,
   SUPER_ADMIN_EXTENSIONS_KEY,
   SUPER_ADMIN_HTTP_KEY,
@@ -7016,19 +8020,28 @@ function planChangeWizardI18n(i18n) {
   SUPER_ADMIN_MANIFEST_CLEAR_CACHE_KEY,
   SUPER_ADMIN_MANIFEST_KEY,
   SUPER_ADMIN_NOTIFY_KEY,
+  SUPER_ADMIN_RESOURCES_KEY,
   TenantSubscriptionBundlesApiError,
+  adminErrorMessage,
+  auditResource,
+  bindResource,
   buildFeatureRegistry,
   buildFeatureRouterGuard,
   buildNavigationGuard,
   buildQuotaRegistry,
   buildRoutes,
   buildSidebar,
+  clampListPage,
+  clampListPageSize,
   countPlans,
   createAdminResourceClient,
   createAdminRoutes,
+  createAxiosHttpClient,
+  createFetchHttpClient,
   createManifestStore,
   createPlatformLoaders,
   createProjectPageHostRoute,
+  createResourceRegistry,
   createSaCatalog,
   createSaTheme,
   createSuperAdminI18n,
@@ -7038,30 +8051,57 @@ function planChangeWizardI18n(i18n) {
   defaultSectionOrder,
   defaultTenantPlanSectionI18n,
   defaultToneForActionKey,
+  defineListOp,
   defineMessages,
+  defineResource,
+  filterQueryString,
   formatCurrency,
   formatMessage,
   getJson,
   identityAccentAt,
   identityAccentFor,
   identityChipStyle,
+  isAdminError,
+  isAxiosNoResponseError,
   isCurrentlyValid,
+  isEmptyResponse,
   isExpired,
   isFutureScheduled,
+  isPlatformError,
   isProductionBoot,
   isSaBuiltinLocale,
+  isSentInQuery,
+  isTransportFailure,
+  listUrl,
+  markEmptyResponse,
+  markPlatformError,
+  markTransportFailure,
   mergeMessages,
   planChangeWizardI18n,
+  planVersionsResource,
+  plansResource,
+  platformResources,
   postJson,
   provideEntitlement,
+  readErrorCode,
+  readErrorDetail,
+  readListPage,
+  requestJson,
+  requestJsonBody,
+  requireServerAnswer,
   resolveExtension,
   resolveLoginBranding,
   resolveMessages,
   resolvePlans,
+  resolveSuperAdminEndpoints,
+  tenantsResource,
+  toAdminError,
   todayIsoDate,
   trimTrailingSlashes,
   useActions,
   useApiList,
+  useAsyncAction,
+  useAsyncData,
   useAuditEntries,
   useBatchColumns,
   useBulkPublish,
@@ -7083,6 +8123,8 @@ function planChangeWizardI18n(i18n) {
   usePlatformTenantActions,
   usePromotions,
   usePublicBoot,
+  useResource,
+  useResourceList,
   useSaMessages,
   useSaTheme,
   useSubscriptionDraft,