akanjs 2.2.4 → 2.2.6

package/types/server/proxy/webProxyRunner.d.ts

@@ -0,0 +1,7 @@
+import { type WebProxyRegistration, type WebProxyRunResult } from "./types.d.ts";
+export declare class WebProxyRunner {
+    #private;
+    static create(registrations?: WebProxyRegistration[]): WebProxyRunner | null;
+    constructor(registrations?: WebProxyRegistration[]);
+    run(input: Request): Promise<WebProxyRunResult>;
+}

package/types/server/proxy.d.ts

@@ -0,0 +1 @@
+export * from "./proxy/index.d.ts";

package/types/server/resolver/database.resolver.d.ts

@@ -0,0 +1,6 @@
+import { type ConstantModel } from "akanjs/constant";
+import { type DatabaseInstance, type DatabaseModel } from "akanjs/document";
+import { type AdaptorCls } from "akanjs/service";
+export declare class DatabaseResolver {
+    static resolveDatabase(constant: ConstantModel, database: DatabaseModel): AdaptorCls<DatabaseInstance>;
+}

package/types/server/resolver/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./database.resolver";
+export * from "./service.resolver";
+export * from "./signal.resolver";

package/types/server/resolver/service.resolver.d.ts

@@ -0,0 +1,7 @@
+import type { ConstantModel } from "akanjs/constant";
+import { type DatabaseModel } from "akanjs/document";
+import type { ServiceCls } from "akanjs/service";
+export declare class ServiceResolver {
+    #private;
+    static resolveDatabaseService(constant: ConstantModel, database: DatabaseModel, srvRef: ServiceCls): ServiceCls;
+}

package/types/server/resolver/signal.resolver.d.ts

@@ -0,0 +1,29 @@
+import { type BaseEnv } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import { type InjectRegistry, type LiveRegistry, type WebsocketAdaptor } from "akanjs/service";
+import { type Endpoint, type EndpointCls } from "../../signal/endpoint.d.ts";
+import type { Internal, InternalCls } from "../../signal/internal.d.ts";
+import type { MiddlewareCls } from "../../signal/middleware.d.ts";
+import type { ServerSignalCls } from "../../signal/serverSignal.d.ts";
+import type { SliceCls } from "../../signal/slice.d.ts";
+import type { SignalRoutes } from "../types.d.ts";
+export declare class SignalResolver {
+    #private;
+    static logger: Logger;
+    static makeRoomId(key: string, args: unknown[]): string;
+    static setLocalPublish(localPublish: (roomId: string, data: object | object[]) => void, websocket: WebsocketAdaptor): void;
+    static resolveServerSignal(serverSignalCls: ServerSignalCls, { registry, live }: {
+        registry: InjectRegistry;
+        live: LiveRegistry;
+    }): ServerSignalCls;
+    static resolveSchedule(internalCls: InternalCls, internal: Internal, serverMode: "federation" | "batch" | "all"): void;
+    static resolveSlice(sliceCls: SliceCls): EndpointCls;
+    static resolveEndpoint(endpointCls: EndpointCls, endpoint: Endpoint, { registry, env, live, middleware, }: {
+        registry: InjectRegistry;
+        env: BaseEnv;
+        live: LiveRegistry;
+        middleware: Map<string, MiddlewareCls>;
+    }): SignalRoutes;
+    static handleWsOpen(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry): Promise<void>;
+    static handleWsClose(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry): Promise<void>;
+}

package/types/server/resolver.d.ts

@@ -0,0 +1 @@
+export * from "./resolver/index.d.ts";

package/types/server/robots.d.ts

@@ -0,0 +1 @@
+export declare function createDefaultRobotsTxt(): string;

package/types/server/routeElementComposer.d.ts

