akanjs 2.3.0 → 2.3.1-rc.1

package/server/rscClientPatch.ts

@@ -0,0 +1,157 @@
+import { type AkanHeadSnapshotV1, type AkanRscPatchMetadata, readAkanRouterStateResponseHeader } from "./routeState";
+import { getRscPayloadStream } from "./rscHttp";
+import {
+  type AkanSegmentCacheNode,
+  type AkanSegmentPatchFailureReason,
+  type AkanSegmentPatchResult,
+  applyAkanSegmentCachePatch,
+} from "./rscNavigationState";
+import { hasAkanSegmentOutlet } from "./rscSegmentOutlet";
+
+const RSC_PATCH_REDIRECT_ROW_RE = /^[0-9a-z]+:E\{[^\n]*"digest":"AKAN_REDIRECT(?:;[^"]*)?"[^\n]*\}\n?$/;
+const RSC_PATCH_ERROR_ROW_RE = /^[0-9a-z]+:E\{[^\n]*\}\n?$/;
+
+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;
+}
+
+function guardRscPatchControlRows(
+  stream: ReadableStream<Uint8Array>,
+  onControl: (reason: Extract<AkanSegmentPatchFailureReason, "redirect-in-patch" | "error-in-patch">) => void,
+): ReadableStream<Uint8Array> {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let buffered = new Uint8Array(new ArrayBuffer(0));
+
+  const concat = (left: Uint8Array, right: Uint8Array): Uint8Array<ArrayBuffer> => {
+    const combined = new Uint8Array(new ArrayBuffer(left.byteLength + right.byteLength));
+    combined.set(left, 0);
+    combined.set(right, left.byteLength);
+    return combined;
+  };
+  const inspectRow = (row: Uint8Array): void => {
+    try {
+      const text = decoder.decode(row);
+      if (RSC_PATCH_REDIRECT_ROW_RE.test(text)) onControl("redirect-in-patch");
+      else if (RSC_PATCH_ERROR_ROW_RE.test(text)) onControl("error-in-patch");
+    } catch {
+    }
+  };
+
+  return stream.pipeThrough(
+    new TransformStream<Uint8Array, Uint8Array>({
+      transform(chunk, controller) {
+        buffered = concat(buffered, chunk);
+        let rowStart = 0;
+        for (let index = 0; index < buffered.byteLength; index += 1) {
+          if (buffered[index] !== 10) continue;
+          const row = buffered.slice(rowStart, index + 1);
+          inspectRow(row);
+          controller.enqueue(row);
+          rowStart = index + 1;
+        }
+        buffered = rowStart === 0 ? buffered : buffered.slice(rowStart);
+      },
+      flush(controller) {
+        if (buffered.byteLength === 0) return;
+        inspectRow(buffered);
+        controller.enqueue(buffered);
+        buffered = new Uint8Array(new ArrayBuffer(0));
+      },
+    }),
+  );
+}
+
+export async function validateRscPatchAndRequestFullFallback<T extends PromiseLike<unknown>>({
+  href,
+  response,
+  patch,
+  currentTree,
+  createThenable,
+  navId,
+  getCurrentNavId,
+}: ValidateRscSegmentPatchInput<T>): Promise<{
+  sendRouterState: false;
+  patchResult: AkanSegmentPatchResult<T>;
+}> {
+  const patchResult = await validateRscSegmentPatch({
+    href,
+    response,
+    patch,
+    currentTree,
+    createThenable,
+    navId,
+    getCurrentNavId,
+  });
+  return {
+    sendRouterState: false,
+    patchResult,
+  };
+}
+
+export async function validateRscSegmentPatch<T extends PromiseLike<unknown>>({
+  href,
+  response,
+  patch,
+  currentTree,
+  createThenable,
+  navId,
+  getCurrentNavId,
+}: ValidateRscSegmentPatchInput<T>): Promise<AkanSegmentPatchResult<T>> {
+  const patchStream = getRscPayloadStream(response);
+  let patchControlReason: Extract<AkanSegmentPatchFailureReason, "redirect-in-patch" | "error-in-patch"> | undefined;
+  const guardedPatchStream = patchStream
+    ? guardRscPatchControlRows(patchStream, (reason) => {
+        patchControlReason ??= reason;
+      })
+    : null;
+  const patchThenable = guardedPatchStream ? createThenable(guardedPatchStream) : undefined;
+  let decodeFailed = !patchThenable;
+
+  if (patchThenable) {
+    try {
+      await patchThenable;
+    } catch {
+      decodeFailed = true;
+    }
+  }
+
+  if (patchControlReason) return { status: "rejected", reason: patchControlReason };
+
+  return applyAkanSegmentCachePatch({
+    currentTree,
+    targetRouterState: readAkanRouterStateResponseHeader(response.headers),
+    patch,
+    href,
+    thenable: patchThenable,
+    navId,
+    getCurrentNavId,
+    decodeFailed,
+  });
+}
+
+export async function validateRscPatchForGuardedCommit<T extends PromiseLike<unknown>>({
+  partialCommitEnabled,
+  ...input
+}: ValidateRscSegmentPatchInput<T> & {
+  partialCommitEnabled: boolean;
+}): Promise<AkanSegmentPatchResult<T>> {
+  const patchResult = await validateRscSegmentPatch(input);
+  if (patchResult.status === "rejected" && patchResult.reason !== "missing-current-tree") return patchResult;
+  if (!partialCommitEnabled) return { status: "rejected", reason: "guard-disabled" };
+  if (input.patch.headSafe !== true) return { status: "rejected", reason: "head-unsafe" };
+  if (input.patch.headSnapshotFailure) return { status: "rejected", reason: input.patch.headSnapshotFailure };
+  if (!input.patch.headSnapshot) return { status: "rejected", reason: "head-missing" };
+  const headPatchFailureReason = input.getHeadSnapshotPatchFailureReason?.(input.patch.headSnapshot);
+  if (headPatchFailureReason) return { status: "rejected", reason: headPatchFailureReason };
+  if (patchResult.status === "rejected") return patchResult;
+  if (!patchResult.patchedNode.thenable) return { status: "rejected", reason: "decode-error" };
+  if (!hasAkanSegmentOutlet(patchResult.outletKey)) return { status: "rejected", reason: "outlet-missing" };
+  return { ...patchResult, headSnapshot: input.patch.headSnapshot };
+}

