akanjs 2.2.4 → 2.2.5

package/types/fetch/fetchType/buildFetch.type.d.ts

@@ -0,0 +1,11 @@
+import type { Assign } from "akanjs/base";
+import type { DatabaseSignal, ServiceSignal } from "akanjs/signal";
+import type { FetchProxy } from "../client.d.ts";
+import type { GetFetchTypeFromEndpoint } from "./endpointFetch.type";
+import type { GetFetchTypeFromSlice } from "./sliceFetch.type";
+type GetFetchType<Signal extends FetchProxy<any> | DatabaseSignal<any, any, any, any> | ServiceSignal<any, any, any>> = Signal extends FetchProxy<infer FetchType> ? FetchType : Signal extends DatabaseSignal<any, infer EndpCls, infer SlceCls, any> ? GetFetchTypeFromEndpoint<EndpCls> & GetFetchTypeFromSlice<SlceCls> : Signal extends ServiceSignal<any, infer EndpCls, any> ? GetFetchTypeFromEndpoint<EndpCls> : unknown;
+export type MergeAllFetchTypes<Signals extends (FetchProxy<any> | DatabaseSignal<any, any, any, any> | ServiceSignal<any, any, any>)[], Acc = unknown> = Signals extends [
+    infer First extends FetchProxy<any> | DatabaseSignal<any, any, any, any> | ServiceSignal<any, any, any>,
+    ...infer Rest extends (FetchProxy<any> | DatabaseSignal<any, any, any, any> | ServiceSignal<any, any, any>)[]
+] ? MergeAllFetchTypes<Rest, Assign<Acc, GetFetchType<First>>> : Acc;
+export {};

package/types/fetch/fetchType/clientSignal.type.d.ts

@@ -0,0 +1,16 @@
+import type { ConstantModel } from "akanjs/constant";
+import type { SerializedSignal, SerializedSlice, SliceCls } from "akanjs/signal";
+import type { FetchProxy } from "../client.d.ts";
+export type ClientSlice = {
+    refName: string;
+    sliceName: string;
+    serializedSlice: SerializedSlice;
+};
+export type ClientSignal<RefName extends string = string, SlceCls extends SliceCls = SliceCls, Cnst extends ConstantModel = ConstantModel> = {
+    refName: RefName;
+    _slice: SlceCls;
+    cnst: Cnst;
+    fetch: FetchProxy<any>;
+    slices: ClientSlice[];
+    serializedSignal: SerializedSignal;
+};

package/types/fetch/fetchType/endpointFetch.type.d.ts

