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

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

@@ -0,0 +1,150 @@
+export interface Download {
+    url: string;
+    sha256: string;
+    /** Bytes, for progress and a sanity check. */
+    size: number;
+    /** "file": a single file (a jar), installed as <install folder>/<root>. */
+    format: "zip" | "tar.gz" | "file";
+    /** The archive's top folder, which becomes the install folder; for "file" the file's name in it. */
+    root: string;
+}
+export declare const TOOLCHAIN: {
+    readonly kotlin: {
+        readonly version: "2.4.20";
+        readonly license: "Apache-2.0";
+        readonly download: {
+            url: string;
+            sha256: string;
+            size: number;
+            format: "zip";
+            root: string;
+        };
+    };
+    readonly jdk: {
+        /** Oldest major that kotlinc, d8, R8 and apksigner accept (we compile with -jvm-target 17). */
+        readonly minMajor: 17;
+        readonly version: "21.0.12.1+1";
+        readonly license: "GPL-2.0-with-classpath-exception";
+        /** Eclipse Temurin via the Adoptium API (checksums from api.adoptium.net). Only on request. */
+        readonly downloads: Record<string, Download>;
+    };
+    /** Android App Bundles (akanjs readiness O1-5): build-bundle, and build-apks for local installs. */
+    readonly bundletool: {
+        readonly version: "1.18.3";
+        readonly license: "Apache-2.0";
+        readonly download: {
+            url: string;
+            sha256: string;
+            size: number;
+            format: "file";
+            root: string;
+        };
+    };
+    readonly android: {
+        readonly buildTools: "37.0.0";
+        /** Older build-tools still work (with a warning); below this they do not. */
+        readonly minBuildTools: "35.0.0";
+        readonly compileSdk: 36;
+    };
+    /** Must match native/desktop/rust-toolchain.toml (a test checks it). wry 0.57 / tao 0.37 need 1.85+. */
+    readonly rust: {
+        readonly version: "1.98.1";
+    };
+    /** The Bun akan-native is tested with, and the lowest it runs on (package.json engines.bun; a test checks it). */
+    readonly bun: {
+        readonly version: "1.4.2";
+        readonly min: "1.4.0";
+    };
+    readonly xcode: {
+        readonly min: "26.0";
+    };
+    readonly iosSdk: {
+        readonly min: "26.0";
+    };
+};
+export type InstallableTool = "kotlin" | "jdk" | "bundletool";
+export declare function compareVersions(a: string, b: string): number;
+/** "info: kotlinc-jvm 2.4.20 (JRE 27)" → "2.4.20". */
+export declare function parseKotlinVersion(output: string): string | undefined;
+/** `java -version` output → major version ("1.8.0_x" → 8, "21.0.11" → 21). */
+export declare function parseJavaMajor(output: string): number | undefined;
+export declare function akanNativeHome(env?: Record<string, string | undefined>): string;
+export declare function toolchainsDir(env?: Record<string, string | undefined>): string;
+export declare function autoInstallAllowed(env?: Record<string, string | undefined>): boolean;
+export declare function hostKey(): string;
+export interface InstallOptions {
+    /** Replaces the network in tests. */
+    fetch?: (url: string) => Promise<Response>;
+    /** Replaces unzip/tar in tests: extract `archive` into `dir`. */
+    extract?: (archive: string, dir: string, format: Download["format"]) => Promise<void>;
+    env?: Record<string, string | undefined>;
+    /** How long to wait for another process that is installing the same version. */
+    lockTimeoutMs?: number;
+    quiet?: boolean;
+}
+export declare function installPath(tool: string, version: string, env?: Record<string, string | undefined>): string;
+/** Installs `spec` as `<toolchains>/<tool>/<version>` unless it is there already; returns that folder. */
+export declare function ensureInstalled(tool: string, version: string, spec: Download, opts?: InstallOptions): Promise<string>;
+export declare function installTool(tool: InstallableTool, opts?: InstallOptions): Promise<string>;
+export type Source = "override" | "akan-native" | "system" | "android-studio";
+export interface KotlinToolchain {
+    home: string;
+    kotlinc: string;
+    stdlib: string;
+    version: string;
+    source: Source;
+    /** Set when the build uses something other than the pinned version. */
+    warning?: string;
+}
+/** The installed pinned kotlinc, or null. Never downloads. */
+export declare function pinnedKotlin(env?: Record<string, string | undefined>): KotlinToolchain | null;
+/**
+ * kotlinc for a build, in this order:
+ * 1. AKAN_NATIVE_KOTLIN_HOME (explicit override, used as is)
+ * 2. the pinned version in ~/.akan/native/toolchains
+ * 3. installing the pinned version now (unless AKAN_NATIVE_NO_AUTO_INSTALL=1)
+ * 4. kotlinc on PATH, with a warning if its version differs. A different compiler still builds
+ *    the shell (it only uses stable Kotlin), and refusing would break offline machines; the
+ *    warning and `akan-native doctor` point back to the pinned one.
+ */
+export declare function resolveKotlin(opts?: InstallOptions & {
+    javaEnv?: Record<string, string>;
+}): Promise<KotlinToolchain>;
+export interface Jdk {
+    home: string;
+    java: string;
+    major: number;
+    version: string;
+    source: Source | "java_home";
+}
+export declare const ANDROID_STUDIO_JBR = "/Applications/Android Studio.app/Contents/jbr/Contents/Home";
+/** Every JDK akan-native would consider, in order of preference (first suitable wins). */
+export declare function jdkCandidates(env?: Record<string, string | undefined>): {
+    home: string;
+    source: Jdk["source"];
+}[];
+/** JAVA_HOME, then an akan-native-installed JDK, then Android Studio's JBR, then the system's (Homebrew etc.). */
+export declare function resolveJdk(env?: Record<string, string | undefined>): Jdk | null;
+/** Environment for every Java-based tool (kotlinc, d8, R8, apksigner, keytool): one JDK for all. */
+export declare function javaEnv(jdk: Jdk): Record<string, string>;
+export declare function androidSdkRoot(env?: Record<string, string | undefined>): string | undefined;
+export declare const BUILD_TOOLS: readonly ["aapt2", "d8", "zipalign", "apksigner"];
+export declare function completeBuildTools(sdk: string): string[];
+export interface BuildToolsChoice {
+    version: string;
+    dir: string;
+    warning?: string;
+}
+/** The pinned build-tools if installed, else the newest installed ones at or above the minimum (with a warning). */
+export declare function resolveBuildTools(sdk: string): BuildToolsChoice | null;
+/** sdkmanager from cmdline-tools (latest first) or PATH. */
+export declare function sdkmanager(sdk: string): string | undefined;
+/** True when the user has accepted the Android SDK license (sdkmanager --licenses or Android Studio). */
+export declare function sdkLicenseAccepted(sdk: string): boolean;
+/** The sdkmanager package ids akan-native pins. */
+export declare function pinnedSdkPackages(): string[];
+export declare function missingSdkPackages(sdk: string): string[];
+export declare const RUST_TOOLCHAIN_FILE: string;
+export declare function rustToolchainFileVersion(file?: string): string | undefined;
+/** The pinned bundletool jar, installed on first use like kotlinc (Apache-2.0, no license to accept). */
+export declare function resolveBundletool(opts?: InstallOptions): Promise<string>;

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

