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

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

@@ -0,0 +1,44 @@
+import type { Platform } from "../../../core/src/index.ts";
+export declare const PUBLIC_PREFIX = "PUBLIC_";
+/** Parses a dotenv file: KEY=value, `export KEY=value`, # comments, '' literal and "" escaped values. */
+export declare function parseDotenv(text: string): Record<string, string>;
+/** App config `env` (ENV-1, ENV-6). */
+export interface EnvConfig {
+    defaults: Record<string, string>;
+    platforms: Partial<Record<Platform, Record<string, string>>>;
+}
+export interface EnvResult {
+    env: Record<string, string>;
+    /** Sources that had values, lowest precedence first ("akan-native.config", ".env", "akan-native.config (android)", ...). */
+    files: string[];
+    /** Keys dropped because they lack the PUBLIC_ prefix. */
+    dropped: string[];
+    /** Every source that set each kept key, lowest precedence first (for the generated types). */
+    sources: Record<string, string[]>;
+}
+/**
+ * The build-time layers for one mode and platform, lowest precedence first: the shared chain,
+ * then the same chain for the platform, so a platform value wins over every shared one (the way
+ * Tauri merges tauri.<platform>.conf.json over tauri.conf.json, tauri-utils config/parse.rs:50-66).
+ *
+ *   env.defaults < .env < .env.<mode> < env.platforms.<p> < .env.<p> < .env.<mode>.<p>
+ */
+export interface EnvLoadOptions {
+    /** false: skip the .env files (docs/api.md envFiles). Default true. */
+    files?: boolean;
+    /** Values above every other layer (docs/api.md env), shown as the source "api". */
+    overrides?: Record<string, string>;
+}
+export declare function loadEnv(appDir: string, mode: string, platform: Platform, config: EnvConfig, options?: EnvLoadOptions): EnvResult;
+/** Checks `env` in akan-native.config.ts. */
+export declare function validateEnvConfig(raw: unknown, problems: string[]): EnvConfig;
+export declare const ENV_TYPES_FILE = "akan-native-env.d.ts";
+/**
+ * akan-native-env.d.ts (ENV-7): the PUBLIC_ keys the build can give the app, over every mode and build
+ * target. A key all of them get is `string`, the rest are optional. Only key names go in the file.
+ * Keys that exist only at run time (AKAN_NATIVE_PUBLIC_*, a replaced env.runtime.json) still read as
+ * the index signature on `env` in @akanjs/native/core.
+ */
+export declare function envTypes(appDir: string, config: EnvConfig): string;
+/** Writes akan-native-env.d.ts next to akan-native.config.ts when it changed. Returns whether it wrote. */
+export declare function writeEnvTypes(appDir: string, config: EnvConfig): boolean;

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

@@ -0,0 +1,31 @@
+import { CliError } from "./log.ts";
+export interface ExecOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    /** Print the command before running it. Default true. */
+    echo?: boolean;
+    /** Stream output to the terminal instead of capturing it (to the log sink inside an API call). */
+    inherit?: boolean;
+    /** The tool name on streamed lines. Default the command's file name. */
+    tool?: string;
+}
+export interface ExecResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+/** Runs `fn` with every command it starts killed when `signal` aborts (docs/api.md `signal`). */
+export declare function withSignal<T>(signal: AbortSignal | undefined, fn: () => T): T;
+/** The abort signal of the API call this runs in, if any. */
+export declare function currentSignal(): AbortSignal | undefined;
+/** A command killed because the API call was cancelled. */
+export declare class CancelledError extends CliError {
+    constructor();
+}
+/** Throws CancelledError once the current API call was cancelled. */
+export declare function throwIfCancelled(): void;
+export declare function formatCommand(cmd: string[]): string;
+/** Runs a command and returns its output. Does not throw on a non-zero exit. */
+export declare function exec(cmd: string[], options?: ExecOptions): Promise<ExecResult>;
+/** Runs a command and throws a ToolError with its output when it fails. */
+export declare function execOrThrow(cmd: string[], options?: ExecOptions): Promise<ExecResult>;

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

@@ -0,0 +1,2 @@
+/** res/values/google_services.xml for `packageName` (and `fallbackPackage` when it has no client). */
+export declare function googleServicesXml(json: string, packageName: string, fallbackPackage?: string): string;

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