@@ -0,0 +1,29 @@
+import type { ENDPOINT_META, PromiseOrObject } from "akanjs/base";
+import type { FetchPolicy } from "akanjs/common";
+import type { EndpointCls, EndpointInfo } from "akanjs/signal";
+type EndpInfoType<E> = E extends EndpointInfo<infer T, any, any, any, any, any, any, any, any, any> ? T : never;
+type EndpInfoArgs<E> = E extends EndpointInfo<any, any, any, infer A, any, any, any, any, any, any> ? A : never;
+type EndpInfoReturns<E> = E extends EndpointInfo<any, any, any, any, any, any, any, infer R, any, infer N> ? R | (N extends true ? null : never) : never;
+type QueryOrMutationFetchFn<E> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => Promise<EndpInfoReturns<E>>;
+type MessageEmitFn<E> = (...args: EndpInfoArgs<E>) => EndpInfoReturns<E>;
+type MessageListenFn<E> = (handleEvent: (data: EndpInfoReturns<E>) => PromiseOrObject<void>, options?: FetchPolicy) => () => void;
+type PubsubSubscribeFn<E> = (...args: [...EndpInfoArgs<E>, handleEvent: (data: EndpInfoReturns<E>) => PromiseOrObject<void>, options?: FetchPolicy]) => () => void;
+type PrimaryFetchType<EInfoObj extends {
+    [key: string]: EndpointInfo;
+}> = {
+    [K in keyof EInfoObj as EndpInfoType<EInfoObj[K]> extends "query" | "mutation" | "message" ? K : never]: EndpInfoType<EInfoObj[K]> extends "query" | "mutation" ? QueryOrMutationFetchFn<EInfoObj[K]> : EndpInfoType<EInfoObj[K]> extends "message" ? MessageEmitFn<EInfoObj[K]> : never;
+};
+type PubsubFetchType<EInfoObj extends {
+    [key: string]: EndpointInfo;
+}> = {
+    [K in keyof EInfoObj as EndpInfoType<EInfoObj[K]> extends "pubsub" ? K extends string ? `subscribe${Capitalize<K>}` : never : never]: PubsubSubscribeFn<EInfoObj[K]>;
+};
+type MessageListenFetchType<EInfoObj extends {
+    [key: string]: EndpointInfo;
+}> = {
+    [K in keyof EInfoObj as EndpInfoType<EInfoObj[K]> extends "message" ? K extends string ? `listen${Capitalize<K>}` : never : never]: MessageListenFn<EInfoObj[K]>;
+};
+export type GetFetchTypeFromEndpoint<EndpCls extends EndpointCls, _EndpointInfoObj extends {
+    [key: string]: EndpointInfo;
+} = EndpCls[typeof ENDPOINT_META]> = PrimaryFetchType<_EndpointInfoObj> & PubsubFetchType<_EndpointInfoObj> & MessageListenFetchType<_EndpointInfoObj>;
+export {};

package/types/fetch/fetchType/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./appliedReturn.type";
+export * from "./buildFetch.type";
+export * from "./clientSignal.type";
+export * from "./endpointFetch.type";
+export * from "./sliceFetch.type";

package/types/fetch/fetchType/sliceFetch.type.d.ts

