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

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

@@ -0,0 +1,278 @@
+/** A scope entry (PL-11): field → glob, e.g. { base: "documents", path: "exports/**" } or { url: "https://example.com/*" }. */
+export type ScopeEntry = Record<string, string>;
+/** A permission with scopes: the plugin enforces them for the calls this permission allows. */
+export interface CapabilityPermission {
+    identifier: string;
+    allow?: ScopeEntry[];
+    deny?: ScopeEntry[];
+}
+/**
+ * Plugin permissions for some windows and platforms (PL-11, Tauri capability style). Identifiers:
+ * "<plugin>:default", "<plugin>:all", "<plugin>:allow-<method>", "<plugin>:deny-<method>",
+ * "<plugin>:allow-listen-<event>", "<plugin>:deny-listen-<event>", "<plugin>:<set>" (from the
+ * plugin's manifest), and "core:deny-print". Anything not granted is refused with NOT_ALLOWED;
+ * a deny wins over every grant, in every window.
+ */
+export interface Capability {
+    /** Lowercase letters, digits and "-", unique. */
+    identifier: string;
+    description?: string;
+    /** Desktop windows: "main" (the first window), window ids, or "*". Default every window. */
+    windows?: ("main" | number | "*")[];
+    /** Default every platform. */
+    platforms?: ("web" | "macos" | "windows" | "linux" | "ios" | "android")[];
+    permissions: (string | CapabilityPermission)[];
+}
+/** A value of an Info.plist or entitlements entry. */
+export type NativeValue = string | number | boolean | NativeValue[] | {
+    [key: string]: NativeValue;
+};
+export interface AkanNativeConfig {
+    app: {
+        /** Reverse-DNS id, used as bundle id / application id. */
+        id: string;
+        /**
+         * Display name: the .app folder, the Windows install folder and shortcuts, CFBundleDisplayName,
+         * the Android label. Any language; no control characters, no / \ : * ? " < > |, no leading or
+         * trailing spaces or trailing dot, not a Windows device name (CON, NUL, COM1 …).
+         */
+        name: string;
+        /**
+         * File name for executables, the Swift module and archives: letters, digits, ".", "_" and "-".
+         * Default: the last part of `id` ("com.example.notes" → "notes"). Identifiers (data folders,
+         * the Windows uninstall key and AUMID, the Linux desktop file) always come from `id`.
+         */
+        fileName?: string;
+        /** Marketing version, e.g. "1.2.0". */
+        version: string;
+        /** Integer build number. Default 1. `akan-native build --build <n>` or AKAN_NATIVE_BUILD overrides it for one build. */
+        build?: number;
+    };
+    web: {
+        /** Folder with the built SPA: index.html (JS inlined) plus any static files such as public/ assets. */
+        dir: string;
+        /** Command that produces `dir`, run by `akan-native build` in the app folder. Optional. */
+        build?: string;
+        /** Path prefix for web deployments under a sub-path. Default "/". Apps always use "/". */
+        base?: string;
+        /**
+         * The source HTML that `akan-native dev <platform> --hmr` hands to Bun's dev server (React Fast
+         * Refresh), relative to the app folder: the file whose `<script type="module" src>` points at
+         * the app's entry, like the one `web.build` bundles. Default "index.html".
+         */
+        devEntry?: string;
+    };
+    /** Plugin packages (or relative folders) that contain an native-plugin.json (PL-3). */
+    plugins?: string[];
+    /**
+     * What the plugins may do, per window and platform (PL-11). Without it every plugin listed in
+     * `plugins` gets its default permissions (usually everything it offers).
+     */
+    capabilities?: Capability[];
+    env?: {
+        /** Lowest-precedence values. Only PUBLIC_ keys are passed to the app. */
+        defaults?: Record<string, string>;
+        /**
+         * Per-platform values (ENV-6), e.g. { android: { PUBLIC_API_URL: "http://10.0.2.2:8787" } }.
+         * They win over every shared value; .env.<platform> and .env.<mode>.<platform> win over them.
+         */
+        platforms?: Partial<Record<"web" | "macos" | "windows" | "linux" | "ios" | "android", Record<string, string>>>;
+    };
+    shell?: {
+        /** Painted before the page loads, to avoid a white flash (SH-3). */
+        backgroundColor?: string;
+        backgroundColorDark?: string;
+    };
+    /** Overrides for permission usage texts, e.g. { NSCameraUsageDescription: "..." }. */
+    usageDescriptions?: Record<string, string>;
+    /**
+     * The app's part of the iOS privacy manifest (PrivacyInfo.xcprivacy, required for App Store
+     * uploads). The Required Reason APIs of akan-native's shell and plugins are added by the build; list here
+     * what the app's own data practices are.
+     */
+    privacy?: {
+        /** NSPrivacyTracking. Default false. */
+        tracking?: boolean;
+        /** NSPrivacyTrackingDomains. */
+        trackingDomains?: string[];
+        /** NSPrivacyCollectedDataTypes, as Apple's dictionaries (NSPrivacyCollectedDataType, …Linked, …Tracking, …Purposes). */
+        collectedDataTypes?: Record<string, string | boolean | string[]>[];
+        /** Extra Required Reason APIs the app's own native code calls, e.g. { "DiskSpace": ["E174.1"] }. */
+        accessedApis?: Record<string, string[]>;
+    };
+    /**
+     * Permissions for web APIs used without a plugin (plugins.md C8): getUserMedia needs camera or
+     * microphone, navigator.geolocation needs location. `true` or the usage text iOS/macOS show,
+     * e.g. { microphone: "Record voice notes." }. Adds the Info.plist texts and Android permissions.
+     */
+    permissions?: {
+        camera?: string | true;
+        microphone?: string | true;
+        location?: string | true;
+    };
+    /**
+     * Over-the-air updates (UP-2 web bundles on iOS / Android, UP-1 app updates on macOS), used by
+     * @akanjs/native/plugins/updates. `akan-native update keygen` makes the signing key and prints `publicKey`;
+     * `akan-native update publish <platform>` writes signed releases for `url`.
+     */
+    updates?: {
+        url: string;
+        publicKey: string;
+        channel?: string;
+        readyTimeout?: number;
+    };
+    /** Links that open the app, delivered through the app plugin's urlOpen (and getLaunchUrl). */
+    deepLinks?: {
+        /** Custom URL schemes (myapp://...). */
+        schemes?: string[];
+        /**
+         * https links of these hosts (akanjs readiness O5-2): iOS universal links (associated-domains
+         * "applinks:<host>") and Android app links (a verified intent filter per host). The site must
+         * serve /.well-known/apple-app-site-association and /.well-known/assetlinks.json for the app;
+         * Android debug builds carry android.debugAppIdSuffix in their id. pathPrefixes limit Android's
+         * filter (iOS takes the paths from the site's file).
+         */
+        domains?: (string | {
+            host: string;
+            pathPrefixes?: string[];
+        })[];
+    };
+    /**
+     * Native settings beyond what plugins declare (akanjs readiness O5, architecture review F): merged
+     * last, over the shell's and the plugins' (arrays union, dictionaries merged, the app's values win).
+     */
+    native?: {
+        ios?: {
+            /** Info.plist entries. Keys akan-native owns (bundle id, executable, versions, minimum OS) cannot be set. */
+            infoPlist?: Record<string, NativeValue>;
+            /** Entitlements (e.g. keychain-access-groups). associated-domains comes from deepLinks.domains. */
+            entitlements?: Record<string, NativeValue>;
+        };
+        android?: {
+            /** XML at the <manifest> level (uses-permission, queries, …). ${applicationId} is replaced. */
+            manifest?: string[];
+            /** XML inside <application> (meta-data, services, receivers, providers). */
+            application?: string[];
+            /** XML inside the app's activity (intent filters). */
+            activity?: string[];
+        };
+        /**
+         * Files copied into the app. `to` is a logical place: "ios/<path>" (the app bundle), "android/res/<type>/<file>"
+         * (a resource, e.g. android/res/raw/chime.mp3), or "android/assets/<path>". `from` is relative to the app folder.
+         */
+        resources?: {
+            from: string;
+            to: string;
+        }[];
+    };
+    security?: {
+        /**
+         * Content-Security-Policy for index.html (SEC-4). "strict" is akan-native's recommended policy
+         * (`STRICT_CSP` in packages/cli/src/lib/csp.ts: same origin only, plus blob:/data: images and
+         * media); a string or a directive map is used as given, e.g. `{ "default-src": "'self'", "connect-src":
+         * ["'self'", "https://api.example.com"] }`. The build adds the hashes of index.html's inline scripts and
+         * styles and puts the policy in a <meta> tag. Default: no policy.
+         */
+        csp?: "strict" | string | Record<string, string | string[]>;
+        /** The shell's own policy (L0, docs/architecture.md "보안 계층"). */
+        shell?: {
+            /**
+             * Schemes, besides http, https, mailto and tel, that links, window.open and the opener may
+             * hand to the OS (e.g. "sms", another app's "otherapp"). javascript, file, data, blob, about,
+             * content, intent and app can never be added.
+             */
+            externalSchemes?: string[];
+        };
+    };
+    android?: {
+        /**
+         * The oldest WebView (Chromium major) the page runs on. On an older one the shell shows its own
+         * "update Android System WebView" screen instead of a page that cannot parse. Default 94, what
+         * akan-native's runtime and unlowered ES2022 syntax (class static blocks) need; raise it for newer syntax
+         * or APIs the bundle uses. Android 10+ devices with Google Play update WebView themselves.
+         */
+        minWebViewVersion?: number;
+        /**
+         * Appended to app.id in debug builds (e.g. ".debug"), so a debug build installs next to the
+         * release app. Deep links and app links must list the suffixed id for debug builds.
+         */
+        debugAppIdSuffix?: string;
+        /**
+         * The Firebase project's google-services.json (relative to the app folder), for the push plugin's
+         * FCM module: its values become the string resources Firebase initializes from, as the
+         * google-services Gradle plugin makes them (google_app_id, gcm_defaultSenderId, google_api_key, …).
+         */
+        googleServices?: string;
+    };
+    /** Remote notifications (the push plugin). */
+    push?: {
+        android?: {
+            /**
+             * The channel pushes arrive in: Firebase's default channel for messages that name none (while
+             * the app is not in front) and the plugin's own notifications in front. Default: Firebase's
+             * "Miscellaneous" channel in the background and "Notifications" in front.
+             */
+            channel?: {
+                id: string;
+                name: string;
+                importance?: "min" | "low" | "default" | "high";
+                description?: string;
+            };
+            /**
+             * The status bar icon: a white-on-transparent PNG (Android shows only its alpha), ideally
+             * 96×96. Default: the app icon, which shows as a gray square.
+             */
+            smallIcon?: string;
+            /** The notification's accent color, e.g. "#1a73e8". */
+            color?: string;
+        };
+    };
+    /**
+     * What the soft keyboard does to the page from the first frame (akanjs readiness O6-1): "resize"
+     * (default) shrinks the page by the keyboard, "none" lets it cover the page. keyboard.setResizeMode()
+     * changes it at run time.
+     */
+    keyboard?: {
+        resize?: "resize" | "none";
+    };
+    ios?: {
+        /** Hide the bar with previous / next / Done above the keyboard for form fields. Default false. */
+        hideFormAccessoryBar?: boolean;
+    };
+    desktop?: {
+        /**
+         * Closing the window quits the app (after app.onBeforeQuit handlers). With false, closing only
+         * hides the window: the app keeps running, a Dock click shows it again, Cmd+Q quits. Default true.
+         */
+        quitOnLastWindowClosed?: boolean;
+    };
+    /**
+     * App icon for every platform, generated from one square PNG, ideally 1024×1024 (CLI-8).
+     * Full-bleed icons work best: iOS and Android mask the corners, macOS gets its rounded grid.
+     * `backgroundColor` fills transparent areas where a platform needs an opaque icon (iOS, the
+     * Android adaptive icon background). Default: the top-left pixel of an opaque icon, else white.
+     * Without an icon the platforms show their placeholder icon.
+     */
+    icon?: string | {
+        image: string;
+        backgroundColor?: string;
+    };
+    /** Launch screen on iOS and Android (SH-6). Desktop windows stay hidden until the first page load instead. */
+    splash?: {
+        /** Default: shell.backgroundColor / shell.backgroundColorDark. */
+        backgroundColor?: string | {
+            light: string;
+            dark: string;
+        };
+        /**
+         * PNG shown centered, fitted into 136×136 pt (iOS) / dp (Android). Without it Android shows
+         * the app icon (the platform default) and iOS only the color.
+         */
+        image?: string;
+        /** Hide when the first page load finishes. With false, call splash.hide() (@akanjs/native/plugins/splash-screen). Default true. */
+        autoHide?: boolean;
+        /** Hide after this many milliseconds at the latest, with a warning. Default 10000. */
+        timeout?: number;
+    };
+}
+export declare function defineConfig(config: AkanNativeConfig): AkanNativeConfig;

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

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