@@ -0,0 +1,120 @@
+import type { Platform } from "../../../core/src/index.ts";
+import { type CspConfig } from "./csp.ts";
+import type { Project } from "./project.ts";
+export declare const HMR_PATH = "/_bun/hmr";
+/** The app's source HTML for Bun's dev server: web.devEntry, else index.html in the app folder. */
+export declare function resolveDevEntry(project: Project): string;
+/**
+ * Inline classic script in the dev page. It runs while the document is parsed, so before Bun's
+ * client (a module script, deferred).
+ * - Bun's error overlay host gets its style with setAttribute("style"), which a hash-based policy
+ *   refuses (style-src-attr); the same text through CSSOM (style.cssText) is allowed. Only that
+ *   element: the app's own style attributes meet the policy as in a build.
+ * - `socket` (native hosts): WebSockets the page opens on its own origin to the HMR path (or one of
+ *   `paths`, the app's own sockets relayed by the gateway) go to the gateway's origin instead, and
+ *   `window.__AKAN_NATIVE_DEV__.gateway` tells the app its page came through the gateway.
+ * - `socket.relayBodies` (Android): fetch and XMLHttpRequest calls on the page's origin with a method
+ *   other than GET or HEAD go to the gateway's http origin instead. shouldInterceptRequest hands the
+ *   shell no request body, so the host cannot carry them; http://localhost is a trustworthy origin
+ *   there, so the call is not mixed content, and the dev server answers the app origin's CORS.
+ */
+export declare function devShim(socket?: {
+    origin: string;
+    path?: string;
+    paths?: string[];
+    relayBodies?: boolean;
+}): string;
+/**
+ * What Bun's dev client needs on top of the app's policy: its updates run as blob: scripts, and
+ * its socket goes to ws://localhost:<port> (neither is covered by 'self' from app://). A directive
+ * that is absent and has no default-src is unrestricted and stays absent.
+ */
+export declare function devCspSources(policy: string, wsOrigin: string): string;
+export interface DevHtmlOptions {
+    platform: Platform;
+    /** The gateway's port. */
+    port: number;
+    /** Where the page's HMR socket goes (native hosts). Default ws://localhost:<port>. */
+    wsOrigin?: string;
+    /** The HMR socket path the page opens. Default Bun's /_bun/hmr. */
+    hmrPath?: string;
+    /** The app's own socket paths the gateway relays too (W4). */
+    wsPaths?: string[];
+    /** security.csp; the policy is built from the rewritten page, as `akan-native build` does (SEC-4). */
+    csp?: CspConfig;
+}
+/**
+ * Bun's page → the page a host serves: the init.js tag first in <head> (IN-3), the dev shim right
+ * before Bun's client script, then the CSP <meta> with the hashes of the final inline scripts
+ * (Bun's own and the shim included) plus devCspSources.
+ */
+export declare function rewriteDevHtml(html: string, opts: DevHtmlOptions): {
+    html: string;
+    warnings: string[];
+};
+export type DevRoute = {
+    kind: "hmr";
+} | {
+    kind: "bun";
+} | {
+    kind: "init";
+} | {
+    kind: "page";
+}
+/** Absolute path of a public file. */
+ | {
+    kind: "file";
+    path: string;
+} | {
+    kind: "not-found";
+};
+/**
+ * The gateway's decision for a path, on top of the host routing rules (lib/routes.ts): Bun's own
+ * paths go to Bun, index.html and SPA routes are the rewritten page, public files come from
+ * `publicDirs` (first match wins; index.html is always the page).
+ */
+export declare function routeDevRequest(pathname: string, publicDirs: string[], hmrPath?: string): DevRoute;
+/** .akan/native/dev/server.ts: Bun's dev server for the entry, reporting its port on stdout. */
+export declare function bunDevServerScript(entry: string): string;
+export interface HmrContext {
+    project: Project;
+    /** web: the /__akan_native/init.js text. Native hosts serve their own. */
+    initScript?: () => string;
+}
+export interface HmrOptions {
+    platform: Platform;
+    /** The app's source HTML for Bun's dev server; unused with `upstream`. */
+    entry?: string;
+    /** An external dev server's origin (akanjs readiness O4-1), proxied instead of Bun's dev server. */
+    upstream?: string;
+    /** The HMR socket path the page opens (O4-2). Default Bun's /_bun/hmr. */
+    hmrPath?: string;
+    /**
+     * The app's own WebSocket paths (W4), e.g. ["/ws"]: a socket the page opens on its origin to one of
+     * them goes through the gateway to the dev server (`upstream`), so a real iPhone reaches the Mac's
+     * server as it does the pages.
+     */
+    wsPaths?: string[];
+    /** The host the app reaches the gateway at: a LAN address for a real iPhone (O4-3). Default the loopback name. */
+    publicHost?: string;
+    /** 0 = any free port. */
+    port: number;
+    hostname: string;
+    /** Read on every request: akan-native dev replaces the project and init.js after a config change. */
+    context: HmrContext;
+    /** Bun's dev server output. */
+    onLine: (line: string) => void;
+    /** Gateway problems (each text once). */
+    onWarning: (text: string) => void;
+}
+export interface HmrServer {
+    /** The gateway, e.g. http://127.0.0.1:52011 */
+    url: string;
+    port: number;
+    /** Rejects when Bun's dev server ends on its own. */
+    exited: Promise<number>;
+    stop(): void;
+}
+export declare function startHmrServer(opts: HmrOptions): Promise<HmrServer>;
+/** The Mac's private IPv4 address on a network (Wi-Fi or Ethernet), for a real iPhone (O4-3). */
+export declare function lanAddress(interfaces?: NodeJS.Dict<import("node:os").NetworkInterfaceInfo[]>): string | undefined;

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