@@ -0,0 +1,76 @@
+import type { GetStateObject, SLICE_META } from "akanjs/base";
+import type { FetchPolicy } from "akanjs/common";
+import type { ConstantModel, DefaultOf, ProtoFile, PurifiedModel } from "akanjs/constant";
+import type { DatabaseModel, ExtractSort, FilterInstance } from "akanjs/document";
+import type { SliceCls, SliceInfoArgs } from "akanjs/signal";
+import type { ClientEdit, ClientInit, ClientView, EditReturn, InitReturn, ViewReturn } from "./appliedReturn.type";
+type _SliceMap<S extends SliceCls> = S[typeof SLICE_META];
+type _RefName<S extends SliceCls> = S["srv"]["cnst"]["refName"];
+type _Cap<S extends SliceCls> = S["srv"]["cnst"]["_CapitalizedRefName"];
+type _Input<S extends SliceCls> = S["srv"]["cnst"]["_Input"];
+type _Full<S extends SliceCls> = S["srv"]["cnst"]["_Full"];
+type _Light<S extends SliceCls> = S["srv"]["cnst"]["_Light"];
+type _Insight<S extends SliceCls> = S["srv"]["cnst"]["_Insight"];
+type _PurifiedInput<S extends SliceCls> = S["srv"]["cnst"]["_PurifiedInput"];
+type _DefaultInput<S extends SliceCls> = S["srv"]["cnst"]["_DefaultInput"];
+type _Filter<S extends SliceCls> = S["srv"]["db"]["_Filter"];
+type _Sort<S extends SliceCls> = S["srv"]["db"]["_Sort"];
+type _LightWithId<S extends SliceCls> = _Light<S> extends {
+    id: string;
+} ? _Light<S> : {
+    id: string;
+};
+type _SliceFetchInitOption<S extends SliceCls> = FetchInitOption<_Input<S>, _Filter<S>, _DefaultInput<S>, _Sort<S>>;
+type SliceListFetch<S extends SliceCls> = {
+    [Suffix in keyof _SliceMap<S> as Suffix extends string ? `${_RefName<S>}List${Capitalize<Suffix>}` : never]: (...args: [
+        ...SliceInfoArgs<_SliceMap<S>[Suffix]>,
+        skip?: number | null,
+        limit?: number | null,
+        sort?: _Sort<S> | null,
+        fetchPolicy?: FetchPolicy
+    ]) => Promise<_Light<S>[]>;
+};
+type SliceInsightFetch<S extends SliceCls> = {
+    [Suffix in keyof _SliceMap<S> as Suffix extends string ? `${_RefName<S>}Insight${Capitalize<Suffix>}` : never]: (...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, fetchPolicy?: FetchPolicy]) => Promise<_Insight<S>>;
+};
+type SliceInitFetch<S extends SliceCls> = {
+    [Suffix in keyof _SliceMap<S> as Suffix extends string ? `init${_Cap<S>}${Capitalize<Suffix>}` : never]: (...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, option?: _SliceFetchInitOption<S>]) => Promise<InitReturn<_RefName<S>, Suffix & string, _Light<S>, _Insight<S>, SliceInfoArgs<_SliceMap<S>[Suffix]>, _Filter<S>, _Cap<S>, Suffix extends string ? Capitalize<Suffix> : never, _LightWithId<S>, GetStateObject<_LightWithId<S>>, GetStateObject<_Insight<S>>, _Sort<S>>>;
+};
+type SliceGetInitFetch<S extends SliceCls> = {
+    [Suffix in keyof _SliceMap<S> as Suffix extends string ? `get${_Cap<S>}Init${Capitalize<Suffix>}` : never]: (...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, option?: _SliceFetchInitOption<S>]) => ClientInit<_RefName<S>, _Light<S>, _Insight<S>, SliceInfoArgs<_SliceMap<S>[Suffix]>, _Filter<S>, _Cap<S>, GetStateObject<_LightWithId<S>>, GetStateObject<_Insight<S>>, _Sort<S>>;
+};
+export type GetFetchTypeFromSlice<SlceCls extends SliceCls> = SlceCls["srv"]["cnst"] extends ConstantModel ? SlceCls["srv"]["db"] extends DatabaseModel ? SliceListFetch<SlceCls> & SliceInsightFetch<SlceCls> & SliceInitFetch<SlceCls> & SliceGetInitFetch<SlceCls> & RawBaseSliceFetchType<_RefName<SlceCls>, _Input<SlceCls>, _Full<SlceCls>, _Light<SlceCls>, _Cap<SlceCls>, _PurifiedInput<SlceCls>> & AppliedBaseSliceFetchType<_RefName<SlceCls>, _Input<SlceCls>, _Full<SlceCls>, _Cap<SlceCls>, _PurifiedInput<SlceCls>> : never : never;
+type RawBaseSliceFetchType<RefName extends string, Input, Full, Light, _CapitalizedRefName extends string = Capitalize<RefName>, _PurifiedInput = PurifiedModel<Input>> = {
+    [K in RefName]: (id: string, fetchPolicy?: FetchPolicy) => Promise<Full>;
+} & {
+    [K in `light${_CapitalizedRefName}`]: (id: string, fetchPolicy?: FetchPolicy) => Promise<Light>;
+} & {
+    [K in `create${_CapitalizedRefName}`]: (input: _PurifiedInput, fetchPolicy?: FetchPolicy) => Promise<Full>;
+} & {
+    [K in `update${_CapitalizedRefName}`]: (id: string, input: _PurifiedInput, fetchPolicy?: FetchPolicy) => Promise<Full>;
+} & {
+    [K in `remove${_CapitalizedRefName}`]: (id: string, fetchPolicy?: FetchPolicy) => Promise<void>;
+};
+type AppliedBaseSliceFetchType<RefName extends string, Input, Full, _CapitalizedRefName extends string = Capitalize<RefName>, _PurifiedInput = PurifiedModel<Input>> = {
+    [K in `view${_CapitalizedRefName}`]: (id: string, option?: FetchPolicy) => Promise<ViewReturn<RefName, Full>>;
+} & {
+    [K in `get${_CapitalizedRefName}View`]: (id: string, option?: FetchPolicy) => ClientView<RefName, Full>;
+} & {
+    [K in `edit${_CapitalizedRefName}`]: (id: string, option?: FetchPolicy) => Promise<EditReturn<RefName, Full>>;
+} & {
+    [K in `get${_CapitalizedRefName}Edit`]: (id: string, option?: FetchPolicy) => ClientEdit<RefName, Full>;
+} & {
+    [K in `add${_CapitalizedRefName}Files`]: (fileList: FileList, parentId?: string, option?: FetchPolicy) => Promise<ProtoFile[]>;
+} & {
+    [K in `merge${_CapitalizedRefName}`]: (modelOrId: Full | string, data: Partial<_PurifiedInput>, option?: FetchPolicy) => Promise<Full>;
+};
+export interface FetchInitForm<Input, Filter extends FilterInstance, _DefaultInput = DefaultOf<Input>, _Sort = ExtractSort<Filter>> {
+    page?: number;
+    limit?: number;
+    sort?: _Sort;
+    default?: Partial<_DefaultInput>;
+    invalidate?: boolean;
+    insight?: boolean;
+}
+type FetchInitOption<Input, Filter extends FilterInstance, _DefaultInput = DefaultOf<Input>, _Sort = ExtractSort<Filter>> = FetchPolicy & FetchInitForm<Input, Filter, _DefaultInput, _Sort>;
+export {};