@@ -0,0 +1,77 @@
+import type { Platform } from "../../../core/src/index.ts";
+export interface UpdatesConfig {
+    /** Base URL of the update files, e.g. "https://example.com/updates". http:// only for localhost / 10.0.2.2 in dev builds. */
+    url: string;
+    /** Raw 32-byte Ed25519 public key, base64 (`akan-native update keygen` prints it). */
+    publicKey: string;
+    /** Manifest name under <platform>/. Default "production". */
+    channel: string;
+    /** How long a newly applied bundle has to call notifyReady() before it is rolled back, ms. Default 10000. */
+    readyTimeout: number;
+}
+export interface UpdateFile {
+    /** Relative path inside the bundle ("index.html", "icons/a.png", "env.runtime.json"). */
+    path: string;
+    sha256: string;
+    size: number;
+}
+export type DesktopArch = "arm64" | "x64";
+/** The CPU of the desktop apps this machine builds (cargo and bun build for the host). */
+export declare function hostArch(): DesktopArch;
+export interface UpdateManifest {
+    schema: 1;
+    kind: "web" | "app";
+    app: string;
+    platform: Platform;
+    channel: string;
+    /** Web bundles: the native API the bundle needs (UP-3); the app ignores bundles for another one. */
+    nativeApi?: string;
+    /** Grows with every release (seconds since the epoch at publish time); older or equal ones are ignored. */
+    sequence: number;
+    /** Directory-safe id of this release. */
+    bundle: string;
+    runtimeVersion: string;
+    /** The app version (app updates) or the version the bundle was built with (web bundles). */
+    version: string;
+    files: UpdateFile[];
+    /** App updates: embeddedSequence of the release's app (updates.json), so it knows it is that release. */
+    build?: number;
+    /** App updates: the CPU the app is built for. Releases live in `<os>-<arch>/`, and an app takes only its own. */
+    arch?: DesktopArch;
+    /** App updates: the .app as a gzip tar; `sha256` is the tar's (what deltas produce), `gzSha256` the download's. */
+    archive?: {
+        sha256: string;
+        url: string;
+        size: number;
+        gzSha256: string;
+    };
+    /** App updates: gzip deltas from earlier releases' tars (`from` = that tar's sha256). */
+    patches?: {
+        from: string;
+        url: string;
+        sha256: string;
+        size: number;
+    }[];
+}
+export declare function validateUpdates(raw: unknown, problems: string[]): UpdatesConfig | null;
+/** Where the signing key of an app lives: AKAN_NATIVE_UPDATE_KEY (a file path), else ~/.akan/native/keys/<app id>.update.key. */
+export declare function updateKeyPath(appId: string, env?: Record<string, string | undefined>): string;
+/** Creates the Ed25519 key pair; returns the public key for akan-native.config.ts. Never overwrites a key. */
+export declare function generateUpdateKey(path: string): {
+    publicKey: string;
+    created: boolean;
+};
+export declare function signManifest(bytes: Uint8Array, keyPath: string, expectedPublicKey: string): string;
+/** Verifies like the apps do: raw public key, base64 signature over the exact manifest bytes. */
+export declare function verifyManifest(bytes: Uint8Array, signature: string, publicKey: string): boolean;
+export declare const sha256: (data: Uint8Array | string) => string;
+/**
+ * updates.json in a native build (next to boot.json), read by the shell at launch and by the
+ * updates plugin. `embeddedSequence` is the build time: a downloaded bundle older than the
+ * binary's own is dropped when a new binary is installed (Capacitor drops its live-update path on
+ * every new binary: capacitor/android/.../Bridge.java:429-455; here only when it is older).
+ */
+export declare function updatesResource(updates: UpdatesConfig, app: {
+    id: string;
+    version: string;
+}, platform: Platform, nativeApi: string | undefined, dev: boolean): string;

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