@@ -0,0 +1,20 @@
+export declare const INIT_SCRIPT_PATH = "__akan_native/init.js";
+/**
+ * Inserts `<script src="/__akan_native/init.js">` as the first element of <head> (IN-3).
+ * A classic, non-async script runs before the inlined module bundle, so the
+ * boot data is ready synchronously.
+ */
+export declare function injectInitScript(html: string, base?: string): string;
+/**
+ * Dev builds (architecture review stage 5, an always-on error path; RN JsErrorHandler): errors of the
+ * page before @akanjs/native/core runs (a bundle that fails to parse or throws at the top) would reach no log.
+ * This collects them in `__AKAN_NATIVE__.early`; core sends them to the host log when it loads
+ * (runtime.ts flushEarlyErrors). If core never loads, the page reports them itself after 5 s: to the
+ * desktop host over /__akan_native/ipc, to iOS over the message handler, and on Android to logcat (the
+ * WebView's console already goes there). The first error keeps its stack; later ones their message.
+ */
+export declare const EARLY_ERRORS_SCRIPT: string;
+/** Puts the early error collector right after the init.js tag (dev builds). */
+export declare function injectEarlyErrors(html: string): string;
+/** External `<script src>` (other than init.js) break the single-file rule (IN-2). */
+export declare function findExternalScripts(html: string): string[];

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

@@ -0,0 +1,44 @@
+import { type Rgba } from "./image.ts";
+import { type Image } from "./png.ts";
+import type { ResolvedConfig } from "./project.ts";
+/** Splash image box on iOS (points) and Android (dp): a square that fits the 192dp splash circle. */
+export declare const SPLASH_BOX = 136;
+export declare function readPng(path: string, what: string): Image;
+export interface IconArt {
+    /** 1024×1024 RGBA. */
+    master: Image;
+    /** Fills transparent areas where a platform needs an opaque icon (iOS, Android adaptive background). */
+    background: Rgba;
+}
+export declare function iconArt(config: ResolvedConfig): IconArt | null;
+export declare function splashArt(config: ResolvedConfig): Image | null;
+/**
+ * Full-bleed (opaque) sources get the macOS icon grid: an 824px rounded square with a 185px
+ * radius centered in 1024px, as in Apple's Big Sur template. Transparent sources are used as is.
+ */
+export declare function macosIconImage(art: IconArt): Image;
+export declare function icns(image: Image): Uint8Array;
+/** An .ico with PNG entries (Windows Vista and later read PNG-compressed icon images). */
+export declare function ico(image: Image): Uint8Array;
+/**
+ * The window icon for Windows and Linux (tao's Icon::from_rgba), read by native/desktop at
+ * startup: [u32 width LE][u32 height LE][RGBA pixels]. No image decoder in the shell this way.
+ */
+export declare function windowIcon(image: Image, size?: number): Uint8Array;
+/**
+ * Writes Assets.xcassets for actool: AppIcon (one 1024 universal image; actool derives the rest),
+ * AkanNativeSplashBackground (light/dark) and AkanNativeSplash (the splash image at 1x/2x/3x) for UILaunchScreen.
+ * Returns the asset names the Info.plist may refer to.
+ */
+export declare function writeIosAssets(dir: string, config: ResolvedConfig): {
+    appIcon: boolean;
+    splashImage: boolean;
+};
+/**
+ * Writes res/ for aapt2 compile: the theme (window and splash background, splash icon), the
+ * adaptive launcher icon and colors with a night variant. Only xxxhdpi bitmaps: the system
+ * scales them down for lower densities.
+ */
+export declare function writeAndroidRes(dir: string, config: ResolvedConfig): {
+    icon: boolean;
+};

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