@@ -0,0 +1,21 @@
+import type { Platform, ResolvedAcl } from "../../../core/src/index.ts";
+import type { Capability } from "../config.ts";
+import type { PluginManifest, ResolvedPlugin } from "./project.ts";
+export type { Capability, CapabilityPermission } from "../config.ts";
+export interface PermissionSet {
+    description?: string;
+    /** Local identifiers: allow-*, allow-listen-*, other set names, "all". */
+    permissions: string[];
+}
+/** Problems in a plugin manifest's permission fields (checked when the plugin is loaded). */
+export declare function manifestPermissionProblems(manifest: PluginManifest): string[];
+/**
+ * Checks the app's capabilities against the registered plugins and resolves them for one platform.
+ * Throws a CliError listing every problem.
+ */
+export declare function resolveAcl(capabilities: Capability[] | undefined, plugins: ResolvedPlugin[], platform: Platform): ResolvedAcl;
+/**
+ * Scopes that build but likely do not say what the app meant. A URL deny written for https:// only
+ * leaves the same host open over http:// (and a URL field matches the scheme exactly).
+ */
+export declare function aclWarnings(acl: ResolvedAcl, plugins: ResolvedPlugin[]): string[];

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

@@ -0,0 +1,40 @@
+export interface ApiClass {
+    since: number;
+    supers: string[];
+    members: Map<string, number>;
+}
+export type ApiVersions = Map<string, ApiClass>;
+/** Reads api-versions.xml (one element per line, as the SDK ships it). */
+export declare function loadApiVersions(path: string): ApiVersions;
+export interface ClassInfo {
+    name: string;
+    superName: string | null;
+    interfaces: string[];
+    /** Classes named in the constant pool (array types stripped). */
+    classes: string[];
+    /** Field and method references: owner, name, descriptor. */
+    members: {
+        owner: string;
+        name: string;
+        descriptor: string;
+        field: boolean;
+    }[];
+    /** Interfaces an invokedynamic call site produces (lambdas turned into framework interfaces). */
+    lambdaTypes: string[];
+}
+/** The parts of a class file this check needs: the constant pool, this class, its supertypes. */
+export declare function readClass(bytes: Uint8Array): ClassInfo;
+/** The API level a class may use: minSdk, a plugin package's minSdk, or N for an `ApiN` class. */
+export declare function allowedLevel(className: string, minSdk: number, packageLevels?: [prefix: string, level: number][]): number;
+export interface ApiProblem {
+    className: string;
+    what: string;
+    since: number;
+    allowed: number;
+}
+/** Checks every class of a jar. */
+export declare function checkApiLevels(jar: Uint8Array, api: ApiVersions, minSdk: number, packageLevels?: [string, number][]): ApiProblem[];
+/** One line per problem, grouped by class, for a build error. */
+export declare function formatApiProblems(problems: ApiProblem[], minSdk: number): string;
+/** api-versions.xml of the SDK platform that android.jar belongs to, when the SDK has it. */
+export declare function apiVersionsFor(androidJar: string): string | null;

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

