akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/server/rscClient.tsx

@@ -42,7 +42,6 @@ declare global {
   var __RSC_PUSH__: ((type: InlineRscChunk[0], data: string) => void) | undefined;
   var __RSC_CLOSE__: (() => void) | undefined;
   var __AKAN_RSC_INITIAL_STATE__: string | undefined;
-  var __AKAN_RSC_REFRESH__: ((options?: { buildId?: number }) => Promise<void>) | undefined;
 }
 
 function decodeInlineRscChunk([type, data]: InlineRscChunk): Uint8Array {
@@ -336,7 +335,7 @@ function Root(): ReactNode {
   globalThis.__AKAN_RSC_REFRESH__ = async (options = {}) => {
     const navId = ++navigationSeq;
     const target = normalizeHref(window.location.href);
-    rscCache.delete(target);
+    rscCache.clear();
     rscPatchCache.clear();
     try {
       const next = await fetchRsc(target, {

package/server/ssrFromRscRenderer.tsx

@@ -1,3 +1,5 @@
+
+
 import { Readable } from "node:stream";
 import { getApiPrefix, getWsPrefix } from "akanjs/base";
 import { Logger } from "akanjs/common";

package/server/webRouter.ts

@@ -325,6 +325,7 @@ export class WebRouter {
       });
     } else {
       this.#devHmr = new DevHmrController({
+        artifactDir: this.#artifactDir,
         renderState: this.renderState,
         rsc: this.#rsc,
         seedIndex: this.#seedIndex,

package/signal/CrossSiteGuard.ts

@@ -10,8 +10,9 @@ export interface CrossSiteOption {
 
 export class CrossSiteGuard {
   static readonly logger = new Logger("CrossSiteGuard");
-  /** iOS ships `capacitor://localhost`, Android `http://localhost`, older shells `ionic://localhost`. */
-  static readonly nativeOrigins = ["capacitor://localhost", "ionic://localhost", "http://localhost"] as const;
+  /** The native shell serves the page from `app://localhost` on iOS, macOS and Linux, `https://app.localhost` on
+   * Android and Windows; both WebViews send exactly that as `Origin`. */
+  static readonly nativeOrigins = ["app://localhost", "https://app.localhost"] as const;
   static #enabled = true;
   static #allowed = new Set<string>(CrossSiteGuard.nativeOrigins);
 
@@ -46,6 +47,37 @@ export class CrossSiteGuard {
     throw new Exception.Forbidden("This request was not permitted.");
   }
 
+  /** The origin a cross-origin caller may read answers from: an allowlisted one, never the serving host's neighbours. */
+  static corsOrigin(req: Request): string | null {
+    const origin = req.headers.get("origin");
+    return origin !== null && CrossSiteGuard.#allowed.has(origin) ? origin : null;
+  }
+
+  static preflight(req: Request, methods: string[]): Response {
+    const origin = CrossSiteGuard.corsOrigin(req);
+    if (!origin) return new Response(null, { status: 403 });
+    return new Response(null, {
+      status: 204,
+      headers: {
+        "access-control-allow-origin": origin,
+        "access-control-allow-methods": [...methods, "OPTIONS"].join(", "),
+        
+        "access-control-allow-headers":
+          req.headers.get("access-control-request-headers") ?? "authorization, content-type",
+        "access-control-max-age": "600",
+        vary: "origin",
+      },
+    });
+  }
+
+  static withCors(req: Request, res: Response): Response {
+    const origin = CrossSiteGuard.corsOrigin(req);
+    if (!origin) return res;
+    res.headers.set("access-control-allow-origin", origin);
+    res.headers.append("vary", "origin");
+    return res;
+  }
+
   static #isSameSite(origin: string, req: Request, url: URL): boolean {
     try {
       const { protocol, host } = new URL(origin);

package/signal/endpoint.ts

@@ -53,7 +53,7 @@ export function endpoint<
   ...libEndpoints: LibEndpoints
 ): EndpointCls<
   SrvModule,
-  LibEndpoints extends readonly [] ? ReturnType<Builder> : Assign<ReturnType<Builder>, MergeEndpointMetas<LibEndpoints>>
+  LibEndpoints extends readonly [] ? ReturnType<Builder> : Assign<MergeEndpointMetas<LibEndpoints>, ReturnType<Builder>>
 > {
   const srvKeys = [
     ...new Set([
@@ -61,18 +61,23 @@ export function endpoint<
       ...libEndpoints.flatMap((libEndpoint) => Object.keys(libEndpoint.srv.srvMap)),
     ]),
   ];
+  const ownEndpointMeta = builder(buildEndpoint);
   const endpointCls = class Endpoint extends dangerouslyAdapt(`${srv.srv.refName}Endpoint`, ({ service }) => ({
     ...Object.fromEntries(srvKeys.map((srvRefName) => [srvRefName, service()])),
   })) {
     static baseName = srv.srv.refName;
     static srv = srv;
-    static [ENDPOINT_META] = builder(buildEndpoint);
+    static [ENDPOINT_META] = Object.assign(
+      {},
+      ...libEndpoints.map((libEndpoint) => libEndpoint[ENDPOINT_META]),
+      ownEndpointMeta,
+    );
   };
-  warnQueryBodyArgs(srv.srv.refName, endpointCls[ENDPOINT_META]);
-  libEndpoints.forEach((libEndpoint) => {
-    Object.assign(endpointCls[ENDPOINT_META], libEndpoint[ENDPOINT_META]);
-    Object.assign(endpointCls.srv.srvMap, libEndpoint.srv.srvMap);
-  });
+  warnQueryBodyArgs(srv.srv.refName, ownEndpointMeta);
+  Object.assign(
+    srv.srvMap,
+    Object.assign({}, ...libEndpoints.map((libEndpoint) => libEndpoint.srv.srvMap), srv.srvMap),
+  );
   applyMixins(endpointCls, [...libEndpoints]);
   return endpointCls as any; 
 }

package/signal/endpointInfo.ts

@@ -325,6 +325,19 @@ export class EndpointInfo<
         ...this.args.filter((arg) => arg.type === "param").map((arg) => `:${arg.name}`),
       ].join("/")}`;
   }
+
+  /** The route the server mounts, below the global prefix; the fetch client is handed it to call the same one. */
+  getRoutePath(key: string, defaultPrefix?: string) {
+    return `${EndpointInfo.resolveServicePrefix(this.signalOption.prefix, defaultPrefix)}${this.getPath(key)}`;
+  }
+
+  static resolveServicePrefix(prefix: false | string | undefined, defaultPrefix?: string): string {
+    if (prefix === false || prefix === "") return "";
+    const resolved = prefix ?? defaultPrefix;
+    if (!resolved) return "";
+    const trimmed = resolved.trim().replace(/^\/+|\/+$/g, "");
+    return trimmed ? `/${trimmed}` : "";
+  }
 }
 
 export type BuildEndpoint<SrvModule extends ServiceModel = ServiceModel> = {

package/signal/internal.ts

@@ -50,12 +50,16 @@ export function internal<
     ...Object.fromEntries(srvKeys.map((srvRefName) => [srvRefName, service()])),
   })) {
     static srv = srv;
-    static [INTERNAL_META] = internalBuilder(buildInternal as any);
+    static [INTERNAL_META] = Object.assign(
+      {},
+      ...libInternals.map((libInternal) => libInternal[INTERNAL_META]),
+      internalBuilder(buildInternal as any),
+    );
   };
-  libInternals.forEach((libInternal) => {
-    Object.assign(internalCls[INTERNAL_META], libInternal[INTERNAL_META]);
-    Object.assign(internalCls.srv.srvMap, libInternal.srv.srvMap);
-  });
+  Object.assign(
+    srv.srvMap,
+    Object.assign({}, ...libInternals.map((libInternal) => libInternal.srv.srvMap), srv.srvMap),
+  );
   applyMixins(internalCls, libInternals);
   return internalCls as any; 
 }

package/signal/serializer/fetch.serializer.ts

@@ -61,13 +61,15 @@ export class FetchSerializer {
     };
   }
 
-  static #serializeEndpoint(endpointInfo: EndpointInfo): SerializedEndpoint {
+  static #serializeEndpoint(key: string, endpointInfo: EndpointInfo, defaultPrefix?: string): SerializedEndpoint {
     const guards = endpointInfo.signalOption.guards?.map((g) => g.name);
+    const { path, name, prefix, globalPrefix } = endpointInfo.signalOption;
     return {
       type: endpointInfo.type,
       args: endpointInfo.args.map(FetchSerializer.#serializeArg),
       returns: FetchSerializer.#serializeReturns(endpointInfo),
-      ...(endpointInfo.signalOption.path ? { path: endpointInfo.signalOption.path } : {}),
+      ...(path || name || prefix !== undefined ? { path: endpointInfo.getRoutePath(key, defaultPrefix) } : {}),
+      ...(globalPrefix === false ? { globalPrefix } : {}),
       ...(endpointInfo.signalOption.method ? { method: endpointInfo.signalOption.method } : {}),
       ...(endpointInfo.signalOption.fileUpload ? { fileUpload: true } : {}),
       ...(endpointInfo.signalOption.timeout ? { timeout: endpointInfo.signalOption.timeout } : {}),
@@ -167,8 +169,9 @@ export class FetchSerializer {
 
   static #serializeEndpoints(endpointCls: EndpointCls) {
     const endpoint: { [key: string]: SerializedEndpoint } = {};
+    const defaultPrefix = endpointCls.srv.cnst?.refName;
     for (const [key, endpointInfo] of Object.entries(endpointCls[ENDPOINT_META] as { [key: string]: EndpointInfo }))
-      endpoint[key] = FetchSerializer.#serializeEndpoint(endpointInfo);
+      endpoint[key] = FetchSerializer.#serializeEndpoint(key, endpointInfo, defaultPrefix);
     return endpoint;
   }
 

package/signal/slice.ts

@@ -97,6 +97,30 @@ type ExtendSliceInfoObj<
     : never;
 };
 
+type RootSliceInfoObj<
+  SrvModule extends ServiceModel,
+  _Input,
+  _Full,
+  _Light,
+  _Insight,
+  _Filter extends FilterInstance,
+  _QueryKey extends string,
+> = {
+  [""]: SliceInfo<
+    SrvRefName<SrvModule>,
+    _Input,
+    _Full,
+    _Light,
+    _Insight,
+    _Filter,
+    SrvMap<SrvModule>,
+    ["queryKey", "args"],
+    [queryKey?: _QueryKey | null, args?: unknown[] | null],
+    [],
+    [_QueryKey | undefined, unknown[] | undefined]
+  >;
+};
+
 export function slice<
   SrvModule extends ServiceModel,
   BuildSlice extends SliceBuilder<SrvModule>,
@@ -114,26 +138,12 @@ export function slice<
   ...libSlices: LibSlices
 ): SliceCls<
   SrvModule,
-  Assign<
-    ReturnType<BuildSlice>,
-    LibSlices extends []
-      ? {
-          [""]: SliceInfo<
-            SrvRefName<SrvModule>,
-            _Input,
-            _Full,
-            _Light,
-            _Insight,
-            _Filter,
-            SrvMap<SrvModule>,
-            ["queryKey", "args"],
-            [queryKey?: _QueryKey | null, args?: unknown[] | null],
-            [],
-            [_QueryKey | undefined, unknown[] | undefined]
-          >;
-        }
-      : ExtendSliceInfoObj<SrvModule, LibSlices>
-  >
+  LibSlices extends []
+    ? Assign<ReturnType<BuildSlice>, RootSliceInfoObj<SrvModule, _Input, _Full, _Light, _Insight, _Filter, _QueryKey>>
+    : Assign<
+        ExtendSliceInfoObj<SrvModule, LibSlices>,
+        Assign<ReturnType<BuildSlice>, RootSliceInfoObj<SrvModule, _Input, _Full, _Light, _Insight, _Filter, _QueryKey>>
+      >
 > {
   if (!srv.cnst || !srv.db) throw new Error("cnst and db are required");
   const filterRef = srv.db.filter;
@@ -169,7 +179,10 @@ export function slice<
     static updateGuards = updateGuards;
     static removeGuards = removeGuards;
     static mcp = mcp;
+    
     static [SLICE_META] = Object.assign(
+      {},
+      ...libSlices.map((libSlice) => libSlice[SLICE_META]),
       {
         
         [""]: init({ guards: rootGuards, ...(mcpOption?.root === false ? { mcp: false } : {}) })
@@ -188,10 +201,7 @@ export function slice<
       sliceBuilder(init as Parameters<BuildSlice>[0]),
     );
   };
-  libSlices.forEach((libSlice) => {
-    Object.assign(sliceCls[SLICE_META], libSlice[SLICE_META]);
-    Object.assign(sliceCls.srv.srvMap, libSlice.srv.srvMap);
-  });
+  Object.assign(srv.srvMap, Object.assign({}, ...libSlices.map((libSlice) => libSlice.srv.srvMap), srv.srvMap));
   applyMixins(sliceCls, libSlices);
   return sliceCls as any; 
 }

package/store/baseSt.ts

@@ -49,7 +49,6 @@ export class BaseStore extends store("base" as const, () => ({
     bottomSafeAreaColor: "var(--color-background, Canvas)",
   } as PageState,
   devMode: false,
-  deviceToken: "" as string,
   currentPath: "" as string,
 })) {
   setDevMode(value: boolean) {

package/store/storeInstance.ts

@@ -1,6 +1,6 @@
-import { ACTION_META, ACTION_OWNER_META, getEnv, STATE_DERIVED_META, STATE_INIT_META } from "akanjs/base";
+import { ACTION_META, ACTION_OWNER_META, STATE_DERIVED_META, STATE_INIT_META } from "akanjs/base";
 import { Translator } from "akanjs/client";
-import { loadCapacitorApp } from "akanjs/client/capacitor";
+import { appState, isNativeApp } from "akanjs/client/native";
 import { capitalize, type DynamicRecord, isRecord, Logger, parseAkanI18nEnv } from "akanjs/common";
 import { ConstantRegistry } from "akanjs/constant";
 import type { SerializedArg } from "akanjs/signal";
@@ -56,6 +56,8 @@ export type ReactAPI = {
 
 export class StoreInstance {
   #state: StoreStateRecord = {};
+  
+  #serverState: StoreStateRecord = {};
   #listeners = new Set<() => void>();
   #derivedMeta: StateDerivedMeta = { drafts: {}, persistSession: {}, search: {}, computed: {}, derivedKeys: new Set() };
   #draftTimers = new Map<string, ReturnType<typeof setTimeout>>();
@@ -146,6 +148,7 @@ export class StoreInstance {
 
   #sel = <U>(selector: (state: StoreStateRecord) => U, equals?: (a: U, b: U) => boolean) => {
     const eq = equals ?? Object.is;
+    let serverSnapshot: { value: U } | null = null;
     return useSyncExternalStore(
       (onStoreChange: () => void) => {
         let prev = selector(this.#state);
@@ -159,7 +162,11 @@ export class StoreInstance {
         return this.subscribe(listener);
       },
       () => selector(this.#state),
-      () => selector(this.#state),
+      
+      () => {
+        serverSnapshot ??= { value: selector(this.#serverState) };
+        return serverSnapshot.value;
+      },
     );
   };
 
@@ -293,16 +300,15 @@ export class StoreInstance {
   addStore(store: RootStoreCls) {
     this.#mergeDerivedMeta(store[STATE_DERIVED_META]);
     const newState = evaluateInitializers(store[STATE_INIT_META] ?? {});
+    this.#serverState = this.#withNewKeys(
+      this.#serverState,
+      this.#materializeDerived({ ...this.#serverState, ...newState }, this.#serverState, true),
+    );
     const hydratedState = this.#hydratePersistSession(newState);
     const derivedState = this.#materializeDerived({ ...this.#state, ...hydratedState }, this.#state);
-    let hasNewStateKey = false;
-    const nextState = { ...this.#state };
-    for (const [key, value] of Object.entries(derivedState)) {
-      if (key in nextState) continue;
-      nextState[key] = value;
-      hasNewStateKey = true;
-    }
-    if (hasNewStateKey) this.#state = nextState;
+    const nextState = this.#withNewKeys(this.#state, derivedState);
+    const hasNewStateKey = nextState !== this.#state;
+    this.#state = nextState;
     for (const [key, owner] of Object.entries(store[ACTION_OWNER_META] ?? {})) this.#actionOwners.set(key, owner);
     this.#mergeActions(store[ACTION_META]);
     this.#extendAccessors(derivedState, store[ACTION_META]);
@@ -311,6 +317,12 @@ export class StoreInstance {
     return this;
   }
 
+  #withNewKeys(state: StoreStateRecord, additions: StoreStateRecord) {
+    const newKeys = Object.keys(additions).filter((key) => !(key in state));
+    if (!newKeys.length) return state;
+    return { ...state, ...Object.fromEntries(newKeys.map((key) => [key, additions[key]])) };
+  }
+
   static #formRefNameOf(key: string) {
     if (!key.endsWith("Form")) return null;
     const refName = key.slice(0, -"Form".length);
@@ -562,18 +574,18 @@ export class StoreInstance {
     window.addEventListener("pagehide", this.flushDrafts);
     document.addEventListener("visibilitychange", onHide);
     
-    if (getEnv().renderMode === "csr")
-      void loadCapacitorApp()
-        .then(({ App }) => App.addListener("pause", this.flushDrafts))
-        .catch(() => undefined);
+    if (isNativeApp())
+      appState.listen("change", ({ state }) => {
+        if (state === "background") this.flushDrafts();
+      });
   }
 
-  #materializeDerived(next: StoreStateRecord, prev: StoreStateRecord) {
+  #materializeDerived(next: StoreStateRecord, prev: StoreStateRecord, server = typeof window === "undefined") {
     const materialized = { ...next };
     const changedKeys = new Set(Object.keys(materialized).filter((key) => !Object.is(materialized[key], prev[key])));
     const searchParams = (materialized.searchParams ?? {}) as SearchParamsState;
     for (const [key, meta] of Object.entries(this.#derivedMeta.search)) {
-      const value = typeof window === "undefined" ? meta.getDefault() : meta.parseSearch(searchParams);
+      const value = server ? meta.getDefault() : meta.parseSearch(searchParams);
       if (!Object.is(materialized[key], value)) {
         materialized[key] = value;
         changedKeys.add(key);

package/types/client/cookie.d.ts

@@ -18,12 +18,14 @@ export declare const removeCookie: (key: string, options?: {
 export declare const headers: () => Map<string, string>;
 export declare const getHeader: (key: string) => string | undefined;
 export { authTokenKey };
-/** The auth token this app holds in the cookie jar, under the app-scoped key or a legacy global one. */
+/** The auth token this app holds: on a CSR client the one `fetch` sends first, since a native shell's page keeps no
+ * session cookie; then the cookie jar, under the app-scoped key or a legacy global one. */
 export declare const getAuthToken: () => string | undefined;
-/** The auth token this app holds in client storage — localStorage under SSR, Capacitor Preferences on CSR. */
+/** The auth token this app holds in client storage — the OS credential store in a native app, localStorage elsewhere. */
 export declare const getStoredAuthToken: () => Promise<string | undefined>;
 /** The current JWT's account when minted for this app and environment. Reads only the two credentials the server
- * honours — the app-scoped auth cookie and `Authorization: Bearer` — so the two never disagree on who is signed in. */
+ * honours — the app-scoped auth cookie (a CSR client's bearer token) and `Authorization: Bearer` — so the two never
+ * disagree on who is signed in. */
 export declare const getAccount: <AddData = unknown>() => Account<AddData>;
 export interface GetOption {
     unauthorize: string;
@@ -31,7 +33,7 @@ export interface GetOption {
 interface SetAuthOption {
     jwt: string;
 }
-/** Sets the active auth token on fetch, cookie storage, and client storage. */
+/** Sets the active auth token on fetch, the cookie jar (except on a CSR client), and client storage. */
 export declare const setAuth: ({ jwt }: SetAuthOption) => void;
 interface InitAuthOption {
     jwt?: string;

package/types/client/device.d.ts

@@ -1,9 +1,7 @@
 import type { RefObject } from "react";
-import type { CapacitorDeviceInfo, CapacitorHapticsModule, CapacitorKeyboardModule } from "./capacitor.d.ts";
-type DeviceInfo = CapacitorDeviceInfo;
-type Keyboard = CapacitorKeyboardModule["Keyboard"];
-type Haptics = CapacitorHapticsModule["Haptics"];
-type ImpactStyle = CapacitorHapticsModule["ImpactStyle"];
+import type { DeviceInfo } from "./native.d.ts";
+type NativeModule = typeof import("./native.d.ts");
+type NativeControls = Pick<NativeModule, "haptics" | "keyboard">;
 type DebugPayload = Record<string, unknown>;
 export declare function debugFrame(event: string, payload?: DebugPayload): void;
 interface DeviceInitOption {
@@ -11,10 +9,10 @@ interface DeviceInitOption {
     info: DeviceInfo;
     topSafeArea: number;
     bottomSafeArea: number;
-    keyboard: Keyboard;
-    haptics: Haptics;
-    impactStyle: ImpactStyle;
+    /** The shell's keyboard and haptics; a page outside a native shell has neither. */
+    native: NativeControls | null;
 }
+export declare const isNativeTarget: () => boolean;
 export declare const isMobileDevice: () => boolean;
 export declare class Device {
     #private;
@@ -29,9 +27,8 @@ export declare class Device {
     topSafeArea: number;
     bottomSafeArea: number;
     isMobile: boolean;
-    constructor({ lang, info, topSafeArea, bottomSafeArea, keyboard, haptics, impactStyle }: DeviceInitOption);
+    constructor({ lang, info, topSafeArea, bottomSafeArea, native }: DeviceInitOption);
     setPageContentRef(pageContentRef: RefObject<HTMLDivElement | null>): void;
-    showKeyboard(): Promise<void>;
     hideKeyboard(): Promise<void>;
     listenKeyboardChanged(onKeyboardChanged: (height: number) => void): void;
     unlistenKeyboardChanged(): void;

package/types/client/native.d.ts

@@ -0,0 +1,26 @@
+import { browser } from "../vendor/@akanjs/native/plugins/browser/src/index.d.ts";
+import { opener } from "../vendor/@akanjs/native/plugins/opener/src/index.d.ts";
+export { AkanNativeError, fileBlob, releaseFile } from "../vendor/@akanjs/native/packages/core/src/index.d.ts";
+export { app } from "../vendor/@akanjs/native/plugins/app/src/index.d.ts";
+export { appState } from "../vendor/@akanjs/native/plugins/app-state/src/index.d.ts";
+export type { Photo } from "../vendor/@akanjs/native/plugins/camera/src/index.d.ts";
+export type { DeviceInfo } from "../vendor/@akanjs/native/plugins/device/src/index.d.ts";
+export { device } from "../vendor/@akanjs/native/plugins/device/src/index.d.ts";
+export { dialog } from "../vendor/@akanjs/native/plugins/dialog/src/index.d.ts";
+export type { Position } from "../vendor/@akanjs/native/plugins/geolocation/src/index.d.ts";
+export { haptics } from "../vendor/@akanjs/native/plugins/haptics/src/index.d.ts";
+export type { IapProduct, IapTransaction } from "../vendor/@akanjs/native/plugins/iap/src/index.d.ts";
+export { keyboard } from "../vendor/@akanjs/native/plugins/keyboard/src/index.d.ts";
+export { preferences } from "../vendor/@akanjs/native/plugins/preferences/src/index.d.ts";
+export type { PushAction, PushMessage, PushPermissionState, PushToken as NativePushToken, } from "../vendor/@akanjs/native/plugins/push/src/index.d.ts";
+export { push } from "../vendor/@akanjs/native/plugins/push/src/index.d.ts";
+export { secureStorage } from "../vendor/@akanjs/native/plugins/secure-storage/src/index.d.ts";
+export { browser, opener };
+export declare const loadCamera: () => Promise<typeof import("../vendor/@akanjs/native/plugins/camera/src/index.d.ts")>;
+export declare const loadGeolocation: () => Promise<typeof import("../vendor/@akanjs/native/plugins/geolocation/src/index.d.ts")>;
+export declare const loadIap: () => Promise<typeof import("../vendor/@akanjs/native/plugins/iap/src/index.d.ts")>;
+/** Inside an iOS or Android shell of the native runtime; a mobile target opened in a browser is not. */
+export declare const isNativeApp: () => boolean;
+export declare const nativePlatform: () => "ios" | "android" | null;
+/** http(s) in the in-app browser, anything else (mailto:, tel:) in the app the system picks. */
+export declare const openExternalUrl: (url: string) => Promise<void>;

package/types/client/rscNavigation.d.ts

@@ -1,6 +1,9 @@
 declare global {
     var __AKAN_RSC_CLEAR_CACHE__: (() => void) | undefined;
     var __AKAN_RSC_IS_FROM_CACHE__: (() => boolean) | undefined;
+    var __AKAN_RSC_REFRESH__: ((options?: {
+        buildId?: number;
+    }) => Promise<void>) | undefined;
     var __AKAN_RSC_NAVIGATE__: ((href: string, options?: {
         replace?: boolean;
         scrollToTop?: boolean;
@@ -16,6 +19,7 @@ export declare const navigateRsc: (href: string, options?: {
     replace?: boolean;
     scrollToTop?: boolean;
 }) => Promise<void> | undefined;
+export declare const refreshRsc: () => Promise<void> | undefined;
 export declare const useRscNavigation: () => {
     clearCache: () => void;
     isFromCache: () => boolean;

package/types/client/storage.d.ts

@@ -1,5 +1,12 @@
+/** Client key-value storage: the shell's preferences in a native app, localStorage in a browser. */
 export declare const storage: {
     getItem: (key: string) => Promise<string | null | undefined>;
     setItem: (key: string, value: string) => Promise<void | undefined>;
-    removeItem: (key: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void | undefined>;
+};
+/** Tokens: the OS credential store in a native app; a browser has none, so localStorage there. */
+export declare const secretStorage: {
+    getItem: (key: string) => Promise<string | null | undefined>;
+    setItem: (key: string, value: string) => Promise<void | undefined>;
+    removeItem: (key: string) => Promise<void | undefined>;
 };