@@ -0,0 +1,13 @@
+export declare const VECTOR_FILES: readonly ["scope", "routes", "ranges", "ids", "bridge", "navigation", "acl", "retained", "ed25519"];
+/**
+ * How many checks each file holds: the runners fail when a file is missing or ran another number,
+ * so an empty or truncated file cannot pass as zero checks.
+ */
+export declare function vectorCounts(): Record<string, number>;
+/** AkanNativeVectorData.swift: the vector files as JSON text (empty for release builds). */
+export declare function swiftVectorData(withVectors: boolean): string;
+/**
+ * AkanNativeVectorData.kt: each vector file as a function returning Kotlin values (Map, List, String,
+ * Long, Double, Boolean, null); one function per file keeps each under the JVM's method size limit.
+ */
+export declare function kotlinVectorData(withVectors: boolean): string;

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

@@ -0,0 +1,13 @@
+export interface XmlElement {
+    name: string;
+    /** In source order; names keep their prefix ("android:name"). */
+    attrs: [name: string, value: string][];
+    children: XmlElement[];
+}
+export declare const escapeXml: (text: string) => string;
+/** Parses a document's root element. Text between elements is ignored (manifests have none that matters). */
+export declare function parseXml(source: string): XmlElement;
+export declare function attr(element: XmlElement, name: string): string | undefined;
+export declare function setAttr(element: XmlElement, name: string, value: string): void;
+/** The element as XML text, indented by `indent`. */
+export declare function serializeXml(element: XmlElement, indent?: string, step?: string): string;

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