@@ -0,0 +1,41 @@
+import type { Head, LayoutFallbackRoute, PathRoute, RouteRender } from "akanjs/client";
+import { type ReactElement, type ReactNode } from "react";
+export declare class RouteElementComposer {
+    #private;
+    static compose({ pathRoute, params, searchParams, }: {
+        pathRoute: PathRoute;
+        params: Record<string, string>;
+        searchParams: Record<string, string | string[]>;
+    }): ReactNode;
+    static resolveHead({ pathRoute, params, searchParams, }: {
+        pathRoute: PathRoute;
+        params: Record<string, string>;
+        searchParams: Record<string, string | string[]>;
+    }): Promise<Head | null | undefined>;
+    static composeFallback({ kind, route, params, searchParams, pathname, error, digest, }: {
+        kind: "not-found" | "error";
+        route: PathRoute | LayoutFallbackRoute;
+        params: Record<string, string>;
+        searchParams: Record<string, string | string[]>;
+        pathname: string;
+        error?: unknown;
+        digest?: string;
+    }): Promise<ReactNode | null>;
+    static composeRenders({ renders, params, searchParams, }: {
+        renders: RouteRender[];
+        params: Record<string, string>;
+        searchParams: Record<string, string | string[]>;
+    }): ReactNode;
+    static renderAsync({ routeRender, children, params, searchParams, }: {
+        routeRender: RouteRender;
+        children: ReactNode;
+        params: Record<string, string>;
+        searchParams: Record<string, string | string[]>;
+    }): Promise<ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | (string | number | bigint | boolean | import("react").ReactPortal | ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined)>;
+    static AsyncRender: (props: {
+        routeRender: RouteRender;
+        children: ReactNode;
+        params: Record<string, string>;
+        searchParams: Record<string, string | string[]>;
+    }) => Promise<ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | (string | number | bigint | boolean | import("react").ReactPortal | ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined)>;
+}

package/types/server/routeTreeBuilder.d.ts

@@ -0,0 +1,28 @@
+import type { LayoutFallbackRoute, PageState, PathRoute, RouteModule } from "akanjs/client";
+export type PagesContext = Record<string, () => Promise<RouteModule>>;
+export declare const defaultPageState: PageState;
+export interface RouteModuleCacheStats {
+    moduleCount: number;
+    loadedModuleCount: number;
+    cacheHits: number;
+    cacheMisses: number;
+    cacheDisabled: boolean;
+    loadedModuleKeys: string[];
+}
+export declare class RouteTreeBuilder {
+    #private;
+    constructor(context: PagesContext);
+    build(): PathRoute[];
+    getFallbackRoutes(): LayoutFallbackRoute[];
+    static getCacheStats(): RouteModuleCacheStats;
+    static resetCacheStats(): void;
+    static match(pathname: string, pathRoutes: PathRoute[]): {
+        pathRoute: PathRoute;
+        params: Record<string, string>;
+    } | null;
+    static matchFallback(pathname: string, fallbackRoutes: LayoutFallbackRoute[]): {
+        fallbackRoute: LayoutFallbackRoute;
+        params: Record<string, string>;
+    } | null;
+    static parseSearchParams(search: string): Record<string, string | string[]>;
+}

package/types/server/routing/apiRouter.d.ts

@@ -0,0 +1,61 @@
+import type { Logger } from "akanjs/common";
+import type { InjectRegistry } from "akanjs/service";
+import type { HmrWsHub } from "../hmr/wsHub.d.ts";
+import { type WebProxyRunner } from "../proxy.d.ts";
+import type { HttpRoutes, SignalRouteOptions, WebsocketRoutes } from "../types.d.ts";
+/**
+ * Minimal render-state view the HMR WS hello message needs.
+ * `LazyHmrController` exposes this shape via `state.buildId` / `state.cssAssets`,
+ * so the ws handler can greet freshly-connected clients
+ * without reaching into the full controller.
+ */
+export interface HmrStateSource {
+    readonly state: {
+        buildId: number;
+        cssAssets?: Record<string, {
+            cssUrl: string;
+            cssRelPath: string;
+        }>;
+    };
+}
+export type NonNullHttpRoutes = NonNullable<HttpRoutes>;
+export interface ApiRouteInputs {
+    prefix: string;
+    websocketPrefix: string;
+    routes: HttpRoutes;
+    routeOptions?: Record<string, SignalRouteOptions>;
+    renderEnvRoutes: HttpRoutes;
+    /** Upgrades the incoming request into an app-signal WebSocket. */
+    upgradeAppWs: (req: Request, data: {
+        createdAt: number;
+    }) => boolean;
+    webProxyRunner?: WebProxyRunner | null;
+}
+export interface WebsocketHandlersInputs {
+    wsRoutes: WebsocketRoutes;
+    registry: InjectRegistry;
+    hmrHub: HmrWsHub | null;
+    hmrState: HmrStateSource | null;
+    logger: Logger;
+}
+type WsTaggedData = {
+    kind?: string;
+};
+export declare class ApiRouter {
+    #private;
+    /**
+     * Builds the full route table served by `Bun.serve`. Responsibilities:
+     *   1. Expose the WS upgrade endpoint at `<prefix><websocketPrefix>`.
+     *   2. Prefix every endpoint-generated route with `prefix`.
+     *   3. Merge render-env routes (CSR/SSR) last so they can catch-all `/*`.
+     */
+    static buildRoutes({ prefix, websocketPrefix, routes, routeOptions, renderEnvRoutes, upgradeAppWs, webProxyRunner, }: ApiRouteInputs): NonNullHttpRoutes;
+    /**
+     * Builds the `websocket` handler config for `Bun.serve`. Multiplexes two
+     * logical channels on the same upgrade port:
+     *   - `kind === "akan-hmr"` — dev HMR, delegated to `HmrWsHub`.
+     *   - everything else — app signal channel, dispatched via `wsRoutes`.
+     */
+    static buildWebsocketHandlers({ wsRoutes, registry, hmrHub, hmrState, logger, }: WebsocketHandlersInputs): Bun.WebSocketHandler<WsTaggedData>;
+}
+export {};