@@ -0,0 +1,36 @@
+interface Entry {
+    name: string;
+    method: 0 | 8;
+    crc: number;
+    compressedSize: number;
+    size: number;
+    data: Uint8Array;
+}
+export declare function readZip(buf: Uint8Array): Entry[];
+export declare function fileEntry(name: string, bytes: Uint8Array, store: boolean): Entry;
+export declare function writeZip(entries: Entry[]): Uint8Array;
+export interface ApkInput {
+    /** aapt2 link output (manifest + resources, no assets). */
+    base: Uint8Array;
+    /** classes.dex, classes2.dex, ... in order. */
+    dex: Uint8Array[];
+    /** Folder whose content goes under assets/. */
+    assetsDir: string;
+    /**
+     * More files by their path in the APK (O8): lib/<abi>/*.so of pinned libraries (compressed: the
+     * installer extracts them, extractNativeLibs is not set) and META-INF/services/* for ServiceLoader.
+     */
+    extra?: {
+        name: string;
+        bytes: Uint8Array;
+    }[];
+}
+export declare function assembleApk({ base, dex, assetsDir, extra }: ApkInput): Uint8Array;
+/**
+ * The base module of an Android App Bundle (akanjs readiness O1-5), for `bundletool build-bundle
+ * --modules`: aapt2's --proto-format output with its manifest under manifest/ (resources.pb and res/
+ * stay at the root), the dex files under dex/ and the assets under assets/. bundletool decides the
+ * APKs' compression and alignment itself.
+ */
+export declare function assembleBundleModule({ base, dex, assetsDir, extra }: ApkInput): Uint8Array;
+export {};

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