@@ -0,0 +1,21 @@
+import type { Image } from "./png.ts";
+export type Rgba = [number, number, number, number];
+/** "#rrggbb" or "#rrggbbaa" → [r, g, b, a], or null. */
+export declare function parseColor(text: string): Rgba | null;
+export declare function toHex([r, g, b]: Rgba): string;
+export declare function blank(width: number, height: number, color?: Rgba): Image;
+export declare function isOpaque(image: Image): boolean;
+/** Top-left pixel: the background of a full-bleed icon. */
+export declare function cornerColor(image: Image): Rgba;
+export declare function resize(image: Image, width: number, height: number): Image;
+/** Draws `top` over `bottom` at (x, y), source-over. */
+export declare function drawOver(bottom: Image, top: Image, x: number, y: number): Image;
+/** A size×size transparent canvas with the image scaled to fit a box×box square in its center. */
+export declare function contain(image: Image, size: number, box: number): Image;
+/** The image composited on an opaque color (iOS app icons must not be transparent). */
+export declare function flatten(image: Image, color: Rgba): Image;
+/**
+ * Keeps only a centered rounded rectangle (inset from each edge, corner radius in pixels),
+ * anti-aliased with a signed distance per pixel.
+ */
+export declare function roundedMask(image: Image, inset: number, radius: number): Image;

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

