akanjs 3.0.0-beta.9 → 3.0.0

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[];

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

@@ -0,0 +1,67 @@
+import type { PluginDecl } from "../../../core/src/index.ts";
+import type { PlistValue } from "./plist.ts";
+import type { AndroidManifest, IosManifest, ResolvedPlugin } from "./project.ts";
+export type NativePlatform = "macos" | "windows" | "linux" | "ios" | "android";
+/** Declarations for boot.json: how this platform provides each plugin. */
+export declare function pluginDecls(plugins: ResolvedPlugin[], platform: NativePlatform): Record<string, PluginDecl>;
+/**
+ * A desktop module against its manifest: the page is told the methods and events of the manifest
+ * (or its `desktop` subset), and the host answers NOT_FOUND for any the module lacks: a `$listen`
+ * of an event without a source, a method that is not there. Imports the module (it only defines
+ * the plugin; setup runs in the app).
+ */
+export declare function desktopModuleProblems(plugin: ResolvedPlugin): Promise<string[]>;
+export interface NativePlugin<M> {
+    plugin: ResolvedPlugin;
+    native: M;
+    /** Absolute source files. */
+    sources: string[];
+}
+/**
+ * A file a manifest names, which must be inside the plugin's folder: relative, no "..", and its real
+ * location (through symbolic links) inside the folder's (N7). A plugin cannot compile someone
+ * else's files into the app.
+ */
+export declare function pluginFile(plugin: ResolvedPlugin, relativePath: string, what: string): string;
+export declare function iosPlugins(plugins: ResolvedPlugin[]): NativePlugin<IosManifest>[];
+export declare function androidPlugins(plugins: ResolvedPlugin[]): NativePlugin<AndroidManifest>[];
+/**
+ * Writes the Swift / Kotlin bindings of the plugins with "codegen": true into `dir` (emptied first,
+ * so a plugin that stops opting in leaves nothing behind) and returns the files (PL-10).
+ */
+export declare function writePluginBindings(plugins: NativePlugin<unknown>[], platform: "ios" | "android", dir: string, appDir: string): string[];
+export declare function swiftRegistry(plugins: NativePlugin<IosManifest>[]): string;
+/** A plugin's `android.minSdk`, checked: at least the app's, at most the SDK akan-native compiles against. */
+export declare function pluginMinSdk(id: string, native: AndroidManifest, appMinSdk: number, compileSdk: number): number;
+/**
+ * AkanNativeFeatures.kt: the shell's optional parts as constants (architecture review stage 6). The shell
+ * reaches them only under these; kotlinc drops the branches of a false constant and R8 the classes
+ * nothing reaches, so a release build without updates carries no update code.
+ */
+export declare function kotlinFeatures(features: {
+    dev: boolean;
+    updates: boolean;
+}): string;
+export declare function kotlinRegistry(plugins: NativePlugin<AndroidManifest>[], appMinSdk: number, compileSdk: number): string;
+/**
+ * The app's Info.plist (O5-1, architecture review F): akan-native's own keys (`base`), each plugin's entries,
+ * then the app last: its permission texts (C8), usageDescriptions overrides of keys that are there,
+ * and native.ios.infoPlist. Arrays union, dictionaries merge, two plugins that disagree on a value
+ * fail the build, and `owned` keys only akan-native sets.
+ */
+export declare function iosInfoPlist(plugins: NativePlugin<IosManifest>[], overrides: Record<string, string>, appEntries?: Record<string, string>, opts?: {
+    base?: Record<string, PlistValue>;
+    app?: Record<string, PlistValue>;
+    owned?: string[];
+}): Record<string, PlistValue>;
+/**
+ * The app's entitlements: akan-native's, each plugin's, associated-domains for deepLinks.domains, then
+ * native.ios.entitlements. Xcode's variables in string values are filled in: $(AppIdentifierPrefix)
+ * and $(TeamIdentifierPrefix) with "<team id>." ("" on the simulator), $(PRODUCT_BUNDLE_IDENTIFIER).
+ */
+export declare function iosEntitlements(bundleId: string, plugins: NativePlugin<IosManifest>[], domains: {
+    host: string;
+}[], app?: Record<string, PlistValue>, teamId?: string): Record<string, PlistValue>;
+export declare function iosFrameworks(plugins: NativePlugin<IosManifest>[]): string[];
+export declare function androidPermissions(plugins: NativePlugin<AndroidManifest>[], appPermissions?: string[]): string[];
+export declare function describeSources(appDir: string, plugins: NativePlugin<unknown>[]): string;

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