@@ -0,0 +1,9 @@
+export interface ParsedArgs {
+    positional: string[];
+    flags: Record<string, string | true>;
+}
+/** Parses `a b --flag value --bool --key=value`. A flag followed by another flag or nothing is boolean. */
+export declare function parseArgs(argv: string[], booleanFlags?: readonly string[]): ParsedArgs;
+/** Rejects flags a command does not know (a typo would otherwise be ignored, e.g. --relase). */
+export declare function checkFlags(args: ParsedArgs, known: readonly string[], usage: string): void;
+export declare function stringFlag(args: ParsedArgs, name: string): string | undefined;

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

@@ -0,0 +1,32 @@
+import type { Platform, PluginDecl, ResolvedAcl } from "../../../core/src/index.ts";
+import { type NativePlatform } from "./native-plugins.ts";
+import type { BuildContext } from "./prepare.ts";
+import type { Project, ResolvedConfig } from "./project.ts";
+export { INIT_PREFIX, INIT_SUFFIX, renderInitScript } from "../../../core/src/protocol.ts";
+export interface BootData {
+    v: 1;
+    platform: Platform;
+    runtimeVersion: string;
+    dev: boolean;
+    app: {
+        id: string;
+        name: string;
+        version: string;
+        build: number;
+    };
+    plugins: Record<string, PluginDecl>;
+    /** Resolved capabilities (PL-11): the host enforces them before dispatching a call. */
+    acl?: ResolvedAcl;
+    /** Native builds: what web bundles this binary can run (UP-3, lib/compat.ts). */
+    nativeApi?: string;
+    /** Native builds: what the hosts speak beyond bridge protocol v1 (architecture.md §4). */
+    bridge?: {
+        features: string[];
+    };
+}
+/** Without `project` there is no ACL (everything allowed), as in unit tests of other parts. */
+export declare function makeBoot(config: ResolvedConfig, platform: Platform, plugins: Record<string, PluginDecl>, dev: boolean, project?: Project): BootData;
+/** boot.json of a native build, with <outDir>/bundle.json written next to the build (UP-3). */
+export declare function makeNativeBoot(ctx: BuildContext, platform: NativePlatform): BootData;
+/** The runtime version (UP-3, packages/core/src/version.ts). */
+export declare function runtimeVersion(): string;

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