@@ -0,0 +1,57 @@
+/** The license notices of an Android build with pinned Maven libraries, in the web root. */
+export declare const LICENSES_FILE = "akan-native-licenses.json";
+import type { ParsedArgs } from "../lib/args.ts";
+import { type ExecResult } from "../lib/exec.ts";
+import { type Device, type Launched, type LaunchOptions } from "../lib/launch.ts";
+import { type NativePlugin } from "../lib/native-plugins.ts";
+import { type BuildContext } from "../lib/prepare.ts";
+import type { AndroidManifest, ResolvedConfig } from "../lib/project.ts";
+/** Android 10. Newer framework APIs live in ApiN classes behind SDK_INT checks (lib/apilevel.ts). */
+export declare const MIN_SDK = 29;
+/** Chromium major: akan-native's runtime (Object.hasOwn 93) and unlowered ES2022 class static blocks (94). */
+export declare const MIN_WEBVIEW = 94;
+interface AndroidTools {
+    sdk: string;
+    androidJar: string;
+    aapt2: string;
+    d8: string;
+    d8Jar: string;
+    apksigner: string;
+    adb: string;
+    emulator: string;
+}
+/** SDK tools, pinned build-tools first (CLI-10). No JDK or Kotlin needed: see javaToolchain(). */
+export declare function androidTools(): AndroidTools;
+/**
+ * The applicationId: app.id, plus android.debugAppIdSuffix in debug builds so they install next to
+ * the release app (and match, say, a server's assetlinks entry for "<id>.debug").
+ */
+export declare function androidAppId(ctx: BuildContext): string;
+export declare function androidManifest(ctx: BuildContext, permissions: string[], applicationXml: string[], manifestXml?: string[], icon?: boolean, activityXml?: string[], applicationAttrs?: [string, string][]): string;
+export declare function buildAndroid(ctx: BuildContext): Promise<string>;
+/**
+ * push.android (N13) → resources and <application> meta-data: Firebase's default channel, icon and
+ * color for the notifications it shows itself (the app not in front), and the channel's name and
+ * importance for the plugin, which creates the channel at startup so Firebase finds it later.
+ */
+export declare function pushResources(res: string, config: Pick<ResolvedConfig, "push">, appDir: string): string[];
+/** Connected devices and emulators, then AVDs that are not running (docs/api.md devices). */
+export declare function androidDevices(): Promise<Device[]>;
+/**
+ * `akan-native test` starts emulators with -no-window, and run/dev reuse whatever is connected, so the app
+ * can end up on an emulator nobody can see. Found by the AVD name (`adb emu avd name`) in the
+ * emulator's command line; the window-less build is also a separate `qemu-system-*-headless` binary.
+ */
+export declare function warnIfWindowless(adb: string, serial: string): Promise<void>;
+export declare function launchAndroid(ctx: BuildContext, apk: string, opts: LaunchOptions & {
+    avd?: string;
+    device?: string;
+    reverse?: number[];
+}): Promise<Launched>;
+export declare function runAndroid(ctx: BuildContext, apk: string, args: ParsedArgs): Promise<number>;
+/**
+ * `akan-native plugin compile android`: compiles the shell, these plugins and their generated bindings
+ * with a registry of just them, in a fresh temporary folder (so several checks can run at once).
+ */
+export declare function compileAndroidPlugins(plugins: NativePlugin<AndroidManifest>[], appDir: string): Promise<ExecResult>;
+export {};

package/types/vendor/@akanjs/native/packages/cli/src/platforms/desktop-update.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "../lib/prepare.ts";
+import { type UpdateManifest } from "../lib/updates.ts";
+import { type DesktopOs } from "./desktop.ts";
+export declare function publishAppUpdate(ctx: BuildContext, os: DesktopOs, app: string, out: string, channel: string, sequence: number): Promise<UpdateManifest>;

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