@@ -0,0 +1,11 @@
+import type { PlistValue } from "./plist.ts";
+export interface PlistSource {
+    /** For error messages: "the shell", "plugin push", "the app (native.ios.infoPlist)". */
+    who: string;
+    values: Record<string, PlistValue | undefined>;
+}
+/**
+ * Merges `sources` in order under the rules above; `final` (the app) wins over them without an
+ * error, but may not touch `owned` keys. Throws a CliError listing every conflict.
+ */
+export declare function mergePlist(sources: PlistSource[], final?: PlistSource, owned?: string[]): Record<string, PlistValue>;

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

@@ -0,0 +1,10 @@
+export declare const PERMISSION_NAMES: readonly ["camera", "microphone", "location"];
+export type PermissionName = (typeof PERMISSION_NAMES)[number];
+/** `true` uses a generic usage text; a string is the text iOS and macOS show. */
+export type PermissionsConfig = Partial<Record<PermissionName, string | true>>;
+export declare function validatePermissions(raw: unknown): PermissionsConfig;
+/** Info.plist usage descriptions for the declared permissions. */
+export declare function permissionPlist(config: PermissionsConfig, platform: "ios" | "macos"): Record<string, string>;
+export declare function androidPermissionsFor(config: PermissionsConfig): string[];
+/** `<uses-feature … android:required="false"/>` lines for the declared permissions. */
+export declare function androidFeaturesFor(config: PermissionsConfig): string[];

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

@@ -0,0 +1,11 @@
+export type PlistValue = string | number | boolean | Date | PlistValue[] | {
+    [key: string]: PlistValue | undefined;
+};
+export declare function toPlist(root: {
+    [key: string]: PlistValue | undefined;
+}): string;
+/**
+ * Reads an XML property list (what `security cms -D` prints for a provisioning profile). <data> comes
+ * back as its base64 text (whitespace removed), <date> as a Date.
+ */
+export declare function parsePlist(xml: string): PlistValue;

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

@@ -0,0 +1,11 @@
+/** 8-bit RGBA, not premultiplied, rows top to bottom. */
+export interface Image {
+    width: number;
+    height: number;
+    data: Uint8Array;
+}
+export declare class PngError extends Error {
+}
+export declare function decodePng(bytes: Uint8Array): Image;
+/** 8-bit RGBA PNG (RGB when fully opaque). Each row gets the filter with the smallest sum of |bytes|. */
+export declare function encodePng(image: Image): Uint8Array;

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

