akanjs 3.0.0-beta.8 → 3.0.0

package/types/vendor/use-agentic/AgentSession.d.ts

@@ -1,6 +1,6 @@
 import type { AgentProgressReport } from "./AgentProgress.d.ts";
 import { type CompactOptions } from "./Compaction.d.ts";
-import type { AgentRunner, ChatMessage, ContextBlock, MessageReference, PublishedTool, SurfaceView } from "./types.d.ts";
+import type { AgentRunner, ChatMessage, ContextBlock, MessageReference, PublishedTool, SurfaceView, ToolActivity, ToolCard } from "./types.d.ts";
 export interface PendingApproval {
     callId: string;
     name: string;
@@ -21,6 +21,19 @@ export interface PendingQuestion {
     answer: (value: string | string[]) => void;
     dismiss: (reason?: string) => void;
 }
+/**
+ * A call parked on a component the app declared with the tool — a form to fill in, a choice no list of strings
+ * could carry. The loop waits on it exactly as it waits on an approval, and `render` is the app's own, so the
+ * framework decides where the card sits and nothing about what it asks.
+ */
+export interface PendingCard {
+    callId: string;
+    name: string;
+    args: Record<string, unknown>;
+    render: ToolCard;
+    submit: (value: unknown) => void;
+    dismiss: (reason?: string) => void;
+}
 /**
  * Where a session keeps its transcript across page loads. Storage-neutral: the host decides what backs it, so a
  * server-side transcript is as legal as web storage — which is why every method may answer asynchronously. A
@@ -76,6 +89,21 @@ export interface AgentSessionOptions {
      * duplicate, no error, just messages that never reach the server. Reset the mark here.
      */
     onCompact?: (replaced: readonly ChatMessage[], summary: ChatMessage) => void;
+    /**
+     * Called as each tool call starts and ends — where a host draws what the agent is doing on the page itself.
+     * The session keeps none of it: nothing here is transcript, and holding it would mean a re-render per call for
+     * something no message renders.
+     */
+    onActivity?: (event: ToolActivity) => void | Promise<void>;
+    /**
+     * Called when a turn starts and when it settles — the boundary a host draws the agent's own presence in. The
+     * calls of one turn arrive with model turns between them, seconds long, so anything measured in the gap
+     * between *calls* keeps ending and restarting inside a turn that never stopped.
+     *
+     * Only the conversation loop reports here. `compact` runs under the same flag and drives nothing on screen, so
+     * a host drawing the agent at work would draw it for a summary nobody asked to watch.
+     */
+    onTurn?: (running: boolean) => void;
 }
 /**
  * The client-side conversation loop: send → model turn → tool calls → approval gate → execute → report diffs → next
@@ -111,6 +139,7 @@ export declare class AgentSession {
     get isCompacting(): boolean;
     get pendingApproval(): PendingApproval | null;
     get pendingQuestion(): PendingQuestion | null;
+    get pendingCard(): PendingCard | null;
     /**
      * What the user has pointed at and not yet sent.
      *
@@ -207,8 +236,18 @@ export declare class AgentSession {
     compact: ({ keep }?: {
         keep?: number;
     }) => Promise<boolean>;
-    /** What the transcript is estimated to cost the next turn, in tokens — the number auto-compaction watches. */
+    /** What the transcript is estimated to cost the next turn, in tokens — the number the `at` ceiling watches. */
     get tokens(): number;
+    /**
+     * How close the conversation is to summarizing itself, measured against whichever trigger is nearer: the `at`
+     * ceiling over the transcript, or the window guard over the whole prompt once the backend has reported its
+     * window. Each pair is in its own unit, which is why only the nearer one is answered. No `compactAt` means
+     * nothing will compact it.
+     */
+    get context(): {
+        used: number;
+        compactAt?: number;
+    };
     /** Records a host-side failure (a prompt fetch, an upload) in the transcript, where every other failure lands. */
     report: (error: string) => void;
     /** A line the host wrote — a command's own output. Rendered in the transcript, withheld from the model. */

