akanjs 3.0.0-beta.2 → 3.0.0-beta.21

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;

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

@@ -0,0 +1,35 @@
+export declare const ERROR_CODES: readonly ["UNSUPPORTED", "PERMISSION_DENIED", "CANCELLED", "TIMEOUT", "INVALID_ARGS", "NOT_FOUND", "NOT_ALLOWED", "INTERNAL"];
+/** File name extension → MIME type (assets and FileRefs). */
+export declare const MIME: Readonly<Record<string, string>>;
+/** Besides text/*, the asset types served with charset=utf-8. */
+export declare const MIME_UTF8: readonly string[];
+/** An id grammar: allowed characters, length, and an optional extension after the first dot. */
+export interface IdSpec {
+    chars: string;
+    first: string;
+    notFirst: string;
+    min: number;
+    max: number;
+    extChars: string;
+    extMax: number;
+}
+export declare const ID_FILE_REF: IdSpec;
+export declare const ID_BUNDLE: IdSpec;
+export declare const ID_DOCUMENT: IdSpec;
+export declare const ID_NAME: IdSpec;
+export declare const EXTERNAL_SCHEMES: readonly string[];
+export declare const FRAME_SCHEMES: readonly string[];
+/** Schemes an app can never add to the external list. */
+export declare const NEVER_EXTERNAL_SCHEMES: readonly string[];
+export declare const ROUTES: {
+    readonly root: "__akan_native";
+    readonly init: "init.js";
+    readonly ipc: "ipc";
+    readonly hello: "hello";
+    readonly file: "file";
+};
+export declare const INIT_PREFIX = "window.__AKAN_NATIVE__=(function(o,b,e){for(var k in b)o[k]=b[k];o.env=e;return o})(window.__AKAN_NATIVE__||{},";
+export declare const INIT_SUFFIX = ");\n";
+export declare const MAX_RANGE_BYTES = 1024000;
+export declare const EXTERNAL_OPENS_PER_SECOND = 1;
+export declare const MAX_RETAINED_EVENTS = 16;

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

@@ -0,0 +1,27 @@
+import { type BridgeErrorBody, type ErrorCode } from "./protocol.ts";
+export interface AkanNativeErrorOptions {
+    cause?: unknown;
+    /** Details a caller can act on, e.g. `{ reason: "packageManaged" }`. */
+    data?: unknown;
+    /** The same call may work later. */
+    retryable?: boolean;
+    /** Overrides the name derived from the code (DataCloneError for arguments JSON cannot carry). */
+    name?: string;
+}
+export declare class AkanNativeError extends Error {
+    readonly code: ErrorCode;
+    readonly data?: unknown;
+    readonly retryable: boolean;
+    constructor(code: ErrorCode, message: string, options?: AkanNativeErrorOptions);
+    /**
+     * Builds a real Error from a wire error so callers get a stack trace
+     * (Capacitor copies native error fields onto an Error for the same reason:
+     * capacitor/core/native-bridge.ts `returnResult`).
+     */
+    static fromBody(body: BridgeErrorBody | undefined, cause?: unknown): AkanNativeError;
+    /** Normalizes anything thrown by an implementation into an AkanNativeError. */
+    static from(error: unknown): AkanNativeError;
+    /** The error body a host sends for this error. */
+    toBody(): BridgeErrorBody;
+}
+export declare function isAkanNativeError(error: unknown, code?: ErrorCode): error is AkanNativeError;

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