@@ -0,0 +1,81 @@
+import { type PlistValue } from "./plist.ts";
+export interface SigningIdentity {
+    /** The certificate's SHA-1, which codesign takes without ambiguity. */
+    sha1: string;
+    /** e.g. "Apple Development: Jane Doe (ABCDE12345)". */
+    name: string;
+}
+export type ProfileKind = "development" | "ad-hoc" | "app-store" | "enterprise";
+export interface ProvisioningProfile {
+    path: string;
+    name: string;
+    uuid: string;
+    teamId: string;
+    /** application-identifier, e.g. "TEAMID.com.akanjs.sample" or "TEAMID.*". */
+    appId: string;
+    entitlements: Record<string, PlistValue>;
+    expires: Date;
+    kind: ProfileKind;
+    /** Device UDIDs (development and ad-hoc). */
+    devices: string[];
+    /** SHA-1 of the certificates the profile allows to sign. */
+    certificates: string[];
+}
+/** Valid code signing identities (`security find-identity -v`: revoked and expired ones are left out). */
+export declare function signingIdentities(): Promise<SigningIdentity[]>;
+export declare function parseIdentities(out: string): SigningIdentity[];
+/**
+ * The identity to sign with: `wanted` as a SHA-1 or a name (a name two valid certificates share is an
+ * error), else the only valid "Apple Development" (development) or "Apple Distribution" identity.
+ */
+export declare function pickIdentity(identities: SigningIdentity[], kind: "development" | "distribution", wanted?: string): SigningIdentity;
+/** The folders Xcode and older tools keep provisioning profiles in. */
+export declare function profileFolders(home?: string): string[];
+/** Decodes a .mobileprovision (a CMS-signed plist). */
+export declare function readProfile(path: string): Promise<ProvisioningProfile>;
+/** A profile from its decoded plist (parsePlist: data as base64, dates as Date). */
+export declare function profileFromPlist(path: string, p: Record<string, unknown>): ProvisioningProfile;
+/** Whether a profile's application-identifier covers the bundle id (exactly, or a wildcard like TEAM.* or TEAM.com.akanjs.*). */
+export declare function profileCovers(profile: ProvisioningProfile, bundleId: string): "exact" | "wildcard" | null;
+/** The profiles in Xcode's folders; unreadable ones are left out. */
+export declare function localProfiles(): Promise<ProvisioningProfile[]>;
+export interface SigningQuery {
+    bundleId: string;
+    /** development for run and dev; app-store for release, ad-hoc only when asked for. */
+    kinds: ProfileKind[];
+    identityKind: "development" | "distribution";
+    /** Only this team's profiles. */
+    teamId?: string;
+    /** A certificate name or SHA-1: only it. */
+    identity?: string;
+    /** The iPhone the build goes on: development and ad hoc profiles must list it. */
+    device?: {
+        udid: string;
+        name?: string;
+    };
+    /** The entitlements the app asks for, as signing with this profile would request them. */
+    entitlementsFor(profile: ProvisioningProfile): Record<string, PlistValue>;
+    now?: Date;
+}
+export interface SigningChoice {
+    identity: SigningIdentity;
+    profile: ProvisioningProfile;
+}
+/**
+ * The identity and profile an iPhone build signs with (D7 step 1: what Xcode made on this Mac;
+ * docs/api.md §3 "Finding the signing"). A profile fits when it covers the bundle id (a wildcard
+ * only when the app asks for neither push nor associated domains), is of the wanted kind, has not
+ * expired, belongs to `teamId` when one is given, lists `device` when it is a development or ad hoc
+ * profile, allows every entitlement the app asks for, and one of its certificates is a valid identity
+ * in the keychain (or the chosen one). Of the fitting ones,
+ * exact bundle ids beat wildcards; then several teams, or several certificates, are not decided
+ * here: the error lists the candidates. One team and one certificate: the profile that expires last
+ * (Xcode makes a new one when it renews).
+ */
+export declare function chooseSigning(identities: SigningIdentity[], profiles: ProvisioningProfile[], q: SigningQuery): SigningChoice;
+/**
+ * Entitlements the app asks for that the profile does not allow (App Store Connect and the device
+ * refuse such a signature). A profile lists what the App ID has: an array value there is a set of
+ * allowed values, where "*" or "TEAM.*" allows any.
+ */
+export declare function entitlementProblems(requested: Record<string, PlistValue>, profile: ProvisioningProfile): string[];

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

@@ -0,0 +1,51 @@
+export interface LaunchOptions {
+    /** Runtime env overrides (dev builds), e.g. { AKAN_NATIVE_PUBLIC_SELFTEST: "1" }. */
+    env: Record<string, string>;
+    /** Do not open windows or steal focus where the platform allows it. */
+    headless: boolean;
+    /** Receives every log line. Default: print it. */
+    onLine?: (line: string) => void;
+}
+/** A simulator, emulator or device an app can run on (docs/api.md devices). */
+export interface Device {
+    platform: "ios" | "android";
+    /** A simulator's UDID, a paired iPhone's devicectl id, an adb serial, or the name of an AVD that is not running. */
+    id: string;
+    name: string;
+    kind: "simulator" | "emulator" | "device";
+    /** "26.5" on iOS; "Android 17 (API 37)" for a running Android device, "API 37" for an AVD that is not. */
+    os: string;
+    /**
+     * booted / shutdown (simulators, AVDs), connected (a paired iPhone, an adb device), unavailable (a
+     * paired iPhone out of reach), unpaired (an iPhone this Mac is not paired with), unauthorized (an
+     * Android device that has not allowed USB debugging), offline.
+     */
+    state: "booted" | "shutdown" | "connected" | "unavailable" | "unpaired" | "unauthorized" | "offline";
+}
+/** Which device: a name or id as text, or one of these. `{ kind }` takes the first one of the kind, running ones first. */
+export type DeviceSelector = string | {
+    id: string;
+} | {
+    name: string;
+} | {
+    kind: Device["kind"];
+};
+export interface Launched {
+    /** Resolves with the exit code once the app (or log stream) ends. */
+    exited: Promise<number>;
+    stop(): void;
+    /** Where the app runs (iOS and Android). */
+    device?: Device;
+}
+/** Splits a byte stream into lines and hands each to `onLine`. */
+export declare function pipeLines(stream: ReadableStream<Uint8Array> | null | undefined, onLine: (line: string) => void): Promise<void>;
+export declare const printLine: (line: string) => void;
+/** AKAN_NATIVE_PUBLIC_* variables of the CLI's own environment. */
+export declare function envFromProcess(): Record<string, string>;
+/**
+ * Calls `handler` once on Ctrl+C, kill or a closed terminal and returns a function that unregisters it.
+ * Spawned children (the app, logcat, simctl log stream, Chrome) outlive a CLI that dies of a signal.
+ */
+export declare function onStopSignal(handler: () => void): () => void;
+/** Waits for a launched app and stops it when the CLI is interrupted. */
+export declare function follow(app: Launched): Promise<number>;

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