package/types/server/rscClient.d.ts

@@ -0,0 +1,15 @@
+declare global {
+    var __RSC_CHUNKS__: string[] | undefined;
+    var __RSC_CLOSED__: boolean | undefined;
+    var __RSC_PUSH__: ((b64: string) => void) | undefined;
+    var __RSC_CLOSE__: (() => void) | undefined;
+    var __AKAN_RSC_NAVIGATE__: ((href: string, options?: {
+        replace?: boolean;
+        scrollToTop?: boolean;
+    }) => Promise<void>) | undefined;
+    var __AKAN_RSC_REFRESH__: ((options?: {
+        buildId?: number;
+    }) => Promise<void>) | undefined;
+    var __AKAN_RSC_CLEAR_CACHE__: (() => void) | undefined;
+}
+export {};

package/types/server/rscWorker.d.ts

@@ -0,0 +1,3 @@
+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;

package/types/server/rscWorkerHost.d.ts

@@ -0,0 +1,83 @@
+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 { BaseBuildArtifact, CssAsset } from "./types.d.ts";
+export type RscRedirectMethod = "replace" | "push";
+export type RscRenderResult = {
+    type: "stream";
+    stream: ReadableStream<Uint8Array>;
+    theme?: AkanTheme;
+    status?: number;
+} | {
+    type: "redirect";
+    location: string;
+    method: RscRedirectMethod;
+} | {
+    type: "not-found";
+};
+export interface RscWorkerReloadInput {
+    clientManifest: ClientManifest;
+    cssAssets?: Record<string, CssAsset>;
+    buildId: number;
+    /**
+     * When the builder emits a freshly bundled `pages-*.js` the host forwards
+     * the new absolute path here so the worker re-imports the new bundle.
+     * Undefined means "keep using the current bundle" (e.g. client-manifest-only
+     * reload after a lazy route build).
+     */
+    pagesBundlePath?: string;
+}
+export interface RscWorkerRestartOptions {
+    /** Initial delay before the first restart attempt. Default: 200ms. */
+    baseDelayMs?: number;
+    /** Upper bound for the exponential backoff. Default: 30s. */
+    maxDelayMs?: number;
+    /**
+     * Give up after this many consecutive failed restarts. `undefined` (default)
+     * means retry forever so a short-lived supervisor outage doesn't wedge the
+     * SSR path permanently.
+     */
+    maxAttempts?: number;
+}
+export interface RscWorkerOptions {
+    clientManifest: ClientManifest;
+    /**
+     * Absolute path to the pre-built server pages bundle. Produced by
+     * `akanjs/devkit`'s `PagesBundleBuilder`; the RSC worker imports it with
+     * `await import(bundlePath?v=<buildId>)` — no runtime transforms.
+     */
+    pagesBundlePath: string;
+    /** Initial build id for the pages bundle (see `pagesBundlePath`). */
+    pagesBundleBuildId: number;
+    cssAssets?: Record<string, CssAsset>;
+    i18n?: AkanI18nConfig;
+    /** Exponential-backoff settings for automatic crash recovery. */
+    restart?: RscWorkerRestartOptions;
+}
+export declare class RscWorker {
+    #private;
+    readonly ready: Promise<void>;
+    constructor(artifact: BaseBuildArtifact);
+    render(req: Request): ReadableStream<Uint8Array>;
+    renderWithMeta(req: Request, options?: {
+        clientManifest?: ClientManifest;
+    }): Promise<RscRenderResult>;
+    kill(): void;
+    getMetrics(): AkanMetricsReport;
+    restartWhenIdle(reason: string): boolean;
+    /**
+     * Update just the CSS assets the worker inlines into rendered HTML, without
+     * re-importing any pages. Cheap enough to use for CSS-only HMR cycles so
+     * a subsequent hard refresh serves the latest hashed stylesheet.
+     */
+    updateCssAssets(cssAssets: Record<string, CssAsset>): void;
+    /**
+     * Apply a new client manifest + CSS assets and instruct the worker to re-import
+     * the pages bundle with a bumped cache-bust token. When `pagesBundlePath`
+     * is provided the worker switches to the new bundle URL too (the builder
+     * emits a fresh hashed filename on every rebundle). Resolves once the
+     * worker has acknowledged via `reloaded`.
+     */
+    reload(input: RscWorkerReloadInput): Promise<void>;
+}

