akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/types/index.d.ts

@@ -34,7 +34,7 @@ export interface AkanRouteConfig {
     basePath?: string;
     domains: AkanRouteDomains;
 }
-/** `ssr`: the RSC/SSR renderer with its bundles and RSC worker; `csr`: the SPA shell Capacitor ships and `/__csr` serves. */
+/** `ssr`: the RSC/SSR renderer with its bundles and RSC worker; `csr`: the SPA shell the native apps ship and `/__csr` serves. */
 export interface AkanWebConfig {
     ssr: boolean;
     csr: boolean;
@@ -72,42 +72,58 @@ export interface AkanMobileTargetDeepLinks {
         sha256CertFingerprints?: 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;
+/**
+ * Files copied into the app, keyed by where they land: `ios/<path>` (the app bundle), `android/res/<type>/<file>` or
+ * `android/assets/<path>`. The value is the source, relative to the app folder.
+ */
+export type AkanMobileTargetFiles = Record<string, string>;
+export type AkanNativeValue = string | number | boolean | AkanNativeValue[] | {
+    [key: string]: AkanNativeValue;
+};
+export interface AkanMobileNativeConfig {
+    /** Native runtime plugins beyond the ones the permissions bring, by builtin id (`"iap"`) or absolute folder. */
+    plugins?: string[];
+    ios?: {
+        infoPlist?: Record<string, AkanNativeValue>;
+        entitlements?: Record<string, AkanNativeValue>;
+    };
+    android?: {
+        /** XML at the `<manifest>` level; `${applicationId}` is replaced. */
+        manifest?: string[];
+        /** XML inside `<application>`. */
+        application?: string[];
+        /** XML inside the app's activity. */
+        activity?: string[];
+        /** The Firebase project's google-services.json, relative to the app folder, for FCM push on Android. */
+        googleServices?: string;
+    };
 }
-export interface AkanMobileTargetConfig extends AkanCapacitorLikeConfig {
+export interface AkanMobileTargetConfig {
     name: string;
     basePath?: string;
     indexPath?: string;
     appName: string;
     appId: string;
+    /** Executables, archives and the Swift module; letters, digits, `.`, `_` and `-`. Default: the app's folder name. */
+    fileName?: string;
     version: string;
     buildNum: number;
     assets?: AkanMobileTargetAssets;
     permissions?: MobilePermission[];
     deepLinks?: AkanMobileTargetDeepLinks;
     files?: AkanMobileTargetFiles;
+    native?: AkanMobileNativeConfig;
 }
-export interface AkanMobileConfig extends AkanCapacitorLikeConfig {
+export interface AkanMobileConfig {
     appName: string;
     appId: string;
+    fileName?: string;
     version: string;
     buildNum: number;
+    files?: AkanMobileTargetFiles;
+    native?: AkanMobileNativeConfig;
     targets: Record<string, AkanMobileTargetConfig>;
 }
-export interface PluginRuntimeContext {
-    readonly appName: string;
-    readonly mobile: AkanMobileConfig;
-    /** True when any mobile target declares the given permission. */
-    hasMobilePermission(permission: MobilePermission): boolean;
-}
 export interface AkanScanInfo {
     /** Transitive lib dependencies of the app (or direct deps of a lib). */
     getLibs(): string[];
@@ -152,36 +168,24 @@ export interface AkanSyncContext {
     /** Resolves `env/env.client.ts` and returns its exported `env`, or null when absent/invalid. */
     readEnvClient(): Promise<Record<string, unknown> | null>;
 }
-export interface AkanNativeContext {
-    readonly appPath: string;
-    readonly executor: AkanExecutor;
-    readonly target: AkanMobileTargetConfig;
-    readonly operation: "local" | "release";
-    readonly env: MobileEnv;
-    /** Set NS-prefixed usage descriptions in the iOS Info.plist (Debug + Release). */
-    setIosUsageDescriptions(descriptions: Record<string, string>): Promise<void>;
-    /** Merge raw key/values into the iOS Info.plist (Debug + Release). */
-    updateIosInfoPlist(values: Record<string, unknown>): Promise<void>;
-    /** Contribute entries to the iOS entitlements file (merged, then written once per prepare). */
-    addIosEntitlements(entitlements: Record<string, string | string[]>): void;
-    /** Transform `ios/App/App/AppDelegate.swift` in place (no-op when the file is absent). */
-    editIosAppDelegate(transform: (content: string) => string): Promise<void>;
-    /** Add `uses-permission` entries to the Android manifest (without the `android.permission.` prefix). */
-    addAndroidPermissions(permissions: string[]): void;
-    /** Add `uses-feature` entries to the Android manifest. */
-    addAndroidFeatures(features: string[]): void;
-}
-export interface AkanPluginCapacitorConfig {
-    /** Mobile permission that activates this plugin's native config (reuses the existing permission model). */
-    permission?: MobilePermission;
-    configureNative?: (ctx: AkanNativeContext) => Promise<void>;
+/** What a plugin adds to a mobile app whose target asks for its permission; the native build merges every one. */
+export interface AkanPluginNativeConfig {
+    permission: MobilePermission;
+    /** Native runtime plugins, by builtin id (`"camera"`). */
+    plugins?: string[];
+    /** iOS usage texts by description name (`cameraUsageDescription`); `$(PRODUCT_NAME)` becomes the app name. */
+    usageDescriptions?: Record<string, string>;
+    infoPlist?: Record<string, AkanNativeValue>;
+    entitlements?: Record<string, AkanNativeValue>;
+    /** `uses-permission` names, without the `android.permission.` prefix. */
+    androidPermissions?: string[];
+    /** `uses-feature` names, declared as not required. */
+    androidFeatures?: string[];
 }
 /** Read live by the CLI at build time; it carries functions, so it stays out of the serializable config results. */
 export interface AkanPlugin {
     name: string;
-    /** Runtime npm packages this plugin needs; installed on demand by the CLI (e.g. firebase for push). */
-    runtimePackages?: (ctx: PluginRuntimeContext) => string[];
-    capacitor?: AkanPluginCapacitorConfig;
+    native?: AkanPluginNativeConfig;
     /** Build-time asset generation (e.g. `public/firebase-messaging-sw.js`). */
     syncAssets?: (ctx: AkanSyncContext) => Promise<void>;
 }

package/types/server/hmr/devHmrController.d.ts

@@ -8,6 +8,7 @@ export declare function devBuildStatusToHmrMessage(status: DevBuildStatus, previ
     type: "build-status";
 }> | null;
 export interface DevHmrControllerOptions {
+    artifactDir: string;
     renderState: RenderState;
     rsc: RscWorker;
     seedIndex: RouteSeedIndex;
@@ -16,7 +17,7 @@ export interface DevHmrControllerOptions {
 export declare class DevHmrController {
     #private;
     readonly routeCache: RouteClientCache;
-    constructor({ renderState, rsc, seedIndex, upgradeHmrWs }: DevHmrControllerOptions);
+    constructor({ artifactDir, renderState, rsc, seedIndex, upgradeHmrWs }: DevHmrControllerOptions);
     get hub(): HmrWsHub;
     get builderRpc(): BuilderRpc;
     dispose(): void;

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

@@ -35,7 +35,6 @@ export declare class SignalResolver {
         live: LiveRegistry;
         middleware: Map<string, MiddlewareCls>;
     }): SignalRoutes;
-    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/rscClient.d.ts

@@ -5,8 +5,5 @@ declare global {
     var __RSC_PUSH__: ((type: InlineRscChunk[0], data: string) => void) | undefined;
     var __RSC_CLOSE__: (() => void) | undefined;
     var __AKAN_RSC_INITIAL_STATE__: string | undefined;
-    var __AKAN_RSC_REFRESH__: ((options?: {
-        buildId?: number;
-    }) => Promise<void>) | undefined;
 }
 export {};

package/types/signal/CrossSiteGuard.d.ts

@@ -8,12 +8,17 @@ export interface CrossSiteOption {
 export declare class CrossSiteGuard {
     #private;
     static readonly logger: Logger;
-    /** iOS ships `capacitor://localhost`, Android `http://localhost`, older shells `ionic://localhost`. */
-    static readonly nativeOrigins: readonly ["capacitor://localhost", "ionic://localhost", "http://localhost"];
+    /** The native shell serves the page from `app://localhost` on iOS, macOS and Linux, `https://app.localhost` on
+     * Android and Windows; both WebViews send exactly that as `Origin`. */
+    static readonly nativeOrigins: readonly ["app://localhost", "https://app.localhost"];
     /** Applied at boot from the mounting app's `option.ts`; the native shells stay allowed unless disabled. */
     static configure({ allowedOrigins, enabled }: CrossSiteOption): void;
     static reset(): void;
     /** Call only where a JSON body is read: a multipart upload relies on `assertOrigin` alone. */
     static assertJsonBody(contentType: string | null): void;
     static assertOrigin(req: Request, url: URL, key: string): void;
+    /** The origin a cross-origin caller may read answers from: an allowlisted one, never the serving host's neighbours. */
+    static corsOrigin(req: Request): string | null;
+    static preflight(req: Request, methods: string[]): Response;
+    static withCors(req: Request, res: Response): Response;
 }

package/types/signal/endpoint.d.ts

@@ -29,6 +29,6 @@ type MergeEndpointMetas<EndpClses extends readonly EndpointCls[], Acc = unknown>
     infer First extends EndpointCls,
     ...infer Rest extends readonly EndpointCls[]
 ] ? MergeEndpointMetas<Rest, Assign<Acc, EndpointMetaOf<First>>> : Acc;
-export declare function endpoint<SrvModule extends ServiceModel, Builder extends EndpointBuilder<SrvModule>, LibEndpoints extends readonly EndpointCls[]>(srv: SrvModule, builder: Builder, ...libEndpoints: LibEndpoints): EndpointCls<SrvModule, LibEndpoints extends readonly [] ? ReturnType<Builder> : Assign<ReturnType<Builder>, MergeEndpointMetas<LibEndpoints>>>;
+export declare function endpoint<SrvModule extends ServiceModel, Builder extends EndpointBuilder<SrvModule>, LibEndpoints extends readonly EndpointCls[]>(srv: SrvModule, builder: Builder, ...libEndpoints: LibEndpoints): EndpointCls<SrvModule, LibEndpoints extends readonly [] ? ReturnType<Builder> : Assign<MergeEndpointMetas<LibEndpoints>, ReturnType<Builder>>>;
 export declare function sliceEndpoint<SrvModule extends ServiceModel, Builder extends EndpointBuilder<SrvModule>>(srv: SrvModule, builder: Builder): EndpointCls<SrvModule, ReturnType<Builder>>;
 export {};

package/types/signal/endpointInfo.d.ts

@@ -56,6 +56,9 @@ export declare class EndpointInfo<ReqType extends EndpointType = EndpointType, S
     _addInternalArgs(args: InternalArgInfo<boolean>[]): this;
     exec<ExecFn extends (this: Srvs, ...args: [...ServerArgs, ...InternalArgs]) => ReqType extends "pubsub" ? Promise<void> | void : PromiseOrObject<DocumentModel<FieldToValue<Returns>> | (Nullable extends true ? null | undefined : never)>>(execFn: ExecFn): EndpointInfo<ReqType, Srvs, ArgNames, Args, InternalArgs, ServerArgs, Returns, FieldToValue<Returns>, ReturnType<ExecFn>, Nullable>;
     getPath(key: string): string;
+    /** The route the server mounts, below the global prefix; the fetch client is handed it to call the same one. */
+    getRoutePath(key: string, defaultPrefix?: string): string;
+    static resolveServicePrefix(prefix: false | string | undefined, defaultPrefix?: string): string;
 }
 export type BuildEndpoint<SrvModule extends ServiceModel = ServiceModel> = {
     query: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(returnRef: Returns, signalOption?: SignalOption<Returns, Nullable>) => EndpointInfo<"query", SrvMap<SrvModule>, [], [], [], [], Returns, never, never, Nullable>;

package/types/signal/slice.d.ts

@@ -65,7 +65,7 @@ type RootSliceQueryKey<Filter extends FilterInstance> = Extract<keyof Filter["qu
 type ExtendSliceInfoObj<SrvModule extends ServiceModel, LibSlices extends SliceCls[], _Input = CnstInput<SrvModule>, _Full = CnstFull<SrvModule>, _Light = CnstLight<SrvModule>, _Insight = CnstInsight<SrvModule>, _Filter extends FilterInstance = DbFilter<SrvModule>, _Merged = MergeAllKeyOfObjects<LibSlices, typeof SLICE_META>> = {
     [K in keyof _Merged]: _Merged[K] extends SliceInfo ? SliceInfo<SrvRefName<SrvModule>, _Input, _Full, _Light, _Insight, _Filter, SliceInfoSrvs<_Merged[K]>, SliceInfoArgNames<_Merged[K]>, SliceInfoArgs<_Merged[K]>, SliceInfoInternalArgs<_Merged[K]>, SliceInfoServerArgs<_Merged[K]>> : never;
 };
-export declare function slice<SrvModule extends ServiceModel, BuildSlice extends SliceBuilder<SrvModule>, LibSlices extends SliceCls[], _Input = CnstInput<SrvModule>, _Full = CnstFull<SrvModule>, _Light = CnstLight<SrvModule>, _Insight = CnstInsight<SrvModule>, _Filter extends FilterInstance = DbFilter<SrvModule>, _QueryKey extends string = RootSliceQueryKey<_Filter>>(srv: SrvModule, option: RootSliceOption, sliceBuilder: BuildSlice, ...libSlices: LibSlices): SliceCls<SrvModule, Assign<ReturnType<BuildSlice>, LibSlices extends [] ? {
+type RootSliceInfoObj<SrvModule extends ServiceModel, _Input, _Full, _Light, _Insight, _Filter extends FilterInstance, _QueryKey extends string> = {
     [""]: SliceInfo<SrvRefName<SrvModule>, _Input, _Full, _Light, _Insight, _Filter, SrvMap<SrvModule>, [
         "queryKey",
         "args"
@@ -77,5 +77,6 @@ export declare function slice<SrvModule extends ServiceModel, BuildSlice extends
         _QueryKey | undefined,
         unknown[] | undefined
     ]>;
-} : ExtendSliceInfoObj<SrvModule, LibSlices>>>;
+};
+export declare function slice<SrvModule extends ServiceModel, BuildSlice extends SliceBuilder<SrvModule>, LibSlices extends SliceCls[], _Input = CnstInput<SrvModule>, _Full = CnstFull<SrvModule>, _Light = CnstLight<SrvModule>, _Insight = CnstInsight<SrvModule>, _Filter extends FilterInstance = DbFilter<SrvModule>, _QueryKey extends string = RootSliceQueryKey<_Filter>>(srv: SrvModule, option: RootSliceOption, sliceBuilder: BuildSlice, ...libSlices: LibSlices): SliceCls<SrvModule, LibSlices extends [] ? Assign<ReturnType<BuildSlice>, RootSliceInfoObj<SrvModule, _Input, _Full, _Light, _Insight, _Filter, _QueryKey>> : Assign<ExtendSliceInfoObj<SrvModule, LibSlices>, Assign<ReturnType<BuildSlice>, RootSliceInfoObj<SrvModule, _Input, _Full, _Light, _Insight, _Filter, _QueryKey>>>>;
 export {};

package/types/store/baseSt.d.ts

@@ -35,7 +35,6 @@ declare const BaseStore_base: import("./store.d.ts").StoreCls<"base", import("./
     keyboardHeight: number;
     pageState: PageState;
     devMode: boolean;
-    deviceToken: string;
     currentPath: string;
 }>, unknown, any, unknown, import("./stateBuilder.d.ts").WritableStateOf<{
     csrLoaded: boolean;
@@ -60,7 +59,6 @@ declare const BaseStore_base: import("./store.d.ts").StoreCls<"base", import("./
     keyboardHeight: number;
     pageState: PageState;
     devMode: boolean;
-    deviceToken: string;
     currentPath: string;
 }>, any, any, any, any, any, any, any, any>;
 export declare class BaseStore extends BaseStore_base {
@@ -95,7 +93,6 @@ declare const RootStore_base: import("./rootStore.d.ts").RootStoreCls<"root", im
     keyboardHeight: number;
     pageState: PageState;
     devMode: boolean;
-    deviceToken: string;
     currentPath: string;
 }>, Omit<BaseStore, "slice" | keyof import("./types.d.ts").SetGet<any>>, {
     [x: `base${Capitalize<string>}`]: {
@@ -154,7 +151,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
             keyboardHeight: number;
             pageState: PageState;
             devMode: boolean;
-            deviceToken: string;
             currentPath: string;
         }>, prev: import("./stateBuilder.d.ts").WritableStateOf<{
             csrLoaded: boolean;
@@ -179,7 +175,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
             keyboardHeight: number;
             pageState: PageState;
             devMode: boolean;
-            deviceToken: string;
             currentPath: string;
         }>) => void): () => void;
         <U>(selector: (state: import("./stateBuilder.d.ts").WritableStateOf<{
@@ -205,7 +200,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
             keyboardHeight: number;
             pageState: PageState;
             devMode: boolean;
-            deviceToken: string;
             currentPath: string;
         }>) => U, listener: (state: U, prev: U) => void, options?: {
             equalityFn?: ((a: U, b: U) => boolean) | undefined;
@@ -235,7 +229,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>) => U) => import("react").RefObject<U>;
     sel: <U>(selector: (state: import("./stateBuilder.d.ts").WritableStateOf<{
@@ -261,7 +254,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>) => U, equals?: ((a: U, b: U) => boolean) | undefined) => U;
     use: {
@@ -292,7 +284,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: (options?: import("./types.d.ts").StoreUseOptions) => number;
         pageState: (options?: import("./types.d.ts").StoreUseOptions) => PageState;
         devMode: (options?: import("./types.d.ts").StoreUseOptions) => boolean;
-        deviceToken: (options?: import("./types.d.ts").StoreUseOptions) => string;
         currentPath: (options?: import("./types.d.ts").StoreUseOptions) => string;
     };
     do: import("./types.d.ts").VoidActions<RootStore> & {
@@ -323,7 +314,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         setKeyboardHeight: (value: number) => void;
         setPageState: (value: PageState) => void;
         setDevMode: (value: boolean) => void;
-        setDeviceToken: (value: string) => void;
         setCurrentPath: (value: string) => void;
     };
     get: () => import("./stateBuilder.d.ts").WritableStateOf<{
@@ -349,7 +339,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>;
     set: (state: Partial<import("./stateBuilder.d.ts").WritableStateOf<{
@@ -375,7 +364,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>> | ((state: import("./stateBuilder.d.ts").WritableStateOf<{
         csrLoaded: boolean;
@@ -400,7 +388,6 @@ export declare const st: import("./agentic.d.ts").StAgentic & {
         keyboardHeight: number;
         pageState: PageState;
         devMode: boolean;
-        deviceToken: string;
         currentPath: string;
     }>) => any)) => void;
     slice: {

package/types/vendor/@akanjs/native/packages/cli/src/api.d.ts

@@ -0,0 +1,182 @@
+import { type DoctorCheck } from "./commands/doctor.ts";
+import type { AkanNativeConfig } from "./config.ts";
+import type { Device, DeviceSelector } from "./lib/launch.ts";
+import { type LogEvent, type LogSink } from "./lib/log.ts";
+import { type AndroidSigning, type BuildProfile, type IosBuild, type IosSigning, type IosSigningResult } from "./lib/prepare.ts";
+import { type TargetPlatform } from "./platforms/index.ts";
+export type { AkanNativeConfig, AndroidSigning, Device, DeviceSelector, DoctorCheck, IosBuild, IosSigning, IosSigningResult, LogEvent, TargetPlatform, };
+/** semver of this API. A caller checks the major before it relies on anything here. */
+export declare const API_VERSION = "0.1.0";
+export type AkanNativeErrorCode = "CONFIG_INVALID" | "TOOLCHAIN_MISSING" | "WEB_INPUT_INVALID" | "WEB_BUILD_FAILED" | "NATIVE_BUILD_FAILED" | "SIGNING_FAILED" | "DEVICE_FAILED" | "CANCELLED" | "INTERNAL";
+export declare class AkanNativeError extends Error {
+    readonly code: AkanNativeErrorCode;
+    readonly details: {
+        problems?: string[];
+        hint?: string;
+        logTail?: string[];
+        cause?: unknown;
+    };
+    constructor(code: AkanNativeErrorCode, message: string, details?: {
+        problems?: string[];
+        hint?: string;
+        logTail?: string[];
+        cause?: unknown;
+    });
+    get problems(): string[] | undefined;
+    get hint(): string | undefined;
+    get logTail(): string[] | undefined;
+}
+export interface TaskOptions {
+    /** Base of the config's relative paths (web.dir, icon, relative plugin folders). */
+    appDir: string;
+    /** What akan-native.config.ts would export. No file is read. */
+    config: AkanNativeConfig;
+    platform: TargetPlatform;
+    /** Default <appDir>/.akan/native/build/<platform>. */
+    outDir?: string;
+    /** Picks .env.<mode>. Default "production" for build, "development" for run. */
+    mode?: string;
+    /** false: no .env files from appDir. Default true. */
+    envFiles?: boolean;
+    /** PUBLIC_ values above .env files and config.env. */
+    env?: Record<string, string>;
+    /** Skip config.web.build and use web.dir as it is. */
+    skipWebBuild?: boolean;
+    /** Where plugin package names resolve from. Default appDir. */
+    resolveFrom?: string;
+    /** Receives the log. Without it nothing is logged. */
+    log?: LogSink;
+    /** Kills the running tools and rejects with CANCELLED. */
+    signal?: AbortSignal;
+}
+export interface Artifact {
+    kind: "app" | "apk" | "aab" | "ipa" | "folder" | "web";
+    path: string;
+    signing: "none" | "adhoc" | "debug" | "development" | "distribution";
+    device?: "simulator" | "device";
+}
+export interface BuildResult {
+    platform: TargetPlatform;
+    profile: BuildProfile;
+    outDir: string;
+    artifacts: Artifact[];
+    warnings: string[];
+    durationMs: number;
+    /** iPhone builds: the identity and provisioning profile found (docs/api.md §3 "Finding the signing"). */
+    signing?: IosSigningResult;
+    /**
+     * Android builds that contain pinned libraries (push's FCM module, iap): the license notices file
+     * (akan-native-licenses.json, also served in the app at /akan-native-licenses.json).
+     */
+    licenses?: string;
+}
+export interface RunningApp {
+    build: BuildResult;
+    /** Where the app runs (iOS and Android). */
+    device?: Device;
+    /** Resolves with the exit code once the app (or its log stream) ends. */
+    exited: Promise<number>;
+    stop(): Promise<void>;
+}
+/** Problems of a config, without building (an empty list: valid). */
+export declare function validateConfig(config: AkanNativeConfig, options: {
+    appDir: string;
+    resolveFrom?: string;
+}): string[];
+/** Builds the app. Default profile release (like `akan-native build`). `ios.device`: an iPhone build (signed; release adds an .ipa). */
+export declare function build(options: TaskOptions & {
+    profile?: BuildProfile;
+    ios?: IosBuild;
+}): Promise<BuildResult>;
+/**
+ * Store files: a release build signed for distribution. Android: the .aab (and, with formats, the
+ * .apk) signed with `signing`. iOS: an iPhone .app and its .ipa, signed with the App Store profile
+ * found for the app (or the ad hoc one when signing.distribution asks for it; docs/api.md §3).
+ */
+export declare function release(options: TaskOptions & ({
+    platform: "android";
+    signing: AndroidSigning;
+    formats?: ("aab" | "apk")[];
+} | {
+    platform: "ios";
+    signing?: IosSigning;
+})): Promise<BuildResult>;
+/** Builds (default profile debug) and launches the app on a simulator, emulator, desktop or browser. */
+export declare function run(options: TaskOptions & {
+    profile?: BuildProfile;
+    /**
+     * iOS: a simulator's name or UDID, or a paired iPhone's name (an iPhone build). Android: a device's
+     * serial or an AVD name. Or `{ id }`, `{ name }`, `{ kind }` from devices().
+     */
+    device?: DeviceSelector;
+    headless?: boolean;
+    /** Runtime env for dev builds (AKAN_NATIVE_PUBLIC_* overrides). */
+    runtimeEnv?: Record<string, string>;
+    /** The app's log lines. */
+    onLine?: (line: string) => void;
+    /** An iPhone build: narrows how the signing is found (e.g. only teamId). */
+    ios?: {
+        signing?: IosSigning;
+    };
+}): Promise<RunningApp>;
+export interface DevSession {
+    /** The dev gateway the app's pages come from. */
+    gateway: string;
+    build: BuildResult;
+    /** Where the app runs (iOS and Android); after a rebuild, where it runs now. */
+    readonly device?: Device;
+    /** Builds again (a changed config or env), reinstalls and relaunches; the pages keep coming from the gateway. */
+    rebuild(config?: AkanNativeConfig): Promise<BuildResult>;
+    /** Starts the installed app again without building: a fresh process that loads its first page again. */
+    reload(): Promise<void>;
+    /** Resolves when the app's log stream or the gateway ends. */
+    exited: Promise<number>;
+    stop(): Promise<void>;
+}
+/**
+ * Development on a simulator, emulator or device (akanjs readiness O4, docs/api.md): a debug build
+ * whose pages come from the dev gateway, which proxies an external dev server (`upstream`) or runs
+ * Bun's own for web.devEntry. The pages keep the app's origin; only the HMR socket (`hmrPath`) goes to
+ * the gateway. `startPath` is the first page; `lan` lets a real iPhone reach the Mac, and is on by
+ * default when `device` is a paired iPhone.
+ */
+export declare function dev(options: TaskOptions & {
+    upstream?: string;
+    hmrPath?: string;
+    startPath?: string;
+    lan?: boolean;
+    /** The app's own WebSocket paths the gateway relays to `upstream` (W4), e.g. ["/ws"]. */
+    wsPaths?: string[];
+    /** Android: more device ports than the gateway's that reach the same port on this computer (adb reverse). */
+    reversePorts?: number[];
+    device?: DeviceSelector;
+    headless?: boolean;
+    runtimeEnv?: Record<string, string>;
+    onLine?: (line: string) => void;
+    ios?: {
+        signing?: IosSigning;
+    };
+}): Promise<DevSession>;
+/** Simulators, emulators and devices of a platform (docs/api.md devices), running and connected ones first. */
+export declare function devices(options: {
+    platform: "ios" | "android";
+    log?: LogSink;
+    signal?: AbortSignal;
+}): Promise<Device[]>;
+export interface DoctorReport {
+    /** No check failed (warnings allowed). */
+    ok: boolean;
+    checks: DoctorCheck[];
+}
+/**
+ * The toolchains the platforms need, pinned version against what is found (R4-4, akan doctor).
+ * Default: what this machine can build. `fix` installs only what akan-native pins (kotlinc, bundletool,
+ * the pinned Rust, SDK packages once their licenses are accepted), then checks again; it never
+ * accepts a license and never downloads a JDK.
+ */
+export declare function doctor(options?: {
+    platforms?: TargetPlatform[];
+    fix?: boolean;
+    log?: LogSink;
+    signal?: AbortSignal;
+}): Promise<DoctorReport>;

package/types/vendor/@akanjs/native/packages/cli/src/commands/build.d.ts

@@ -0,0 +1,28 @@
+import { type ParsedArgs } from "../lib/args.ts";
+import { type BuildContext, type BuildProfile } from "../lib/prepare.ts";
+import { type TargetPlatform } from "../platforms/index.ts";
+export declare const BOOLEAN_FLAGS: string[];
+/** Flags of every build: the app, the env mode (.env.<mode>), the profile, the web build. */
+export declare const BUILD_FLAGS: string[];
+/** Flags of launching a build (web server, simulators, emulators). */
+export declare const LAUNCH_FLAGS: string[];
+export declare const BUILD_USAGE: string;
+export declare const RUN_USAGE: string;
+export interface BuildDefaults {
+    /** .env.<mode>, unless --mode */
+    mode: string;
+    /** Unless --release or --debug (commands that allow them). */
+    profile: BuildProfile;
+}
+export declare function buildFromArgs(args: ParsedArgs, defaults: BuildDefaults, platformOverride?: TargetPlatform, extra?: {
+    devServer?: string;
+    startPath?: string;
+}): Promise<{
+    ctx: BuildContext;
+    artifact: string;
+    platform: TargetPlatform;
+}>;
+/** `akan-native build`: a release build unless --debug. */
+export declare function build(argv: string[]): Promise<number>;
+/** `akan-native run`: a debug build unless --release. */
+export declare function run(argv: string[]): Promise<number>;

package/types/vendor/@akanjs/native/packages/cli/src/commands/compat.d.ts

@@ -0,0 +1,2 @@
+export declare const COMPAT_USAGE: string;
+export declare function compat(argv: string[]): Promise<number>;

package/types/vendor/@akanjs/native/packages/cli/src/commands/dev.d.ts

@@ -0,0 +1,2 @@
+export declare const DEV_USAGE: string;
+export declare function dev(argv: string[]): Promise<number>;

package/types/vendor/@akanjs/native/packages/cli/src/commands/doctor.d.ts

@@ -0,0 +1,37 @@
+export type Platform = "web" | "macos" | "windows" | "linux" | "ios" | "android";
+export declare const PLATFORMS: readonly Platform[];
+/** Without arguments: what this machine can build (desktop apps and iOS only on their own OS). */
+export declare function hostPlatforms(): Platform[];
+interface Fix {
+    /** What --fix does, shown in the plan. */
+    describe: string;
+    run: () => Promise<void>;
+}
+/** One check's result, as the API reports it (docs/api.md doctor). */
+export interface DoctorCheck {
+    /** "Common", "iOS", "Android", "macOS desktop", … */
+    group: string;
+    /** What is checked, e.g. "kotlinc", "Xcode", "SDK licenses". */
+    name: string;
+    ok: boolean;
+    /** Works, but not with the pinned version or without an optional piece. Not a failure. */
+    warn: boolean;
+    /** What was found (a version, a path) or what is wrong. */
+    detail: string;
+    /** What to do about it. */
+    hint?: string;
+    /** doctor({ fix: true }) can fix it (only toolchains akan-native pins; never a license or a JDK). */
+    fixable: boolean;
+}
+/** The checks for these platforms, with what --fix would run. */
+export declare function doctorChecks(targets: Platform[]): {
+    check: DoctorCheck;
+    fix?: Fix;
+}[];
+/** Runs every fix of these checks; a failing one is logged and the others still run. */
+export declare function runFixes(checks: {
+    check: DoctorCheck;
+    fix?: Fix;
+}[]): Promise<void>;
+export declare function doctor(args: string[]): Promise<number>;
+export {};

package/types/vendor/@akanjs/native/packages/cli/src/commands/plugin.d.ts

@@ -0,0 +1,2 @@
+export declare const PLUGIN_USAGE = "akan-native plugin check [dir] | akan-native plugin codegen [dir] [--out <dir>] | akan-native plugin stub <ios|android> [dir] | akan-native plugin compile <ios|android> [dir] [--only id,id]";
+export declare function plugin(argv: string[]): Promise<number>;

package/types/vendor/@akanjs/native/packages/cli/src/commands/signing.d.ts

@@ -0,0 +1,2 @@
+export declare const SIGNING_USAGE = "akan-native signing setup | akan-native signing status";
+export declare function signing(argv: string[]): Promise<number>;

package/types/vendor/@akanjs/native/packages/cli/src/commands/test.d.ts

@@ -0,0 +1,2 @@
+export declare const TEST_USAGE: string;
+export declare function test(argv: string[]): Promise<number>;

package/types/vendor/@akanjs/native/packages/cli/src/commands/toolchain.d.ts

@@ -0,0 +1,2 @@
+export declare const TOOLCHAIN_USAGE = "akan-native toolchain [list] | akan-native toolchain install <kotlin|jdk|bundletool|rust|android>";
+export declare function toolchain(args: string[]): Promise<number>;

package/types/vendor/@akanjs/native/packages/cli/src/commands/update.d.ts

@@ -0,0 +1,2 @@
+export declare const UPDATE_USAGE = "akan-native update keygen [--app <dir>] | akan-native update publish <ios|android|macos|windows|linux> [--app <dir>] [--mode <mode>] [--debug] [--channel <name>] [--out <dir>] | akan-native update serve [--app <dir>] [--out <dir>] [--port <n>]";
+export declare function update(argv: string[]): Promise<number>;