akanjs 2.3.0 → 2.3.1-rc.0

package/types/constant/fieldInfo.d.ts

@@ -14,7 +14,8 @@ export interface FieldInfoObject {
 export type ExtractFieldInfoObject<Obj extends FieldInfoObject> = {
     [K in keyof Obj]: Obj[K] extends FieldInfo<any, infer FieldValue, infer ExplicitType, infer MapValue> ? unknown extends ExplicitType ? FieldToValue<FieldValue, MapValue> : ExplicitType : never;
 };
-export interface ConstantFieldProps<FieldType extends "property" | "hidden" | "resolve" = "property" | "hidden" | "resolve", FieldValue = any, MapValue = any, Metadata = {
+export type ConstantFieldKind = "property" | "hidden" | "secret" | "resolve";
+export interface ConstantFieldProps<FieldType extends ConstantFieldKind = ConstantFieldKind, FieldValue = any, MapValue = any, Metadata = {
     [key: string]: any;
 }> {
     nullable?: boolean;
@@ -42,7 +43,7 @@ export interface ConstantFieldProps<FieldType extends "property" | "hidden" | "r
 }
 export declare const fieldPresets: readonly ["email", "password", "url"];
 export type FieldPreset = (typeof fieldPresets)[number];
-declare class FieldInfo<FieldType extends "property" | "hidden" | "resolve" = any, Value extends ConstantFieldTypeInput | null = null, ExplicitType = unknown, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never> {
+declare class FieldInfo<FieldType extends ConstantFieldKind = any, Value extends ConstantFieldTypeInput | null = null, ExplicitType = unknown, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never> {
     readonly value: Value;
     readonly type: ConstantFieldTypeInput;
     readonly option: ConstantFieldProps;
@@ -54,7 +55,7 @@ declare class FieldInfo<FieldType extends "property" | "hidden" | "resolve" = an
         [key: string]: any;
     }>;
 }
-interface ConstantFieldBuildProps<FieldType extends "property" | "hidden" | "resolve" = any, FieldValue = any, MapValue = any, Metadata = any, Nullable extends boolean = boolean> {
+interface ConstantFieldBuildProps<FieldType extends ConstantFieldKind = any, FieldValue = any, MapValue = any, Metadata = any, Nullable extends boolean = boolean> {
     nullable: Nullable;
     ref?: string;
     refPath?: string;
@@ -91,7 +92,7 @@ export type FieldInfoObjectToFieldObject<Obj extends FieldInfoObject> = {
     [K in keyof Obj]: Obj[K] extends FieldInfo<infer FieldType, infer Value, infer ExplicitType, infer MapValue> ? ConstantField<FieldType, Value, unknown extends ExplicitType ? FieldToValue<Value, MapValue> : ExplicitType, MapValue> : never;
 };
 /** Runtime metadata for a single Akan constant field. */
-export declare class ConstantField<FieldType extends "property" | "hidden" | "resolve" = "property" | "hidden" | "resolve", Value extends ConstantFieldTypeInput | null = any, FieldValue = any, MapValue = any, Nullable extends boolean = false, Metadata = {
+export declare class ConstantField<FieldType extends ConstantFieldKind = ConstantFieldKind, Value extends ConstantFieldTypeInput | null = any, FieldValue = any, MapValue = any, Nullable extends boolean = false, Metadata = {
     [key: string]: any;
 }> implements ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata> {
     static getBaseModelField(): FieldObject;
@@ -122,7 +123,7 @@ export declare class ConstantField<FieldType extends "property" | "hidden" | "re
     readonly optArrDepth: number;
     readonly meta: Metadata;
     constructor(props: ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata>);
-    static fromFieldInfo<FieldType extends "property" | "hidden" | "resolve" = any, Value extends ConstantFieldTypeInput | null = null, FieldValue = any, MapValue = any, Nullable extends boolean = false, Metadata = {
+    static fromFieldInfo<FieldType extends ConstantFieldKind = any, Value extends ConstantFieldTypeInput | null = null, FieldValue = any, MapValue = any, Nullable extends boolean = false, Metadata = {
         [key: string]: any;
     }>(fieldInfo: FieldInfo<FieldType, Value, FieldValue, MapValue>): ConstantField<FieldType, Value, FieldValue, MapValue, Nullable, Metadata>;
     get isClass(): boolean;
@@ -138,13 +139,13 @@ type FieldOption<Value extends ConstantFieldTypeInput, MapValue = Value extends
     [key: string]: any;
 } = {
     [key: string]: any;
-}, _FieldToValue = FieldToValue<Value, MapValue> | null | undefined> = Omit<ConstantFieldProps<"property" | "hidden" | "resolve", _FieldToValue, MapValue, Metadata>, "enum" | "meta" | "nullable" | "fieldType" | "select"> | Omit<ConstantFieldProps<"property" | "hidden" | "resolve", SingleValue<_FieldToValue>, MapValue, Metadata>, "enum" | "meta" | "nullable" | "fieldType" | "select">[];
+}, _FieldToValue = FieldToValue<Value, MapValue> | null | undefined> = Omit<ConstantFieldProps<ConstantFieldKind, _FieldToValue, MapValue, Metadata>, "enum" | "meta" | "nullable" | "fieldType" | "select"> | Omit<ConstantFieldProps<ConstantFieldKind, SingleValue<_FieldToValue>, MapValue, Metadata>, "enum" | "meta" | "nullable" | "fieldType" | "select">[];
 export type PlainTypeToFieldType<PlainType> = PlainType extends [infer First, ...infer Rest] ? PlainTypeToFieldType<First>[] : PlainType extends number ? typeof Int | typeof Float : PlainType extends string ? StringConstructor : typeof Any;
 /** Builds a stored property field with optional validation, default, ref, text, and metadata options. */
 export declare const field: {
     <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"property", Value, ExplicitType, MapValue>;
     hidden<ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"hidden", Value | null, ExplicitType | null, MapValue>;
-    secret<ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"hidden", Value | null, ExplicitType | null, MapValue>;
+    secret<ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<"secret", Value | null, ExplicitType | null, MapValue>;
 };
 /** Builds a resolved field that is derived rather than treated as a stored property. */
 export declare const resolve: <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never>(value: Value, option?: FieldOption<Value, MapValue>) => FieldInfo<"resolve", Value, ExplicitType, MapValue>;

package/types/fetch/requestStorage.d.ts

@@ -42,6 +42,8 @@ export declare function getRequestPolicy(): AkanRequestPolicy | undefined;
 export declare function updateRequestPolicy(patch: Partial<Omit<AkanRequestPolicy, "tags">> & {
     tags?: Iterable<string>;
 }): AkanRequestPolicy | undefined;
+/** @internal Route cache tag collection is reserved for framework-owned cache policy experiments. */
+export declare function cacheTag(...tags: string[]): AkanRequestPolicy | undefined;
 export declare function getRequestDynamicUsage(): AkanDynamicUsage | undefined;
 /** Deduplicates a promise-producing query within the active request. */
 export declare function memoizeRequestQuery<T>(key: string, factory: () => Promise<T>): Promise<T>;

package/types/server/cachePolicy.d.ts

@@ -7,15 +7,45 @@ export interface RouteCacheKeyInput {
 }
 export interface RouteCacheRenderState {
     cacheable: boolean;
+    routeId?: string;
     revalidate?: number | false;
     tags?: string[];
     dynamicUsage?: AkanDynamicUsage;
     reason?: string;
 }
+export interface RouteCacheMetadata {
+    pathname: string;
+    routeId?: string;
+    tags?: string[];
+}
+export interface RouteCacheInvalidation {
+    tags?: string[];
+    paths?: string[];
+    reason?: string;
+}
 export interface RouteCacheEntry {
     key: string;
     ttl: number;
 }
+export interface PublicRouteCacheEntryInput extends RouteCacheKeyInput {
+    env: {
+        enabled?: string | null;
+        ttl?: string | null;
+        allow?: string | null;
+        deny?: string | null;
+    };
+    defaultTtl?: number;
+    defaultEnabled?: boolean;
+    defaultAllow?: boolean;
+}
+export type RouteCacheBypassReason = "env-opt-out" | "dev-default-off" | "ttl-disabled" | "path-excluded" | "request-not-public";
+export type RouteCacheEntryDecision = {
+    entry: RouteCacheEntry;
+    reason?: undefined;
+} | {
+    entry: null;
+    reason: RouteCacheBypassReason;
+};
 export type RouteCacheRenderControlType = "redirect" | "not-found" | "error";
 export declare function parsePositiveInt(value: string | undefined | null): number | null;
 export declare function normalizeRouteCacheTtl(value: unknown, fallback?: number): number | null;
@@ -23,6 +53,7 @@ export declare function resolveAutoRouteCacheTtl(input: {
     enabled?: string | null;
     ttl?: string | null;
     defaultTtl?: number;
+    defaultEnabled?: boolean;
 }): number | null;
 export declare function combineMinRevalidate(...values: Array<number | false | null | undefined>): number | false | undefined;
 export declare function getClientFacingOrigin(request: Request, url?: URL): string;
@@ -30,11 +61,14 @@ export declare function isPublicRouteCacheableRequest(request: Request): boolean
 export declare function isRouteCachePathAllowed(pathname: string, options?: {
     allow?: string | null;
     deny?: string | null;
+    defaultAllow?: boolean;
 }): boolean;
 export declare function createRouteCacheKey({ request, url, theme }: RouteCacheKeyInput): string;
 export declare function createRouteCacheEntry(input: RouteCacheKeyInput & {
     ttl: number;
 }): RouteCacheEntry;
+export declare function resolvePublicRouteCacheEntryDecision(input: PublicRouteCacheEntryInput): RouteCacheEntryDecision;
+export declare function resolvePublicRouteCacheEntry(input: PublicRouteCacheEntryInput): RouteCacheEntry | null;
 export declare function resolveRouteCacheStoreTtl(baseTtl: number, state: RouteCacheRenderState): number | null;
 export declare function shouldStoreRouteCache(input: {
     policy?: AkanRequestPolicy;
@@ -42,6 +76,8 @@ export declare function shouldStoreRouteCache(input: {
     renderControlType?: RouteCacheRenderControlType;
     lateRedirect?: boolean;
 }): RouteCacheRenderState;
+export declare function hasRouteCacheInvalidationScope(invalidation?: RouteCacheInvalidation): boolean;
+export declare function shouldInvalidateRouteCacheEntry(metadata: RouteCacheMetadata, invalidation: RouteCacheInvalidation): boolean;
 export declare class LruTtlCache<T> {
     #private;
     readonly maxEntries: number;

package/types/server/metadata.d.ts

@@ -1,5 +1,12 @@
 import type { AkanMetadata, Head, ResolvedHead, ResolveHeadResult } from "akanjs/client";
+import { type AkanHeadSnapshotV1 } from "./routeState.d.ts";
 export declare function isAkanMetadata(value: unknown): value is AkanMetadata;
+export declare function createAkanMetadataHeadSnapshot(metadata: AkanMetadata): AkanHeadSnapshotV1;
+export declare function createAkanLocaleAlternateHeadSnapshot(languages: Record<string, string>): AkanHeadSnapshotV1;
+export declare function mergeAkanHeadSnapshots(...snapshots: Array<AkanHeadSnapshotV1 | null | undefined>): AkanHeadSnapshotV1 | undefined;
+export declare function renderAkanHeadSnapshot(snapshot: AkanHeadSnapshotV1, options?: {
+    markRouteOwned?: boolean;
+}): Head;
 export declare function renderMetadata(metadata: AkanMetadata): Head;
 export declare function hasExplicitLanguageAlternates(metadata: AkanMetadata | null | undefined): boolean;
 export declare function shouldRenderLocaleAlternates(options: {
@@ -8,6 +15,8 @@ export declare function shouldRenderLocaleAlternates(options: {
 }): boolean;
 export declare function isResolvedHead(value: unknown): value is ResolvedHead;
 export declare function resolveMetadataHead(metadata: AkanMetadata): ResolvedHead;
-export declare function resolveHeadExport(value: Head | AkanMetadata | null | undefined): ResolvedHead;
+export declare function resolveHeadExport(value: Head | AkanMetadata | null | undefined, options?: {
+    includeHeadSnapshot?: boolean;
+}): ResolvedHead;
 export declare function resolveHeadResult(value: ResolveHeadResult): ResolvedHead;
 export declare function normalizeHead(value: Head | AkanMetadata | null | undefined): Head | null | undefined;

package/types/server/routeElementComposer.d.ts

@@ -1,5 +1,6 @@
 import type { Head, LayoutFallbackRoute, PathRoute, ResolvedHead, RouteRender } from "akanjs/client";
 import { type ReactElement, type ReactNode } from "react";
+import { type AkanRouteSegmentState } from "./routeState.d.ts";
 export declare class RouteElementComposer {
     #private;
     static compose({ pathRoute, params, searchParams, }: {
@@ -7,6 +8,12 @@ export declare class RouteElementComposer {
         params: Record<string, string>;
         searchParams: Record<string, string | string[]>;
     }): ReactNode;
+    static composeSuffix({ pathRoute, params, searchParams, patchStartIndex, }: {
+        pathRoute: PathRoute;
+        params: Record<string, string>;
+        searchParams: Record<string, string | string[]>;
+        patchStartIndex: number;
+    }): ReactNode | null;
     static resolveHead({ pathRoute, params, searchParams, }: {
         pathRoute: PathRoute;
         params: Record<string, string>;
@@ -26,8 +33,9 @@ export declare class RouteElementComposer {
         error?: unknown;
         digest?: string;
     }): Promise<ReactNode | null>;
-    static composeRenders({ renders, params, searchParams, }: {
+    static composeRenders({ renders, segments, params, searchParams, }: {
         renders: RouteRender[];
+        segments?: AkanRouteSegmentState[];
         params: Record<string, string>;
         searchParams: Record<string, string | string[]>;
     }): ReactNode;

package/types/server/routeState.d.ts

@@ -0,0 +1,94 @@
+import type { PathRoute } from "akanjs/client";
+export declare const AKAN_RSC_STATE_VERSION = 1;
+export declare const AKAN_RSC_STATE_VERSION_HEADER = "X-Akan-Rsc-State-Version";
+export declare const AKAN_RSC_CURRENT_ROUTE_HEADER = "X-Akan-Rsc-Current-Route";
+export declare const AKAN_RSC_CURRENT_STATE_HEADER = "X-Akan-Rsc-Current-State";
+export declare const AKAN_RSC_RESPONSE_STATE_HEADER = "X-Akan-Rsc-State";
+export declare const AKAN_RSC_PATCH_START_INDEX_HEADER = "X-Akan-Rsc-Patch-Start-Index";
+export declare const AKAN_RSC_PATCH_SEGMENT_PATH_HEADER = "X-Akan-Rsc-Patch-Segment-Path";
+export declare const AKAN_RSC_PATCH_START_SEGMENT_HEADER = "X-Akan-Rsc-Patch-Start-Segment";
+export declare const AKAN_RSC_PATCH_HEAD_SAFE_HEADER = "X-Akan-Rsc-Patch-Head-Safe";
+export declare const AKAN_RSC_PATCH_HEAD_SNAPSHOT_HEADER = "X-Akan-Rsc-Patch-Head-Snapshot";
+export declare const AKAN_RSC_HEAD_SNAPSHOT_VERSION = 1;
+export declare const AKAN_RSC_HEAD_SNAPSHOT_MAX_HEADER_BYTES: number;
+export type AkanRscPartialStatus = "full" | "candidate" | "patch" | "fallback";
+export interface AkanRouteSegmentState {
+    key: string;
+    path: string;
+    kind: "root-layout" | "layout" | "page";
+}
+export interface AkanRouterStateV1 {
+    version: typeof AKAN_RSC_STATE_VERSION;
+    buildId?: number;
+    href: string;
+    routeId: string;
+    segments: AkanRouteSegmentState[];
+}
+export type AkanHeadSnapshotTag = "title" | "meta" | "link";
+export interface AkanHeadSnapshotNode {
+    tag: AkanHeadSnapshotTag;
+    attrs?: Record<string, string>;
+    text?: string;
+}
+export interface AkanHeadSnapshotV1 {
+    version: typeof AKAN_RSC_HEAD_SNAPSHOT_VERSION;
+    nodes: AkanHeadSnapshotNode[];
+}
+export type AkanHeadSnapshotDecodeResult = {
+    status: "ok";
+    snapshot: AkanHeadSnapshotV1;
+} | {
+    status: "missing" | "invalid" | "too-large";
+};
+export interface AkanRscPartialDecision {
+    status: AkanRscPartialStatus;
+    reason?: string;
+    commonPrefixLength: number;
+}
+export interface AkanRscPatchMetadata {
+    patchStartIndex: number;
+    patchStartSegmentKey: string;
+    segmentPath: string[];
+    headSafe?: boolean;
+    headSnapshot?: AkanHeadSnapshotV1;
+    headSnapshotFailure?: "head-invalid" | "head-too-large";
+}
+export interface AkanRscPatchDecision extends AkanRscPartialDecision {
+    status: "full" | "patch" | "fallback";
+    patch?: AkanRscPatchMetadata;
+}
+export declare function isAkanHeadSnapshotV1(value: unknown): value is AkanHeadSnapshotV1;
+export declare function isAkanRouterStateV1(value: unknown): value is AkanRouterStateV1;
+export declare function encodeAkanRouterState(state: AkanRouterStateV1): string;
+export declare function encodeAkanHeadSnapshot(snapshot: AkanHeadSnapshotV1): string | null;
+export declare function decodeAkanHeadSnapshot(value: string | null | undefined): AkanHeadSnapshotDecodeResult;
+export declare function readAkanHeadSnapshotResponseHeader(headers: Headers): AkanHeadSnapshotDecodeResult;
+export declare function decodeAkanRouterState(value: string | null | undefined): AkanRouterStateV1 | null;
+export declare function appendAkanRouterStateRequestHeaders(headers: Headers, state: AkanRouterStateV1 | null | undefined): void;
+export declare function readAkanRouterStateResponseHeader(headers: Headers): AkanRouterStateV1 | null;
+export declare function encodeAkanRscPatchSegmentPath(segmentPath: string[]): string;
+export declare function decodeAkanRscPatchSegmentPath(value: string | null | undefined): string[] | null;
+export declare function readAkanRscPatchMetadataResponseHeaders(headers: Headers): AkanRscPatchMetadata | null;
+export declare function createAkanRouterState({ pathRoute, href, buildId, }: {
+    pathRoute: PathRoute;
+    href: string;
+    buildId?: number;
+}): AkanRouterStateV1;
+export declare function createAkanRouteSegments(pathRoute: PathRoute): AkanRouteSegmentState[];
+export declare function createAkanSegmentOutletKey(segmentPath: string[], segmentIndex: number): string | null;
+export declare function readAkanRouterStateRequest(headers: Headers): {
+    state: AkanRouterStateV1 | null;
+    currentRoute?: string;
+    reason?: string;
+};
+export declare function resolveAkanRscPartialDecision({ currentState, currentRoute, targetState, }: {
+    currentState: AkanRouterStateV1 | null;
+    currentRoute?: string;
+    targetState: AkanRouterStateV1;
+}): AkanRscPartialDecision;
+export declare function resolveAkanRscPatchDecision({ currentState, targetState, partialDecision, }: {
+    currentState: AkanRouterStateV1 | null;
+    targetState: AkanRouterStateV1;
+    partialDecision: AkanRscPartialDecision;
+}): AkanRscPatchDecision;
+export declare function countCommonRouteSegments(currentSegments: AkanRouteSegmentState[], targetSegments: AkanRouteSegmentState[]): number;

package/types/server/rscClient.d.ts

@@ -4,6 +4,7 @@ declare global {
     var __RSC_CLOSED__: boolean | undefined;
     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_NAVIGATE__: ((href: string, options?: {
         replace?: boolean;
         scrollToTop?: boolean;

package/types/server/rscClientFetch.d.ts

@@ -0,0 +1,24 @@
+import { type AkanRouterStateV1, type AkanRscPatchMetadata } from "./routeState.d.ts";
+type RscNavigate = (href: string, options?: {
+    replace?: boolean;
+    scrollToTop?: boolean;
+}) => Promise<void> | void;
+export type RscClientFetchResponseResult = {
+    type: "response";
+    response: Response;
+} | {
+    type: "patch";
+    response: Response;
+    patch: AkanRscPatchMetadata;
+} | {
+    type: "redirected";
+    status?: number;
+};
+export declare function fetchRscNavigationResponse(href: string, options: {
+    buildId?: number;
+    currentRouterState: AkanRouterStateV1 | null;
+    navigate?: RscNavigate;
+    sendRouterState?: boolean;
+    shouldApplyNavigation?: () => boolean;
+}): Promise<RscClientFetchResponseResult>;
+export {};

package/types/server/rscClientPatch.d.ts

@@ -0,0 +1,21 @@
+import { type AkanHeadSnapshotV1, type AkanRscPatchMetadata } from "./routeState.d.ts";
+import { type AkanSegmentCacheNode, type AkanSegmentPatchFailureReason, type AkanSegmentPatchResult } from "./rscNavigationState.d.ts";
+interface ValidateRscSegmentPatchInput<T extends PromiseLike<unknown>> {
+    href: string;
+    response: Response;
+    patch: AkanRscPatchMetadata;
+    currentTree: AkanSegmentCacheNode<T> | null;
+    createThenable: (stream: ReadableStream<Uint8Array>) => T;
+    navId?: number;
+    getCurrentNavId?: () => number;
+    getHeadSnapshotPatchFailureReason?: (snapshot: AkanHeadSnapshotV1) => AkanSegmentPatchFailureReason | null;
+}
+export declare function validateRscPatchAndRequestFullFallback<T extends PromiseLike<unknown>>({ href, response, patch, currentTree, createThenable, navId, getCurrentNavId, }: ValidateRscSegmentPatchInput<T>): Promise<{
+    sendRouterState: false;
+    patchResult: AkanSegmentPatchResult<T>;
+}>;
+export declare function validateRscSegmentPatch<T extends PromiseLike<unknown>>({ href, response, patch, currentTree, createThenable, navId, getCurrentNavId, }: ValidateRscSegmentPatchInput<T>): Promise<AkanSegmentPatchResult<T>>;
+export declare function validateRscPatchForGuardedCommit<T extends PromiseLike<unknown>>({ partialCommitEnabled, ...input }: ValidateRscSegmentPatchInput<T> & {
+    partialCommitEnabled: boolean;
+}): Promise<AkanSegmentPatchResult<T>>;
+export {};

package/types/server/rscHeadPatch.d.ts

@@ -0,0 +1,12 @@
+import type { AkanHeadSnapshotV1 } from "./routeState.d.ts";
+import type { AkanSegmentPatchFailureReason } from "./rscNavigationState.d.ts";
+export interface PreparedAkanHeadSnapshotPatch {
+    existing: HTMLElement[];
+    replacement: HTMLElement[];
+}
+export declare function getAkanHeadSnapshotPatchFailureReason(snapshot: AkanHeadSnapshotV1): Extract<AkanSegmentPatchFailureReason, "head-missing" | "head-invalid"> | null;
+export declare function canApplyAkanHeadSnapshotPatch(snapshot: AkanHeadSnapshotV1): boolean;
+export declare function prepareAkanHeadSnapshotPatch(snapshot: AkanHeadSnapshotV1): PreparedAkanHeadSnapshotPatch | null;
+export declare function commitPreparedAkanHeadSnapshotPatch(prepared: PreparedAkanHeadSnapshotPatch): boolean;
+export declare function rollbackPreparedAkanHeadSnapshotPatch(prepared: PreparedAkanHeadSnapshotPatch): void;
+export declare function applyAkanHeadSnapshotPatch(snapshot: AkanHeadSnapshotV1): boolean;

package/types/server/rscNavigationState.d.ts

@@ -1,3 +1,4 @@
+import { type AkanHeadSnapshotV1, type AkanRouterStateV1, type AkanRouteSegmentState, type AkanRscPatchMetadata } from "./routeState.d.ts";
 export interface RscNavigationCache<T> {
     get(key: string): T | undefined;
     set(key: string, value: T): void;
@@ -5,8 +6,77 @@ export interface RscNavigationCache<T> {
     keys(): IterableIterator<string>;
     readonly size: number;
 }
+export interface RscNavigationCacheNode<T> {
+    href: string;
+    thenable: T;
+    routerState: AkanRouterStateV1 | null;
+}
+export interface RscPatchNavigationCacheNode<T> {
+    href: string;
+    thenable: T;
+    routerState: AkanRouterStateV1;
+    patch: AkanRscPatchMetadata;
+    outletKey: string;
+    headSnapshot: AkanHeadSnapshotV1;
+}
+export interface AkanSegmentCacheNode<T> {
+    segment: AkanRouteSegmentState;
+    href: string;
+    routerState: AkanRouterStateV1;
+    thenable?: T;
+    children: AkanSegmentCacheNode<T>[];
+}
+export type AkanSegmentPatchFailureReason = "missing-current-tree" | "segment-path-mismatch" | "stale" | "unsupported-suffix" | "decode-error" | "guard-disabled" | "outlet-missing" | "redirect-in-patch" | "error-in-patch" | "head-unsafe" | "head-missing" | "head-invalid" | "head-too-large";
+export type AkanSegmentPatchResult<T> = {
+    status: "patched";
+    tree: AkanSegmentCacheNode<T>;
+    patchedNode: AkanSegmentCacheNode<T>;
+    outletKey: string;
+    headSnapshot?: AkanHeadSnapshotV1;
+} | {
+    status: "rejected";
+    reason: AkanSegmentPatchFailureReason;
+};
+export type RscPatchNavigationCacheResult<T> = {
+    status: "patched";
+    tree: AkanSegmentCacheNode<T>;
+    patchedNode: AkanSegmentCacheNode<T>;
+    outletKey: string;
+    headSnapshot: AkanHeadSnapshotV1;
+} | {
+    status: "rejected";
+    reason: AkanSegmentPatchFailureReason;
+};
+export declare function createRscNavigationCacheNode<T>({ href, thenable, routerState, }: RscNavigationCacheNode<T>): RscNavigationCacheNode<T>;
+export declare function createRscPatchNavigationCacheNode<T>({ href, patch, patchedNode, outletKey, headSnapshot, }: {
+    href: string;
+    patch: AkanRscPatchMetadata;
+    patchedNode: AkanSegmentCacheNode<T>;
+    outletKey: string;
+    headSnapshot: AkanHeadSnapshotV1;
+}): RscPatchNavigationCacheNode<T> | null;
+export declare function createAkanSegmentCacheTree<T>(node: RscNavigationCacheNode<T>): AkanSegmentCacheNode<T> | null;
+export declare function applyAkanSegmentCachePatch<T>({ currentTree, targetRouterState, patch, href, thenable, navId, getCurrentNavId, decodeFailed, }: {
+    currentTree: AkanSegmentCacheNode<T> | null;
+    targetRouterState: AkanRouterStateV1 | null;
+    patch: AkanRscPatchMetadata;
+    href: string;
+    thenable?: T;
+    navId?: number;
+    getCurrentNavId?: () => number;
+    decodeFailed?: boolean;
+}): AkanSegmentPatchResult<T>;
 export declare function rememberRscCacheEntry<T>(cache: RscNavigationCache<T>, href: string, thenable: T, maxEntries: number): void;
 export declare function deleteRscCacheEntryIfCurrent<T>(cache: RscNavigationCache<T>, href: string, thenable: T): boolean;
+export declare function rememberRscCacheNode<T>(cache: RscNavigationCache<RscNavigationCacheNode<T>>, node: RscNavigationCacheNode<T>, maxEntries: number): void;
+export declare function rememberRscPatchCacheNode<T>(cache: RscNavigationCache<RscPatchNavigationCacheNode<T>>, node: RscPatchNavigationCacheNode<T>, maxEntries: number): void;
+export declare function resolveCachedRscPatchNavigation<T>({ currentTree, node, partialCommitEnabled, navId, getCurrentNavId, }: {
+    currentTree: AkanSegmentCacheNode<T> | null;
+    node: RscPatchNavigationCacheNode<T>;
+    partialCommitEnabled: boolean;
+    navId?: number;
+    getCurrentNavId?: () => number;
+}): RscPatchNavigationCacheResult<T>;
 interface CommitRscNavigationInput<T> {
     cache: RscNavigationCache<T>;
     href: string;
@@ -32,4 +102,12 @@ export declare function observeRscNavigation<T extends PromiseLike<unknown>>({ c
     isExpectedNavigationError?: (error: unknown) => boolean;
     onLatestError: (error: unknown) => void;
 }): void;
+export declare function observeRscNavigationNode<T extends PromiseLike<unknown>>({ cache, node, navId, getCurrentNavId, isExpectedNavigationError, onLatestError, }: {
+    cache: RscNavigationCache<RscNavigationCacheNode<T>>;
+    node: RscNavigationCacheNode<T>;
+    navId: number;
+    getCurrentNavId: () => number;
+    isExpectedNavigationError?: (error: unknown) => boolean;
+    onLatestError: (error: unknown) => void;
+}): void;
 export {};

package/types/server/rscPartialCommit.d.ts

@@ -0,0 +1 @@
+export declare function isAkanRscPartialCommitEnabled(): boolean;

package/types/server/rscPatchSafety.d.ts

@@ -0,0 +1,8 @@
+import type { PageConfig } from "akanjs/client";
+import { type AkanHeadSnapshotV1, type AkanRscPatchDecision } from "./routeState.d.ts";
+export declare function resolveAkanRscHeadSafePatchDecision({ partialCommitEnabled, patchDecision, pageConfig, headSnapshot, }: {
+    partialCommitEnabled: boolean;
+    patchDecision: AkanRscPatchDecision;
+    pageConfig?: PageConfig;
+    headSnapshot?: AkanHeadSnapshotV1;
+}): AkanRscPatchDecision;

package/types/server/rscSegmentOutlet.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from "react";
+type RscSegmentThenable = PromiseLike<ReactNode>;
+interface RscSegmentOutletStore {
+    entries: Map<string, RscSegmentThenable>;
+    listeners: Map<string, Set<() => void>>;
+}
+declare global {
+    var __AKAN_RSC_SEGMENT_OUTLET_STORE__: RscSegmentOutletStore | undefined;
+}
+export declare function hasAkanSegmentOutlet(segmentKey: string): boolean;
+export declare function commitAkanSegmentOutletPatch(segmentKey: string, thenable: RscSegmentThenable): boolean;
+export declare function resetAkanSegmentOutletPatches(): void;
+export declare function AkanSegmentOutlet({ segmentKey, children }: {
+    segmentKey: string;
+    children: ReactNode;
+}): ReactNode;
+export {};

package/types/server/rscSegmentOutletReference.d.ts

@@ -0,0 +1,2 @@
+import type { AkanSegmentOutlet } from "./rscSegmentOutlet.d.ts";
+export declare const AkanSegmentOutletReference: typeof AkanSegmentOutlet;

package/types/server/rscWorker.d.ts

@@ -1,3 +1,8 @@
 import type { AkanNotFoundError, AkanRedirectError } from "akanjs/client";
 export declare function isAkanRedirectError(error: unknown): error is AkanRedirectError;
 export declare function isAkanNotFoundError(error: unknown): error is AkanNotFoundError;
+export declare class RscRenderer {
+    #private;
+    constructor();
+    start(): void;
+}

package/types/server/rscWorkerCache.d.ts

@@ -0,0 +1,63 @@
+import { type LruTtlCache, type RouteCacheEntry, type RouteCacheInvalidation, type RouteCacheRenderState } from "./cachePolicy.d.ts";
+import type { AkanRouterStateV1, AkanRscPatchDecision, AkanRscPatchMetadata } from "./routeState.d.ts";
+export interface CachedRscResult {
+    chunks: Uint8Array[];
+    bytes: number;
+    chunksCount: number;
+    pathname: string;
+    routeId?: string;
+    tags?: string[];
+    theme?: string;
+    cacheState: RouteCacheRenderState;
+    patch?: CachedRscPatchMetadata;
+}
+export interface CachedRscPatchMetadata {
+    targetRouterState: AkanRouterStateV1;
+    patch: AkanRscPatchMetadata;
+}
+export interface RscPatchCacheKeyInput {
+    baseEntry: RouteCacheEntry;
+    targetRouterState: AkanRouterStateV1;
+    patch: AkanRscPatchMetadata;
+}
+export declare function createRscPatchCacheKey({ baseEntry, targetRouterState, patch }: RscPatchCacheKeyInput): string;
+export declare function createRscPatchCacheEntry(input: RscPatchCacheKeyInput): RouteCacheEntry;
+export declare function isRscPatchResultCacheEligible(input: {
+    partialCommitEnabled: boolean;
+    patch?: AkanRscPatchMetadata;
+}): boolean;
+export declare function createCachedRscPatchMetadata(input: {
+    targetRouterState: AkanRouterStateV1;
+    patch: AkanRscPatchMetadata;
+}): CachedRscPatchMetadata;
+export declare function isCachedRscPatchMetadataCompatible(input: {
+    cached?: CachedRscPatchMetadata;
+    targetRouterState: AkanRouterStateV1 | null;
+    safePatchDecision: AkanRscPatchDecision;
+}): boolean;
+export declare function createRscWorkerCachedPatchReplayDecision(input: {
+    cached: CachedRscPatchMetadata;
+    safePatchDecision: AkanRscPatchDecision;
+}): AkanRscPatchDecision;
+export declare function resolveRscWorkerPatchCacheEntry(input: {
+    cacheEntry: RouteCacheEntry | null;
+    targetRouterState: AkanRouterStateV1 | null;
+    safePatchDecision: AkanRscPatchDecision;
+    partialCommitEnabled: boolean;
+}): RouteCacheEntry | null;
+export declare function shouldCollectRscWorkerRenderChunks(input: {
+    cacheEntry: RouteCacheEntry | null;
+    effectivePatchDecision: AkanRscPatchDecision;
+    patchCacheEntry: RouteCacheEntry | null;
+}): boolean;
+export declare function shouldStoreRscWorkerPatchResult(input: {
+    cacheEntry: RouteCacheEntry | null;
+    patchCacheEntry: RouteCacheEntry | null;
+    effectivePatchDecision: AkanRscPatchDecision;
+    storeTtl: number | null;
+}): boolean;
+export declare function shouldUseRscWorkerFullResultCache(input: {
+    cacheEntry: RouteCacheEntry | null;
+    patchCacheEntry: RouteCacheEntry | null;
+}): boolean;
+export declare function invalidateCachedRscResults(cache: LruTtlCache<CachedRscResult>, invalidation: RouteCacheInvalidation): void;

package/types/server/rscWorkerHost.d.ts

@@ -2,8 +2,8 @@ import { type AkanI18nConfig } from "akanjs/common";
 import type { AkanTheme } from "akanjs/fetch";
 import type { AkanMetricsReport } from "akanjs/service";
 import type { ClientManifest } from "./artifact.d.ts";
-import type { RouteCacheRenderState } from "./cachePolicy.d.ts";
-import type { SsrLateRedirect } from "./ssrTypes.d.ts";
+import type { RouteCacheInvalidation, RouteCacheRenderState } from "./cachePolicy.d.ts";
+import type { RscTraceMetadata, SsrLateRedirect } from "./ssrTypes.d.ts";
 import type { BaseBuildArtifact, CssAsset } from "./types.d.ts";
 export interface RscPending {
     onChunk: (data: Uint8Array) => void;
@@ -12,6 +12,7 @@ export interface RscPending {
     onMeta?: (meta: {
         theme?: AkanTheme;
         status?: number;
+        trace?: RscTraceMetadata;
     }) => void;
     onCacheState?: (state: RouteCacheRenderState) => void;
     onRedirect?: (location: string, method: RscRedirectMethod, status: RscRedirectStatus) => void;
@@ -23,12 +24,15 @@ export type RscRedirectStatus = 303 | 307 | 308;
 export interface RscWorkerInvalidateCacheMessage {
     type: "invalidate-cache";
     reason?: string;
+    tags?: string[];
+    paths?: string[];
 }
 export type RscRenderResult = {
     type: "stream";
     stream: ReadableStream<Uint8Array>;
     theme?: AkanTheme;
     status?: number;
+    trace?: RscTraceMetadata;
     lateControl: Promise<SsrLateRedirect | null>;
     cacheState: Promise<RouteCacheRenderState>;
     cancel: (reason?: unknown) => void;
@@ -44,7 +48,7 @@ export declare function getRscHostMaxPendingChunks(value?: string | undefined):
 export declare function nextRscHostPendingChunkCount(currentPendingChunks: number, desiredSize: number | null): number;
 export declare function isRscHostPendingChunkOverflow(pendingChunks: number, maxPendingChunks: number): boolean;
 export declare function createIdempotentRscRenderCancel(onCancel: (reason?: unknown) => void): (reason?: unknown) => void;
-export declare function createRscWorkerInvalidateCacheMessage(reason?: string): RscWorkerInvalidateCacheMessage;
+export declare function createRscWorkerInvalidateCacheMessage(invalidation?: string | RouteCacheInvalidation): RscWorkerInvalidateCacheMessage;
 export declare function createRscHostRenderStream(input: {
     setPending: (pending: RscPending) => void;
     deletePending: () => void;
@@ -102,7 +106,7 @@ export declare class RscWorker {
         clientManifest?: ClientManifest;
         signal?: AbortSignal;
     }): Promise<RscRenderResult>;
-    invalidateRouteResultCache(reason?: string): void;
+    invalidateRouteResultCache(invalidation?: string | RouteCacheInvalidation): void;
     kill(): void;
     getMetrics(): AkanMetricsReport;
     restartWhenIdle(reason: string): boolean;

package/types/server/rscWorkerReplay.d.ts

@@ -1,9 +1,11 @@
 import type { RouteCacheRenderState } from "./cachePolicy.d.ts";
+import type { RscTraceMetadata } from "./ssrTypes.d.ts";
 export type CachedRscReplayMessage = {
     type: "meta";
     requestId: string;
     theme?: string;
     status?: number;
+    trace?: RscTraceMetadata;
 } | {
     type: "cache-state";
     requestId: string;
@@ -21,6 +23,7 @@ export declare function replayCachedRscResult(input: {
     chunks: readonly Uint8Array[];
     theme?: string;
     status?: number;
+    trace?: RscTraceMetadata;
     cacheState?: RouteCacheRenderState;
     send: (message: CachedRscReplayMessage) => void;
     isCancelled: () => boolean;