@@ -0,0 +1,6 @@
+export declare function findChrome(): string;
+/** Opens `url` in a fresh headless profile and forwards console lines and exceptions. */
+export declare function openHeadless(url: string, onLine: (line: string) => void): Promise<{
+    stop(): void;
+    exited: Promise<number>;
+}>;

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

@@ -0,0 +1,94 @@
+import type { PluginManifest, ResolvedPlugin } from "./project.ts";
+import { type PluginSpec } from "./spec.ts";
+export type GenType = {
+    t: "string" | "number" | "boolean" | "any";
+} | {
+    t: "enum";
+    name: string;
+} | {
+    t: "struct";
+    name: string;
+} | {
+    t: "array";
+    of: GenType;
+} | {
+    t: "map";
+    of: GenType;
+};
+export interface GenField {
+    /** The JSON key. */
+    name: string;
+    type: GenType;
+    /** `name?:` — may be missing; results leave it out when nil. */
+    optional: boolean;
+    /** `| null` — results write null when nil. */
+    nullable: boolean;
+    doc?: string;
+}
+export interface GenStruct {
+    name: string;
+    doc?: string;
+    fields: GenField[];
+    /** Extends FileRef: gets a constructor taking the runtime AkanNativeFileRef for url, mime and size. */
+    fileRef?: true;
+}
+export interface GenEnum {
+    name: string;
+    doc?: string;
+    values: string[];
+}
+export interface GenMethod {
+    name: string;
+    doc?: string;
+    /** Missing for methods without an argument. */
+    args?: string;
+    /** null for Promise<void>. */
+    result: {
+        type: GenType;
+        nullable: boolean;
+    } | null;
+    /** Set when the types cannot be generated: the method gets the raw AkanNativeCall. */
+    untyped?: string;
+}
+export interface GenEvent {
+    name: string;
+    doc?: string;
+    /** null when the payload type cannot be generated (the helper then takes Any). */
+    type: GenType | null;
+    nullable: boolean;
+    untyped?: string;
+}
+export interface GenModel {
+    pluginId: string;
+    /** PascalCase plugin id, the prefix of every generated name (all iOS plugins share one Swift module). */
+    prefix: string;
+    source: string;
+    structs: GenStruct[];
+    enums: GenEnum[];
+    methods: GenMethod[];
+    events: GenEvent[];
+}
+/**
+ * Resolves the spec's types into named structs and enums. `methods` / `events` limit the model to
+ * what a platform implements (the manifest's per-platform subset).
+ */
+export declare function buildModel(spec: PluginSpec, pluginId: string, options?: {
+    methods?: string[];
+    events?: string[];
+    source?: string;
+}): GenModel;
+export declare function generateSwift(model: GenModel): string;
+export declare function generateKotlin(model: GenModel, pkg: string): string;
+/** Where the spec and the manifest disagree (method and event names, platform subsets). */
+export declare function specProblems(manifest: PluginManifest, spec: PluginSpec): string[];
+/** Methods and events whose types could not be generated, with the reason. */
+export declare function untypedMembers(model: GenModel): string[];
+/** The generated source for one plugin on one platform (file name relative to the gen folder). */
+export declare function pluginBindings(plugin: ResolvedPlugin, platform: "ios" | "android", appDir: string): {
+    file: string;
+    text: string;
+};
+/** A Swift plugin class that conforms to the generated protocol, every method still to write. */
+export declare function swiftStub(model: GenModel, className: string): string;
+/** A Kotlin plugin class that implements the generated interface, every method still to write. */
+export declare function kotlinStub(model: GenModel, pkg: string, className: string): string;

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