@@ -0,0 +1,42 @@
+export type LogLevel = "step" | "info" | "ok" | "warn" | "error" | "tool";
+export interface LogEvent {
+    level: LogLevel;
+    message: string;
+    /** For "tool": whose output the line is ("web-build", "swiftc", "kotlinc", "cargo" …). */
+    tool?: string;
+    time: number;
+}
+export type LogSink = (event: LogEvent) => void;
+/** Runs `fn` with its log going to `sink` (none: dropped) instead of the terminal. */
+export declare function withLogSink<T>(sink: LogSink | undefined, fn: () => T): T;
+/** Whether output goes to the terminal (the CLI), not to an API caller's sink. */
+export declare function isTerminal(): boolean;
+export declare const dim: (text: string) => string;
+export declare const bold: (text: string) => string;
+export declare const green: (text: string) => string;
+export declare const yellow: (text: string) => string;
+export declare const red: (text: string) => string;
+export declare const cyan: (text: string) => string;
+export declare const log: {
+    step: (text: string) => void;
+    info: (text: string) => void;
+    ok: (text: string) => void;
+    warn: (text: string) => void;
+    error: (text: string) => void;
+    /** A line of a child process's output (web build, compilers) that the terminal would show as is. */
+    tool: (tool: string, line: string) => void;
+};
+/** An error whose message is shown to the user without a stack trace. */
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}
+/** A required toolchain (SDK, JDK, kotlinc, simulator runtime) is missing (AkanNativeError TOOLCHAIN_MISSING). */
+export declare class ToolchainError extends CliError {
+    constructor(message: string);
+}
+/** A command that failed: its last output lines travel with the error (AkanNativeError.logTail). */
+export declare class ToolError extends CliError {
+    readonly tail: string[];
+    constructor(message: string, tail: string[]);
+}

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

@@ -0,0 +1,18 @@
+export interface LibraryManifest {
+    /** For messages. */
+    from: string;
+    xml: string;
+}
+export interface MergedManifest {
+    /** uses-permission names. */
+    permissions: string[];
+    /** XML at the <manifest> level: permission definitions and one <queries>. */
+    manifestXml: string[];
+    /** XML inside <application>: components and meta-data. */
+    applicationXml: string[];
+    /** Attributes for <application>, e.g. android:appComponentFactory. */
+    applicationAttrs: [string, string][];
+    /** Component classes, for R8 keep rules. */
+    components: string[];
+}
+export declare function mergeLibraryManifests(manifests: LibraryManifest[], applicationId: string): MergedManifest;

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