package/types/server/sitemap.d.ts

@@ -0,0 +1,13 @@
+import type { AkanI18nConfig } from "akanjs/common";
+import type { RouteSeedEntry } from "./artifact.d.ts";
+export interface DefaultSitemapOptions {
+    origin: string;
+    basePath?: string | null;
+    entries: RouteSeedEntry[];
+    i18n: AkanI18nConfig;
+}
+export declare function createSitemapXml(urls: string[]): string;
+export declare function createDefaultSitemapXml({ origin, basePath, entries, i18n }: DefaultSitemapOptions): string;
+export declare function createDefaultSitemapUrls({ origin, basePath, entries, i18n }: DefaultSitemapOptions): string[];
+export declare function isSitemapPath(pathname: string, basePaths: readonly string[]): boolean;
+export declare function getSitemapBasePath(pathname: string, basePaths: readonly string[], headerBasePath?: string | null): string | null | undefined;

package/types/server/ssrFromRscRenderer.d.ts

@@ -0,0 +1,6 @@
+import type { SsrChunkRegistryStats, SsrFromRscInput } from "./ssrTypes.d.ts";
+export declare class SsrFromRscRenderer {
+    #private;
+    static getChunkRegistryStats(): SsrChunkRegistryStats;
+    render(input: SsrFromRscInput): Promise<ReadableStream<Uint8Array>>;
+}

package/types/server/ssrTypes.d.ts

@@ -0,0 +1,47 @@
+import type { AkanTheme } from "akanjs/fetch";
+export interface SsrManifestEntry {
+    id: string;
+    chunks: string[];
+    name: string;
+    async?: boolean;
+}
+export interface SsrManifest {
+    moduleLoading: {
+        prefix: string;
+        crossOrigin?: string;
+    } | null;
+    moduleMap: Record<string, Record<string, SsrManifestEntry>>;
+}
+export interface SsrChunkRegistryStats {
+    ssrChunkRegistrySize: number;
+    ssrChunkLoadCount: number;
+    ssrChunkCacheHitCount: number;
+}
+export interface SsrFromRscInput {
+    request?: Request;
+    rscStream: ReadableStream<Uint8Array>;
+    ssrManifest: SsrManifest;
+    bootstrapModules?: string[];
+    /** Extra inline JS appended to the framework's bootstrap script. The HMR
+     * dev client lives here so the browser wires up its reload channel before
+     * any application module evaluates. */
+    extraBootstrapInline?: string;
+    /**
+     * Bare specifier -> served URL mapping for the `<script type="importmap">`
+     * the HTML stream should prepend to `<head>`. Used so per-route client
+     * chunks (which externalize `react`, `react-dom/client`, ...) resolve
+     * those specifiers to the base build's vendor entries at load time,
+     * guaranteeing one React instance across rscClient and every route
+     * chunk.
+     *
+     * Injection happens via a stream transform, not React children, because
+     * React Fizz hoists `<link rel="modulepreload">` (generated from
+     * `bootstrapModules`) to the top of `<head>`, which would otherwise sit
+     * before any importmap rendered via JSX. The spec is strict: import maps
+     * must be acquired before any module script fetch starts, including
+     * modulepreload.
+     */
+    importmap?: Record<string, string>;
+    theme?: AkanTheme;
+    injectThemeInitScript?: boolean;
+}