@@ -0,0 +1,164 @@
+import type { Platform } from "../../../core/src/index.ts";
+import { CliError } from "./log.ts";
+import type { MacosBuild } from "./macossigning.ts";
+import { type Project } from "./project.ts";
+import { type DesktopArch } from "./updates.ts";
+import type { WindowsSigning } from "./windowssigning.ts";
+/**
+ * debug: inspectable webview, dev signing, runtime env overrides, the dev server (akan-native run, dev,
+ * test). release: none of that (akan-native build, update publish). Independent of `mode`, which only
+ * picks the .env files, so a staging build is still a release build.
+ */
+export type BuildProfile = "debug" | "release";
+export interface WindowsBuild {
+    installer?: boolean;
+    /** Authenticode for every PE file, the setup program and its uninstaller (lib/windowssigning.ts). */
+    signing?: WindowsSigning;
+}
+export interface BuildOptions {
+    mode: string;
+    profile: BuildProfile;
+    /** Skip `web.build` and use what is already in web.dir. */
+    skipWebBuild: boolean;
+    /**
+     * `akan-native dev --hmr`: the dev gateway the native host fetches pages from instead of its bundled
+     * files (lib/hmr.ts). Ignored by release builds, which never contain it.
+     */
+    devServer?: string;
+    /** Default <app>/.akan/native/build/<platform>. */
+    outDir?: string;
+    /**
+     * Dev builds: the path and query of the first page (akanjs readiness O4-5), e.g.
+     * "/en/?csr=true&akanMobileTarget=default". Release builds always start at "/".
+     */
+    startPath?: string;
+    /** false: no .env files (docs/api.md envFiles). Default true. */
+    envFiles?: boolean;
+    /** PUBLIC_ values above every other source (docs/api.md env). */
+    env?: Record<string, string>;
+    /**
+     * Called through the programmatic API (docs/api.md): nothing is written into the app folder (no
+     * akan-native-env.d.ts), and signing comes only from the options, never from AKAN_NATIVE_ANDROID_* or
+     * AKAN_NATIVE_IOS_* variables.
+     */
+    api?: boolean;
+    /** Android release output (akanjs readiness O1-5). */
+    android?: AndroidRelease;
+    /** iOS devices (akanjs readiness O1-2, O1-3). */
+    ios?: IosBuild;
+    /** Windows: an NSIS setup program next to the app folder (platforms/windows-installer.ts). */
+    windows?: WindowsBuild;
+    /** macOS: Developer ID signing, notarization and a dmg (lib/macossigning.ts). */
+    macos?: MacosBuild;
+    /** Linux: an AppImage beside the app folder (platforms/linux-appimage.ts). */
+    linux?: LinuxBuild;
+    /** Desktop builds: the CPU the app runs on, of the same OS; a macOS app is arm64 only. Default this computer's. */
+    arch?: DesktopArch;
+}
+export interface LinuxBuild {
+    appImage?: boolean;
+}
+/** Which identity and profile an iOS device build signs with; unset: found in the keychain and Xcode's profiles. */
+export interface IosSigning {
+    /** A certificate name ("Apple Development: …") or its SHA-1. Default: found (docs/api.md §3). */
+    identity?: string;
+    /** A .mobileprovision file. Default: the fitting local profile (docs/api.md §3). */
+    provisioningProfile?: string;
+    /** Only this team's profiles (when several teams have one for the app). */
+    teamId?: string;
+    /** Release builds: an App Store profile (default) or, only when asked for, an ad hoc one. */
+    distribution?: "app-store" | "ad-hoc";
+}
+/** What an iPhone build was signed with (BuildResult.signing), for the caller to show. */
+export interface IosSigningResult {
+    identity: string;
+    identitySha1: string;
+    profile: string;
+    profileUuid: string;
+    teamId: string;
+    kind: string;
+    /** ISO date. */
+    expires: string;
+}
+export interface IosBuild {
+    /** An iPhone build (iphoneos, signed with a certificate and a profile) instead of the simulator's. Release builds also get an .ipa. */
+    device?: boolean;
+    signing?: IosSigning;
+    /** The iPhone this build is installed on (run, dev): a development or ad hoc profile must list its UDID. */
+    target?: {
+        udid: string;
+        name?: string;
+    };
+}
+/** An upload or release key in a keystore (JKS or PKCS12). The passwords never reach a command line. */
+export interface AndroidSigning {
+    keystore: string;
+    alias: string;
+    storePassword: string;
+    /** Default the store password (PKCS12 keystores have one password). */
+    keyPassword?: string;
+}
+export interface AndroidRelease {
+    /** Release builds only; without it they are signed with ~/.akan/native/debug.keystore (with a warning). */
+    signing?: AndroidSigning;
+    /** Also build an App Bundle (.aab), signed with the same key. */
+    bundle?: boolean;
+}
+/** The release key is missing or does not sign (AkanNativeError SIGNING_FAILED). */
+/** Signing failed; `problems`: the candidates, or why each profile did not fit. */
+export declare class SigningError extends CliError {
+    readonly problems: string[];
+    constructor(message: string, problems?: string[]);
+}
+export interface BuildContext {
+    project: Project;
+    platform: Platform;
+    mode: string;
+    profile: BuildProfile;
+    /** profile === "debug" */
+    dev: boolean;
+    /** <app>/.akan/native/build/<platform> */
+    outDir: string;
+    /** Absolute web.dir */
+    webDir: string;
+    /** index.html with the init script injected */
+    html: string;
+    env: Record<string, string>;
+    /** Dev builds only: see BuildOptions.devServer. The native builders write it to shell.json. */
+    devServer?: string;
+    /** Dev builds only: see BuildOptions.startPath. */
+    startPath?: string;
+    android?: AndroidRelease;
+    ios?: IosBuild;
+    windows?: WindowsBuild;
+    macos?: MacosBuild;
+    linux?: LinuxBuild;
+    /** Desktop builds: see BuildOptions.arch, resolved. */
+    arch?: DesktopArch;
+    /** Artifacts besides the one the builder returns (an .aab next to the .apk, a Windows setup program). */
+    artifacts: {
+        kind: "aab" | "ipa" | "installer";
+        path: string;
+    }[];
+    /** What the builder signed with, when it signs (Android: the app's release key or the debug key). */
+    signedAs?: "adhoc" | "debug" | "development" | "distribution";
+    /** Called through the API (BuildOptions.api). */
+    api: boolean;
+    /** Android builds with pinned libraries: the license notices file written next to the app (BuildResult.licenses). */
+    licenses?: string;
+    /** iPhone builds: the identity and profile they were signed with. */
+    iosSigning?: IosSigningResult;
+}
+/** A dev start path: a path on the app's origin, not one of akan-native's (/__akan_native/*). */
+export declare function checkStartPath(path: string): string;
+/** The app's own web build failed (AkanNativeError WEB_BUILD_FAILED). */
+export declare class WebBuildError extends CliError {
+}
+/** web.dir cannot be used as it is (AkanNativeError WEB_INPUT_INVALID). */
+export declare class WebInputError extends CliError {
+}
+export declare function prepare(project: Project, platform: Platform, options: BuildOptions): Promise<BuildContext>;
+/** The arch a build makes: the one asked for, checked against the platform, else this computer's for a desktop. */
+export declare function desktopArch(platform: Platform, arch: DesktopArch | undefined): DesktopArch | undefined;
+/** https, or http to this machine (a local test server, `akan-native update serve`). */
+export declare function secureUpdateUrl(url: string): boolean;

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

