akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/types/server/oauth/OAuthErrors.d.ts

@@ -10,20 +10,11 @@ export declare class OAuthErrors {
         readonly "cache-control": "no-store";
         readonly pragma: "no-cache";
     };
-    /**
-     * RFC 6749 §5.2. `invalid_client` is 401, and when the client authenticated with the `Authorization` header the
-     * answer names that scheme back — the one case the RFC requires a `WWW-Authenticate` on a token response.
-     */
     static token(error: OAuthTokenErrorCode, description: string, { method }?: {
         method?: OAuthClientCredential["method"];
     }): Response;
     /** RFC 7591 §3.2.2. */
     static registration(error: OAuthRegistrationErrorCode, description: string): Response;
-    /**
-     * An authorization error that travels back through the redirect URI (RFC 6749 §4.1.2.1) — legal only once that
-     * URI has been matched against the client's registration, which is why `OAuthAuthorize` answers the client and
-     * redirect checks with a page instead.
-     */
     static redirect(redirectUri: string, { error, description, state, iss }: OAuthRedirectParams & {
         error: OAuthAuthorizeErrorCode;
         description?: string;
@@ -31,10 +22,6 @@ export declare class OAuthErrors {
     static redirectWithCode(redirectUri: string, { code, state, iss }: OAuthRedirectParams & {
         code: string;
     }): Response;
-    /**
-     * The answer when nothing may be redirected to: an unknown client or an unregistered redirect URI, where the
-     * destination the request named is the one thing that cannot be trusted with the user (RFC 6749 §4.1.2.1).
-     */
     static page(status: number, title: string, detail: string): Response;
 }
 export {};

package/types/server/oauth/OAuthMetadata.d.ts

@@ -5,17 +5,11 @@ export interface OAuthMetadataProps {
     registrationEndpoint?: string;
     revocationEndpoint?: string;
     scopesSupported?: string[];
-    /** Whether a `client_id` that is an HTTPS URL is read as a metadata document. Advertised as true unless a deployment turned it off. */
+    /** Whether an HTTPS `client_id` is read as a metadata document; defaults to `true`. */
     clientIdMetadataDocumentSupported?: boolean;
 }
 export declare class OAuthMetadata {
     static readonly wellKnownSuffix = "/.well-known/oauth-authorization-server";
-    /**
-     * The RFC 8414 document. Three fixed fields are load-bearing for MCP clients: `code_challenge_methods_supported`
-     * (a client MUST refuse to proceed without it), `client_id_metadata_document_supported` (the registration path the
-     * spec prefers), and `authorization_response_iss_parameter_supported` (which is what obliges the client to check
-     * `iss` on the way back).
-     */
     static document({ issuer, authorizationEndpoint, tokenEndpoint, registrationEndpoint, revocationEndpoint, scopesSupported, clientIdMetadataDocumentSupported, }: OAuthMetadataProps): {
         scopes_supported?: string[] | undefined;
         response_types_supported: string[];

package/types/server/oauth/OAuthPkce.d.ts

@@ -1,4 +1,3 @@
-/** RFC 7636 with `S256` only: OAuth 2.1 drops `plain`, and an MCP client refuses a server whose metadata offers nothing else. */
 export declare class OAuthPkce {
     #private;
     static readonly method = "S256";

package/types/server/oauth/OAuthRedirect.d.ts

@@ -4,16 +4,7 @@ export declare class OAuthRedirect {
     /** A parsed redirect URI, or `null` for one that does not parse or carries a fragment (RFC 6749 §3.1.2). */
     static parse(uri: string): URL | null;
     static isLoopback(url: URL): boolean;
-    /**
-     * What may be registered: HTTPS, loopback HTTP, or a private-use scheme the deployment named. The MCP spec allows
-     * only the first two; the third exists because Cursor's desktop client registers `cursor://…/oauth/callback`, and
-     * a server that refuses it cannot be used from Cursor at all.
-     */
     static isRegistrable(uri: string, { allowedSchemes }?: OAuthRedirectPolicy): boolean;
-    /**
-     * Exact match against what was registered, except that a loopback redirect may vary its port: a native client
-     * binds whichever port is free at the time (RFC 8252 §7.3), and Claude Code picks one at random per session.
-     */
     static matches(registered: readonly string[], presented: string): boolean;
     /** The host a consent page shows the user — the one thing that tells a real client's redirect from an impostor's. */
     static hostOf(uri: string): string;

package/types/server/oauth/OAuthRegistration.d.ts

@@ -6,7 +6,6 @@ export type OAuthRegistrationResult = {
     ok: false;
     response: Response;
 };
-/** RFC 7591 Dynamic Client Registration — the request's validation and the response's shape; the identifier is the caller's. */
 export declare class OAuthRegistration {
     #private;
     static readonly authMethods: readonly OAuthClientAuthMethod[];

package/types/server/oauth/OAuthRevocation.d.ts

@@ -2,7 +2,7 @@ import type { OAuthClientCredential } from "./oauthTypes.d.ts";
 export type OAuthTokenTypeHint = "access_token" | "refresh_token";
 export interface OAuthRevocationParams {
     token: string;
-    /** The client's guess at what it is handing over; a server may ignore it, and an unknown hint reads as none. */
+    /** Advisory only; an unknown hint reads as none. */
     tokenTypeHint?: OAuthTokenTypeHint;
     client: OAuthClientCredential;
 }
@@ -13,19 +13,9 @@ export type OAuthRevocationParseResult = {
     ok: false;
     response: Response;
 };
-/**
- * RFC 7009 Token Revocation — the request's shape and the two answers it allows. What a token *is* and whose it
- * is are the issuer's to decide, so the parse hands back the credential and the token and nothing more.
- */
 export declare class OAuthRevocation {
     #private;
     static readonly hints: readonly OAuthTokenTypeHint[];
-    /** §2.1: form-encoded like the token endpoint, with the same client authentication and `token` required. */
     static parse(req: Request): Promise<OAuthRevocationParseResult>;
-    /**
-     * §2.2: a revoked token and a token the server never knew get the same empty 200, so the endpoint cannot be used
-     * to test whether a token exists. The only refusals are a malformed request and a client that failed to
-     * authenticate, both answered as the token endpoint would.
-     */
     static success(): Response;
 }

package/types/server/oauth/OAuthToken.d.ts

@@ -14,22 +14,10 @@ export interface OAuthTokenSuccess {
 }
 export declare class OAuthToken {
     #private;
-    /**
-     * RFC 6749 §4.1.3 and §6: the token endpoint speaks form encoding only, and a client authenticates through the
-     * `Authorization` header or the body, never both — two credentials on one request is a request nobody can audit.
-     */
     static parse(req: Request): Promise<OAuthTokenParseResult>;
-    /**
-     * Whether the credential presented is this client's. A public client has none to present, and a secret it sends
-     * anyway is ignored rather than refused — OAuth 2.1 §2.3 lets a public client keep naming itself. A confidential
-     * client must present its secret, compared as hashes in constant time.
-     */
     static authenticate(client: OAuthClientRecord, credential: OAuthClientCredential, hash: (secret: string) => string): boolean;
     /** RFC 6749 §5.1, with the caching headers it makes mandatory. */
     static success({ accessToken, expiresIn, refreshToken, scope }: OAuthTokenSuccess): Response;
-    /**
-     * `null` when both channels carried a credential. RFC 6749 §2.3.1 form-encodes the two halves of the Basic pair.
-     * Shared with the revocation endpoint, which RFC 7009 §2.1 authenticates the same way.
-     */
+    /** `null` when both channels carried a credential. Basic halves are form-encoded (RFC 6749 §2.3.1). */
     static credentialOf(req: Request, form: URLSearchParams): OAuthClientCredential | null;
 }

package/types/server/oauth/oauthTypes.d.ts

@@ -1,5 +1,5 @@
 export type OAuthClientAuthMethod = "none" | "client_secret_post" | "client_secret_basic";
-/** How a client came to be known: declared in the app's option, registered over RFC 7591, or read off its `client_id` URL. */
+/** Declared in the app's option, registered over RFC 7591, or read off its `client_id` URL. */
 export type OAuthClientSource = "static" | "dynamic" | "metadataDocument";
 export interface OAuthClientRecord {
     clientId: string;
@@ -10,7 +10,6 @@ export interface OAuthClientRecord {
     clientSecretHash?: string;
     source: OAuthClientSource;
 }
-/** The metadata a registration request carries, before the server assigns an identifier to it. */
 export type OAuthClientMetadata = Pick<OAuthClientRecord, "clientName" | "redirectUris" | "grantTypes" | "tokenEndpointAuthMethod">;
 export interface OAuthRedirectPolicy {
     /** Private-use URI schemes accepted as redirect targets besides HTTPS and loopback HTTP, e.g. `cursor`. */

package/types/server/ops/ageEncryption.d.ts

@@ -0,0 +1,19 @@
+import { type KeyObject } from "node:crypto";
+import type { SnapshotDecryptor } from "./snapshotRestore.d.ts";
+import type { SnapshotEncryptor } from "./sqliteSnapshot.d.ts";
+export declare class AgeEncryption {
+    #private;
+    static readonly intro = "age-encryption.org/v1";
+    static readonly chunkSize: number;
+    static readonly tagSize = 16;
+    static encryptor(recipients: string[]): Promise<SnapshotEncryptor>;
+    static decryptor(identities: string[]): Promise<SnapshotDecryptor>;
+    static fromEnv(): Promise<SnapshotEncryptor | null>;
+    static identitiesIn(text: string): string[];
+    static generateIdentity(): {
+        identity: string;
+        recipient: string;
+    };
+    static parseRecipient(recipient: string): KeyObject;
+    static parseIdentity(identity: string): KeyObject;
+}

package/types/server/ops/appInfo.d.ts

@@ -0,0 +1,36 @@
+import { type DatabaseMode } from "../../base/baseEnv.d.ts";
+export interface AppPublicInfo {
+    appName: string;
+    repoName: string;
+    environment: string;
+    operationMode: string;
+}
+export interface AppDetailInfo extends AppPublicInfo {
+    akanVersion: string | null;
+    buildId: string | null;
+    serverMode: string;
+    databaseMode: DatabaseMode | null;
+    solo: boolean;
+    startedAt: string;
+    replicaIdx: number | null;
+}
+export interface AppBuildInfo {
+    buildId: string | null;
+    akanVersion: string | null;
+    builtAt: string | null;
+}
+export interface AppProcessInfo {
+    serverMode: string;
+    solo: boolean;
+    replicaIdx: number | null;
+}
+export declare class AppInfo {
+    #private;
+    static readonly publicPath = "/_akan/app/info";
+    static readonly buildFileName = "akan.build.json";
+    static readonly startedAt: Date;
+    static public(): AppPublicInfo;
+    static detail(proc: AppProcessInfo): AppDetailInfo;
+    static build(): AppBuildInfo;
+    static handlePublic(): Response;
+}

package/types/server/ops/opsCommand.d.ts

@@ -0,0 +1,5 @@
+export declare class OpsCommand {
+    #private;
+    static readonly usage: string;
+    static run(argv: string[]): Promise<number>;
+}

package/types/server/ops/opsRoute.d.ts

@@ -0,0 +1,24 @@
+import type { AppDetailInfo } from "./appInfo.d.ts";
+import { OpsTokenVerifier } from "./opsToken.d.ts";
+import { type SnapshotJobRequest, SnapshotJobs } from "./snapshotJobs.d.ts";
+import type { SnapshotSources } from "./snapshotTypes.d.ts";
+import { type SnapshotCapture } from "./sqliteSnapshot.d.ts";
+export interface OpsRouteOptions {
+    verifier: OpsTokenVerifier;
+    detail: () => AppDetailInfo;
+    jobs: SnapshotJobs;
+    rateLimitPerMinute?: number;
+}
+export interface OpsRouteEnvOptions {
+    detail: () => AppDetailInfo;
+    sources?: () => SnapshotSources;
+}
+export declare class OpsRoute {
+    #private;
+    static readonly prefix = "/_akan/ops/";
+    constructor({ verifier, detail, jobs, rateLimitPerMinute }: OpsRouteOptions);
+    static fromEnv({ detail, sources }: OpsRouteEnvOptions): OpsRoute | null;
+    static captureInChild(request: SnapshotJobRequest, sources: SnapshotSources, dir: string): Promise<SnapshotCapture>;
+    matches(pathname: string): boolean;
+    handle(req: Request): Promise<Response>;
+}

package/types/server/ops/opsToken.d.ts

@@ -0,0 +1,26 @@
+import { type KeyObject } from "node:crypto";
+export interface OpsTokenClaims {
+    aud: string;
+    exp: number;
+    iat: number;
+    jti: string;
+}
+export type OpsTokenVerdict = {
+    ok: true;
+    claims: OpsTokenClaims;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare class OpsTokenVerifier {
+    #private;
+    static readonly maxLifetimeSec = 300;
+    static readonly clockSkewSec = 30;
+    static readonly maxRememberedJti = 10000;
+    readonly audience: string;
+    constructor(key: KeyObject, audience: string);
+    static audienceOf(appName: string, environment: string, instance?: string | undefined): string;
+    static parsePublicKey(value: string): KeyObject;
+    verifyRequest(req: Request, nowSec?: number): OpsTokenVerdict;
+    verify(token: string, nowSec?: number): OpsTokenVerdict;
+}

package/types/server/ops/snapshotJobs.d.ts

@@ -0,0 +1,24 @@
+import type { SnapshotJobState, SnapshotUploadUrls } from "./snapshotTypes.d.ts";
+import type { SnapshotCapture } from "./sqliteSnapshot.d.ts";
+export interface SnapshotJobRequest {
+    id: string;
+    includeSolid: boolean;
+    uploadUrls: SnapshotUploadUrls;
+}
+export interface SnapshotJobsOptions {
+    capture: (request: SnapshotJobRequest) => Promise<SnapshotCapture>;
+    snapshotDir: string;
+    keep?: number;
+    fetcher?: typeof fetch;
+    uploadAttempts?: number;
+    retryDelayMs?: number;
+}
+export declare class SnapshotJobs {
+    #private;
+    static readonly maxRemembered = 20;
+    static readonly uploadTimeoutMs: number;
+    constructor({ keep, fetcher, uploadAttempts, retryDelayMs, ...options }: SnapshotJobsOptions);
+    get(id: string): SnapshotJobState | null;
+    start(request: SnapshotJobRequest): SnapshotJobState | "busy" | "exists";
+    idle(): Promise<void>;
+}

package/types/server/ops/snapshotRestore.d.ts

@@ -0,0 +1,24 @@
+import type { Transform } from "node:stream";
+import type { SnapshotFile, SnapshotManifest, SnapshotSources } from "./snapshotTypes.d.ts";
+export interface SnapshotDecryptor {
+    transform(): Transform;
+}
+export interface SnapshotRestoreOptions {
+    manifestPath: string;
+    sources: SnapshotSources;
+    decryptor?: SnapshotDecryptor | null;
+    now?: Date;
+}
+export interface RestoredFile {
+    role: SnapshotFile["role"];
+    target: string;
+    preservedAs: string | null;
+}
+/** Offline only: it swaps files under a closed database, and nothing here can tell an open connection to let go. */
+export declare class SnapshotRestore {
+    #private;
+    static run({ manifestPath, sources, decryptor, now }: SnapshotRestoreOptions): Promise<{
+        manifest: SnapshotManifest;
+        restored: RestoredFile[];
+    }>;
+}

package/types/server/ops/snapshotTypes.d.ts

@@ -0,0 +1,45 @@
+import type { DatabaseMode } from "../../base/baseEnv.d.ts";
+export type SnapshotFileRole = "main" | "solid";
+export interface SnapshotFile {
+    role: SnapshotFileRole;
+    name: string;
+    sizeBytes: number;
+    sha256: string;
+    encoding: "gzip";
+    uploadBytes: number;
+    uploadSha256: string;
+}
+export interface SnapshotEncryption {
+    format: "age";
+    recipients: string[];
+}
+export interface SnapshotManifest {
+    format: "akan-snapshot/v1";
+    id: string;
+    appName: string;
+    environment: string;
+    akanVersion: string | null;
+    buildId: string | null;
+    databaseMode: DatabaseMode;
+    createdAt: string;
+    files: SnapshotFile[];
+    integrity: "ok" | string[];
+    encryption: SnapshotEncryption | null;
+}
+export interface SnapshotSources {
+    main: string;
+    solid: string | null;
+}
+export interface SnapshotUploadUrls {
+    main: string;
+    solid?: string;
+    manifest: string;
+}
+export interface SnapshotJobState {
+    id: string;
+    status: "running" | "uploading" | "done" | "failed";
+    startedAt: string;
+    finishedAt?: string;
+    manifest?: SnapshotManifest;
+    error?: string;
+}

package/types/server/ops/sqliteFiles.d.ts

@@ -0,0 +1,5 @@
+import type { SnapshotSources } from "./snapshotTypes.d.ts";
+export declare class SqliteFiles {
+    static fromEnv(): SnapshotSources;
+    static snapshotDir(sources: SnapshotSources): string;
+}

package/types/server/ops/sqliteSnapshot.d.ts

@@ -0,0 +1,32 @@
+import { createHash } from "node:crypto";
+import { Transform } from "node:stream";
+import type { SnapshotEncryption, SnapshotFileRole, SnapshotManifest, SnapshotSources } from "./snapshotTypes.d.ts";
+export interface SnapshotEncryptor {
+    readonly encryption: SnapshotEncryption;
+    readonly extension: string;
+    transform(): Transform;
+}
+export interface SnapshotCaptureOptions {
+    id: string;
+    dir: string;
+    sources: SnapshotSources;
+    includeSolid?: boolean;
+    encryptor?: SnapshotEncryptor | null;
+}
+export interface SnapshotCapture {
+    dir: string;
+    manifest: SnapshotManifest;
+    manifestPath: string;
+    paths: {
+        [role in SnapshotFileRole]?: string;
+    };
+}
+export declare class SqliteSnapshot {
+    #private;
+    static readonly manifestName = "manifest.json";
+    static readonly idPattern: RegExp;
+    static capture({ id, dir, sources, includeSolid, encryptor, }: SnapshotCaptureOptions): Promise<SnapshotCapture>;
+    static vacuumInto(source: string, target: string): void;
+    static integrityProblems(file: string): string[];
+    static tap(hash: ReturnType<typeof createHash>): Transform;
+}

package/types/server/processMetricsCollector.d.ts

@@ -2,7 +2,9 @@ import type { AkanMetricsReport } from "akanjs/service";
 export declare class ProcessMetricsCollector {
     #private;
     static parseMemoryLogIntervalMs(value?: string | undefined): number;
-    /** Begin sampling event-loop lag. Idempotent; safe to call from each server role. */
+    /** Calls `report` now and then every AKAN_MEMORY_LOG_INTERVAL_MS; the caller owns the returned timer. */
+    static startReporting(report: () => Promise<void>): NodeJS.Timeout;
+    /** Idempotent; safe to call from each server role. */
     static startEventLoopLagMonitor(intervalMs?: number): void;
     static collect(extra?: AkanMetricsReport): Promise<AkanMetricsReport>;
     static formatBytes(bytes?: number): string;

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

@@ -1,6 +1,12 @@
-import type { WebProxy } from "./types.d.ts";
+import { Logger } from "akanjs/common";
+import { type WebProxy } from "./types.d.ts";
 export declare class HostBasePathWebProxy implements WebProxy {
     #private;
     static readonly refName = "HostBasePathWebProxy";
     use(request: Bun.BunRequest): Response | import("./types.d.ts").WebProxyResult | undefined;
 }
+export declare function resolveArtifactDir(): string;
+export declare function warnIgnoredSubRouteBasePaths(logger: Logger, ignoredBasePaths: string[]): void;
+export declare function normalizeHost(host: string | null): string;
+export declare function getPublicRequestUrl(request: Bun.BunRequest): URL;
+export declare function isInternalProxyRequest(requestUrl: URL): boolean;

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

@@ -1,6 +1,5 @@
-export { AkanResponse } from "./akanResponse.d.ts";
-export { copyBunRequestFields } from "./bunRequestFields.d.ts";
 export { HostBasePathWebProxy } from "./hostBasePathWebProxy.d.ts";
 export { LocaleWebProxy } from "./localeWebProxy.d.ts";
 export type { WebProxy, WebProxyCls, WebProxyMatcher, WebProxyNextInit, WebProxyRegistration, WebProxyResult, WebProxyReturn, WebProxyRunResult, } from "./types.d.ts";
-export { WebProxyRunner } from "./webProxyRunner.d.ts";
+export { AkanResponse } from "./types.d.ts";
+export { copyBunRequestFields, WebProxyRunner } from "./webProxyRunner.d.ts";

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

@@ -1,4 +1,4 @@
-import type { WebProxy } from "./types.d.ts";
+import { type WebProxy } from "./types.d.ts";
 export declare class LocaleWebProxy implements WebProxy {
     static readonly refName = "LocaleWebProxy";
     use(request: Bun.BunRequest): Response | import("./types.d.ts").WebProxyResult;

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

@@ -35,3 +35,8 @@ export interface WebProxyRunResult {
     request: Request;
     response?: Response;
 }
+export declare class AkanResponse {
+    static next(init?: WebProxyNextInit): WebProxyResult;
+    static redirect(url: string | URL, status?: number): Response;
+    static rewrite(url: string | URL, init?: WebProxyNextInit): WebProxyResult;
+}

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

@@ -1,4 +1,5 @@
 import { type WebProxyRegistration, type WebProxyRunResult } from "./types.d.ts";
+export declare const copyBunRequestFields: (target: Request, source: Request) => Request;
 export declare class WebProxyRunner {
     #private;
     static create(registrations?: WebProxyRegistration[]): WebProxyRunner | null;

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

@@ -4,10 +4,6 @@ import type { DatabaseService, ServiceCls } from "akanjs/service";
 export declare class CascadeRunner {
     #private;
     register(constant: ConstantModel, schema: DocumentSchema, srvRef: ServiceCls): void;
-    /**
-     * Called once every service is live. A `_postRemove` and a `listenPost("remove")` registered during boot both
-     * count against bulk removal, so the strategy cannot be decided before the last service has initialized.
-     */
     seal(getService: (refName: string) => DatabaseService): void;
     run(refName: string, doc: Record<string, unknown>): Promise<void>;
 }

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

@@ -2,7 +2,7 @@ import { type ConstantModel } from "akanjs/constant";
 import { type DatabaseInstance, type DatabaseModel, DocumentSchema } from "akanjs/document";
 import { type AdaptorCls } from "akanjs/service";
 export declare class DatabaseResolver {
-    /** Returns the schema alongside the adaptor: the cascade planner reads its `remove` hooks to pick a strategy. */
+    static applyFilterMethods(prototype: object, database: DatabaseModel, className: string): void;
     static resolveDatabase(constant: ConstantModel, database: DatabaseModel): {
         adaptor: AdaptorCls<DatabaseInstance>;
         schema: DocumentSchema;

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

@@ -1,5 +1,5 @@
-import { type DatabaseModel } from "akanjs/document";
-import type { ServiceCls } from "akanjs/service";
+import type { DatabaseModel } from "akanjs/document";
+import { type ServiceCls } from "akanjs/service";
 import type { CascadeRunner } from "./CascadeRunner.d.ts";
 export declare class ServiceResolver {
     #private;

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

@@ -18,26 +18,16 @@ export declare class SignalResolver {
         registry: InjectRegistry;
         live: LiveRegistry;
     }): ServerSignalCls;
-    /**
-     * Attaches the change listeners that feed live rooms, once per model that declares a `.live()` slice.
-     *
-     * Only the document write paths reach here. A query-level write — `updateManyByQuery`, the generated
-     * `update<Filter>` / `remove<Filter>`, `updateById` / `removeById` — is one atomic statement that fires no
-     * document hooks at all, exactly as it fires no cascade, so a model whose fields move that way will not push
-     * those moves to a live list. It is the same blind spot cascade has and it cannot be closed from here.
-     */
     static registerLiveSync(sliceCls: SliceCls, { registry, live }: {
         registry: InjectRegistry;
         live: LiveRegistry;
     }): string[];
     static resolveSchedule(internalCls: InternalCls, internal: Internal, serverMode: "federation" | "batch" | "all"): void;
-    /** Why an internal is not scheduled on this server, or null when it is. `placement` marks a deliberate role split. */
     static getScheduleSkipReason(internalInfo: InternalInfo, serverMode: "federation" | "batch" | "all"): {
         reason: string;
         placement: boolean;
     } | null;
     static resolveSlice(sliceCls: SliceCls): EndpointCls;
-    /** Same rule across endpoint classes, which are resolved one at a time and then folded into one table. */
     static mergeHttpRoutes(target: HttpRoutes, source: HttpRoutes): void;
     static resolveEndpoint(endpointCls: EndpointCls, endpoint: Endpoint, { registry, env, live, middleware, }: {
         registry: InjectRegistry;
@@ -45,11 +35,7 @@ export declare class SignalResolver {
         live: LiveRegistry;
         middleware: Map<string, MiddlewareCls>;
     }): SignalRoutes;
-    /**
-     * Re-checks the guards of every room this socket is subscribed to and drops the ones that no
-     * longer pass. Called when the socket's credential changes: a pubsub room is authorized once at
-     * subscribe time, so without this a signed-out socket would keep receiving its old rooms.
-     */
+    static resolveServicePrefix(prefix: false | string | undefined, defaultPrefix?: string): string;
     static revalidateWsRooms(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry, live?: LiveRegistry): Promise<string[]>;
     static handleWsOpen(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry): Promise<void>;
     static handleWsClose(ws: Bun.ServerWebSocket<any>, registry: InjectRegistry, live?: LiveRegistry): Promise<void>;

package/types/server/routeElementComposer.d.ts

@@ -30,7 +30,7 @@ export declare class RouteElementComposer {
         params: Record<string, string>;
         searchParams: Record<string, string | string[]>;
     }): Promise<Head | null | undefined>;
-    static resolveHeadWithMetadata({ pathRoute, params, searchParams, }: {
+    static resolveHeadWithSnapshot({ pathRoute, params, searchParams, }: {
         pathRoute: PathRoute;
         params: Record<string, string>;
         searchParams: Record<string, string[] | string>;
@@ -51,13 +51,7 @@ export declare class RouteElementComposer {
         searchParams: Record<string, string | string[]>;
         navKey?: 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: {
+    static AsyncRender: ({ routeRender, children, params, searchParams, }: {
         routeRender: RouteRender;
         children: ReactNode;
         params: Record<string, string>;

package/types/server/routeState.d.ts

@@ -62,7 +62,6 @@ export declare function isAkanRouterStateV1(value: unknown): value is AkanRouter
 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;
@@ -92,3 +91,4 @@ export declare function resolveAkanRscPatchDecision({ currentState, targetState,
     partialDecision: AkanRscPartialDecision;
 }): AkanRscPatchDecision;
 export declare function countCommonRouteSegments(currentSegments: AkanRouteSegmentState[], targetSegments: AkanRouteSegmentState[]): number;
+export declare function isAkanRscPartialCommitEnabled(): boolean;

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

@@ -4,12 +4,6 @@ import type { HmrWsHub } from "../hmr/wsHub.d.ts";
 import { type WebProxyRunner } from "../proxy.d.ts";
 import type { HttpRoutes, SignalRouteOptions, WebsocketRoutes } from "../types.d.ts";
 import { AppWsData } from "./appWsData.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;
@@ -27,14 +21,12 @@ export interface ApiRouteInputs {
     builtinRoutes?: HttpRoutes;
     routeOptions?: Record<string, SignalRouteOptions>;
     renderEnvRoutes: HttpRoutes;
-    /** Upgrades the incoming request into an app-signal WebSocket. */
     upgradeAppWs: (req: Request, data: AppWsData) => boolean;
     webProxyRunner?: WebProxyRunner | null;
 }
 export interface WebsocketHandlersInputs {
     wsRoutes: WebsocketRoutes;
     registry: InjectRegistry;
-    /** Only live rooms need it — a room is released from the routing table when its last socket goes. */
     live?: LiveRegistry;
     hmrHub: HmrWsHub | null;
     hmrState: HmrStateSource | null;
@@ -46,19 +38,9 @@ type WsTaggedData = {
 };
 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, builtinRoutes, 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, live, hmrHub, hmrState, logger, onDrain, }: WebsocketHandlersInputs): Bun.WebSocketHandler<WsTaggedData>;
+    static applyGlobalPrefix(prefix: string, path: string, options?: SignalRouteOptions): string;
+    static joinRoutePath(prefix: string, path: string): string;
 }
 export {};