package/types/server/systemPages.d.ts

@@ -0,0 +1,27 @@
+import type { AkanI18nConfig } from "akanjs/common";
+import type { ReactNode } from "react";
+export type SystemPageKind = "not-found" | "error";
+export interface SystemPageOptions {
+    kind: SystemPageKind;
+    pathname: string;
+    homeHref: string;
+    lang?: string;
+    stylesheetHref?: string | null;
+    showDetails?: boolean;
+    error?: unknown;
+}
+export interface SystemPageResponseOptions extends SystemPageOptions {
+    method?: string;
+}
+export interface SystemPageHomeHrefOptions {
+    pathname: string;
+    i18n?: AkanI18nConfig;
+    basePaths?: Iterable<string>;
+    headerBasePath?: string | null;
+}
+export declare function createSystemPageDocument(options: SystemPageOptions): ReactNode;
+export declare function createSystemPageResponse(options: SystemPageResponseOptions): Promise<Response>;
+export declare function createSystemPageHeaders(): Headers;
+export declare function createSystemPageFallbackText(kind: SystemPageKind): string;
+export declare function getSystemPageErrorDetails(error: unknown): string;
+export declare function getSystemPageHomeHref({ pathname, i18n, basePaths, headerBasePath, }: SystemPageHomeHrefOptions): string;

package/types/server/types/react-server-dom-webpack.d.ts

@@ -0,0 +1,91 @@
+
+
+declare module "react-server-dom-webpack/server.node" {
+  export interface ClientReferenceManifestEntry {
+    id: string;
+    chunks: string[];
+    name: string;
+    async?: boolean;
+  }
+
+  export type ClientManifest = Record<string, ClientReferenceManifestEntry>;
+
+  export function renderToReadableStream(
+    model: unknown,
+    clientManifest?: ClientManifest,
+    options?: {
+      environmentName?: string;
+      filterStackFrame?: (url: string, functionName: string) => boolean;
+      onError?: (error: unknown) => string | undefined;
+      onPostpone?: (reason: string) => void;
+      identifierPrefix?: string;
+      temporaryReferences?: unknown;
+      signal?: AbortSignal;
+    },
+  ): Promise<ReadableStream<Uint8Array>>;
+
+  export function registerClientReference<T>(proxyImplementation: T, id: string, exportName: string): T;
+
+  export function registerServerReference<T>(reference: T, id: string, exportName: string | null): T;
+
+  export function decodeReply<T = unknown>(
+    body: string | FormData,
+    webpackMap?: unknown,
+    options?: { temporaryReferences?: unknown },
+  ): Promise<T>;
+}
+
+declare module "react-server-dom-webpack/client.node" {
+  import type { ReactNode } from "react";
+
+  export interface SSRManifestEntry {
+    id: string;
+    chunks: string[];
+    name: string;
+    async?: boolean;
+  }
+
+  export interface SSRManifest {
+    moduleLoading: { prefix: string; crossOrigin?: string } | null;
+    moduleMap: Record<string, Record<string, SSRManifestEntry>>;
+  }
+
+  export function createFromNodeStream<T = ReactNode>(
+    stream: NodeJS.ReadableStream,
+    ssrManifest: SSRManifest,
+    options?: {
+      nonce?: string;
+      encodeFormAction?: unknown;
+      temporaryReferences?: unknown;
+      findSourceMapURL?: (fileName: string) => string | null;
+      replayConsoleLogs?: boolean;
+      environmentName?: string;
+    },
+  ): PromiseLike<T>;
+}
+
+declare module "react-server-dom-webpack/client.browser" {
+  import type { ReactNode } from "react";
+
+  interface ClientOptions {
+    serverConsumerManifest?: unknown;
+    nonce?: string;
+    encodeFormAction?: unknown;
+    temporaryReferences?: unknown;
+    findSourceMapURL?: (fileName: string) => string | null;
+    replayConsoleLogs?: boolean;
+    environmentName?: string;
+  }
+
+  export function createFromReadableStream<T = ReactNode>(
+    stream: ReadableStream<Uint8Array>,
+    options?: ClientOptions,
+  ): PromiseLike<T>;
+
+  export function createFromFetch<T = ReactNode>(response: Promise<Response>, options?: ClientOptions): PromiseLike<T>;
+
+  export function encodeReply(
+    value: unknown,
+    options?: { temporaryReferences?: unknown; signal?: AbortSignal },
+  ): Promise<string | FormData>;
+}