package/types/vendor/use-agentic/AgenticSurface.d.ts

@@ -1,3 +1,4 @@
+import { AgentGate } from "./AgentGate.d.ts";
 import type { AgentCall, ResourceDiff, ResourceEntry, ScopeEntry, SurfaceSnapshot, SurfaceSource, SurfaceView, ToolEntry } from "./types.d.ts";
 /**
  * The live registry of what the mounted screen offers an agent: tools, readable resources, and scopes.
@@ -20,17 +21,26 @@ export declare class AgenticSurface {
      * argument rather than closing over it: every registration is then interchangeable and last-wins picks an
      * equivalent one. The description is what says so — two registrations that describe the same action to a model
      * are the same declaration twice, and fifty rows are one entry rather than fifty collisions. Two that describe
-     * different actions under one name are a real clash whichever of them mounted last, and warn.
+     * different actions under one name are a real clash whichever of them mounted last, and warn. A clash needs both
+     * published at once, so a registration behind a parked gate, or over only parked ones, never warns.
      */
-    registerTool(scope: string[], entry: ToolEntry): () => void;
-    registerResource(scope: string[], entry: ResourceEntry): () => void;
-    openScope(parent: string[], scope: ScopeEntry): () => void;
+    registerTool(scope: string[], entry: ToolEntry, gate?: AgentGate | null): () => void;
+    registerResource(scope: string[], entry: ResourceEntry, gate?: AgentGate | null): () => void;
+    openScope(parent: string[], scope: ScopeEntry, gate?: AgentGate | null): () => void;
     /**
      * Standing guidance for the agent while the registrant is mounted — instructions, not context data. Kept in
      * registration order rather than sorted: guides are prose, and each one must stay a coherent block.
      */
-    registerGuide(scope: string[], text: string): () => void;
+    registerGuide(scope: string[], text: string, gate?: AgentGate | null): () => void;
     addSource(source: SurfaceSource): () => void;
+    /** A gate whose every flip re-publishes this surface. Under `parent`, it is active only while the parent is. */
+    gate(active: boolean, parent?: AgentGate | null): AgentGate;
+    /**
+     * This surface for a subtree behind `gate`: what registers through it is published only while the gate is active,
+     * and every other call reaches this surface untouched. A proxy rather than a wrapper class, so a method added to the
+     * surface later is forwarded instead of missing.
+     */
+    gated(gate: AgentGate): AgenticSurface;
     snapshot(view?: string[]): SurfaceSnapshot;
     /**
      * A zone session's reading half: the same registry filtered to one scope subtree. Hook entries filter by their

package/types/vendor/use-agentic/Compaction.d.ts

@@ -1,9 +1,19 @@
-import type { ChatMessage } from "./types.d.ts";
+import type { ChatMessage, TurnLimits } from "./types.d.ts";
 export interface CompactOptions {
-    /** Estimated transcript tokens above which a turn summarizes its own history first. `0` never compacts. */
+    /**
+     * Estimated transcript tokens above which a turn summarizes its own history first — a ceiling on what each turn
+     * costs, apart from the window guard. `Infinity` leaves only the guard; `0` turns automatic compaction off
+     * altogether, the guard and the recovery from a refusal included.
+     */
     at?: number;
     /** Messages left verbatim below the summary. The cut slides down to the first message that can safely open one. */
     keep?: number;
+    /**
+     * Tokens held free below the model's window on top of its answer ceiling, once the backend has reported the
+     * window. It covers what the estimate cannot see: what arrived after the provider last counted, and a screen
+     * that changed since.
+     */
+    buffer?: number;
     /** Produces the summary from the digest. Default: one tool-less turn through the session's own runner. */
     summarize?: (digest: string, signal: AbortSignal) => Promise<string>;
 }