@@ -0,0 +1,49 @@
+import type { Platform, PluginDecl, ResolvedAcl } from "../../../core/src/index.ts";
+import type { Project } from "./project.ts";
+export declare const BUNDLE_FILE = "bundle.json";
+export interface NativeApi {
+    /** Bridge protocol version (architecture.md §4) and the v1.1 features the hosts speak. */
+    protocol: 1;
+    features: string[];
+    /** @akanjs/native/core major.minor, or major alone from 1.0 on (semver caret compatibility). */
+    runtime: string;
+    platform: Platform;
+    /** Every plugin the binary declares, with the package version of native implementations. */
+    plugins: Record<string, {
+        decl: PluginDecl;
+        version?: string;
+    }>;
+    /** The capabilities the binary enforces (PL-11). */
+    acl: ResolvedAcl | null;
+    /** App-level permissions (C8) and deep-link schemes the binary declares. */
+    permissions: string[];
+    deepLinks: string[];
+}
+export interface BundleInfo {
+    schema: 1;
+    app: {
+        id: string;
+        version: string;
+        build: number;
+    };
+    platform: Platform;
+    runtimeVersion: string;
+    nativeApi: {
+        hash: string;
+        inputs: NativeApi;
+    };
+    /** sha256 of the web files (index.html as served and public/), for update integrity later. */
+    web: {
+        hash: string;
+        files: number;
+    };
+}
+/** "0.1.4" → "0.1", "1.2.0" → "1". */
+export declare function runtimeLine(version: string): string;
+export declare function nativeApi(project: Project, platform: Platform, decls: Record<string, PluginDecl>, acl: ResolvedAcl | undefined, runtimeVersion: string): NativeApi;
+export declare function nativeApiHash(api: NativeApi): string;
+/** Why a bundle built against `bundle` cannot run in a binary that provides `installed` (empty: it can). */
+export declare function compatProblems(installed: NativeApi, bundle: NativeApi): string[];
+/** Writes <outDir>/bundle.json for a native build. */
+export declare function writeBundleInfo(outDir: string, project: Project, platform: Platform, runtimeVersion: string, api: NativeApi, webDir: string, html: string): BundleInfo;
+export declare function readBundleInfo(path: string): BundleInfo;

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