package/types/server/types.d.ts

@@ -0,0 +1,67 @@
+import type { PromiseOrObject } from "akanjs/base";
+import type { AkanI18nConfig } from "akanjs/common";
+export type WebsocketRoute = (ws: Bun.ServerWebSocket<unknown>, data: unknown[], event?: "message" | "subscribe" | "unsubscribe") => PromiseOrObject<unknown>;
+export type WebsocketRoutes = Record<string, WebsocketRoute>;
+export type HttpRoutes = Bun.Serve.Options<unknown>["routes"];
+export interface SignalRouteOptions {
+    globalPrefix?: false;
+}
+export type SignalRoutes = {
+    routes: HttpRoutes;
+    wsRoutes: WebsocketRoutes;
+    routeOptions?: Record<string, SignalRouteOptions>;
+};
+export interface LocalFile {
+    filename: string;
+    mimetype: string;
+    encoding: string;
+    localPath: string;
+}
+export type AkanImageFormat = "image/avif" | "image/webp";
+export interface AkanImagePattern {
+    protocol?: "http" | "https";
+    hostname?: string;
+    port?: string;
+    pathname?: string;
+    search?: string;
+}
+export interface AkanImageConfig {
+    deviceSizes: number[];
+    imageSizes: number[];
+    formats: AkanImageFormat[];
+    qualities: number[];
+    minimumCacheTTL: number;
+    remotePatterns: AkanImagePattern[];
+    localPatterns: Pick<AkanImagePattern, "pathname" | "search">[];
+    dangerouslyAllowSVG: boolean;
+    maximumRedirects: number;
+    fetchTimeoutMs: number;
+    maxRemoteBytes: number;
+}
+export declare const defaultAkanImageConfig: AkanImageConfig;
+export declare function mergeAkanImageConfig(config?: Partial<AkanImageConfig>): AkanImageConfig;
+export declare function getAkanImageWidths(config: Pick<AkanImageConfig, "deviceSizes" | "imageSizes">): number[];
+export type BaseBuildArtifact = {
+    rscClientUrl: string;
+    vendorMap: Record<string, string>;
+    pagesBundlePath: string;
+    pagesBundleBuildId: number;
+    cssAssets: Record<string, CssAsset>;
+    domains: string[];
+    subRoutes: {
+        [key: string]: string[];
+    };
+    basePaths: string[];
+    branches: string[];
+    i18n: AkanI18nConfig;
+    imageConfig: AkanImageConfig;
+};
+export interface CssAsset {
+    cssUrl: string;
+    cssRelPath: string;
+}
+export interface RenderState {
+    buildId: number;
+    cssAssets: Record<string, CssAsset>;
+    cssBytesByUrl: Record<string, Uint8Array>;
+}

package/types/server/vendor/akanjs-base.d.ts

@@ -0,0 +1 @@
+export * from "akanjs/base";

package/types/server/vendor/akanjs-common.d.ts

@@ -0,0 +1 @@
+export * from "akanjs/common";

package/types/server/vendor/akanjs-constant.d.ts

@@ -0,0 +1 @@
+export * from "akanjs/constant";

package/types/server/vendor/akanjs-store.d.ts

@@ -0,0 +1 @@
+export * from "akanjs/store";

package/types/server/vendor/react-dom-client.d.ts

@@ -0,0 +1,3 @@
+import * as m from "react-dom/client";
+export default m;
+export declare const createRoot: typeof m.createRoot, hydrateRoot: typeof m.hydrateRoot, version: any;

package/types/server/vendor/react-dom.d.ts

@@ -0,0 +1,3 @@
+import * as m from "react-dom";
+export default m;
+export declare const __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE: any, createPortal: typeof m.createPortal, flushSync: typeof m.flushSync, preconnect: typeof m.preconnect, prefetchDNS: typeof m.prefetchDNS, preinit: typeof m.preinit, preinitModule: typeof m.preinitModule, preload: typeof m.preload, preloadModule: typeof m.preloadModule, requestFormReset: typeof m.requestFormReset, unstable_batchedUpdates: typeof m.unstable_batchedUpdates, useFormState: typeof m.useFormState, useFormStatus: typeof m.useFormStatus, version: string;

package/types/server/vendor/react-jsx-dev-runtime.d.ts