@@ -0,0 +1,23 @@
+import { type FileRef } from "./protocol.ts";
+/**
+ * Stops serving a FileRef. FileRefs live for the app session (architecture review, 2026-09-26), so
+ * release the ones the page no longer shows: photos, picked files, downloads. The host forgets the
+ * URL and deletes akan-native's own copy of the file; files that belong to the user (a document served in
+ * place) stay. Holding the URL is the permission, as for any follow-up on what a call handed out.
+ * Resolves whether it was served. On the web, a blob: URL is revoked.
+ */
+export declare function releaseFile(file: FileRef | string): Promise<boolean>;
+export interface FileReadOptions {
+    /** Bytes per Range request. Default 4 MiB. */
+    chunkSize?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Reads a FileRef (or any same-origin URL) in pieces with HTTP Range requests, so a big file never
+ * has to be one response: the desktop shell answers without streaming (WRY), reading a whole
+ * response into memory (architecture review stage 4). Every host serves FileRefs with
+ * `Accept-Ranges: bytes`. A server that ignores Range (200) is streamed as it answers.
+ */
+export declare function fileStream(file: FileRef | string, options?: FileReadOptions): ReadableStream<Uint8Array>;
+/** A FileRef as a Blob, read in Range pieces (see fileStream); `type` is the FileRef's MIME type. */
+export declare function fileBlob(file: FileRef | string, options?: FileReadOptions): Promise<Blob>;

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

@@ -0,0 +1,14 @@
+export type { Access, AclGrant, CallScope, ResolvedAcl, ScopeEntry } from "./acl.ts";
+export { aclCheck, aclProblem, DENY_ALL, globMatch, listenItem, loadAcl, scopePermits, urlMatch } from "./acl.ts";
+export type { AkanNativeBoot, AppInfo, Platform, PluginDecl } from "./boot.ts";
+export { AkanNativeError, type AkanNativeErrorOptions, isAkanNativeError } from "./errors.ts";
+export { type FileReadOptions, fileBlob, fileStream, releaseFile } from "./files.ts";
+export type { LiveValue } from "./live.ts";
+export { createLiveValue, shallowEqual } from "./live.ts";
+export { mimeFor } from "./mime.ts";
+export type { CallOptions, Implementation, ListenOptions, Plugin, PluginHandle, PluginMethods, PluginOptions, WebCallContext, WebPlugin, } from "./plugin.ts";
+export { definePlugin, defineWebPlugin } from "./plugin.ts";
+export type { CancelReason, ErrorCode, FileRef } from "./protocol.ts";
+export { type AkanNativeEnv, app, type Env, env, isDev, isNative, nativeApi, platform, runtimeVersion, windowId, } from "./state.ts";
+export type { VetoEvent, VetoHandler } from "./veto.ts";
+export { vetoable } from "./veto.ts";

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

@@ -0,0 +1,112 @@
+import { type IdSpec } from "./contract.ts";
+/** Whether `s` follows an id grammar: its characters and length, and an optional ".ext" after the first dot. */
+export declare function idValid(spec: IdSpec, s: string): boolean;
+export declare const isFileRefId: (s: string) => boolean;
+export declare const isBundleId: (s: string) => boolean;
+export declare const isDocumentId: (s: string) => boolean;
+export declare const isName: (s: string) => boolean;
+/** Strict percent-decoding: "%" and two hex digits, and the result must be UTF-8; otherwise null. */
+export declare function decodePath(s: string): string | null;
+export type Route = {
+    kind: "init";
+} | {
+    kind: "ipc";
+} | {
+    kind: "hello";
+} | {
+    kind: "file";
+    id: string;
+} | {
+    kind: "asset";
+    path: string;
+} | {
+    kind: "not-found";
+};
+/**
+ * Maps a URL pathname (still percent-encoded) to a route. `exists` tells whether a relative asset
+ * path exists. Every host routes /__akan_native/ipc and /__akan_native/hello; the ones that do not serve them
+ * answer 404.
+ *
+ *   /__akan_native/init.js · /__akan_native/ipc · /__akan_native/hello · /__akan_native/file/<id>   the host's own
+ *   /__akan_native/<anything else>                                             404
+ *   existing file                                                       the file
+ *   missing, no extension                                               index.html (SPA route)
+ *   missing, with extension                                             404 (a missing asset should not turn into HTML)
+ *
+ * Traversal is refused, not normalized. A path with ":" is never looked up as a file: on Windows
+ * "C:" makes the joined path absolute (the host would read outside the app folder) and "a:b" names
+ * an alternate data stream. It can still be an SPA route ("/at/12:30").
+ */
+export declare function route(pathname: string, exists: (relativePath: string) => boolean): Route;
+/** Paths a host answers itself even when its pages come from a dev server: /__akan_native/*, and paths that do not decode. */
+export declare function isHostPath(pathname: string): boolean;
+/** The MIME type for a file name (FileRefs): application/octet-stream when unknown. */
+export declare function fileMime(path: string): string;
+/** The Content-Type an asset is served with: text types carry charset=utf-8. */
+export declare function assetMime(path: string): string;
+/**
+ * Whether a FileRef of this type is served with `Content-Security-Policy: sandbox`: everything but
+ * images other than SVG, audio, video, fonts and PDF. A sandboxed document has an opaque origin, so
+ * an HTML or SVG file a plugin serves (a picked or downloaded file) cannot reach the bridge or the
+ * page even when it is opened as a document; <img>, <video> and <audio> are unaffected. PDF is left
+ * out because macOS WebKit draws nothing for a sandboxed PDF (iOS and WebView2 do; checked
+ * 2026-09-26); its viewer runs no page script, and nosniff keeps HTML named .pdf a PDF.
+ */
+export declare function fileRefSandboxed(mime: string): boolean;
+export type RangeAnswer = {
+    status: 200;
+} | {
+    status: 206;
+    start: number;
+    end: number;
+} | {
+    status: 416;
+};
+/**
+ * A Range header (IN-5, RFC 9110 §14) for a file of `size` bytes. One "bytes=" range is supported:
+ * a header that is not one (another unit, several ranges, bad syntax, last before first) is ignored
+ * and the whole file is sent. A valid range the file cannot satisfy is 416. A response carries at
+ * most MAX_RANGE_BYTES, from the range's start.
+ */
+export declare function parseRange(header: string | null, size: number): RangeAnswer;
+export type Admission = "current" | "new" | "ended" | "no-doc";
+/**
+ * What a host does with a request of document `requested` (null: none) while `current` is the
+ * window's document (null: none; "": one without an id): join the current one, start a new one
+ * (ending the current), refuse it because that document ended, or refuse it because it has no id
+ * while the current document has one (its answer would take a number the page never sees).
+ */
+export declare function admitDocument(current: string | null, ended: readonly string[], requested: string | null): Admission;
+/**
+ * Events that can come before the page listens (links, notification taps; plugins.md C2, Capacitor
+ * retainUntilConsumed). A live event goes to every listener; one that no listener accepted is kept
+ * when `retain` (at most MAX_RETAINED_EVENTS, the oldest go) and replayed, in order, to the next
+ * listener, once. A listener returns false when it is gone (its window ended): it is dropped and the
+ * event counts as not delivered.
+ */
+export declare class RetainedEvents<T> {
+    private readonly listeners;
+    private readonly queue;
+    listen(key: string, listener: (event: T) => boolean): void;
+    unlisten(key: string): void;
+    emit(event: T, retain: boolean): void;
+}
+/**
+ * Whether a plugin's declaration in boot.json (`plugins[id]`: "web", or its native methods and
+ * events on this platform) lets a call through: hosts refuse undeclared methods and events with
+ * NOT_FOUND before the ACL and the plugin, whatever the plugin's code implements.
+ */
+export declare function declares(decl: unknown, method: string, event: string | null): boolean;
+/** The lowercase scheme of a URL, or null when it has none. */
+export declare function schemeOf(url: string): string | null;
+/** The schemes the shell hands to the OS: the contract's, and what the app added (never the forbidden ones). */
+export declare function externalSchemes(extra?: readonly string[]): string[];
+/**
+ * Where a navigation goes. The app's own pages (and about:) load, but its /__akan_native/* paths never
+ * become a document of the app's origin: a FileRef holding someone's HTML would run with the
+ * bridge (Capacitor GHSA-rvm3-566m-v7fv); a frame may show a FileRef, which is served sandboxed
+ * (fileRefSandboxed). Otherwise a top-level navigation is handed to the OS when its scheme is an
+ * external one and dropped when not; a frame may load http, https, data, blob and about pages but
+ * never opens anything.
+ */
+export declare function decideNavigation(url: string, topLevel: boolean, origin: string, extra?: readonly string[]): "load" | "open" | "drop";

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

@@ -0,0 +1,12 @@
+export interface LiveValue<T> {
+    get(): T;
+    set(value: T): void;
+    subscribe(onChange: () => void): () => void;
+}
+/**
+ * `start` runs when the first subscriber arrives and may return a stop function,
+ * which runs one microtask after the last subscriber leaves (StrictMode safe).
+ */
+export declare function createLiveValue<T>(initial: T, start?: (set: (value: T) => void) => (() => void) | void, equals?: (a: T, b: T) => boolean): LiveValue<T>;
+/** Shallow equality for plain state objects. */
+export declare function shallowEqual<T extends object>(a: T, b: T): boolean;

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

@@ -0,0 +1,2 @@
+/** MIME type from the file name's extension; application/octet-stream when unknown. */
+export declare function mimeFor(name: string): string;

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

@@ -0,0 +1,71 @@
+import { type CallScope } from "./acl.ts";
+export type Implementation = "native" | "web" | "none";
+type Unsubscribe = () => void;
+type Emit<T> = (data: T) => void;
+/** Second argument of a web implementation method: what the app's capabilities allow this call (PL-11). */
+export interface WebCallContext {
+    scope?: CallScope;
+    /** The caller's AbortSignal: stop the work when it fires (the call has already been rejected). */
+    signal?: AbortSignal;
+}
+/**
+ * The last argument of every plugin method (bridge v1.1 `cancel`). There is no timeout option:
+ * `AbortSignal.timeout(ms)` rejects with TIMEOUT, any other abort with CANCELLED, and
+ * `AbortSignal.any([...])` combines them.
+ */
+export interface CallOptions {
+    signal?: AbortSignal;
+}
+export interface ListenOptions {
+    /** Unsubscribes when it fires. */
+    signal?: AbortSignal;
+    /** Unsubscribes after the first event. */
+    once?: boolean;
+}
+export interface WebPlugin<Api, Events> {
+    methods: {
+        [K in keyof Api]?: Api[K];
+    };
+    /** Event sources. Started for the first listener, stopped after the last one leaves. */
+    events?: {
+        [E in keyof Events]?: (emit: Emit<Events[E]>) => Unsubscribe;
+    };
+}
+export interface PluginOptions<Api, Events> {
+    methods: readonly (keyof Api & string)[];
+    events?: readonly (keyof Events & string)[];
+    web?: WebPlugin<Api, Events>;
+}
+export interface PluginHandle<Api, Events> {
+    readonly id: string;
+    readonly methods: readonly (keyof Api & string)[];
+    readonly events: readonly (keyof Events & string)[];
+    /** Where a call to this method would go on the current host. */
+    implementation(method: keyof Api & string): Implementation;
+    isSupported(method: keyof Api & string): boolean;
+    /** Whether the app's capabilities let this window call the method (PL-11). Independent of isSupported. */
+    isAllowed(method: keyof Api & string): boolean;
+    eventImplementation(event: keyof Events & string): Implementation;
+    /** Subscribes to an event. Safe to call and undo repeatedly (React StrictMode). */
+    listen<E extends keyof Events & string>(event: E, listener: (data: Events[E]) => void, options?: ListenOptions): Unsubscribe;
+}
+/** A method with the CallOptions argument after its own (a method without arguments takes `undefined` first). */
+type WithOptions<F> = F extends (...args: infer P) => infer R ? (...args: P extends [] ? [args: undefined, options: CallOptions] : [...P, options: CallOptions]) => R : never;
+/**
+ * Each method keeps its own signature (generics and overloads intact) and gains an overload that
+ * takes CallOptions last. With options, the argument types come from the last overload.
+ */
+export type PluginMethods<Api> = {
+    [K in keyof Api]: Api[K] & WithOptions<Api[K]>;
+};
+export type Plugin<Api, Events = {}> = PluginMethods<Api> & PluginHandle<Api, Events>;
+/** Identity helper that gives web implementations their types. */
+export declare function defineWebPlugin<Api, Events = {}>(impl: WebPlugin<Api, Events>): WebPlugin<Api, Events>;
+export declare function definePlugin<Api extends object, Events extends object = {}>(id: string, options: PluginOptions<Api, Events>): Plugin<Api, Events>;
+/**
+ * Dev builds: why `value` would not survive the JSON trip to a native host, or null. JSON would
+ * silently turn these into something else (a Date into a string, a Map into {}, NaN into null) or
+ * throw (BigInt, a cycle). Plain objects, arrays, strings, finite numbers, booleans and null pass.
+ */
+export declare function cloneProblem(value: unknown, path: string, ancestors?: object[]): string | null;
+export {};