@@ -0,0 +1,40 @@
+import type { ParsedArgs } from "../lib/args.ts";
+import { type Launched, type LaunchOptions } from "../lib/launch.ts";
+import type { BuildContext } from "../lib/prepare.ts";
+export declare const NATIVE_DIR: string;
+export type DesktopOs = "macos" | "windows" | "linux";
+/** The cdylib cargo builds, per OS. */
+export declare const NATIVE_LIB: Record<DesktopOs, string>;
+export declare function hostDesktopOs(platform?: NodeJS.Platform): DesktopOs | null;
+/** Desktop apps are built on their own OS: the webview SDKs and native toolchains live there. */
+export declare function requireHost(os: DesktopOs): void;
+/** The resources folder inside a built desktop app (what the build returned). */
+export declare function resourcesOf(os: DesktopOs, artifact: string): string;
+/**
+ * Cargo's output folder: CARGO_TARGET_DIR, else a cache under the akan-native home keyed by the
+ * source folder. Never inside native/desktop (gigabytes that a vendored or copied package would
+ * carry along, and a read-only install could not hold).
+ */
+export declare function cargoTargetDir(): string;
+/** Builds (incrementally) the Rust cdylib and returns its path. */
+export declare function buildNativeLibrary(os: DesktopOs, release: boolean): Promise<string>;
+/**
+ * The app never reads a .env or bunfig.toml from the folder it is started in: Bun's standalone
+ * executables do by default, which would let a file next to the app set its environment and
+ * runtime options.
+ */
+export declare const COMPILE_FLAGS: string[];
+/** bun build --compile of the main thread entry and the plugin host Worker into `outfile`. */
+export declare function compileExecutable(ctx: BuildContext, outfile: string, extra?: string[]): Promise<void>;
+/** The resources folder every desktop app reads (see the top of this file). */
+export declare function writeDesktopResources(ctx: BuildContext, resources: string, os: DesktopOs, shellExtra?: Record<string, unknown>): void;
+/**
+ * Starts a desktop executable directly, so native logs and the page console reach the CLI (WV-3).
+ * stop() asks the app to quit through its lifecycle (the onQuit hooks run): SIGTERM on macOS and
+ * Linux; on Windows, which has no such signal, a "quit" line on the app's stdin (lib.rs
+ * stdin_quit), then TerminateProcess if it is still running after 6 s.
+ */
+export declare function launchExecutable(exe: string, opts: LaunchOptions): Launched;
+export declare function runExecutable(exe: string, artifact: string, args: ParsedArgs): Promise<number>;
+/** Folder size for the build summary. */
+export declare function folderSize(path: string): Promise<string | null>;

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

@@ -0,0 +1,14 @@
+import type { ParsedArgs } from "../lib/args.ts";
+import type { Launched, LaunchOptions } from "../lib/launch.ts";
+import type { BuildContext } from "../lib/prepare.ts";
+import type { TargetPlatform } from "./targets.ts";
+export { hostTargets, TARGETS, type TargetPlatform } from "./targets.ts";
+export interface PlatformTarget {
+    /** Builds into ctx.outDir and returns the main artifact path. */
+    build(ctx: BuildContext): Promise<string>;
+    /** Launches a built artifact and follows its logs. Resolves when the app (or server) exits. */
+    run(ctx: BuildContext, artifact: string, args: ParsedArgs): Promise<number>;
+    /** Launches a built artifact with env overrides and a log line callback (akan-native test). */
+    launch(ctx: BuildContext, artifact: string, opts: LaunchOptions): Promise<Launched>;
+}
+export declare const PLATFORM_TARGETS: Record<TargetPlatform, PlatformTarget>;

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

@@ -0,0 +1,44 @@
+import type { ParsedArgs } from "../lib/args.ts";
+import { type ExecResult } from "../lib/exec.ts";
+import { type Device, type Launched, type LaunchOptions } from "../lib/launch.ts";
+import { type NativePlugin } from "../lib/native-plugins.ts";
+import { type BuildContext } from "../lib/prepare.ts";
+import type { IosManifest } from "../lib/project.ts";
+export declare const IOS_MIN = "16.0";
+/**
+ * swiftc conditions for the shell's optional parts: AKAN_NATIVE_DEV (the self-test's $host methods and
+ * shared vectors) and AKAN_NATIVE_UPDATES (web bundle updates, AkanNativeUpdates.swift). Code outside a condition
+ * reaches these parts only under it (architecture review stage 6; Capacitor #8436, #8580: an
+ * optional part that is still referenced breaks the builds without it).
+ */
+export declare function shellFeatureFlags(features: {
+    dev: boolean;
+    updates: boolean;
+}): string[];
+/** Module and executable name: app.fileName without punctuation, starting with a letter (a Swift identifier). */
+export declare function moduleName(fileName: string): string;
+export declare function buildIos(ctx: BuildContext): Promise<string>;
+export interface PhysicalIosDevice {
+    /** devicectl's identifier. */
+    id: string;
+    name: string;
+    udid: string;
+    os: string;
+    /** connected, disconnected (devicectl connects on demand), unavailable (not reachable). */
+    tunnel: string;
+}
+/** Paired iPhones and iPads (`xcrun devicectl list devices`). */
+export declare function physicalIosDevices(): Promise<PhysicalIosDevice[]>;
+/** The paired device `wanted` names (its name, with ' or ’, its UDID or devicectl id), else null (a simulator then). */
+export declare function physicalIosDevice(wanted: string): Promise<PhysicalIosDevice | null>;
+/** iOS simulators and iPhones (docs/api.md devices), booted and connected ones first. */
+export declare function iosDevices(): Promise<Device[]>;
+export declare function launchIos(ctx: BuildContext, appPath: string, opts: LaunchOptions & {
+    device?: string;
+}): Promise<Launched>;
+export declare function runIos(ctx: BuildContext, appPath: string, args: ParsedArgs): Promise<number>;
+/**
+ * `akan-native plugin compile ios`: typechecks the shell, these plugins and their generated bindings with
+ * a registry of just them, in a fresh temporary folder (so several checks can run at once).
+ */
+export declare function typecheckIosPlugins(plugins: NativePlugin<IosManifest>[], appDir: string): Promise<ExecResult>;

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