@@ -0,0 +1,97 @@
+export declare const MAVEN_LOCK: string;
+export interface License {
+    name: string;
+    url?: string;
+}
+export interface MavenArtifact {
+    coordinate: string;
+    url: string;
+    sha256: string;
+    size: number;
+    packaging: "aar" | "jar";
+    /** The artifact's POM, pinned for its licenses (scripts/maven-licenses.ts). */
+    pom?: {
+        url: string;
+        sha256: string;
+        size: number;
+    };
+    /** What the POM (or, see licensesFrom, its parent) declares. */
+    licenses?: License[];
+    licensesFrom?: string;
+}
+export interface MavenLock {
+    format: string;
+    closures: {
+        name: string;
+        roots: string[];
+        artifacts: string[];
+    }[];
+    artifacts: Record<string, Omit<MavenArtifact, "coordinate">>;
+}
+export declare function loadMavenLock(path?: string): MavenLock;
+/** The locked closure whose roots are exactly `roots` (in any order); null for no roots. */
+export declare function closureFor(lock: MavenLock, roots: string[]): {
+    name: string;
+    artifacts: MavenArtifact[];
+} | null;
+export declare function mavenCache(env?: Record<string, string | undefined>): string;
+/** The artifact's file in the cache, downloaded and checked first when needed. */
+export declare function fetchArtifact(a: MavenArtifact, cache?: string, fetcher?: typeof fetch): Promise<string>;
+export interface Library {
+    coordinate: string;
+    /** The AAR manifest's package (its R class package); none for plain jars. */
+    package?: string;
+    /** Compile classpath and dex input. */
+    classes: string;
+    manifest?: string;
+    res?: string;
+    /** R.txt with at least one entry: the library reads R fields and needs an R class. */
+    hasResources: boolean;
+    proguard?: string;
+    /** jni/<abi>/<lib>.so */
+    nativeLibs: {
+        abi: string;
+        name: string;
+        path: string;
+    }[];
+    /** META-INF/services/* of the classes jar (ServiceLoader: kotlinx-coroutines' main dispatcher). */
+    services: {
+        name: string;
+        path: string;
+    }[];
+    /** The licenses its POM declares (from the lock). */
+    licenses: License[];
+    /** Notices of code built into it (an AAR's third_party_licenses.json and .txt: Play services, Billing). */
+    notices: {
+        name: string;
+        text: string;
+    }[];
+}
+/** Unpacks an AAR (or indexes a jar) into the cache once; returns where its parts are. */
+export declare function unpackLibrary(a: MavenArtifact, file: string, cache?: string): Library;
+/**
+ * Google's AARs carry notices for code built into them: third_party_licenses.json maps each name to
+ * {start, length}, byte offsets into third_party_licenses.txt (the format the oss-licenses plugin reads).
+ */
+export declare function embeddedNotices(aar: Uint8Array): {
+    name: string;
+    text: string;
+}[];
+/** akan-native-licenses.json: what an Android build with pinned Maven libraries puts into the app (user decision 2026-09-27). */
+export interface LicenseNotices {
+    about: string;
+    /** Every pinned library: its coordinate and the licenses its POM declares. */
+    libraries: {
+        name: string;
+        version: string;
+        licenses: License[];
+    }[];
+    /** Code built into those libraries, with its notice text; one entry per name. */
+    notices: {
+        name: string;
+        text: string;
+    }[];
+}
+export declare function licenseNotices(libraries: Library[]): LicenseNotices;
+/** Downloads (once) and unpacks a closure; logs what it fetched. */
+export declare function prepareLibraries(artifacts: MavenArtifact[], cache?: string): Promise<Library[]>;

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

@@ -0,0 +1,45 @@
+export interface Named {
+    name: string;
+    /** Where it comes from, for the message: "plugin sqlite (ios/SqlitePlugin.swift)". */
+    from: string;
+}
+/** One message per clash of names that are the same by letters and digits, case-folded. */
+export declare function collisions(entries: Named[], what: string): string[];
+/** A plugin's name prefix in generated code, as codegen.ts makes it. */
+export declare const pascal: (text: string) => string;
+/**
+ * Top-level Swift types of a source file (the module's namespace): class, struct, enum, protocol,
+ * actor, typealias at the start of a line, not private or fileprivate (those are the file's own).
+ */
+export declare function swiftTypes(text: string): string[];
+/** A Kotlin file's package and top-level types (class, object, interface, enum class, typealias …). */
+export declare function kotlinTypes(text: string): {
+    pkg: string;
+    types: string[];
+};
+export interface IosNameInput {
+    /** The app's Swift module name. */
+    module: string;
+    shellSources: string[];
+    plugins: {
+        id: string;
+        className: string;
+        sources: string[];
+        frameworks: string[];
+    }[];
+    /** Generated Swift files (bindings, registry). */
+    generated: string[];
+}
+/** Clashes in the iOS app's one Swift module: plugin prefixes, top-level types, file names, the module's own name. */
+export declare function iosNameProblems(input: IosNameInput): string[];
+export interface AndroidNameInput {
+    plugins: {
+        id: string;
+        className: string;
+        sources: string[];
+    }[];
+    /** Generated Kotlin files (bindings, registry). */
+    generated: string[];
+}
+/** Clashes among Android classes: plugin prefixes, plugin classes, and types by package (case-folded). */
+export declare function androidNameProblems(input: AndroidNameInput): string[];