@@ -0,0 +1,13 @@
+import type { AkanNativeConfig } from "../config.ts";
+import type { PlistValue } from "./plist.ts";
+/** The categories Apple lists, without the NSPrivacyAccessedAPICategory prefix. */
+export declare const PRIVACY_API_CATEGORIES: readonly ["FileTimestamp", "SystemBootTime", "DiskSpace", "ActiveKeyboards", "UserDefaults"];
+export interface PrivacySource {
+    /** Who declares it, for error messages ("plugin filesystem", "the app"). */
+    who: string;
+    apis: Record<string, string[]> | undefined;
+}
+/** Problems with a category → reasons map. */
+export declare function privacyApiProblems({ who, apis }: PrivacySource): string[];
+/** PrivacyInfo.xcprivacy's root dictionary: every declared category once, reasons merged and sorted. */
+export declare function privacyManifest(sources: PrivacySource[], privacy?: AkanNativeConfig["privacy"]): Record<string, PlistValue>;

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

@@ -0,0 +1,218 @@
+import type { AkanNativeConfig } from "../config.ts";
+import { type PermissionSet } from "./acl.ts";
+import { type DesktopServerConfig } from "./desktop-server.ts";
+import { type EnvConfig } from "./env.ts";
+import { CliError } from "./log.ts";
+import { type PermissionsConfig } from "./permissions.ts";
+import type { PlistValue } from "./plist.ts";
+import { type UpdatesConfig } from "./updates.ts";
+export interface ResolvedConfig extends Omit<AkanNativeConfig, "icon" | "splash" | "permissions" | "updates"> {
+    app: Required<AkanNativeConfig["app"]>;
+    web: Required<Pick<AkanNativeConfig["web"], "dir" | "base">> & {
+        build?: string;
+        devEntry?: string;
+    };
+    plugins: string[];
+    env: EnvConfig;
+    shell: {
+        backgroundColor: string;
+        backgroundColorDark: string;
+    };
+    usageDescriptions: Record<string, string>;
+    permissions: PermissionsConfig;
+    deepLinks: {
+        schemes: string[];
+        domains: {
+            host: string;
+            pathPrefixes: string[];
+        }[];
+    };
+    desktop: {
+        quitOnLastWindowClosed: boolean;
+        recovery: "errorPage" | "reload";
+        window: {
+            fullscreen: boolean;
+            skipTaskbar: boolean;
+        };
+        screenCapture: "picker" | "auto";
+        server?: DesktopServerConfig;
+        /** Absolute. */
+        bin?: string;
+    };
+    updates: UpdatesConfig | null;
+    /** Absolute image path. */
+    icon: {
+        image: string;
+        backgroundColor?: string;
+    } | null;
+    splash: {
+        backgroundColor: string;
+        backgroundColorDark: string;
+        image?: string;
+        autoHide: boolean;
+        timeout: number;
+    };
+}
+export interface Project {
+    appDir: string;
+    /** The config file, or "the config" when an API caller passed the object (docs/api.md). */
+    configPath: string;
+    config: ResolvedConfig;
+    plugins: ResolvedPlugin[];
+}
+export declare function findAppDir(from: string): string;
+export declare function loadProject(appDir: string): Promise<Project>;
+export interface ProjectOptions {
+    /** For messages. Default "the config". */
+    configPath?: string;
+    /** Where plugin package names resolve from. Default the app folder. Relative plugin folders always use the app folder. */
+    resolveFrom?: string;
+}
+/** Invalid config values, all of them at once (AkanNativeError CONFIG_INVALID carries the list). */
+export declare class ConfigError extends CliError {
+    readonly problems: string[];
+    constructor(where: string, problems: string[]);
+}
+/**
+ * Why a display name cannot be a folder or shortcut name on every OS, or null (Dioxus #5743,
+ * Electrobun #514: names like "My App." or "A/B" broke installs).
+ */
+export declare function appNameProblem(name: unknown): string | null;
+/**
+ * What each target accepts as the build number (app.build, `--build`, AKAN_NATIVE_BUILD), or null: a positive
+ * integer; Android's versionCode goes to 2,100,000,000; Windows puts it in a version resource field
+ * (at most 65535); Apple takes any positive integer as CFBundleVersion.
+ */
+export declare function buildNumberProblem(build: unknown, platform: string): string | null;
+/** The last part of the app id, lowercased: "com.example.Notes" → "notes". */
+export declare function defaultFileName(id: string): string;
+export declare function projectFromConfig(raw: AkanNativeConfig, appDir: string, options?: ProjectOptions): Project;
+export interface NativeSubset {
+    /** Methods this platform implements. Default: all of the manifest's methods. */
+    methods?: string[];
+    events?: string[];
+    /** The methods and events not listed run the plugin's web implementation instead of being UNSUPPORTED. */
+    web?: boolean;
+}
+export interface IosManifest extends NativeSubset {
+    /** Swift files, relative to the plugin folder. Globs allowed. */
+    sources: string[];
+    /** Swift class conforming to AkanNativePlugin. */
+    class: string;
+    frameworks?: string[];
+    /** Info.plist entries, typically usage descriptions. The app config may override the texts. */
+    infoPlist?: Record<string, PlistValue>;
+    /**
+     * Required Reason APIs the plugin's code calls (App Store privacy manifest), by category without the
+     * NSPrivacyAccessedAPICategory prefix, e.g. { "UserDefaults": ["CA92.1"] }. Merged into
+     * PrivacyInfo.xcprivacy (lib/privacy.ts).
+     */
+    privacyApis?: Record<string, string[]>;
+    /** Entitlements the plugin's feature needs (e.g. aps-environment), merged like Info.plist entries. */
+    entitlements?: Record<string, PlistValue>;
+}
+export interface AndroidManifest extends NativeSubset {
+    /** Kotlin or Java files, relative to the plugin folder. Globs allowed. */
+    sources: string[];
+    /** Fully qualified class with a constructor (AkanNativePluginContext). */
+    class: string;
+    permissions?: string[];
+    /** Extra XML inserted into <application> (e.g. a <provider>). ${applicationId} is replaced. */
+    applicationXml?: string;
+    /** Extra XML at the <manifest> level (e.g. <queries> for package visibility). ${applicationId} is replaced. */
+    manifestXml?: string;
+    /** Extra R8 rules for release builds. Components named in applicationXml are kept automatically. */
+    proguard?: string[];
+    /**
+     * Pinned Maven libraries the plugin needs (akanjs readiness O8), as root coordinates, e.g.
+     * "com.android.billingclient:billing:9.1.0". Their closure comes from native/android/maven.lock.json
+     * and goes only into apps that use the plugin.
+     */
+    maven?: string[];
+    /**
+     * The lowest Android API the plugin runs on, when it is above the app's (e.g. 35 for sqlite, built on
+     * SQLiteRawStatement). Below it the plugin is not created and every call is UNSUPPORTED; its package
+     * may use APIs up to this level without version checks (apilevel.ts).
+     */
+    minSdk?: number;
+}
+/** Desktop Bun module that implements only some methods (the rest are UNSUPPORTED, or web with `web: true`). */
+export interface DesktopManifest extends NativeSubset {
+    module: string;
+}
+export interface PluginManifest {
+    id: string;
+    apiVersion: 1;
+    /** The JS API surface. Native implementations must handle all of them. */
+    methods: string[];
+    events: string[];
+    web?: string | null;
+    /**
+     * Per platform: "web" = the web implementation runs in the app's WebView,
+     * native description = native implementation, null or missing = unsupported.
+     * desktop takes a path to a Bun module (run in the desktop Worker) as its native form.
+     */
+    desktop?: "web" | string | DesktopManifest | null;
+    /** macOS packaging extras, e.g. usage descriptions needed by a "web" desktop implementation. */
+    macos?: {
+        infoPlist?: Record<string, PlistValue>;
+    };
+    ios?: IosManifest | "web" | null;
+    android?: AndroidManifest | "web" | null;
+    /**
+     * PL-11. What "<id>:default" grants: local permission names (allow-<method>,
+     * allow-listen-<event>, set names, "all"). Absent: every method and event.
+     */
+    defaultPermissions?: string[];
+    /** Named permission sets, e.g. { read: { permissions: ["allow-readFile", "allow-stat"] } } → "<id>:read". */
+    permissionSets?: Record<string, PermissionSet>;
+    /** The scope fields the plugin enforces, with a description each, e.g. { path: "glob relative to base" }. */
+    /** `urlFields`: the fields that hold URL patterns (matched by urlMatch; the build checks their denies). */
+    scope?: {
+        description?: string;
+        fields: Record<string, string>;
+        urlFields?: string[];
+        pathFields?: string[];
+    };
+    /**
+     * Scopes of `<plugin>:default`, which an app without `capabilities` gets: what the plugin allows
+     * without the app asking (filesystem: the app's own folders; http: no URL). A capability's own
+     * `allow` on `<plugin>:default` replaces these; its `deny` is added.
+     */
+    defaultScope?: {
+        allow?: Record<string, string>[];
+        deny?: Record<string, string>[];
+    };
+    /**
+     * PL-10: generate Swift / Kotlin types and a `<Plugin>PluginSpec` protocol from the
+     * definePlugin<Api, Events> interfaces in src/index.ts into every iOS and Android build.
+     */
+    codegen?: boolean;
+    /**
+     * Plugins whose native code this plugin's native code uses (architecture review stage 6). Each must
+     * be in the app's plugins (akan-native never adds one by itself) and have a native part wherever this one does.
+     */
+    dependencies?: string[];
+    /**
+     * Events whose payload is a snapshot (progress, a size, a position): the host sends only the latest
+     * of a burst, at most about every 100 ms (architecture review stage 4). The payload must be
+     * cumulative or absolute, never a delta; an end state is a method's result, not an event.
+     */
+    coalesce?: string[];
+}
+export interface ResolvedPlugin {
+    /** What the app config listed. */
+    spec: string;
+    dir: string;
+    manifest: PluginManifest;
+}
+export declare function resolvePlugins(appDir: string, specs: string[], resolveFrom?: string): ResolvedPlugin[];
+/** Keys akan-native does not know, at the top and in the platform entries ("ios.bogus"). A typo would otherwise do nothing. */
+export declare function unknownManifestKeys(manifest: object): string[];
+/**
+ * Plugins whose native part needs another plugin's native part on this platform (dependencies):
+ * the other one must not be web-only or missing there.
+ */
+export declare function dependencyProblems(plugins: ResolvedPlugin[], platform: string): string[];
+/** Why a resource's logical `to` is not allowed, or null. */
+export declare function resourceTargetProblem(to: string): string | null;