@@ -15,14 +25,24 @@ export interface CompactOptions {
 export declare class Compaction {
     #private;
     /**
-     * Deliberately well under the smallest window a provider is likely to have: what a conversation loses to an
-     * early summary is detail, and what it loses to a late one is the conversation. The tools, the screen context
-     * and the system prompt ride on top of the transcript on every turn, and none of them is compactable.
+     * `at` is a ceiling on cost rather than on the window. The relay holds no session, so every turn resends the
+     * whole transcript and the app pays for each one — a chat left to fill a million-token window prefills most of
+     * a million tokens per answer. The window is guarded on its own once the backend reports it, and `buffer` is the
+     * margin that guard holds back: 13k, the one Claude Code leaves below its own threshold.
      */
     static readonly defaults: {
         at: number;
         keep: number;
+        buffer: number;
     };
+    /** The answer ceiling assumed when the backend did not report one — the one most relays request when they do. */
+    static readonly answerTokens = 8192;
+    /**
+     * What one inlined picture costs a turn. A provider bills a picture by its pixels after its own downscale, not by
+     * its bytes — Anthropic lands near 1,600 tokens and OpenAI's high-detail tiles under that — so counted as base64
+     * a 300KB screenshot reads as 100k tokens and compacts itself out of the very task it was attached to.
+     */
+    static readonly imageTokens = 1600;
     static readonly instruction: string;
     /**
      * Four characters per token, counted over the JSON the turn actually posts. A rough estimate on purpose: this
@@ -30,6 +50,19 @@ export declare class Compaction {
      * more than the slack the estimate leaves.
      */
     static tokensOf(messages: readonly ChatMessage[]): number;
+    /**
+     * What the next request is estimated to cost, prompt and all: the provider's own count for the last turn that
+     * reported one, plus four characters a token for what the transcript gained since. The provider's number is the
+     * one that knows its tokenizer — Hangul sits nearer one character a token than four — so the rule only has to
+     * cover the tail. With no count to start from, `overhead` stands in for what rides every turn beside the
+     * transcript: the tools, the screen context and the instructions.
+     */
+    static promptTokensOf(messages: readonly ChatMessage[], overhead: () => number): number;
+    /**
+     * The prompt size past which a turn compacts first, or `Infinity` while the window is unknown. The answer shares
+     * the window with the prompt, so its ceiling is held back along with `buffer`.
+     */
+    static thresholdOf(limits: TurnLimits, buffer: number): number;
     /**
      * Where the kept half starts, or `-1` when nothing can be cut. A user message is the boundary to prefer —
      * everything above it is settled — but one assistant turn that ran ten tools leaves no user message anywhere
@@ -42,6 +75,10 @@ export declare class Compaction {
     /**
      * The messages as one bounded block of text. Bounded is the point: the transcript being summarized is the one
      * that no longer fits, so feeding it back verbatim would fail exactly where compaction is needed most.
+     *
+     * A previous summary is the exception: carried whole, outside the bound and under its own label. It is the only
+     * record of everything compacted before it, so whatever is clipped from it here the next summary loses for good —
+     * and it wears the user's role on the wire without being anything the user said.
      */
     static digest(messages: readonly ChatMessage[], budget?: number): string;
     static message(summary: string): ChatMessage;

package/types/vendor/use-agentic/ToolRunner.d.ts

@@ -1,5 +1,5 @@
 import { type AgentProgressReport } from "./AgentProgress.d.ts";
-import type { SurfaceView, ToolCallRequest, ToolCallResult, ToolEntry } from "./types.d.ts";
+import type { SurfaceView, ToolActivity, ToolCallRequest, ToolCallResult, ToolCard, ToolEntry } from "./types.d.ts";
 export interface ToolApprovalRequest {
     callId: string;
     name: string;
@@ -7,6 +7,19 @@ export interface ToolApprovalRequest {
     /** What the user is asked, already resolved from the entry's `confirm`. */
     message: string;
 }
+/** A call whose answer the user writes, handed to the host with the component its declaration named. */
+export interface ToolCardRequest {
+    callId: string;
+    name: string;
+    args: Record<string, unknown>;
+    render: ToolCard;
+}
+/** What the card settled on: the value the model reads back, or why there is none. */
+export type ToolCardAnswer = {
+    result: unknown;
+} | {
+    error: string;
+};
 /** `report` is `null` once the call is over, carrying the id so a host can ignore a clear that is not its own. */
 export interface ToolProgress {
     callId: string;
@@ -25,6 +38,13 @@ export interface ToolRunnerHost {
      * a host that may not perform the action, and the refusal says so rather than silently downgrading the gate.
      */
     approve?: (request: ToolApprovalRequest, signal: AbortSignal) => Promise<true | string>;
+    /**
+     * Parks the call until the user fills in the card its declaration named, and answers with what they submitted.
+     *
+     * Omitting it refuses those calls rather than running something in their place: a card tool has no function to
+     * fall back to — the user *is* the implementation — so a host with nowhere to render one may not answer it.
+     */
+    card?: (request: ToolCardRequest, signal: AbortSignal) => Promise<ToolCardAnswer>;
     /**
      * Awaited after a tool that changed something and before its change report is taken. A surface is read
      * synchronously and a screen does not settle synchronously, so without this the report describes the moment
@@ -32,6 +52,16 @@ export interface ToolRunnerHost {
      */
     settle?: () => Promise<void> | void;
     progress?: (progress: ToolProgress) => void;
+    /**
+     * That a call is running, for a host drawing it on the page rather than in a transcript. Separate from
+     * `progress`, which only ever fires for a tool that chose to report: a call the user has to be told about is
+     * every call, and one that says nothing about itself is exactly the one whose effect arrives unexplained.
+     *
+     * **The `start` is awaited**, so a host may draw something that has to land before the call does — a pointer
+     * pressing the link a `navigate` is about to follow is drawing on an element the router would otherwise have
+     * replaced first. The host owns the deadline: a decoration that takes its time makes the agent take its time.
+     */
+    activity?: (event: ToolActivity) => void | Promise<void>;
     /**
      * Answers a name the surface does not carry — where a consumer puts a built-in of its own. Reached only after
      * the surface came up empty, so a registered tool of the same name shadows it.

package/types/vendor/use-agentic/Transcript.d.ts

@@ -13,6 +13,8 @@ export declare class Transcript {
     static readonly unanswered = "The turn was stopped before this call ran.";
     /** What one turn posts: no host-only message, no unanswered call, no result answering a call nobody sees. */
     static wire(messages: readonly ChatMessage[]): ChatMessage[];
+    /** A message without the provider's count for its turn — what the wire carries and what a compaction keeps. */
+    static unmeasured(message: ChatMessage): ChatMessage;
     static sanitize(messages: readonly ChatMessage[]): ChatMessage[];
     /** An empty assistant message is a draft a reload or an abort caught before it said anything. */
     static carries(message: ChatMessage): boolean;

package/types/vendor/use-agentic/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./AgentAbort.d.ts";
+export * from "./AgentActivity.d.ts";
+export * from "./AgentGate.d.ts";
 export * from "./Agentic.d.ts";
 export * from "./AgenticSurface.d.ts";
 export * from "./AgentProgress.d.ts";

package/types/vendor/use-agentic/surfaceContext.d.ts

@@ -1,5 +1,8 @@
+import type { AgentGate } from "./AgentGate.d.ts";
 import { AgenticSurface } from "./AgenticSurface.d.ts";
 export declare const SurfaceContext: import("react").Context<AgenticSurface | null>;
 export declare const ScopeContext: import("react").Context<string[]>;
+export declare const GateContext: import("react").Context<AgentGate | null>;
 export declare const useSurface: () => AgenticSurface;
 export declare const useScopePath: () => string[];
+export declare const useAgentGate: () => AgentGate | null;

package/types/vendor/use-agentic/types.d.ts

@@ -1,9 +1,25 @@
+import type { ReactNode } from "react";
 export type JsonSchema = Record<string, unknown>;
 /** `true` asks with a default message, a string is the message, a function decides from the arguments. */
 export type ToolConfirm = boolean | string | ((args: Record<string, unknown>) => string | boolean);
 /** Re-checked at the moment of execution; a string is the refusal reason the agent reads. */
 export type ToolGuard = (args: Record<string, unknown>) => true | string;
-export interface ToolEntry {
+/**
+ * What a card tool renders while its call waits, and the two ways the user ends that wait. `submit` is the call's
+ * result, `cancel` is its refusal; whichever comes first settles the call and takes the card off the screen, so a
+ * second call of either does nothing.
+ */
+export interface ToolCardControl {
+    args: Record<string, unknown>;
+    submit: (value: unknown) => void;
+    cancel: (reason?: string) => void;
+}
+/**
+ * Called, not mounted — the host invokes it inside its own render, so the returned tree keeps no state of its
+ * own between renders. Put anything stateful in a component the function returns.
+ */
+export type ToolCard = (control: ToolCardControl) => ReactNode;
+interface ToolEntryBase {
     name: string;
     description?: string;
     parameters?: JsonSchema;
@@ -14,7 +30,33 @@ export interface ToolEntry {
     settle?: boolean;
     confirm?: ToolConfirm;
     guard?: ToolGuard;
+}
+export interface ToolActionEntry extends ToolEntryBase {
     run: (args: Record<string, unknown>) => unknown;
+    card?: never;
+}
+/**
+ * A call the **user** answers rather than the screen: the host parks the call, renders `card`, and what the card
+ * submits is what the model reads back. `confirm` is not read for one — the card in front of the user is already
+ * the asking, and a gate before it would ask them twice for one thing.
+ */
+export interface ToolCardEntry extends ToolEntryBase {
+    card: ToolCard;
+    run?: never;
+}
+export type ToolEntry = ToolActionEntry | ToolCardEntry;
+/**
+ * That a call is happening, for a host drawing it on the screen rather than in a transcript.
+ *
+ * Emitted around the execution alone — after the approval card settled, and never for a call a guard or an
+ * approval refused before it ran, so a host may treat `start` as "this is being done to the page right now".
+ */
+export interface ToolActivity {
+    callId: string;
+    name: string;
+    args: Record<string, unknown>;
+    phase: "start" | "end";
+    error?: string;
 }
 /** One call an agent made through the surface, in the order it made them. */
 export interface AgentCall {
@@ -107,6 +149,21 @@ export interface ToolCallResult {
  * neither is distinguishable from `end` without it.
  */
 export type TurnStop = "end" | "toolUse" | "length";
+/** What the provider counted for one turn. `input` is the whole prompt, cached part included — what the window held. */
+export interface TurnUsage {
+    input: number;
+    output: number;
+}
+/**
+ * What the backend knows about the model it relays to, each only when it was told: a window it guesses is worse
+ * than none, because a guard placed on a wrong number fires at the wrong time and nothing says so.
+ */
+export interface TurnLimits {
+    /** The model's context window, prompt and answer together. */
+    window?: number;
+    /** The answer ceiling the backend actually requests. */
+    output?: number;
+}
 /**
  * A file the user handed the conversation rather than the screen — which is why it rides a message instead of a
  * tool, the same reason `askUser` belongs to the session and not to the surface.
@@ -185,6 +242,12 @@ export interface ChatMessage {
      * a host renders it as one.
      */
     summary?: boolean;
+    /**
+     * What the provider counted for the turn that wrote this assistant message. Kept on the message so it moves,
+     * persists and is summarized away with it; never sent, and dropped from what a compaction keeps, since it
+     * measured a prompt that no longer exists.
+     */
+    usage?: TurnUsage;
 }
 /** One block of screen context the host assembles per turn. `kind` is the host's vocabulary; the wire forwards it verbatim. */
 export interface ContextBlock {
@@ -202,15 +265,23 @@ export type RunnerEvent = {
 } | {
     type: "done";
     stop: TurnStop;
+    usage?: TurnUsage;
+    limits?: TurnLimits;
 }
 /**
  * `data` accompanies a message that is a code rather than a sentence — the values whoever resolves the code
  * interpolates into its text. A host that does not know the code shows the message as it stands.
+ *
+ * `overflow` marks the provider refusing a prompt too long for its window — the one refusal a session can undo
+ * on its own, by compacting and asking again. `limit` is the window when the refusal named it.
  */
  | {
     type: "error";
     message: string;
     data?: Record<string, string | number>;
+    overflow?: {
+        limit?: number;
+    };
 };
 export interface RunnerRequest {
     messages: ChatMessage[];
@@ -223,3 +294,4 @@ export interface RunnerRequest {
 export interface AgentRunner {
     run: (request: RunnerRequest) => AsyncIterable<RunnerEvent>;
 }
+export {};

package/types/webkit/CsrRouteTable.d.ts

@@ -0,0 +1,32 @@
+import { type Device, type PathRoute, type RouteGuide, type RouteModuleSource } from "akanjs/client";
+type CsrRouteModuleLoader = () => Promise<RouteModuleSource>;
+export type CsrRouteModuleEntry = CsrRouteModuleLoader | {
+    loader: CsrRouteModuleLoader;
+    isAsyncDefault?: boolean;
+};
+export type CsrRouteContext = Record<string, CsrRouteModuleEntry>;
+export interface CsrRoutes {
+    pathRoutes: PathRoute[];
+    routeGuide: RouteGuide;
+}
+interface CsrRouteTableOptions {
+    device: Pick<Device, "info" | "topSafeArea" | "bottomSafeArea">;
+    basePaths: string[] | null;
+    currentBasePath?: string;
+}
+/**
+ * The CSR bundle's route table, built from the route modules the entry hands over. It is a store rather than a value
+ * so a dev server can swap the modules in place: `replace` rebuilds the table and the router renders the new one while
+ * the history, the mounted pages and every store keep going.
+ */
+export declare class CsrRouteTable {
+    #private;
+    static get active(): CsrRouteTable | null;
+    static boot(context: CsrRouteContext, options: CsrRouteTableOptions): Promise<CsrRouteTable>;
+    private constructor();
+    subscribe: (listener: () => void) => () => void;
+    snapshot: () => CsrRoutes;
+    /** `false` when the context names another set of modules: a route added or removed needs a reload. */
+    replace(context: CsrRouteContext): Promise<boolean>;
+}
+export {};

package/types/webkit/CsrStack.d.ts

@@ -0,0 +1,45 @@
+import type { CsrNavigationPhase, CsrStackEntry, History, Location } from "akanjs/client";
+interface CsrStackState {
+    history: History;
+    location: Location;
+    prevLocation: Location | null;
+    pendingLocation: Location | null;
+    phase: CsrNavigationPhase;
+}
+/**
+ * Which history entries keep a mounted page. The current, previous and pending entries are live. Below them the
+ * nearest `retainLimit` stack entries stay mounted but hidden, so going back reveals each with its state instead of
+ * mounting it again, and every `cache` route visited keeps one page for the whole session.
+ */
+export declare class CsrStack {
+    #private;
+    static retainLimit: number;
+    /** Kept per tab, so a reload — or a WebView whose content process died and reloaded — gets its stack back. */
+    static save(history: History): void;
+    /**
+     * The stack this tab had, when the entry it reopened on is the one the stack was on. Only the current and previous
+     * entries are mounted at once; the rest come back dormant and mount when they are visited.
+     */
+    static restore(current: Location, locate: (href: string) => Location): {
+        locations: {
+            entryId: string;
+            href: string;
+            pathname: string;
+            search: string;
+            params: {
+                [key: string]: string;
+            };
+            searchParams: {
+                [key: string]: string | string[];
+            };
+            pathRoute: import("akanjs/client").PathRoute;
+            hash: string;
+        }[];
+        idx: number;
+        dormant: Set<string>;
+    } | null;
+    static nextEntryId(): string;
+    static keyOf(location: Location): string;
+    static entriesOf({ history, location, prevLocation, pendingLocation, phase }: CsrStackState): CsrStackEntry[];
+}
+export {};

package/types/webkit/RenderLayer.d.ts

@@ -0,0 +1,11 @@
+import { type RouteRender } from "akanjs/client";
+import { type ReactNode } from "react";
+interface RenderLayerProps {
+    renders: RouteRender[];
+    index: number;
+    params: Record<string, string>;
+    searchParams: Record<string, string | string[]>;
+    leaf?: ReactNode;
+}
+export declare const RenderLayer: import("react").MemoExoticComponent<({ renders, index, params, searchParams, leaf }: RenderLayerProps) => import("react").JSX.Element | null>;
+export {};

package/types/webkit/bootCsr.d.ts

@@ -1,9 +1,4 @@
-import { type RouteModuleSource } from "akanjs/client";
-type CsrRouteModuleLoader = () => Promise<RouteModuleSource>;
-type CsrRouteModuleEntry = CsrRouteModuleLoader | {
-    loader: CsrRouteModuleLoader;
-    isAsyncDefault?: boolean;
-};
+import { type CsrRouteContext } from "./CsrRouteTable.d.ts";
 declare global {
     interface Window {
         __AKAN_MOBILE_TARGET__?: {
@@ -13,5 +8,9 @@ declare global {
         };
     }
 }
-export declare const bootCsr: (context: Record<string, CsrRouteModuleEntry>) => Promise<void>;
-export {};
+export declare const bootCsr: (context: CsrRouteContext) => Promise<void>;
+/**
+ * Swaps the route modules of a running CSR bundle — what a dev server calls when a page, layout or overrides module
+ * changed. History, mounted pages and stores stay; `false` means the set of routes changed and the page must reload.
+ */
+export declare const replacePages: (context: CsrRouteContext) => Promise<boolean>;

package/types/webkit/csrFrameDump.d.ts

@@ -0,0 +1,42 @@
+interface LayerRecord {
+    layer: string;
+    status: "pending" | "settled" | "failed";
+    startedAt: number;
+    settledAt: number | null;
+    /** A mounted layer is waiting on this render's promise; false once it unmounts or its Activity hides. */
+    subscribed: boolean;
+    /** The layer has drawn this render's value. */
+    delivered: boolean;
+}
+interface FrameState {
+    phase: string;
+    location: string;
+    prevLocation: string | null;
+    pendingLocation: string | null;
+    stack: {
+        key: string;
+        path: string;
+        pageType: string;
+    }[];
+}
+export declare class CsrFrameDump {
+    #private;
+    static readonly limit = 300;
+    static track(layer: string, result: Promise<unknown>): LayerRecord;
+    static watchFrame(read: () => FrameState): void;
+    static dump(): {
+        now: number;
+        frame: FrameState | null;
+        layers: {
+            layer: string;
+            status: "pending" | "settled" | "failed";
+            startedAt: number;
+            settledAt: number | null;
+            /** A mounted layer is waiting on this render's promise; false once it unmounts or its Activity hides. */
+            subscribed: boolean;
+            /** The layer has drawn this render's value. */
+            delivered: boolean;
+        }[];
+    };
+}
+export {};

package/types/webkit/index.d.ts

@@ -1,12 +1,9 @@
-export { bootCsr } from "./bootCsr.d.ts";
-export { createRobotPage } from "./createRobotPage.d.ts";
-export { createSitemapPage } from "./createSitemapPage.d.ts";
+export { bootCsr, replacePages } from "./bootCsr.d.ts";
 export { lazy } from "./lazy.d.ts";
+export { createRobotPage, createSitemapPage } from "./seoPages.d.ts";
 export type * from "./types.d.ts";
 export { useBodyScrollLock } from "./useBodyScrollLock.d.ts";
 export { useCamera } from "./useCamera.d.ts";
-export { useCodepush } from "./useCodepush.d.ts";
-export { useContact } from "./useContact.d.ts";
 export { useCsrValues } from "./useCsrValues.d.ts";
 export { useDebounce } from "./useDebounce.d.ts";
 export { useEscapeKey } from "./useEscapeKey.d.ts";
@@ -15,6 +12,9 @@ export { useGeoLocation } from "./useGeoLocation.d.ts";
 export { useHistory } from "./useHistory.d.ts";
 export { useInterval } from "./useInterval.d.ts";
 export { useLocation } from "./useLocation.d.ts";
+export { usePageActivity } from "./usePageActivity.d.ts";
+export { usePageFocusEffect } from "./usePageFocusEffect.d.ts";
+export { usePageLocation } from "./usePageLocation.d.ts";
 export { usePageTool } from "./usePageTool.d.ts";
 export type { ScreenScopeItem } from "./useScreenScope.d.ts";
 export { useScreenScope } from "./useScreenScope.d.ts";

package/types/webkit/lazy.d.ts

@@ -1,15 +1,6 @@
 import type { ReactNode } from "react";
-/**
- * `suspense` puts a Suspense boundary around the lazy component, so a chunk that resolves *after* the
- * page is painted — a modal body, a dropdown menu — suspends only itself. Without one the suspension
- * travels up to the nearest boundary, which is the route (`server/routeElementComposer.tsx`), and the
- * whole page repaints as its loading fallback on the first open.
- *
- * It is opt-in rather than the default because a boundary also changes server rendering: under the
- * default `renderMode: "stream"` the boundary's subtree leaves the shell as `loading` and arrives later
- * in the stream. That is fine for an interaction shell and wrong for a page body, which SEO snapshots,
- * prerendering and pre-hydration E2E read out of the shell.
- */
+/** `suspense`: a late chunk suspends only itself, not the route. Opt-in: under streaming the boundary's subtree
+ * leaves the shell, which SEO snapshots, prerendering and pre-hydration E2E read. */
 type LazyOption = {
     ssr?: boolean;
     suspense?: boolean;
@@ -18,6 +9,6 @@ type LazyOption = {
 type LoadedOf<Loaded> = Loaded extends {
     default: infer T;
 } ? T : Loaded;
-/** React lazy wrapper with Akan's `ssr: false` server stub and client mount gate. */
+/** `ssr: false` renders `loading` on the server and mounts the component only after hydration. */
 export declare const lazy: <Loaded>(loader: () => Promise<Loaded>, option?: LazyOption) => LoadedOf<Loaded>;
 export {};

package/types/webkit/nativeNavigation.d.ts

@@ -0,0 +1,39 @@
+export interface NativeBackState {
+    path: string;
+    keyboardHeight: number;
+    keyboardVisible: boolean;
+    router: {
+        back: () => void;
+    };
+}
+export interface NativeBackProgress {
+    phase: "started" | "progressed" | "cancelled";
+    progress: number;
+}
+interface NativeNavigationOptions {
+    historyIdx: () => number;
+    backState: () => NativeBackState;
+    /** A back press while the keyboard is up only puts it away. */
+    dismissKeyboard: () => unknown;
+    /** Android 14+: the swipe of a back this page will take, before it commits or is let go. */
+    onBackProgress?: (progress: NativeBackProgress) => void;
+    onMemoryWarning?: () => void;
+}
+/** A native shell's deep links, push taps and Android back button, for the CSR frame that owns the history. */
+export declare class NativeNavigation {
+    #private;
+    readonly options: NativeNavigationOptions;
+    constructor(options: NativeNavigationOptions);
+    showPushesExcept(pathname: string): void;
+    listen(): () => void;
+    /**
+     * Tells an Android shell whether back is the page's right now: the keyboard is up, there is history, or the
+     * index is still to come. Otherwise the system takes it and shows its own back-to-home animation.
+     */
+    syncBack(force?: boolean): void;
+    openDeepLink(url: string): void;
+    openPushLink(url: unknown): void;
+    back(): void;
+    static isMacBackKey({ key, metaKey, altKey, ctrlKey, shiftKey, }: Pick<KeyboardEvent, "key" | "metaKey" | "altKey" | "ctrlKey" | "shiftKey">): boolean;
+}
+export {};