package/server/rscHeadPatch.ts

@@ -0,0 +1,80 @@
+import type { AkanHeadSnapshotNode, AkanHeadSnapshotV1 } from "./routeState";
+import type { AkanSegmentPatchFailureReason } from "./rscNavigationState";
+
+const AKAN_ROUTE_HEAD_SELECTOR = '[data-akan-head="route"]';
+
+export interface PreparedAkanHeadSnapshotPatch {
+  existing: HTMLElement[];
+  replacement: HTMLElement[];
+}
+
+function createHeadElement(node: AkanHeadSnapshotNode, index: number): HTMLElement {
+  const element = document.createElement(node.tag);
+  element.setAttribute("data-akan-head", "route");
+  element.setAttribute("data-akan-head-key", `${node.tag}:${index}`);
+  for (const [key, value] of Object.entries(node.attrs ?? {})) {
+    element.setAttribute(key, value);
+  }
+  if (node.tag === "title") element.textContent = node.text ?? "";
+  return element;
+}
+
+export function getAkanHeadSnapshotPatchFailureReason(
+  snapshot: AkanHeadSnapshotV1,
+): Extract<AkanSegmentPatchFailureReason, "head-missing" | "head-invalid"> | null {
+  if (typeof document === "undefined" || !document.head) return "head-invalid";
+  const existing = document.head.querySelector(AKAN_ROUTE_HEAD_SELECTOR);
+  if (!existing) return "head-missing";
+  if (!Array.isArray(snapshot.nodes)) return "head-invalid";
+  return null;
+}
+
+export function canApplyAkanHeadSnapshotPatch(snapshot: AkanHeadSnapshotV1): boolean {
+  return getAkanHeadSnapshotPatchFailureReason(snapshot) === null;
+}
+
+export function prepareAkanHeadSnapshotPatch(snapshot: AkanHeadSnapshotV1): PreparedAkanHeadSnapshotPatch | null {
+  try {
+    if (getAkanHeadSnapshotPatchFailureReason(snapshot)) return null;
+    const existing = [...document.head.querySelectorAll<HTMLElement>(AKAN_ROUTE_HEAD_SELECTOR)];
+    if (!existing[0]) return null;
+    return {
+      existing,
+      replacement: snapshot.nodes.map((node, index) => createHeadElement(node, index)),
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function commitPreparedAkanHeadSnapshotPatch(prepared: PreparedAkanHeadSnapshotPatch): boolean {
+  try {
+    const anchor = prepared.existing[0];
+    if (!anchor) return false;
+    const fragment = document.createDocumentFragment();
+    for (const node of prepared.replacement) fragment.appendChild(node);
+    document.head.insertBefore(fragment, anchor);
+    for (const node of prepared.existing) node.remove();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function rollbackPreparedAkanHeadSnapshotPatch(prepared: PreparedAkanHeadSnapshotPatch): void {
+  try {
+    const anchor = prepared.replacement.find((node) => node.parentNode === document.head) ?? null;
+    if (anchor) {
+      const fragment = document.createDocumentFragment();
+      for (const node of prepared.existing) fragment.appendChild(node);
+      document.head.insertBefore(fragment, anchor);
+    }
+    for (const node of prepared.replacement) node.remove();
+  } catch {
+  }
+}
+
+export function applyAkanHeadSnapshotPatch(snapshot: AkanHeadSnapshotV1): boolean {
+  const prepared = prepareAkanHeadSnapshotPatch(snapshot);
+  return prepared ? commitPreparedAkanHeadSnapshotPatch(prepared) : false;
+}

package/server/rscNavigationState.ts

@@ -1,3 +1,11 @@
+import {
+  type AkanHeadSnapshotV1,
+  type AkanRouterStateV1,
+  type AkanRouteSegmentState,
+  type AkanRscPatchMetadata,
+  createAkanSegmentOutletKey,
+} from "./routeState";
+
 export interface RscNavigationCache<T> {
   get(key: string): T | undefined;
   set(key: string, value: T): void;
@@ -6,6 +14,190 @@ export interface RscNavigationCache<T> {
   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 function createRscNavigationCacheNode<T>({
+  href,
+  thenable,
+  routerState,
+}: RscNavigationCacheNode<T>): RscNavigationCacheNode<T> {
+  return { href, thenable, routerState };
+}
+
+export function createRscPatchNavigationCacheNode<T>({
+  href,
+  patch,
+  patchedNode,
+  outletKey,
+  headSnapshot,
+}: {
+  href: string;
+  patch: AkanRscPatchMetadata;
+  patchedNode: AkanSegmentCacheNode<T>;
+  outletKey: string;
+  headSnapshot: AkanHeadSnapshotV1;
+}): RscPatchNavigationCacheNode<T> | null {
+  if (!patchedNode.thenable) return null;
+  return {
+    href,
+    thenable: patchedNode.thenable,
+    routerState: patchedNode.routerState,
+    patch,
+    outletKey,
+    headSnapshot,
+  };
+}
+
+export function createAkanSegmentCacheTree<T>(node: RscNavigationCacheNode<T>): AkanSegmentCacheNode<T> | null {
+  const routerState = node.routerState;
+  if (!routerState || routerState.segments.length === 0) return null;
+
+  const root = createAkanSegmentCacheNode<T>({
+    segment: routerState.segments[0],
+    href: node.href,
+    routerState,
+  });
+  let current = root;
+  for (let index = 1; index < routerState.segments.length; index++) {
+    const child = createAkanSegmentCacheNode<T>({
+      segment: routerState.segments[index],
+      href: node.href,
+      routerState,
+    });
+    current.children.push(child);
+    current = child;
+  }
+  current.thenable = node.thenable;
+  return root;
+}
+
+export 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> {
+  if (decodeFailed) return { status: "rejected", reason: "decode-error" };
+  if (navId !== undefined && getCurrentNavId && navId !== getCurrentNavId()) {
+    return { status: "rejected", reason: "stale" };
+  }
+  if (!currentTree || !targetRouterState) {
+    return { status: "rejected", reason: "missing-current-tree" };
+  }
+  if (!isSupportedSinglePagePatch(targetRouterState, patch)) {
+    return { status: "rejected", reason: "unsupported-suffix" };
+  }
+
+  const targetPatchPath = targetRouterState.segments.slice(0, patch.patchStartIndex + 1).map((segment) => segment.key);
+  const expectedPatchPath = patch.segmentPath.slice(0, patch.patchStartIndex + 1);
+  if (
+    targetPatchPath.length !== expectedPatchPath.length ||
+    targetPatchPath.some((segmentKey, index) => segmentKey !== expectedPatchPath[index])
+  ) {
+    return { status: "rejected", reason: "segment-path-mismatch" };
+  }
+
+  const currentPrefix = flattenAkanSegmentCacheTree(currentTree, patch.patchStartIndex);
+  const expectedPrefix = patch.segmentPath.slice(0, patch.patchStartIndex);
+  if (
+    currentPrefix.length !== expectedPrefix.length ||
+    currentPrefix.some((node, index) => node.segment.key !== expectedPrefix[index])
+  ) {
+    return { status: "rejected", reason: "segment-path-mismatch" };
+  }
+
+  const patchedTree = cloneAkanSegmentCacheTree(currentTree);
+  const parent = getAkanSegmentCacheNodeAt(patchedTree, patch.patchStartIndex - 1);
+  if (!parent) return { status: "rejected", reason: "segment-path-mismatch" };
+
+  const patchedSegment = targetRouterState.segments[patch.patchStartIndex];
+  const outletKey = createAkanSegmentOutletKey(patch.segmentPath, patch.patchStartIndex);
+  if (!outletKey) return { status: "rejected", reason: "unsupported-suffix" };
+  const patchedNode = createAkanSegmentCacheNode({
+    segment: patchedSegment,
+    href,
+    routerState: targetRouterState,
+    thenable,
+  });
+  parent.children = [patchedNode];
+  return { status: "patched", tree: patchedTree, patchedNode, outletKey };
+}
+
 export function rememberRscCacheEntry<T>(
   cache: RscNavigationCache<T>,
   href: string,
@@ -26,6 +218,107 @@ export function deleteRscCacheEntryIfCurrent<T>(cache: RscNavigationCache<T>, hr
   return cache.delete(href);
 }
 
+export function rememberRscCacheNode<T>(
+  cache: RscNavigationCache<RscNavigationCacheNode<T>>,
+  node: RscNavigationCacheNode<T>,
+  maxEntries: number,
+): void {
+  rememberRscCacheEntry(cache, node.href, node, maxEntries);
+}
+
+export function rememberRscPatchCacheNode<T>(
+  cache: RscNavigationCache<RscPatchNavigationCacheNode<T>>,
+  node: RscPatchNavigationCacheNode<T>,
+  maxEntries: number,
+): void {
+  rememberRscCacheEntry(cache, node.href, node, maxEntries);
+}
+
+export function resolveCachedRscPatchNavigation<T>({
+  currentTree,
+  node,
+  partialCommitEnabled,
+  navId,
+  getCurrentNavId,
+}: {
+  currentTree: AkanSegmentCacheNode<T> | null;
+  node: RscPatchNavigationCacheNode<T>;
+  partialCommitEnabled: boolean;
+  navId?: number;
+  getCurrentNavId?: () => number;
+}): RscPatchNavigationCacheResult<T> {
+  if (!partialCommitEnabled) return { status: "rejected", reason: "guard-disabled" };
+  const patchResult = applyAkanSegmentCachePatch({
+    currentTree,
+    targetRouterState: node.routerState,
+    patch: node.patch,
+    href: node.href,
+    thenable: node.thenable,
+    navId,
+    getCurrentNavId,
+  });
+  if (patchResult.status === "rejected") return patchResult;
+  if (patchResult.outletKey !== node.outletKey) return { status: "rejected", reason: "segment-path-mismatch" };
+  return { ...patchResult, headSnapshot: node.headSnapshot };
+}
+
+function createAkanSegmentCacheNode<T>({
+  segment,
+  href,
+  routerState,
+  thenable,
+}: {
+  segment: AkanRouteSegmentState;
+  href: string;
+  routerState: AkanRouterStateV1;
+  thenable?: T;
+}): AkanSegmentCacheNode<T> {
+  return {
+    segment,
+    href,
+    routerState,
+    thenable,
+    children: [],
+  };
+}
+
+function flattenAkanSegmentCacheTree<T>(
+  tree: AkanSegmentCacheNode<T>,
+  limit = Number.POSITIVE_INFINITY,
+): AkanSegmentCacheNode<T>[] {
+  const nodes: AkanSegmentCacheNode<T>[] = [];
+  let current: AkanSegmentCacheNode<T> | undefined = tree;
+  while (current && nodes.length < limit) {
+    nodes.push(current);
+    current = current.children[0];
+  }
+  return nodes;
+}
+
+function getAkanSegmentCacheNodeAt<T>(tree: AkanSegmentCacheNode<T>, index: number): AkanSegmentCacheNode<T> | null {
+  if (index < 0) return null;
+  return flattenAkanSegmentCacheTree(tree, index + 1)[index] ?? null;
+}
+
+function cloneAkanSegmentCacheTree<T>(tree: AkanSegmentCacheNode<T>): AkanSegmentCacheNode<T> {
+  return {
+    segment: tree.segment,
+    href: tree.href,
+    routerState: tree.routerState,
+    thenable: tree.thenable,
+    children: tree.children.map(cloneAkanSegmentCacheTree),
+  };
+}
+
+function isSupportedSinglePagePatch(targetRouterState: AkanRouterStateV1, patch: AkanRscPatchMetadata): boolean {
+  const targetSuffix = targetRouterState.segments.slice(patch.patchStartIndex);
+  if (targetSuffix.length !== 1 || targetSuffix[0]?.kind !== "page") return false;
+  if (patch.segmentPath.length !== targetRouterState.segments.length) return false;
+  if (patch.segmentPath[patch.patchStartIndex] !== patch.patchStartSegmentKey) return false;
+  const patchStartSegment = targetRouterState.segments[patch.patchStartIndex];
+  return patchStartSegment?.key === patch.patchStartSegmentKey;
+}
+
 interface CommitRscNavigationInput<T> {
   cache: RscNavigationCache<T>;
   href: string;
@@ -93,3 +386,25 @@ export function observeRscNavigation<T extends PromiseLike<unknown>>({
     if (navId === getCurrentNavId()) onLatestError(error);
   });
 }
+
+export 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 {
+  void Promise.resolve(node.thenable).catch((error) => {
+    deleteRscCacheEntryIfCurrent(cache, node.href, node);
+    if (isExpectedNavigationError?.(error)) return;
+    if (navId === getCurrentNavId()) onLatestError(error);
+  });
+}

package/server/rscPartialCommit.ts

@@ -0,0 +1,3 @@
+export function isAkanRscPartialCommitEnabled(): boolean {
+  return process.env.AKAN_PUBLIC_RSC_PARTIAL_COMMIT === "1";
+}

package/server/rscPatchSafety.ts

@@ -0,0 +1,57 @@
+import type { PageConfig } from "akanjs/client";
+import {
+  type AkanHeadSnapshotV1,
+  type AkanRscPatchDecision,
+  encodeAkanHeadSnapshot,
+  isAkanHeadSnapshotV1,
+} from "./routeState";
+
+export function resolveAkanRscHeadSafePatchDecision({
+  partialCommitEnabled,
+  patchDecision,
+  pageConfig,
+  headSnapshot,
+}: {
+  partialCommitEnabled: boolean;
+  patchDecision: AkanRscPatchDecision;
+  pageConfig?: PageConfig;
+  headSnapshot?: AkanHeadSnapshotV1;
+}): AkanRscPatchDecision {
+  if (!partialCommitEnabled || patchDecision.status !== "patch" || !patchDecision.patch) return patchDecision;
+  if (pageConfig?.rscPatchHeadSafe !== true) {
+    return {
+      status: "full",
+      reason: "head-unsafe",
+      commonPrefixLength: patchDecision.commonPrefixLength,
+    };
+  }
+  if (!headSnapshot) {
+    return {
+      status: "full",
+      reason: "head-missing",
+      commonPrefixLength: patchDecision.commonPrefixLength,
+    };
+  }
+  if (!isAkanHeadSnapshotV1(headSnapshot)) {
+    return {
+      status: "full",
+      reason: "head-invalid",
+      commonPrefixLength: patchDecision.commonPrefixLength,
+    };
+  }
+  if (!encodeAkanHeadSnapshot(headSnapshot)) {
+    return {
+      status: "full",
+      reason: "head-too-large",
+      commonPrefixLength: patchDecision.commonPrefixLength,
+    };
+  }
+  return {
+    ...patchDecision,
+    patch: {
+      ...patchDecision.patch,
+      headSafe: true,
+      headSnapshot,
+    },
+  };
+}

package/server/rscSegmentOutlet.tsx

@@ -0,0 +1,69 @@
+"use client";
+
+import { type ReactNode, use, useSyncExternalStore } 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;
+}
+
+function getStore(): RscSegmentOutletStore {
+  globalThis.__AKAN_RSC_SEGMENT_OUTLET_STORE__ ??= {
+    entries: new Map(),
+    listeners: new Map(),
+  };
+  return globalThis.__AKAN_RSC_SEGMENT_OUTLET_STORE__;
+}
+
+function subscribeSegment(segmentKey: string, listener: () => void): () => void {
+  const store = getStore();
+  let listeners = store.listeners.get(segmentKey);
+  if (!listeners) {
+    listeners = new Set();
+    store.listeners.set(segmentKey, listeners);
+  }
+  listeners.add(listener);
+  return () => {
+    listeners?.delete(listener);
+    if (listeners?.size === 0) store.listeners.delete(segmentKey);
+  };
+}
+
+function getSegmentThenable(segmentKey: string): RscSegmentThenable | null {
+  return getStore().entries.get(segmentKey) ?? null;
+}
+
+export function hasAkanSegmentOutlet(segmentKey: string): boolean {
+  return Boolean(getStore().listeners.get(segmentKey)?.size);
+}
+
+export function commitAkanSegmentOutletPatch(segmentKey: string, thenable: RscSegmentThenable): boolean {
+  if (!hasAkanSegmentOutlet(segmentKey)) return false;
+  const store = getStore();
+  store.entries.set(segmentKey, thenable);
+  for (const listener of store.listeners.get(segmentKey) ?? []) listener();
+  return true;
+}
+
+export function resetAkanSegmentOutletPatches(): void {
+  const store = getStore();
+  store.entries.clear();
+  for (const listeners of store.listeners.values()) {
+    for (const listener of listeners) listener();
+  }
+}
+
+export function AkanSegmentOutlet({ segmentKey, children }: { segmentKey: string; children: ReactNode }): ReactNode {
+  const patchedThenable = useSyncExternalStore(
+    (listener) => subscribeSegment(segmentKey, listener),
+    () => getSegmentThenable(segmentKey),
+    () => null,
+  );
+  return patchedThenable ? use(patchedThenable) : children;
+}