@krizaka/app-config 0.0.0-stage → 0.1.0

package/dist/client.js

@@ -0,0 +1,142 @@
+import {
+  APP_CONFIG_PATH,
+  CLIENT_HEADERS,
+  isAppConfigPayload
+} from "./chunk-D3DIU5IW.js";
+
+// src/client.ts
+var DEFAULT_MIN_INTERVAL_MS = 3e5;
+var DISMISS_KEY = "krizaka.app-config.soft-dismissed";
+function decide(config, softDismissedFor) {
+  if (!config) return { kind: "ok" };
+  if (config.maintenance.on) return { kind: "maintenance", config };
+  if (config.updateMode === "force") return { kind: "force", config };
+  if (config.updateMode === "soft" && softDismissedFor !== config.latestVersion) return { kind: "soft", config };
+  return { kind: "ok" };
+}
+function clientHeaders(info) {
+  return {
+    [CLIENT_HEADERS.platform]: info.platform,
+    [CLIENT_HEADERS.version]: info.version,
+    [CLIENT_HEADERS.contract]: String(info.contract ?? 1),
+    ...info.build ? { [CLIENT_HEADERS.build]: info.build } : {}
+  };
+}
+function isUpgradeRequired(response) {
+  return response.status === 426;
+}
+function upgradePayloadOf(body) {
+  const appConfig = body?.appConfig;
+  return isAppConfigPayload(appConfig) ? normalise(appConfig) : null;
+}
+async function readUpgradeRequired(response) {
+  try {
+    return upgradePayloadOf(await response.clone().json());
+  } catch {
+    return null;
+  }
+}
+function normalise(payload) {
+  return { ...payload, flags: payload.flags ?? {}, message: payload.message ?? null, storeUrl: payload.storeUrl ?? null, locale: payload.locale ?? "en" };
+}
+function withoutTrailingSlashes(url) {
+  let end = url.length;
+  while (end > 0 && url.endsWith("/", end)) end -= 1;
+  return url.slice(0, end);
+}
+function withDefaults(given, defaults) {
+  if (given instanceof Headers) {
+    const merged = new Headers(given);
+    for (const [name, value] of Object.entries(defaults)) if (!merged.has(name)) merged.set(name, value);
+    return merged;
+  }
+  const own = Array.isArray(given) ? Object.fromEntries(given) : { ...given };
+  const known = new Set(Object.keys(own).map((name) => name.toLowerCase()));
+  for (const [name, value] of Object.entries(defaults)) if (!known.has(name.toLowerCase())) own[name] = value;
+  return own;
+}
+function createAppConfigClient(options) {
+  const base = withoutTrailingSlashes(options.baseUrl);
+  const doFetch = options.fetch ?? ((...args) => fetch(...args));
+  const now = options.now ?? Date.now;
+  const interval = options.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+  const headers = clientHeaders(options);
+  const listeners = /* @__PURE__ */ new Set();
+  let dismissed = null;
+  let lastCheck = Number.NEGATIVE_INFINITY;
+  let state = { status: "idle", config: null, decision: { kind: "ok" }, upgradeRequired: null };
+  const set = (patch) => {
+    state = { ...state, ...patch };
+    state = { ...state, decision: state.upgradeRequired ? { kind: "force", config: state.upgradeRequired } : decide(state.config, dismissed) };
+    for (const listener of listeners) listener();
+  };
+  const client = {
+    headers,
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    async check({ force = false } = {}) {
+      if (!force && now() - lastCheck < interval) return;
+      lastCheck = now();
+      set({ status: "loading" });
+      try {
+        if (options.storage && dismissed === null) dismissed = await options.storage.getItem(DISMISS_KEY) ?? "";
+        const query = new URLSearchParams({ platform: options.platform, version: options.version });
+        const language = options.language?.();
+        if (language) query.set("locale", language);
+        const response = await doFetch(`${base}${APP_CONFIG_PATH}?${query}`, { headers });
+        const body = response.ok ? await response.json() : null;
+        if (!isAppConfigPayload(body)) {
+          set({ status: "failed" });
+          return;
+        }
+        set({ status: "ready", config: normalise(body) });
+      } catch {
+        set({ status: "failed" });
+      }
+    },
+    async dismissSoft() {
+      const latest = state.config?.latestVersion;
+      if (!latest) return;
+      dismissed = latest;
+      await options.storage?.setItem(DISMISS_KEY, latest);
+      set({});
+    },
+    reportUpgradeRequired(payload) {
+      const known = payload ?? state.config;
+      const fallback = {
+        platform: options.platform,
+        minSupportedVersion: known?.minSupportedVersion ?? options.version,
+        latestVersion: known?.latestVersion ?? options.version,
+        updateMode: "force",
+        storeUrl: known?.storeUrl ?? null,
+        maintenance: { on: false, message: null },
+        contract: known?.contract ?? { min: 1, max: 1, sunset: null },
+        flags: known?.flags ?? {},
+        message: known?.message ?? null,
+        locale: known?.locale ?? "en"
+      };
+      set({ upgradeRequired: { ...fallback, updateMode: "force" } });
+    },
+    fetch: async (input, init) => {
+      const response = await doFetch(input, { ...init, headers: withDefaults(init?.headers, headers) });
+      if (isUpgradeRequired(response)) client.reportUpgradeRequired(await readUpgradeRequired(response));
+      return response;
+    },
+    attach(resume) {
+      return resume(() => void client.check());
+    }
+  };
+  return client;
+}
+export {
+  clientHeaders,
+  createAppConfigClient,
+  decide,
+  isUpgradeRequired,
+  readUpgradeRequired,
+  upgradePayloadOf
+};
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"sourcesContent":["import {\n  APP_CONFIG_PATH,\n  type AppConfigPayload,\n  CLIENT_HEADERS,\n  isAppConfigPayload,\n  type Platform,\n} from \"./core\";\n\n/** What the app must show, decided from the payload. Maintenance outranks an update. */\nexport type Decision =\n  | { kind: \"ok\" }\n  | { kind: \"soft\"; config: AppConfigPayload }\n  | { kind: \"force\"; config: AppConfigPayload }\n  | { kind: \"maintenance\"; config: AppConfigPayload };\n\nexport type AppConfigStatus = \"idle\" | \"loading\" | \"ready\" | \"failed\";\n\nexport interface AppConfigState {\n  status: AppConfigStatus;\n  config: AppConfigPayload | null;\n  decision: Decision;\n  /** The 426 payload that forced the screen, if a request got one. */\n  upgradeRequired: AppConfigPayload | null;\n}\n\n/** A place to remember which version's soft prompt the person already dismissed. */\nexport interface DismissStorage {\n  getItem(key: string): string | null | Promise<string | null>;\n  setItem(key: string, value: string): void | Promise<void>;\n}\n\nexport interface AppConfigClientOptions {\n  /** The backend's origin, e.g. `https://dev.orazaka.com`. */\n  baseUrl: string;\n  platform: Platform;\n  /** The version the app runs (`1.4.0`), from the build, never typed twice. */\n  version: string;\n  /** The API contract the app speaks. Defaults to 1. */\n  contract?: number;\n  build?: string;\n  fetch?: typeof fetch;\n  /** The language to ask texts in (`fr`); defaults to the backend's `Accept-Language` reading. */\n  language?: () => string | undefined;\n  storage?: DismissStorage;\n  now?: () => number;\n  /** A check requested sooner than this after the last one is skipped (resume storms). Default 300 s. */\n  minIntervalMs?: number;\n}\n\n// @fixed: interface setting — a resume within five minutes of the last check is not worth a request.\nconst DEFAULT_MIN_INTERVAL_MS = 300_000;\nconst DISMISS_KEY = \"krizaka.app-config.soft-dismissed\";\n\n/** Maintenance first, then a forced update, then a soft one. */\nexport function decide(config: AppConfigPayload | null, softDismissedFor?: string | null): Decision {\n  if (!config) return { kind: \"ok\" };\n  if (config.maintenance.on) return { kind: \"maintenance\", config };\n  if (config.updateMode === \"force\") return { kind: \"force\", config };\n  if (config.updateMode === \"soft\" && softDismissedFor !== config.latestVersion) return { kind: \"soft\", config };\n  return { kind: \"ok\" };\n}\n\n/** The headers every request of the app carries. */\nexport function clientHeaders(info: { platform: Platform; version: string; contract?: number; build?: string }): Record<string, string> {\n  return {\n    [CLIENT_HEADERS.platform]: info.platform,\n    [CLIENT_HEADERS.version]: info.version,\n    [CLIENT_HEADERS.contract]: String(info.contract ?? 1),\n    ...(info.build ? { [CLIENT_HEADERS.build]: info.build } : {}),\n  };\n}\n\n/** Whether a response is the backend telling the app to update. */\nexport function isUpgradeRequired(response: { status: number }): boolean {\n  return response.status === 426;\n}\n\n/** The `appConfig` member of an already parsed `426` body, or `null` (for a transport that is not `fetch`, e.g. XHR). */\nexport function upgradePayloadOf(body: unknown): AppConfigPayload | null {\n  const appConfig = (body as { appConfig?: unknown } | null)?.appConfig;\n  return isAppConfigPayload(appConfig) ? normalise(appConfig) : null;\n}\n\n/** The `appConfig` of a `426` response, or `null` when the body is not one (the app still must update). */\nexport async function readUpgradeRequired(response: Response): Promise<AppConfigPayload | null> {\n  try {\n    return upgradePayloadOf(await response.clone().json());\n  } catch {\n    return null;\n  }\n}\n\nfunction normalise(payload: AppConfigPayload): AppConfigPayload {\n  return { ...payload, flags: payload.flags ?? {}, message: payload.message ?? null, storeUrl: payload.storeUrl ?? null, locale: payload.locale ?? \"en\" };\n}\n\n/** `https://x//` → `https://x` (a loop, not a regular expression: no backtracking on a long run of slashes). */\nfunction withoutTrailingSlashes(url: string): string {\n  let end = url.length;\n  while (end > 0 && url.endsWith(\"/\", end)) end -= 1;\n  return url.slice(0, end);\n}\n\n/** The caller's headers with ours added where it has not set them (names compare case-insensitively). A plain object stays one. */\nfunction withDefaults(given: NonNullable<RequestInit[\"headers\"]> | undefined, defaults: Readonly<Record<string, string>>): NonNullable<RequestInit[\"headers\"]> {\n  if (given instanceof Headers) {\n    const merged = new Headers(given);\n    for (const [name, value] of Object.entries(defaults)) if (!merged.has(name)) merged.set(name, value);\n    return merged;\n  }\n  const own: Record<string, string> = Array.isArray(given) ? Object.fromEntries(given) : { ...given };\n  const known = new Set(Object.keys(own).map((name) => name.toLowerCase()));\n  for (const [name, value] of Object.entries(defaults)) if (!known.has(name.toLowerCase())) own[name] = value;\n  return own;\n}\n\nexport interface AppConfigClient {\n  /** The headers every request carries — for a transport that is not `fetch` (XHR, a native module). */\n  readonly headers: Readonly<Record<string, string>>;\n  getState(): AppConfigState;\n  subscribe(listener: () => void): () => void;\n  /** Checks the backend. Skipped when a check ran less than `minIntervalMs` ago, unless `force`. Never throws. */\n  check(options?: { force?: boolean }): Promise<void>;\n  /** The person dismissed the soft prompt: not shown again for this `latestVersion`. */\n  dismissSoft(): Promise<void>;\n  /** A request got a 426 (the global interceptor calls this). */\n  reportUpgradeRequired(payload: AppConfigPayload | null): void;\n  /** `fetch` that sends the client headers and reports every 426 to this client. */\n  fetch: typeof fetch;\n  /** Checks again each time `resume` fires (app foreground, tab visible). Returns the unsubscribe. */\n  attach(resume: (callback: () => void) => () => void): () => void;\n}\n\nexport function createAppConfigClient(options: AppConfigClientOptions): AppConfigClient {\n  const base = withoutTrailingSlashes(options.baseUrl);\n  const doFetch = options.fetch ?? ((...args: Parameters<typeof fetch>) => fetch(...args));\n  const now = options.now ?? Date.now;\n  const interval = options.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;\n  const headers = clientHeaders(options);\n  const listeners = new Set<() => void>();\n  let dismissed: string | null = null;\n  let lastCheck = Number.NEGATIVE_INFINITY;\n  let state: AppConfigState = { status: \"idle\", config: null, decision: { kind: \"ok\" }, upgradeRequired: null };\n\n  const set = (patch: Partial<AppConfigState>) => {\n    state = { ...state, ...patch };\n    state = { ...state, decision: state.upgradeRequired ? { kind: \"force\", config: state.upgradeRequired } : decide(state.config, dismissed) };\n    for (const listener of listeners) listener();\n  };\n\n  const client: AppConfigClient = {\n    headers,\n    getState: () => state,\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => void listeners.delete(listener);\n    },\n    async check({ force = false } = {}) {\n      if (!force && now() - lastCheck < interval) return;\n      lastCheck = now();\n      set({ status: \"loading\" });\n      try {\n        if (options.storage && dismissed === null) dismissed = (await options.storage.getItem(DISMISS_KEY)) ?? \"\";\n        const query = new URLSearchParams({ platform: options.platform, version: options.version });\n        const language = options.language?.();\n        if (language) query.set(\"locale\", language);\n        const response = await doFetch(`${base}${APP_CONFIG_PATH}?${query}`, { headers });\n        const body: unknown = response.ok ? await response.json() : null;\n        if (!isAppConfigPayload(body)) {\n          set({ status: \"failed\" });\n          return;\n        }\n        set({ status: \"ready\", config: normalise(body) });\n      } catch {\n        // Fail open: an unreachable or broken config endpoint never locks the app.\n        set({ status: \"failed\" });\n      }\n    },\n    async dismissSoft() {\n      const latest = state.config?.latestVersion;\n      if (!latest) return;\n      dismissed = latest;\n      await options.storage?.setItem(DISMISS_KEY, latest);\n      set({});\n    },\n    reportUpgradeRequired(payload) {\n      const known = payload ?? state.config;\n      // A 426 without a usable body still blocks: the person must update, whatever the store says.\n      const fallback: AppConfigPayload = {\n        platform: options.platform,\n        minSupportedVersion: known?.minSupportedVersion ?? options.version,\n        latestVersion: known?.latestVersion ?? options.version,\n        updateMode: \"force\",\n        storeUrl: known?.storeUrl ?? null,\n        maintenance: { on: false, message: null },\n        contract: known?.contract ?? { min: 1, max: 1, sunset: null },\n        flags: known?.flags ?? {},\n        message: known?.message ?? null,\n        locale: known?.locale ?? \"en\",\n      };\n      set({ upgradeRequired: { ...fallback, updateMode: \"force\" } });\n    },\n    fetch: async (input, init) => {\n      const response = await doFetch(input, { ...init, headers: withDefaults(init?.headers, headers) });\n      if (isUpgradeRequired(response)) client.reportUpgradeRequired(await readUpgradeRequired(response));\n      return response;\n    },\n    attach(resume) {\n      return resume(() => void client.check());\n    },\n  };\n  return client;\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+/**
+ * The contract, pure: versions, the payload, and the rules that decide what happens to a client.
+ * Twin of the Java building block `krizaka-app-config`; `test/cases.json` is the fixture both obey.
+ */
+declare const PLATFORMS: readonly ["ios", "android", "macos", "windows", "linux", "web"];
+type Platform = (typeof PLATFORMS)[number];
+declare const UPDATE_MODES: readonly ["none", "soft", "force"];
+type UpdateMode = (typeof UPDATE_MODES)[number];
+/** The headers an app sends and the backend answers with. */
+declare const CLIENT_HEADERS: {
+    readonly version: "X-Client-Version";
+    readonly platform: "X-Client-Platform";
+    readonly contract: "X-Contract-Version";
+    readonly build: "X-Client-Build";
+    readonly deprecation: "Deprecation";
+    readonly sunset: "Sunset";
+};
+/** The public endpoint's path. */
+declare const APP_CONFIG_PATH = "/api/v1/app-config";
+type FlagValue = boolean | number | string;
+/** What `GET /api/v1/app-config` returns and what a `426` carries as `appConfig`. */
+interface AppConfigPayload {
+    platform: Platform;
+    minSupportedVersion: string;
+    latestVersion: string;
+    updateMode: UpdateMode;
+    storeUrl: string | null;
+    maintenance: {
+        on: boolean;
+        message: string | null;
+    };
+    contract: {
+        min: number;
+        max: number;
+        sunset: string | null;
+    };
+    flags: Record<string, FlagValue>;
+    message: string | null;
+    locale: string;
+}
+/** The parameters of one platform, as the database holds them (the admin edits this shape). */
+interface AppConfigRecord {
+    platform: Platform;
+    minSupportedVersion: string;
+    latestVersion: string;
+    updateOverride: UpdateMode | null;
+    storeUrl: string | null;
+    maintenanceOn: boolean;
+    maintenanceMessage: Record<string, string>;
+    message: Record<string, string>;
+    contractMin: number;
+    contractMax: number;
+    contractSunset: string | null;
+    flags: Record<string, FlagValue>;
+    revision: number;
+    updatedAt: string;
+    updatedBy: string;
+}
+/** What a client says about itself (headers or query). */
+interface ClientInfo {
+    platform?: string | null;
+    version?: string | null;
+    contract?: string | number | null;
+    language?: string | null;
+}
+type Version = readonly [major: number, minor: number, patch: number];
+/** `1.4`, `v1.4.0`, `1.4.0-beta.2` and `1.4.0+42` all read as `[1, 4, 0]`; anything else is `null`. */
+declare function parseVersion(text: string | null | undefined): Version | null;
+declare function compareVersions(a: Version, b: Version): number;
+declare function formatVersion(version: Version): string;
+declare function isPlatform(value: unknown): value is Platform;
+declare function toPlatform(value: string | null | undefined): Platform | null;
+/** The permissive parameters a platform starts with: nobody is locked out. */
+declare function defaultRecord(platform: Platform): AppConfigRecord;
+/** The safety bounds of an edit; an empty list means the record can be published. */
+declare function validateRecord(record: AppConfigRecord): string[];
+/** `none`, `soft` or `force` for the version the client runs. The operator's override wins. */
+declare function updateModeFor(record: AppConfigRecord, client: Version | null): UpdateMode;
+/** The public payload for a client, its texts in the best language available. */
+declare function buildPayload(record: AppConfigRecord, client: Version | null, language?: string | null): AppConfigPayload;
+type GuardCode = "upgrade-required" | "contract-unsupported";
+/** What the 426 filter does with a request. */
+type GuardResult = {
+    /** `Deprecation: true` — the contract the client speaks is served but on its way out. */
+    deprecation: boolean;
+    /** The newest contract the backend speaks (`X-Contract-Version` of the answer). */
+    contract: number;
+} & ({
+    status: 200;
+    /** The `Sunset` HTTP date, when announced. */
+    sunset?: string;
+} | {
+    status: 426;
+    code: GuardCode;
+    /** The `appConfig` of a 426: the payload with `updateMode: "force"`. */
+    payload: AppConfigPayload;
+});
+/** The 426 filter's decision: below the minimum or an unserved contract is refused; N-1 is deprecated. */
+declare function evaluateGuard(record: AppConfigRecord, client: ClientInfo): GuardResult;
+/** A structural check of a payload read from the network: anything else is ignored (fail open). */
+declare function isAppConfigPayload(value: unknown): value is AppConfigPayload;
+
+export { APP_CONFIG_PATH, type AppConfigPayload, type AppConfigRecord, CLIENT_HEADERS, type ClientInfo, type FlagValue, type GuardCode, type GuardResult, PLATFORMS, type Platform, UPDATE_MODES, type UpdateMode, type Version, buildPayload, compareVersions, defaultRecord, evaluateGuard, formatVersion, isAppConfigPayload, isPlatform, parseVersion, toPlatform, updateModeFor, validateRecord };

package/dist/index.js

@@ -0,0 +1,35 @@
+import {
+  APP_CONFIG_PATH,
+  CLIENT_HEADERS,
+  PLATFORMS,
+  UPDATE_MODES,
+  buildPayload,
+  compareVersions,
+  defaultRecord,
+  evaluateGuard,
+  formatVersion,
+  isAppConfigPayload,
+  isPlatform,
+  parseVersion,
+  toPlatform,
+  updateModeFor,
+  validateRecord
+} from "./chunk-D3DIU5IW.js";
+export {
+  APP_CONFIG_PATH,
+  CLIENT_HEADERS,
+  PLATFORMS,
+  UPDATE_MODES,
+  buildPayload,
+  compareVersions,
+  defaultRecord,
+  evaluateGuard,
+  formatVersion,
+  isAppConfigPayload,
+  isPlatform,
+  parseVersion,
+  toPlatform,
+  updateModeFor,
+  validateRecord
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/react.d.ts

@@ -0,0 +1,31 @@
+import { AppConfigState, AppConfigClient } from './client.js';
+export { Decision } from './client.js';
+import './index.js';
+
+/** A source of "the app came back": call the callback each time, return the unsubscribe. */
+type ResumeSource = (callback: () => void) => () => void;
+/** React Native: `appStateResume(AppState)` — fires when the app returns to the foreground. */
+declare function appStateResume(appState: {
+    addEventListener(type: "change", listener: (state: string) => void): {
+        remove(): void;
+    };
+}): ResumeSource;
+/** Web and desktop (a WebView): fires when the tab or window becomes visible again. */
+declare function visibilityResume(target: {
+    addEventListener(type: "visibilitychange", listener: () => void): void;
+    removeEventListener(type: "visibilitychange", listener: () => void): void;
+    visibilityState: string;
+}): ResumeSource;
+interface UseAppConfig extends AppConfigState {
+    /** Dismiss the soft prompt for this `latestVersion`. */
+    dismissSoft(): void;
+    /** Check now, ignoring the minimum interval. */
+    refresh(): void;
+}
+/**
+ * The app's version state: checks at launch, again on every `resume`, and follows the 426 that any
+ * request made through `client.fetch` reports.
+ */
+declare function useAppConfig(client: AppConfigClient, resume?: ResumeSource): UseAppConfig;
+
+export { AppConfigClient, AppConfigState, type ResumeSource, type UseAppConfig, appStateResume, useAppConfig, visibilityResume };

package/dist/react.js

@@ -0,0 +1,35 @@
+// src/react.ts
+import { useCallback, useEffect, useSyncExternalStore } from "react";
+function appStateResume(appState) {
+  return (callback) => {
+    const subscription = appState.addEventListener("change", (state) => {
+      if (state === "active") callback();
+    });
+    return () => subscription.remove();
+  };
+}
+function visibilityResume(target) {
+  return (callback) => {
+    const listener = () => {
+      if (target.visibilityState === "visible") callback();
+    };
+    target.addEventListener("visibilitychange", listener);
+    return () => target.removeEventListener("visibilitychange", listener);
+  };
+}
+function useAppConfig(client, resume) {
+  const state = useSyncExternalStore(client.subscribe, client.getState, client.getState);
+  useEffect(() => {
+    void client.check({ force: true });
+    return resume ? client.attach(resume) : void 0;
+  }, [client, resume]);
+  const dismissSoft = useCallback(() => void client.dismissSoft(), [client]);
+  const refresh = useCallback(() => void client.check({ force: true }), [client]);
+  return { ...state, dismissSoft, refresh };
+}
+export {
+  appStateResume,
+  useAppConfig,
+  visibilityResume
+};
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react.ts"],"sourcesContent":["import { useCallback, useEffect, useSyncExternalStore } from \"react\";\n\nimport type { AppConfigClient, AppConfigState } from \"./client\";\n\nexport type { AppConfigClient, AppConfigState, Decision } from \"./client\";\n\n/** A source of \"the app came back\": call the callback each time, return the unsubscribe. */\nexport type ResumeSource = (callback: () => void) => () => void;\n\n/** React Native: `appStateResume(AppState)` — fires when the app returns to the foreground. */\nexport function appStateResume(appState: {\n  addEventListener(type: \"change\", listener: (state: string) => void): { remove(): void };\n}): ResumeSource {\n  return (callback) => {\n    const subscription = appState.addEventListener(\"change\", (state) => {\n      if (state === \"active\") callback();\n    });\n    return () => subscription.remove();\n  };\n}\n\n/** Web and desktop (a WebView): fires when the tab or window becomes visible again. */\nexport function visibilityResume(target: {\n  addEventListener(type: \"visibilitychange\", listener: () => void): void;\n  removeEventListener(type: \"visibilitychange\", listener: () => void): void;\n  visibilityState: string;\n}): ResumeSource {\n  return (callback) => {\n    const listener = () => {\n      if (target.visibilityState === \"visible\") callback();\n    };\n    target.addEventListener(\"visibilitychange\", listener);\n    return () => target.removeEventListener(\"visibilitychange\", listener);\n  };\n}\n\nexport interface UseAppConfig extends AppConfigState {\n  /** Dismiss the soft prompt for this `latestVersion`. */\n  dismissSoft(): void;\n  /** Check now, ignoring the minimum interval. */\n  refresh(): void;\n}\n\n/**\n * The app's version state: checks at launch, again on every `resume`, and follows the 426 that any\n * request made through `client.fetch` reports.\n */\nexport function useAppConfig(client: AppConfigClient, resume?: ResumeSource): UseAppConfig {\n  const state = useSyncExternalStore(client.subscribe, client.getState, client.getState);\n  useEffect(() => {\n    void client.check({ force: true });\n    return resume ? client.attach(resume) : undefined;\n  }, [client, resume]);\n  const dismissSoft = useCallback(() => void client.dismissSoft(), [client]);\n  const refresh = useCallback(() => void client.check({ force: true }), [client]);\n  return { ...state, dismissSoft, refresh };\n}\n"],"mappings":";AAAA,SAAS,aAAa,WAAW,4BAA4B;AAUtD,SAAS,eAAe,UAEd;AACf,SAAO,CAAC,aAAa;AACnB,UAAM,eAAe,SAAS,iBAAiB,UAAU,CAAC,UAAU;AAClE,UAAI,UAAU,SAAU,UAAS;AAAA,IACnC,CAAC;AACD,WAAO,MAAM,aAAa,OAAO;AAAA,EACnC;AACF;AAGO,SAAS,iBAAiB,QAIhB;AACf,SAAO,CAAC,aAAa;AACnB,UAAM,WAAW,MAAM;AACrB,UAAI,OAAO,oBAAoB,UAAW,UAAS;AAAA,IACrD;AACA,WAAO,iBAAiB,oBAAoB,QAAQ;AACpD,WAAO,MAAM,OAAO,oBAAoB,oBAAoB,QAAQ;AAAA,EACtE;AACF;AAaO,SAAS,aAAa,QAAyB,QAAqC;AACzF,QAAM,QAAQ,qBAAqB,OAAO,WAAW,OAAO,UAAU,OAAO,QAAQ;AACrF,YAAU,MAAM;AACd,SAAK,OAAO,MAAM,EAAE,OAAO,KAAK,CAAC;AACjC,WAAO,SAAS,OAAO,OAAO,MAAM,IAAI;AAAA,EAC1C,GAAG,CAAC,QAAQ,MAAM,CAAC;AACnB,QAAM,cAAc,YAAY,MAAM,KAAK,OAAO,YAAY,GAAG,CAAC,MAAM,CAAC;AACzE,QAAM,UAAU,YAAY,MAAM,KAAK,OAAO,MAAM,EAAE,OAAO,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC;AAC9E,SAAO,EAAE,GAAG,OAAO,aAAa,QAAQ;AAC1C;","names":[]}