@@ -0,0 +1,6 @@
+import type { ParsedArgs } from "../lib/args.ts";
+import type { Launched, LaunchOptions } from "../lib/launch.ts";
+import type { BuildContext } from "../lib/prepare.ts";
+export declare function buildLinux(ctx: BuildContext): Promise<string>;
+export declare function launchLinux(ctx: BuildContext, dir: string, opts: LaunchOptions): Promise<Launched>;
+export declare function runLinux(ctx: BuildContext, dir: string, args: ParsedArgs): Promise<number>;

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

@@ -0,0 +1,7 @@
+import type { ParsedArgs } from "../lib/args.ts";
+import type { Launched, LaunchOptions } from "../lib/launch.ts";
+import type { BuildContext } from "../lib/prepare.ts";
+export declare const MACOS_MIN = "26.0";
+export declare function buildMacos(ctx: BuildContext): Promise<string>;
+export declare function launchMacos(ctx: BuildContext, appPath: string, opts: LaunchOptions): Promise<Launched>;
+export declare function runMacos(ctx: BuildContext, appPath: string, args: ParsedArgs): Promise<number>;

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

@@ -0,0 +1,4 @@
+export type TargetPlatform = "web" | "macos" | "windows" | "linux" | "ios" | "android";
+export declare const TARGETS: readonly TargetPlatform[];
+/** What `all` means on this machine: desktop apps and iOS build only on their own OS. */
+export declare function hostTargets(host?: NodeJS.Platform): TargetPlatform[];

package/types/vendor/@akanjs/native/packages/cli/src/platforms/web-run.d.ts

@@ -0,0 +1,15 @@
+import { type ParsedArgs } from "../lib/args.ts";
+import { type Launched, type LaunchOptions } from "../lib/launch.ts";
+import type { BuildContext } from "../lib/prepare.ts";
+import { type LiveReload } from "../lib/serve.ts";
+export interface WebLaunchOptions extends LaunchOptions {
+    port?: number;
+    hostname?: string;
+    /** Called with the server URL once it listens. */
+    onReady?: (url: string) => void;
+    liveReload?: LiveReload;
+}
+/** The web platform's /__akan_native/init.js with runtime env overrides (AKAN_NATIVE_PUBLIC_X → PUBLIC_X), as the native dev hosts do (§3.1). */
+export declare function webInitScript(ctx: BuildContext, env: Record<string, string>): string;
+export declare function launchWeb(ctx: BuildContext, outDir: string, opts: WebLaunchOptions): Promise<Launched>;
+export declare function runWeb(ctx: BuildContext, outDir: string, args: ParsedArgs): Promise<number>;

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

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../lib/prepare.ts";
+export declare function buildWeb(ctx: BuildContext): Promise<string>;

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

@@ -0,0 +1,8 @@
+import type { ParsedArgs } from "../lib/args.ts";
+import type { Launched, LaunchOptions } from "../lib/launch.ts";
+import type { BuildContext } from "../lib/prepare.ts";
+/** The version resource wants four numbers: major.minor.patch.build. */
+export declare function windowsVersion(version: string, build: number): string;
+export declare function buildWindows(ctx: BuildContext): Promise<string>;
+export declare function launchWindows(ctx: BuildContext, dir: string, opts: LaunchOptions): Promise<Launched>;
+export declare function runWindows(ctx: BuildContext, dir: string, args: ParsedArgs): Promise<number>;

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