package/types/fetch/fetchType.d.ts

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

package/types/fetch/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./client.d.ts";
+export * from "./fetchType.d.ts";
+export * from "./requestStorage.d.ts";
+export * from "./types.d.ts";

package/types/fetch/requestStorage.d.ts

@@ -0,0 +1,29 @@
+export interface RequestStorage {
+    run<T>(store: Request, callback: () => T): T;
+    getStore(): Request | undefined;
+}
+export type AkanTheme = "css" | "system" | (string & {});
+declare global {
+    var __AKAN_REQUEST_STORAGE__: RequestStorage | undefined;
+    var __AKAN_REQUEST_THEME__: WeakMap<Request, AkanTheme> | undefined;
+    var __AKAN_REQUEST_QUERY_CACHE__: WeakMap<Request, Map<string, Promise<unknown>>> | undefined;
+    var __AKAN_REQUEST_FALLBACK_STACK__: Request[] | undefined;
+}
+export declare const requestStorage: RequestStorage | null;
+/** Stores theme preference on the active request when server rendering. */
+export declare function setRequestTheme(theme: AkanTheme | undefined): void;
+export declare function getRequestTheme(): AkanTheme | undefined;
+export declare function pushRequestFallback(req: Request): () => void;
+/** Returns the active server request from AsyncLocalStorage or the fallback stack. */
+export declare function getRequest(): Request | undefined;
+/** Deduplicates a promise-producing query within the active request. */
+export declare function memoizeRequestQuery<T>(key: string, factory: () => Promise<T>): Promise<T>;
+/** Returns current request headers as a Map, or an empty Map outside a request. */
+export declare function headers(): Map<string, string>;
+export interface CookieEntry {
+    name: string;
+    value: string;
+}
+export declare function parseCookieHeader(cookieHeader: string): Map<string, CookieEntry>;
+/** Returns parsed cookies from the current request, or an empty Map outside a request. */
+export declare function cookies(): Map<string, CookieEntry>;

package/types/fetch/serializer/fetch.serializer.d.ts