@@ -0,0 +1,2 @@
+/** "unknown key deepLink (did you mean deepLinks?)" for every key the config should not have. */
+export declare function unknownConfigKeys(config: unknown): string[];

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

@@ -0,0 +1,51 @@
+export type CspDirectives = Record<string, string | string[]>;
+/** "strict" is akan-native's recommended policy; a string or a directive map is used as given. */
+export type CspConfig = "strict" | string | CspDirectives;
+/**
+ * Everything an akan-native app needs and nothing else: the page, init.js, the bridge (desktop fetch to
+ * /__akan_native/ipc, Android /__akan_native/hello + MessagePort; iOS messageHandlers are outside CSP), FileRefs
+ * (/__akan_native/file/*), blob:/data: images and media (camera, file-picker, filesystem on the web), dev
+ * live reload (same-origin EventSource), fetch() of blob:/data: URLs (web FileRefs). Remote APIs,
+ * CDNs and fonts must be added by the app.
+ */
+export declare const STRICT_CSP: Record<string, string[]>;
+export declare function parseCsp(text: string): Map<string, string[]>;
+export declare function serializeCsp(map: Map<string, string[]>): string;
+/** The HTML parser turns CRLF and lone CR into LF before a script's text is hashed. */
+export declare function normalizeForHash(text: string): string;
+export declare function cspHash(text: string): string;
+/**
+ * Inline <script> (without src) and <style> contents of a document. Like the HTML tokenizer, a
+ * script or style ends at the first `</script` / `</style`, so text in the bundle that merely
+ * mentions a tag does not start a new element (bundlers escape `</script` inside JS).
+ */
+export declare function inlineBlocks(html: string): {
+    scripts: string[];
+    styles: string[];
+};
+/**
+ * The policy for this index.html: the configured directives plus hashes of its inline scripts
+ * and styles. A directive the app left out is derived from default-src first, so adding hashes
+ * never drops sources the app allowed. A directive with 'unsafe-inline' stays as it is: hashes
+ * would switch 'unsafe-inline' off (CSP2) and break inline styles the app relies on.
+ */
+export declare function buildCsp(config: CspConfig, html: string): {
+    policy: string;
+    scripts: number;
+    styles: number;
+    warnings: string[];
+};
+export declare function validateCsp(raw: unknown): CspConfig | undefined;
+/**
+ * Inserts the policy near the top of <head>: right after `<meta charset>` when there is one (so
+ * the charset stays in the first 1024 bytes a browser scans), else first. Either way it comes
+ * before the inlined styles and the bundle; only init.js may precede it, which 'self' allows.
+ */
+export declare function injectCspMeta(html: string, policy: string): string;
+/** True when the source index.html brings its own policy (left alone when security.csp is unset). */
+export declare function hasCspMeta(html: string): boolean;
+/**
+ * security.shell.externalSchemes (L0): lowercase URL schemes the shell may also hand to the OS.
+ * Schemes that reach local files, run script or name the app itself can never be added.
+ */
+export declare function validateExternalSchemes(raw: unknown): string[];