@@ -0,0 +1,3 @@
+import * as m from "react/jsx-dev-runtime";
+export default m;
+export declare const Fragment: import("react").ExoticComponent<import("react").FragmentProps>, jsxDEV: typeof m.jsxDEV;

package/types/server/vendor/react-jsx-runtime.d.ts

@@ -0,0 +1,3 @@
+import * as m from "react/jsx-runtime";
+export default m;
+export declare const Fragment: import("react").ExoticComponent<import("react").FragmentProps>, jsx: typeof m.jsx, jsxs: typeof m.jsxs;

package/types/server/vendor/react-refresh-runtime.d.ts

@@ -0,0 +1,3 @@
+import * as m from "react-refresh/runtime";
+export default m;
+export declare const injectIntoGlobalHook: any, performReactRefresh: any, register: any, createSignatureFunctionForTransform: any;

package/types/server/vendor/react-server-dom-webpack-client-browser.d.ts

@@ -0,0 +1,3 @@
+import * as m from "react-server-dom-webpack/client.browser";
+export default m;
+export declare const createFromFetch: typeof m.createFromFetch, createFromReadableStream: typeof m.createFromReadableStream, createServerReference: any, createTemporaryReferenceSet: any, encodeReply: typeof m.encodeReply, registerServerReference: any;

package/types/server/vendor/react.d.ts

@@ -0,0 +1,11 @@
+import * as m from "react";
+export default m;
+export declare const Activity: m.ExoticComponent<m.ActivityProps>, Children: {
+    map<T, C>(children: C | readonly C[], fn: (child: C, index: number) => T): C extends null | undefined ? C : Array<Exclude<T, boolean | null | undefined>>;
+    forEach<C>(children: C | readonly C[], fn: (child: C, index: number) => void): void;
+    count(children: any): number;
+    only<C>(children: C): C extends any[] ? never : C;
+    toArray(children: m.ReactNode | m.ReactNode[]): Array<Exclude<m.ReactNode, boolean | null | undefined>>;
+}, Component: typeof m.Component, Fragment: m.ExoticComponent<m.FragmentProps>, Profiler: m.ExoticComponent<m.ProfilerProps>, PureComponent: typeof m.PureComponent, StrictMode: m.ExoticComponent<{
+    children?: m.ReactNode | undefined;
+}>, Suspense: m.ExoticComponent<m.SuspenseProps>, __CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE: any, __COMPILER_RUNTIME: any, act: typeof m.act, cache: typeof m.cache, cacheSignal: typeof m.cacheSignal, captureOwnerStack: typeof m.captureOwnerStack, cloneElement: typeof m.cloneElement, createContext: typeof m.createContext, createElement: typeof m.createElement, createRef: typeof m.createRef, forwardRef: typeof m.forwardRef, isValidElement: typeof m.isValidElement, lazy: typeof m.lazy, memo: typeof m.memo, startTransition: typeof m.startTransition, unstable_useCacheRefresh: any, use: typeof m.use, useActionState: typeof m.useActionState, useCallback: typeof m.useCallback, useContext: typeof m.useContext, useDebugValue: typeof m.useDebugValue, useDeferredValue: typeof m.useDeferredValue, useEffect: typeof m.useEffect, useEffectEvent: typeof m.useEffectEvent, useId: typeof m.useId, useImperativeHandle: typeof m.useImperativeHandle, useInsertionEffect: typeof m.useInsertionEffect, useLayoutEffect: typeof m.useLayoutEffect, useMemo: typeof m.useMemo, useOptimistic: typeof m.useOptimistic, useReducer: typeof m.useReducer, useRef: typeof m.useRef, useState: typeof m.useState, useSyncExternalStore: typeof m.useSyncExternalStore, useTransition: typeof m.useTransition, version: string;

package/types/server/vendor/scheduler.d.ts

@@ -0,0 +1,3 @@
+import * as m from "scheduler";
+export default m;
+export declare const unstable_IdlePriority: any, unstable_ImmediatePriority: any, unstable_LowPriority: any, unstable_NormalPriority: any, unstable_Profiling: any, unstable_UserBlockingPriority: any, unstable_cancelCallback: any, unstable_forceFrameRate: any, unstable_getCurrentPriorityLevel: any, unstable_next: any, unstable_now: any, unstable_requestPaint: any, unstable_runWithPriority: any, unstable_scheduleCallback: any, unstable_shouldYield: any, unstable_wrapCallback: any;