@saasicat/ui-vue 0.24.2 → 0.26.0

package/dist/client/index.cjs

@@ -23,6 +23,7 @@ __export(client_exports, {
   ADMIN_UI_VERSION: () => ADMIN_UI_VERSION,
   ActionDefNotInManifestError: () => ActionDefNotInManifestError,
   ActionRegistry: () => ActionRegistry,
+  AdminError: () => AdminError,
   BatchColumnDriftError: () => BatchColumnDriftError,
   BatchColumnFetcher: () => BatchColumnFetcher,
   BootLoadError: () => BootLoadError,
@@ -34,6 +35,10 @@ __export(client_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,
   MissingHandlerError: () => MissingHandlerError,
@@ -41,32 +46,63 @@ __export(client_exports, {
   SA_LOCALES: () => SA_LOCALES,
   SA_LOCALE_LABELS: () => SA_LOCALE_LABELS,
   SA_MESSAGES: () => SA_MESSAGES,
+  adminErrorMessage: () => adminErrorMessage,
+  auditResource: () => auditResource,
+  bindResource: () => bindResource,
   buildRoutes: () => buildRoutes,
   buildSidebar: () => buildSidebar,
+  clampListPage: () => clampListPage,
+  clampListPageSize: () => clampListPageSize,
   countPlans: () => countPlans,
   createAdminResourceClient: () => createAdminResourceClient,
+  createAxiosHttpClient: () => createAxiosHttpClient,
+  createFetchHttpClient: () => createFetchHttpClient,
   createSaCatalog: () => createSaCatalog,
   defaultHttpClient: () => defaultHttpClient,
   defaultKvStore: () => defaultKvStore,
   defaultSectionOrder: () => defaultSectionOrder,
+  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,
+  planVersionsResource: () => planVersionsResource,
+  plansResource: () => plansResource,
+  platformResources: () => platformResources,
   postJson: () => postJson,
+  readErrorCode: () => readErrorCode,
+  readErrorDetail: () => readErrorDetail,
+  readListPage: () => readListPage,
+  requestJson: () => requestJson,
+  requestJsonBody: () => requestJsonBody,
+  requireServerAnswer: () => requireServerAnswer,
   resolveExtension: () => resolveExtension,
   resolveLoginBranding: () => resolveLoginBranding,
   resolveMessages: () => resolveMessages,
   resolvePlans: () => resolvePlans,
+  tenantsResource: () => tenantsResource,
+  toAdminError: () => toAdminError,
   todayIsoDate: () => todayIsoDate,
   trimTrailingSlashes: () => trimTrailingSlashes
 });
@@ -75,6 +111,287 @@ module.exports = __toCommonJS(client_exports);
 // src/client/version.ts
 var ADMIN_UI_VERSION = "1.2.0";
 
+// 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), { cause: 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,
@@ -116,51 +433,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}`;
   }
-  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;
+  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;
   }
+  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;
 }
-function trimTrailingSlashes(url) {
-  let end = url.length;
-  while (end > 0 && url[end - 1] === "/") end--;
-  return url.slice(0, end);
+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;
 }
-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 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);
+    }
+  };
+}
+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 {
@@ -168,6 +760,7 @@ var BootLoadError = class extends Error {
     super(message);
     this.status = status;
     this.name = "BootLoadError";
+    markPlatformError(this);
   }
   status;
 };
@@ -185,19 +778,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;
 };
@@ -225,24 +826,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,
@@ -577,7 +1202,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";
   }
@@ -620,7 +1245,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();
@@ -696,10 +1321,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,
@@ -709,7 +1334,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
       })}`
@@ -734,21 +1359,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";
@@ -1447,9 +2057,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"
@@ -1551,9 +2158,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"
@@ -1758,6 +2362,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(
   {
@@ -1882,9 +2516,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}"
     }
   },
   {
@@ -2009,9 +2640,6 @@ var marketingMessages = defineMessages(
       colorLabel: "Color",
       delete: "Delete promotion",
       deleteConfirm: 'Really delete promotion "{label}"?'
-    },
-    errors: {
-      projectionsApi: "MarketingProjections API responded with HTTP {status}"
     }
   }
 );
@@ -3205,7 +3833,6 @@ var promosMessages = defineMessages(
   {
     title: "Promo-Codes",
     createAction: "Promo-Code anlegen",
-    apiErrorHttpStatus: "Promotions-API antwortete mit HTTP {status}",
     list: {
       searchLabel: "Suche (Code)",
       tileScheduled: "Geplant",
@@ -3303,7 +3930,6 @@ var promosMessages = defineMessages(
   {
     title: "Promo codes",
     createAction: "Create promo code",
-    apiErrorHttpStatus: "Promotions API responded with HTTP {status}",
     list: {
       searchLabel: "Search (code)",
       tileScheduled: "Scheduled",
@@ -3411,7 +4037,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"
@@ -3480,7 +4112,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"
@@ -3724,6 +4362,7 @@ var usersMessages = defineMessages(
 function catalogFor(locale) {
   return {
     common: commonMessages[locale],
+    errors: errorsMessages[locale],
     nav: navMessages[locale],
     shell: shellMessages[locale],
     dashboard: dashboardMessages[locale],
@@ -3912,6 +4551,7 @@ function identityChipStyle(accent) {
   ADMIN_UI_VERSION,
   ActionDefNotInManifestError,
   ActionRegistry,
+  AdminError,
   BatchColumnDriftError,
   BatchColumnFetcher,
   BootLoadError,
@@ -3923,6 +4563,10 @@ function identityChipStyle(accent) {
   IDENTITY_ACCENT_VALUES,
   IDENTITY_NEUTRAL,
   IDENTITY_NEUTRAL_VALUE,
+  LIST_FIRST_PAGE,
+  LIST_PAGE_SIZE_DEFAULT,
+  LIST_PAGE_SIZE_MAX,
+  LIST_PAGINATION_PARAMS,
   ManifestLoadError,
   ManifestLoader,
   MissingHandlerError,
@@ -3930,32 +4574,63 @@ function identityChipStyle(accent) {
   SA_LOCALES,
   SA_LOCALE_LABELS,
   SA_MESSAGES,
+  adminErrorMessage,
+  auditResource,
+  bindResource,
   buildRoutes,
   buildSidebar,
+  clampListPage,
+  clampListPageSize,
   countPlans,
   createAdminResourceClient,
+  createAxiosHttpClient,
+  createFetchHttpClient,
   createSaCatalog,
   defaultHttpClient,
   defaultKvStore,
   defaultSectionOrder,
+  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,
+  planVersionsResource,
+  plansResource,
+  platformResources,
   postJson,
+  readErrorCode,
+  readErrorDetail,
+  readListPage,
+  requestJson,
+  requestJsonBody,
+  requireServerAnswer,
   resolveExtension,
   resolveLoginBranding,
   resolveMessages,
   resolvePlans,
+  tenantsResource,
+  toAdminError,
   todayIsoDate,
   trimTrailingSlashes
 });