@@ -0,0 +1,14 @@
+import { Logger } from "akanjs/common";
+import type { LiveRegistry } from "akanjs/service";
+import type { EndpointCls, SerializedSignal, SliceCls } from "akanjs/signal";
+export declare class FetchSerializer {
+    #private;
+    static logger: Logger;
+    static serializeDatabaseSignal(sliceCls: SliceCls, endpointCls: EndpointCls): SerializedSignal;
+    static serializeServiceSignal(endpointCls: EndpointCls): SerializedSignal;
+    static serializeRegistry({ endpointCls, sliceCls }: LiveRegistry): {
+        signal: {
+            [key: string]: SerializedSignal;
+        };
+    };
+}

package/types/fetch/serializer/index.d.ts

@@ -0,0 +1 @@
+export * from "./fetch.serializer";

package/types/fetch/serializer.d.ts

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

package/types/fetch/types.d.ts

@@ -0,0 +1,19 @@
+import { type Environment, type SLICE_META } from "akanjs/base";
+import type { DatabaseSignal } from "akanjs/signal";
+import type { SliceMeta } from "./fetchType/appliedReturn.type";
+/** Account data made available to services for the current app/environment. */
+export type Account<AddData = unknown> = {
+    appName: string;
+    environment: Environment;
+} & AddData;
+export declare const getDefaultAccount: () => Account;
+type GetSliceNameFromSignal<Signal> = Signal extends DatabaseSignal<any, any, any, any> ? `${Signal["slice"]["baseName"]}${Capitalize<keyof Signal["slice"][typeof SLICE_META] & string>}` : Signal extends {
+    slice: {
+        [K in infer Key]: SliceMeta;
+    };
+} ? Key : never;
+type GetSliceNamesFromSignals<Signals> = Signals extends [infer First, ...infer Rest] ? Rest extends [] ? GetSliceNameFromSignal<First> : GetSliceNamesFromSignals<Rest> | GetSliceNameFromSignal<First> : never;
+export type GetSliceMetaObjFromDatabaseSignals<Signals extends unknown[]> = {
+    [K in GetSliceNamesFromSignals<Signals>]: SliceMeta;
+};
+export {};

package/types/fetch.d.ts

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

package/types/index.d.ts