@@ -0,0 +1 @@
+export * from "./platforms/index.d.ts";

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

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

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

@@ -0,0 +1,97 @@
+/** A scope entry: field → glob. The plugin says which fields it knows (its manifest `scope`). */
+export type ScopeEntry = Record<string, string>;
+export interface AclGrant {
+    plugin: string;
+    /** Window ids (1 = the main window), or every window. Mobile and web pages are window 1. */
+    windows: "*" | number[];
+    /** Methods, `listen:<event>` for subscriptions, or everything. */
+    items: "*" | string[];
+    /** Absent: no restriction from this grant. */
+    allow?: ScopeEntry[];
+    deny?: ScopeEntry[];
+}
+export interface ResolvedAcl {
+    grants: AclGrant[];
+    /** plugin → items denied everywhere. */
+    denied?: Record<string, string[]>;
+}
+/** What a call may touch. `allow: null`: anything the plugin allows by itself, minus `deny`. */
+export interface CallScope {
+    allow: ScopeEntry[] | null;
+    deny: ScopeEntry[];
+}
+export interface Access {
+    allowed: boolean;
+    /** Only when some matching grant carries scopes. */
+    scope?: CallScope;
+}
+/** What hosts enforce when boot.json's ACL is broken: nothing is allowed (fail-closed). */
+export declare const DENY_ALL: ResolvedAcl;
+/**
+ * Why an ACL from boot.json is not one the hosts can enforce, or null. Every host checks the same
+ * shape (Swift AkanNativeAcl.from, Kotlin AkanNativeAcl.from; vectors/acl.json): a malformed part must not
+ * loosen the rest, as when one bad denial dropped every denial or one bad grant allowed everything.
+ */
+export declare function aclProblem(value: unknown): string | null;
+/**
+ * A host's ACL from its boot data. boot.json without one (a build without capabilities, unit
+ * tests): null, everything allowed. One that is not well formed: nothing allowed.
+ */
+export declare function loadAcl(boot: {
+    acl?: unknown;
+}): {
+    acl: ResolvedAcl | null;
+    problem: string | null;
+};
+/** The ACL item of a `$listen` for `event`. */
+export declare const listenItem: (event: string) => string;
+/**
+ * The C7 check. Without an ACL (older builds, unit tests) everything is allowed, as before PL-11.
+ */
+export declare function aclCheck(acl: ResolvedAcl | undefined | null, plugin: string, item: string, window?: number): Access;
+/**
+ * Glob match of the whole `text`. Path mode (`path: true`): `*` and `?` stop at "/", `**` crosses
+ * it, `**​/` also matches no folder, and a trailing `/**` also matches the folder itself
+ * ("exports/**" covers "exports"). In an allow entry no wildcard matches a name that starts with
+ * "." (".env", ".git/"): dot files are allowed only when the pattern names the dot itself
+ * (".config/**", "**​/.env"). A deny entry (`deny: true`) covers them too ("private/**" keeps
+ * "private/.env" out). Otherwise `*` and `**` match anything (plain values such as a filesystem
+ * base; URLs use urlMatch). No other syntax: every other character is literal. Case-sensitive;
+ * scopePermits folds case for case-insensitive volumes.
+ */
+export declare function globMatch(pattern: string, text: string, path: boolean, deny?: boolean): boolean;
+export declare function globSource(pattern: string, path: boolean, deny?: boolean): string;
+/**
+ * A URL split for matching. `rest` is the path of a URL with an authority, or what follows the
+ * scheme otherwise (the addresses of mailto:, the number of tel:). Scheme and host are lowercase.
+ * A URL's query and fragment are not part of it; in a pattern `?` is a wildcard, so only "/" ends
+ * the authority.
+ */
+export interface UrlParts {
+    scheme: string;
+    host: string | null;
+    port: string;
+    rest: string;
+}
+export declare function urlParts(text: string, pattern?: boolean): UrlParts | null;
+/**
+ * URL scope match, for the fields a plugin names in scopePermits' `urlFields`: scheme, host, port
+ * and the rest are compared separately, so no wildcard reaches from one into another
+ * ("https://*.example.com/*" never matches "https://evil.com/x.example.com/"). Scheme and host
+ * ignore case, and `*` in the host spans dots (a.b.example.com). A pattern without a port matches
+ * only the scheme's default port in an allow entry ("https://api.example.com/*" does not reach a
+ * debug server on :8443, as URLPattern strings in Tauri do), but every port in a deny entry (a deny
+ * of a host covers all of it); ":*" is any port. A pattern without a path matches any path, and `*`
+ * alone every URL; `*` in the path crosses "/". The query and fragment are never compared, and `?`
+ * is always a one-character wildcard. A pattern without a scheme matches nothing. `url` is the
+ * plugin's normalized URL (percent-encoded, no default port, dot segments resolved).
+ */
+export declare function urlMatch(pattern: string, url: string, deny?: boolean): boolean;
+/**
+ * Whether `value` (the fields of what a call touches, e.g. { base, path } or { url }) is inside the
+ * call's scope: no deny entry matches, and some allow entry matches unless allow is unrestricted.
+ * `fold`: the path fields name files on a case-insensitive volume (macOS and Windows by default,
+ * Android's shared storage), so "Secret/x" is compared as "secret/x" and a deny cannot be passed
+ * by changing case.
+ */
+export declare function scopePermits(scope: CallScope | undefined | null, value: Record<string, string>, pathFields?: readonly string[], urlFields?: readonly string[], fold?: boolean): boolean;

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