package/dist/server.d.ts

@@ -0,0 +1,63 @@
+import { Platform, AppConfigRecord, GuardResult } from './index.js';
+export { APP_CONFIG_PATH } from './index.js';
+
+/**
+ * The tables of the contract, for a Next.js backend's own migration. The same DDL ships with the Java building block
+ * (`krizaka-app-config-schema.sql`, copied verbatim to `contract/` and checked by a test): one schema, whichever stack
+ * serves it. Version 1 is seeded permissive (no minimum, no maintenance, one contract).
+ */
+declare const schemaSql = "-- krizaka-app-config: the parameters of the app-version contract, one row per platform.\n-- Version 1 is seeded here (permissive: no minimum, no maintenance, one contract); a product's own\n-- migration publishes its real values through the admin API, never by editing the row by hand.\nCREATE TABLE IF NOT EXISTS app_config (\n    platform              VARCHAR(16)  PRIMARY KEY,\n    min_supported_version VARCHAR(32)  NOT NULL DEFAULT '0.0.0',\n    latest_version        VARCHAR(32)  NOT NULL DEFAULT '0.0.0',\n    update_override       VARCHAR(8),\n    store_url             TEXT,\n    maintenance_on        BOOLEAN      NOT NULL DEFAULT FALSE,\n    maintenance_message   JSONB        NOT NULL DEFAULT '{}'::jsonb,\n    message               JSONB        NOT NULL DEFAULT '{}'::jsonb,\n    contract_min          INTEGER      NOT NULL DEFAULT 1,\n    contract_max          INTEGER      NOT NULL DEFAULT 1,\n    contract_sunset       DATE,\n    flags                 JSONB        NOT NULL DEFAULT '{}'::jsonb,\n    revision              INTEGER      NOT NULL DEFAULT 1,\n    updated_at            TIMESTAMPTZ  NOT NULL DEFAULT now(),\n    updated_by            VARCHAR(255) NOT NULL DEFAULT 'seed',\n    CONSTRAINT app_config_platform_known CHECK (platform IN ('ios', 'android', 'macos', 'windows', 'linux', 'web')),\n    CONSTRAINT app_config_contract_range CHECK (contract_min >= 1 AND contract_max >= contract_min)\n);\n\n-- Every published revision, append-only: the audit trail and the source of a rollback.\nCREATE TABLE IF NOT EXISTS app_config_history (\n    id                    BIGSERIAL    PRIMARY KEY,\n    platform              VARCHAR(16)  NOT NULL,\n    revision              INTEGER      NOT NULL,\n    min_supported_version VARCHAR(32)  NOT NULL,\n    latest_version        VARCHAR(32)  NOT NULL,\n    update_override       VARCHAR(8),\n    store_url             TEXT,\n    maintenance_on        BOOLEAN      NOT NULL,\n    maintenance_message   JSONB        NOT NULL,\n    message               JSONB        NOT NULL,\n    contract_min          INTEGER      NOT NULL,\n    contract_max          INTEGER      NOT NULL,\n    contract_sunset       DATE,\n    flags                 JSONB        NOT NULL,\n    reason                TEXT         NOT NULL,\n    changed_by            VARCHAR(255) NOT NULL,\n    changed_at            TIMESTAMPTZ  NOT NULL DEFAULT now(),\n    CONSTRAINT app_config_history_revision UNIQUE (platform, revision)\n);\n\nINSERT INTO app_config (platform)\nVALUES ('ios'), ('android'), ('macos'), ('windows'), ('linux'), ('web')\nON CONFLICT (platform) DO NOTHING;\n\nINSERT INTO app_config_history (platform, revision, min_supported_version, latest_version, update_override,\n                                store_url, maintenance_on, maintenance_message, message, contract_min,\n                                contract_max, contract_sunset, flags, reason, changed_by, changed_at)\nSELECT platform, revision, min_supported_version, latest_version, update_override, store_url, maintenance_on,\n       maintenance_message, message, contract_min, contract_max, contract_sunset, flags, 'seed', updated_by,\n       updated_at\nFROM app_config\nON CONFLICT (platform, revision) DO NOTHING;\n";
+
+/** Where a Next.js backend keeps the parameters; the tables are `schemaSql`. */
+interface AppConfigStore {
+    get(platform: Platform): Promise<AppConfigRecord | undefined>;
+}
+/** A store over fixed records: tests and demos. */
+declare function memoryStore(records?: readonly AppConfigRecord[]): AppConfigStore;
+interface CacheOptions {
+    /** How long a read value is reused. */
+    ttlMs: number;
+    now?: () => number;
+}
+/**
+ * Reads through a short cache and never lets the store take the API down: on a failure the last value is
+ * served, and with none the permissive defaults.
+ */
+declare function cachedStore(store: AppConfigStore, { ttlMs, now }: CacheOptions): AppConfigStore & {
+    evict(platform?: Platform): void;
+};
+interface HandlerOptions {
+    store: AppConfigStore;
+    /** The public `max-age`, seconds. Defaults to 60. */
+    maxAgeSeconds?: number;
+}
+/**
+ * `GET /api/v1/app-config` for a route handler: public, cacheable, `ETag`, `304`. Mount it at
+ * `app/api/v1/app-config/route.ts`: `export const GET = createAppConfigHandler({ store })`.
+ */
+declare function createAppConfigHandler({ store, maxAgeSeconds }: HandlerOptions): (request: Request) => Promise<Response>;
+/** What the guard decided, ready to apply to a response. */
+interface GuardOutcome {
+    /** The `426` to return, or `null` to continue. */
+    refusal: Response | null;
+    /** `X-Contract-Version`, `Deprecation`, `Sunset` — set them on the response you return. */
+    headers: Record<string, string>;
+    result: GuardResult | null;
+}
+interface GuardOptions {
+    store: AppConfigStore;
+    /** The base of Problem Details `type`. Defaults to `https://krizaka.com/problems/`. */
+    problemBase?: string;
+}
+/**
+ * The `426 Upgrade Required` filter for a Next.js backend (a route handler, or the proxy/middleware). A request
+ * without `X-Client-Platform` is not an app and passes untouched.
+ */
+declare function checkClientVersion(request: Request, { store, problemBase }: GuardOptions): Promise<GuardOutcome>;
+/**
+ * Wraps a route handler: an app below the minimum gets the `426` before the handler runs; otherwise the
+ * handler's response carries the contract headers. `APP_CONFIG_PATH` itself should not be wrapped.
+ */
+declare function withClientVersionGuard<A extends unknown[]>(options: GuardOptions, handler: (request: Request, ...args: A) => Response | Promise<Response>): (request: Request, ...args: A) => Promise<Response>;
+
+export { type AppConfigStore, type CacheOptions, type GuardOptions, type GuardOutcome, type HandlerOptions, cachedStore, checkClientVersion, createAppConfigHandler, memoryStore, schemaSql, withClientVersionGuard };