@@ -0,0 +1,213 @@
+import type { AkanI18nConfig } from "akanjs/common";
+import type { AkanImageConfig } from "akanjs/server";
+export declare const archs: readonly ["amd64", "arm64"];
+export type Arch = (typeof archs)[number];
+export interface DockerConfig {
+    content: string;
+    image: string | {
+        [key in Arch]?: string;
+    };
+    preRuns: (string | {
+        [key in Arch]?: string;
+    })[];
+    postRuns: (string | {
+        [key in Arch]?: string;
+    })[];
+    command: string[];
+}
+export interface AkanRouteDomains {
+    main?: string[];
+    develop?: string[];
+    debug?: string[];
+    [branch: string]: string[] | undefined;
+}
+export interface AkanRouteConfig {
+    basePath?: string;
+    domains: AkanRouteDomains;
+}
+export type DatabaseMode = "single" | "multiple" | "cluster";
+export type MobileEnv = "local" | "debug" | "develop" | "main";
+export type MobilePermission = "camera" | "contacts" | "location" | "push";
+export interface AkanMobileTargetAssets {
+    icon?: string;
+    splash?: string;
+}
+export interface AkanMobileTargetLinks {
+    schemes?: string[];
+    associatedDomains?: string[];
+    androidHosts?: string[];
+}
+export interface AkanMobileTargetFiles {
+    ios?: Record<string, string>;
+    android?: Record<string, string>;
+}
+export interface AkanCapacitorLikeConfig {
+    plugins?: Record<string, unknown>;
+    android?: Record<string, unknown>;
+    ios?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface AkanMobileTargetConfig extends AkanCapacitorLikeConfig {
+    name: string;
+    basePath?: string;
+    appName: string;
+    appId: string;
+    version: string;
+    buildNum: number;
+    assets?: AkanMobileTargetAssets;
+    permissions?: MobilePermission[];
+    links?: AkanMobileTargetLinks;
+    files?: AkanMobileTargetFiles;
+}
+export interface AkanMobileConfig extends AkanCapacitorLikeConfig {
+    appName: string;
+    appId: string;
+    version: string;
+    buildNum: number;
+    targets: Record<string, AkanMobileTargetConfig>;
+}
+export interface AppConfigResult {
+    docker: DockerConfig;
+    defaultDatabaseMode: DatabaseMode;
+    routes?: AkanRouteConfig[];
+    externalLibs: string[];
+    barrelImports: string[];
+    optimizeImports: string[];
+    images: AkanImageConfig;
+    i18n: AkanI18nConfig;
+    publicEnv: string[];
+    mobile: AkanMobileConfig;
+}
+export interface LibConfigResult {
+    externalLibs: string[];
+}
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends unknown[] ? T[P] : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export interface AppConfigContext {
+    readonly name: string;
+    readonly type: "app";
+}
+export interface LibConfigContext {
+    readonly name: string;
+    readonly type: "lib";
+}
+export type AppConfig = DeepPartial<AppConfigResult> | ((app: AppConfigContext) => DeepPartial<AppConfigResult>);
+export type LibConfig = DeepPartial<LibConfigResult> | ((lib: LibConfigContext) => DeepPartial<LibConfigResult>);
+export type AkanConfigFile = object;
+export interface FileConventionScanResult {
+    constant: {
+        databases: string[];
+        scalars: string[];
+    };
+    dictionary: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+    document: {
+        databases: string[];
+        scalars: string[];
+    };
+    service: {
+        databases: string[];
+        services: string[];
+    };
+    signal: {
+        databases: string[];
+        services: string[];
+    };
+    store: {
+        databases: string[];
+        services: string[];
+    };
+    template: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+    unit: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+    util: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+    view: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+    zone: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+}
+export interface ScanResult {
+    name: string;
+    type: "app" | "lib";
+    repoName: string;
+    serveDomain: string;
+    files: FileConventionScanResult;
+    libDeps: string[];
+    pkgDeps: string[];
+    dependencies: string[];
+    devDependencies: string[];
+}
+export interface AppScanResult extends ScanResult {
+    akanConfig: AppConfigResult;
+    routes: string[];
+}
+export interface LibScanResult extends ScanResult {
+    akanConfig: LibConfigResult;
+}
+export interface PkgScanResult {
+    name: string;
+    pkgDeps: string[];
+    dependencies: string[];
+}
+export interface WorkspaceScanResult {
+    appNames: string[];
+    libNames: string[];
+    pkgNames: string[];
+    apps: {
+        [key: string]: AppScanResult;
+    };
+    libs: {
+        [key: string]: LibScanResult;
+    };
+    pkgs: {
+        [key: string]: PkgScanResult;
+    };
+}
+export interface AppInfo {
+    readonly name: string;
+    readonly type: "app";
+    readonly database: Map<string, Set<string>>;
+    readonly service: Map<string, Set<string>>;
+    readonly scalar: Map<string, Set<string>>;
+    readonly file: FileConventionScanResult;
+    getLibs(): string[];
+    getLibInfos(): Map<string, LibInfo>;
+    getDatabaseModules(): string[];
+    getScalarModules(): string[];
+    getServiceModules(): string[];
+}
+export interface LibInfo {
+    readonly name: string;
+    readonly type: "lib";
+    readonly database: Map<string, Set<string>>;
+    readonly service: Map<string, Set<string>>;
+    readonly scalar: Map<string, Set<string>>;
+    readonly file: FileConventionScanResult;
+    getLibs(): string[];
+    getLibInfos(): Map<string, LibInfo>;
+    getLibInfo(libName: string): LibInfo | undefined;
+    getDatabaseModules(): string[];
+    getScalarModules(): string[];
+    getServiceModules(): string[];
+}

package/types/server/akanApp.d.ts

@@ -0,0 +1,17 @@
+import { Logger } from "akanjs/common";
+/** Options for the Akan gateway that launches child server replicas and listens for traffic. */
+export interface AkanAppOptions {
+    replica?: number | string;
+    serverPath?: string;
+    runtimeDir?: string;
+    port?: number;
+    wsBasePort?: number;
+}
+/** Gateway/orchestrator that starts Akan child servers and proxies HTTP/WebSocket traffic. */
+export declare class AkanApp {
+    #private;
+    readonly logger: Logger;
+    constructor(serverPath?: string, options?: AkanAppOptions);
+    start(): Promise<void>;
+    stop(signal?: string): Promise<void>;
+}

package/types/server/akanAppHeaders.d.ts

@@ -0,0 +1 @@
+export declare function makeAkanChildProxyHeaders(req: Request, childIdx: number): Headers;

package/types/server/akanLib.d.ts

@@ -0,0 +1,33 @@
+import type { ConstantModel, ScalarConstantModel } from "akanjs/constant";
+import type { DatabaseCls, DatabaseModel } from "akanjs/document";
+import type { ServiceModel } from "akanjs/service";
+import type { DatabaseSignal, ServiceSignal } from "akanjs/signal";
+import type { AkanOption } from "./akanOption.d.ts";
+export interface DatabaseModule {
+    constant: ConstantModel;
+    database: DatabaseModel;
+    service: ServiceModel;
+    signal: DatabaseSignal;
+}
+export interface ServiceModule {
+    service: ServiceModel;
+    signal: ServiceSignal;
+}
+export interface ScalarModule {
+    constant: ScalarConstantModel;
+    database: DatabaseCls;
+}
+export interface AkanLibProps {
+    databases: DatabaseModule[];
+    services: ServiceModule[];
+    scalars: ScalarModule[];
+    option: AkanOption<any>;
+}
+export declare class AkanLib {
+    readonly name: string;
+    readonly database: DatabaseModule[];
+    readonly service: ServiceModule[];
+    readonly scalar: ScalarModule[];
+    readonly option: AkanOption<any>;
+    constructor(name: string, props: AkanLibProps);
+}

package/types/server/akanOption.d.ts

@@ -0,0 +1,15 @@
+import type { BaseEnv, PromiseOrObject } from "akanjs/base";
+import type { MiddlewareCls } from "akanjs/signal";
+import type { WebProxyRegistration } from "./proxy.d.ts";
+/** App/library server option builder for use objects, signal middleware, and web proxies. */
+export declare class AkanOption<Env extends BaseEnv = BaseEnv> {
+    #private;
+    constructor();
+    use(fnOrObject: ((env: Env) => Record<string, PromiseOrObject<unknown>>) | Record<string, PromiseOrObject<unknown>>): this;
+    applyMiddleware(...middlewares: MiddlewareCls[]): this;
+    applyWebProxy(...proxies: WebProxyRegistration[]): this;
+    getUses(env: Env): Record<string, PromiseOrObject<unknown>>;
+    getMiddlewares(): MiddlewareCls[];
+    getWebProxies(): WebProxyRegistration[];
+}
+export declare function createDefaultAkanOption(): AkanOption<BaseEnv>;

package/types/server/akanServer.d.ts

@@ -0,0 +1,47 @@
+import { type BaseEnv } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import type { Adaptor, AdaptorCls, DatabaseConfig, Service, ServiceCls, SolidConfig } from "akanjs/service";
+import type { ServerSignal, ServerSignalCls } from "akanjs/signal";
+import type { AkanLib, AkanLibProps } from "./akanLib.d.ts";
+export interface AkanServerProps extends AkanLibProps {
+    env?: BaseEnv;
+    prefix?: string;
+    websocketPrefix?: string;
+}
+export declare class AkanServer {
+    #private;
+    status: "stopped" | "initializing" | "initialized" | "starting" | "running" | "stopping";
+    readonly logger: Logger;
+    readonly name: string;
+    readonly libs: AkanLib[];
+    readonly env: BaseEnv & {
+        database?: DatabaseConfig;
+        solid?: SolidConfig;
+    };
+    prefix: string;
+    websocketPrefix: string;
+    serverMode: "federation" | "batch" | "all";
+    shutdownTimeoutMs: number;
+    constructor(name?: string, env?: BaseEnv, serverMode?: "federation" | "batch" | "all", ...libs: AkanLib[]);
+    setPrefix(prefix: string): this;
+    setWebsocketPrefix(websocketPrefix: string): this;
+    setDatabaseConfig(database: DatabaseConfig): this;
+    setSolidConfig(solid: SolidConfig): this;
+    setShutdownTimeout(timeoutMs: number): this;
+    get<Srv extends ServiceCls>(cls: Srv): InstanceType<Srv>;
+    get<Sig extends ServerSignalCls>(cls: Sig): InstanceType<Sig>;
+    get<Adp extends AdaptorCls>(cls: Adp): InstanceType<Adp>;
+    getService<T = Service>(refName: string): T;
+    getSignal<T = ServerSignal>(refName: string): T;
+    getAdaptor<T = Adaptor>(refName: string): T;
+    init({ routes: initRoutes, web }?: {
+        routes?: boolean;
+        web?: boolean;
+    }): Promise<this>;
+    listen(): Promise<this>;
+    start({ listen, web }?: {
+        listen?: boolean;
+        web?: boolean;
+    }): Promise<this>;
+    stop(): Promise<void>;
+}

package/types/server/artifact/builderRpc.d.ts

@@ -0,0 +1,42 @@
+import type { CssPayload, PagesBundlePayload } from "./ipcTypes.d.ts";
+import type { BuildRouteClientResult } from "./manifestTypes.d.ts";
+export interface BuilderRpcEventHandlers {
+    /**
+     * Filesystem batch invalidation from the builder's watcher. The backend
+     * should treat this as a hint to clear its route cache and broadcast a
+     * dev reload to connected HMR clients.
+     */
+    onInvalidate?: (event: {
+        kinds: ("code" | "css" | "config")[];
+        files: string[];
+        generation?: number;
+    }) => void;
+    /** Builder proactively recompiled CSS; payload includes base64 bytes. */
+    onCssUpdated?: (css: CssPayload) => void;
+    /**
+     * Builder emitted a freshly bundled `pages-*.js`. Backend should
+     * re-import it (e.g. by calling `RscWorker.reload({ pagesBundlePath,
+     * buildId })`) so new user code takes effect without spawning a new
+     * worker subprocess.
+     */
+    onPagesUpdated?: (bundle: PagesBundlePayload) => void;
+}
+/**
+ * Typed RPC facade around the raw `BuilderTransport`. Handles the
+ * correlation-id bookkeeping (request promise + resolver map) and exposes
+ * a narrow surface matching the three builder operations.
+ *
+ * Only one `BuilderRpc` instance should exist per backend process. It
+ * subscribes to the transport at construction and unsubscribes on
+ * `dispose()`.
+ */
+export declare class BuilderRpc {
+    #private;
+    constructor(handlers?: BuilderRpcEventHandlers);
+    buildRoute(routeId: string, { seeds, knownEntries, generation }: {
+        seeds: string[];
+        knownEntries: Set<string>;
+        generation?: number;
+    }): Promise<BuildRouteClientResult>;
+    dispose(): void;
+}

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

@@ -0,0 +1,6 @@
+export * from "./builderRpc.d.ts";
+export * from "./ipcTypes.d.ts";
+export * from "./manifestTypes.d.ts";
+export * from "./routeClientCache.d.ts";
+export * from "./routeSeedIndexStore.d.ts";
+export * from "./routesManifestStore.d.ts";