@@ -0,0 +1,66 @@
+import { type ResolvedAcl } from "./acl.ts";
+export type Platform = "web" | "macos" | "windows" | "linux" | "ios" | "android";
+/**
+ * How a host provides a plugin:
+ * - "web": the plugin's web implementation runs inside the WebView
+ * - { methods, events }: the host has a native implementation of these
+ * A plugin missing from the map is unsupported on that host (web platform excepted).
+ */
+/**
+ * "web": the page runs the web implementation. An object: the host implements these methods and
+ * events; with `web: true` the others fall back to the web implementation (e.g. macOS camera:
+ * native permission state, getUserMedia capture).
+ */
+/**
+ * `coalesce`: events whose payload is a snapshot (progress, sizes, positions): the host sends only the
+ * latest of a burst (architecture review stage 4, `coalesce: "latest"`).
+ */
+export type PluginDecl = "web" | {
+    methods: string[];
+    events: string[];
+    web?: true;
+    coalesce?: string[];
+};
+export interface AppInfo {
+    id: string;
+    name: string;
+    version: string;
+    build?: number;
+}
+export interface AkanNativeBoot {
+    v: 1;
+    platform: Platform;
+    runtimeVersion: string;
+    dev: boolean;
+    app: AppInfo | null;
+    env: Record<string, string>;
+    plugins: Record<string, PluginDecl>;
+    /** Desktop: this page's window (1 = the window the app opened, SH-6). Absent elsewhere. */
+    windowId?: number;
+    /** The resolved capabilities (PL-11). The host enforces them; the page applies them to web implementations. */
+    acl?: ResolvedAcl;
+    /** Native hosts: fingerprint of what the binary provides natively; web bundles must match it (UP-3). */
+    nativeApi?: string;
+    /** Native hosts: bridge v1.1 features (protocol.ts BRIDGE_FEATURES). */
+    bridge?: {
+        features: string[];
+    };
+    /** The app's origin, set by the shell (the web: the page's): the one value origin checks use. */
+    origin?: string;
+    /** Native hosts: the page's engine (wkwebview, webview2, webkitgtk, android-webview) and its version. */
+    engine?: string;
+    engineVersion?: string;
+}
+/** The global object. init.js fills the boot fields, @akanjs/native/core adds `receive`. */
+export interface AkanNativeGlobal extends Partial<AkanNativeBoot> {
+    /** Entry point for host → JS messages (responses on Android, events everywhere). */
+    receive?: (message: unknown) => void;
+    /** Shared runtime state, so that duplicated copies of @akanjs/native/core in one page agree. */
+    __runtime?: unknown;
+}
+export declare function akanNativeGlobal(): AkanNativeGlobal;
+/**
+ * Reads the boot data. Without init.js (plain dev server, unit tests) the page
+ * behaves as the web platform with an empty env.
+ */
+export declare function readBoot(): AkanNativeBoot;