package/dist/server.js

@@ -0,0 +1,176 @@
+import {
+  APP_CONFIG_PATH,
+  CLIENT_HEADERS,
+  buildPayload,
+  defaultRecord,
+  evaluateGuard,
+  parseVersion,
+  toPlatform
+} from "./chunk-D3DIU5IW.js";
+
+// src/schema.ts
+var schemaSql = `-- krizaka-app-config: the parameters of the app-version contract, one row per platform.
+-- Version 1 is seeded here (permissive: no minimum, no maintenance, one contract); a product's own
+-- migration publishes its real values through the admin API, never by editing the row by hand.
+CREATE TABLE IF NOT EXISTS app_config (
+    platform              VARCHAR(16)  PRIMARY KEY,
+    min_supported_version VARCHAR(32)  NOT NULL DEFAULT '0.0.0',
+    latest_version        VARCHAR(32)  NOT NULL DEFAULT '0.0.0',
+    update_override       VARCHAR(8),
+    store_url             TEXT,
+    maintenance_on        BOOLEAN      NOT NULL DEFAULT FALSE,
+    maintenance_message   JSONB        NOT NULL DEFAULT '{}'::jsonb,
+    message               JSONB        NOT NULL DEFAULT '{}'::jsonb,
+    contract_min          INTEGER      NOT NULL DEFAULT 1,
+    contract_max          INTEGER      NOT NULL DEFAULT 1,
+    contract_sunset       DATE,
+    flags                 JSONB        NOT NULL DEFAULT '{}'::jsonb,
+    revision              INTEGER      NOT NULL DEFAULT 1,
+    updated_at            TIMESTAMPTZ  NOT NULL DEFAULT now(),
+    updated_by            VARCHAR(255) NOT NULL DEFAULT 'seed',
+    CONSTRAINT app_config_platform_known CHECK (platform IN ('ios', 'android', 'macos', 'windows', 'linux', 'web')),
+    CONSTRAINT app_config_contract_range CHECK (contract_min >= 1 AND contract_max >= contract_min)
+);
+
+-- Every published revision, append-only: the audit trail and the source of a rollback.
+CREATE TABLE IF NOT EXISTS app_config_history (
+    id                    BIGSERIAL    PRIMARY KEY,
+    platform              VARCHAR(16)  NOT NULL,
+    revision              INTEGER      NOT NULL,
+    min_supported_version VARCHAR(32)  NOT NULL,
+    latest_version        VARCHAR(32)  NOT NULL,
+    update_override       VARCHAR(8),
+    store_url             TEXT,
+    maintenance_on        BOOLEAN      NOT NULL,
+    maintenance_message   JSONB        NOT NULL,
+    message               JSONB        NOT NULL,
+    contract_min          INTEGER      NOT NULL,
+    contract_max          INTEGER      NOT NULL,
+    contract_sunset       DATE,
+    flags                 JSONB        NOT NULL,
+    reason                TEXT         NOT NULL,
+    changed_by            VARCHAR(255) NOT NULL,
+    changed_at            TIMESTAMPTZ  NOT NULL DEFAULT now(),
+    CONSTRAINT app_config_history_revision UNIQUE (platform, revision)
+);
+
+INSERT INTO app_config (platform)
+VALUES ('ios'), ('android'), ('macos'), ('windows'), ('linux'), ('web')
+ON CONFLICT (platform) DO NOTHING;
+
+INSERT INTO app_config_history (platform, revision, min_supported_version, latest_version, update_override,
+                                store_url, maintenance_on, maintenance_message, message, contract_min,
+                                contract_max, contract_sunset, flags, reason, changed_by, changed_at)
+SELECT platform, revision, min_supported_version, latest_version, update_override, store_url, maintenance_on,
+       maintenance_message, message, contract_min, contract_max, contract_sunset, flags, 'seed', updated_by,
+       updated_at
+FROM app_config
+ON CONFLICT (platform, revision) DO NOTHING;
+`;
+
+// src/server.ts
+function memoryStore(records = []) {
+  const byPlatform = new Map(records.map((r) => [r.platform, r]));
+  return { get: async (platform) => byPlatform.get(platform) };
+}
+function cachedStore(store, { ttlMs, now = Date.now }) {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    evict: (platform) => platform ? cache.delete(platform) : cache.clear(),
+    async get(platform) {
+      const hit = cache.get(platform);
+      if (hit && now() - hit.at < ttlMs) return hit.record;
+      try {
+        const record = await store.get(platform) ?? defaultRecord(platform);
+        cache.set(platform, { record, at: now() });
+        return record;
+      } catch {
+        return hit?.record ?? defaultRecord(platform);
+      }
+    }
+  };
+}
+async function etagOf(text) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  const hex = Array.from(new Uint8Array(digest).slice(0, 12), (b) => b.toString(16).padStart(2, "0")).join("");
+  return `"${hex}"`;
+}
+function problem(status, code, detail) {
+  return Response.json({ title: "Bad Request", status, code, detail }, { status, headers: { "content-type": "application/problem+json" } });
+}
+function languageOf(header) {
+  const first = (header ?? "").split(",", 1).join("").trim();
+  return first.length >= 2 ? first.slice(0, 2) : null;
+}
+function createAppConfigHandler({ store, maxAgeSeconds = 60 }) {
+  return async (request) => {
+    const url = new URL(request.url);
+    const platform = toPlatform(url.searchParams.get("platform") ?? request.headers.get(CLIENT_HEADERS.platform));
+    if (!platform) return problem(400, "unknown-platform", "platform must be one of ios, android, macos, windows, linux, web.");
+    const versionText = url.searchParams.get("version");
+    const version = versionText ? parseVersion(versionText) : null;
+    if (versionText && !version) return problem(400, "invalid-version", "version must look like 1.4.0.");
+    const language = url.searchParams.get("locale") ?? languageOf(request.headers.get("accept-language"));
+    const record = await store.get(platform) ?? defaultRecord(platform);
+    const payload = buildPayload(record, version, language);
+    const body = JSON.stringify(payload);
+    const etag = await etagOf(body);
+    const headers = {
+      "cache-control": `public, max-age=${maxAgeSeconds}, stale-while-revalidate=${maxAgeSeconds * 5}`,
+      etag,
+      vary: "Accept-Language",
+      [CLIENT_HEADERS.contract]: String(payload.contract.max)
+    };
+    if (request.headers.get("if-none-match") === etag) return new Response(null, { status: 304, headers });
+    return new Response(body, { status: 200, headers: { ...headers, "content-type": "application/json" } });
+  };
+}
+async function checkClientVersion(request, { store, problemBase = "https://krizaka.com/problems/" }) {
+  const platform = toPlatform(request.headers.get(CLIENT_HEADERS.platform));
+  if (!platform) return { refusal: null, headers: {}, result: null };
+  const record = await store.get(platform) ?? defaultRecord(platform);
+  const result = evaluateGuard(record, {
+    platform,
+    version: request.headers.get(CLIENT_HEADERS.version),
+    contract: request.headers.get(CLIENT_HEADERS.contract),
+    language: languageOf(request.headers.get("accept-language"))
+  });
+  const headers = { [CLIENT_HEADERS.contract]: String(result.contract) };
+  if (result.deprecation) headers[CLIENT_HEADERS.deprecation] = "true";
+  if (result.status === 200 && result.sunset) headers[CLIENT_HEADERS.sunset] = result.sunset;
+  if (result.status !== 426) return { refusal: null, headers, result };
+  const { code, payload } = result;
+  const detail = code === "contract-unsupported" ? "This version of the app speaks an API contract that is no longer served. Update the app." : "This version of the app is no longer supported. Update the app.";
+  const refusal = new Response(
+    JSON.stringify({ type: problemBase + code, title: "Upgrade Required", status: 426, code, detail, instance: new URL(request.url).pathname, appConfig: payload }),
+    {
+      status: 426,
+      headers: {
+        ...headers,
+        "content-type": "application/problem+json",
+        "cache-control": "no-store",
+        upgrade: `krizaka-app/${payload.minSupportedVersion}`
+      }
+    }
+  );
+  return { refusal, headers, result };
+}
+function withClientVersionGuard(options, handler) {
+  return async (request, ...args) => {
+    const outcome = await checkClientVersion(request, options);
+    if (outcome.refusal) return outcome.refusal;
+    const response = await handler(request, ...args);
+    for (const [name, value] of Object.entries(outcome.headers)) response.headers.set(name, value);
+    return response;
+  };
+}
+export {
+  APP_CONFIG_PATH,
+  cachedStore,
+  checkClientVersion,
+  createAppConfigHandler,
+  memoryStore,
+  schemaSql,
+  withClientVersionGuard
+};
+//# sourceMappingURL=server.js.map