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

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 {};

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

@@ -0,0 +1,109 @@
+import { ERROR_CODES as CONTRACT_ERROR_CODES, INIT_PREFIX, INIT_SUFFIX } from "./contract.ts";
+export declare const PROTOCOL_VERSION = 1;
+/**
+ * What the hosts of this akan-native version speak beyond v1 (boot.json `bridge.features`, part of the UP-3
+ * fingerprint, so a web bundle never runs on a shell that lacks one):
+ * - doc: every request names its document (one page load); the host ends the previous document
+ *   when a new one calls or the main frame commits a navigation, and refuses calls of ended ones
+ * - seq: the host numbers a document's responses and events (from 1) where it sends them; the page
+ *   delivers them in that order
+ * - once: a document's request id runs at most once
+ * - cancel: `$bridge.cancel { id, reason }` ends a running call of the same document at once
+ *   (CANCELLED, or TIMEOUT for reason "timeout") and tells its plugin; `$bridge.release { url }`
+ *   drops a FileRef. Errors may carry `data` and `retryable`.
+ */
+export declare const BRIDGE_FEATURES: readonly ["doc", "seq", "once", "cancel"];
+/** Reserved method names for event subscription. */
+export declare const LISTEN = "$listen";
+export declare const UNLISTEN = "$unlisten";
+/**
+ * Reserved plugin id for the bridge's follow-up operations (v1.1 `cancel`). They act on something a
+ * call of the same page handed out, so holding it is the permission (no ACL entry):
+ * - cancel { id, reason }: the call `id` of this document ends now (reason "abort" → CANCELLED,
+ *   "timeout" → TIMEOUT); answers `{ cancelled }`, false when the call already finished
+ * - release { url }: the FileRef at `url` is no longer served; answers `{ released }`
+ */
+export declare const BRIDGE_PLUGIN = "$bridge";
+export declare const CANCEL = "cancel";
+export declare const RELEASE = "release";
+export type CancelReason = "abort" | "timeout";
+/**
+ * A plugin's method and event names (manifest, definePlugin): a letter, then letters, digits and "_".
+ * Names starting with "$" belong to the bridge ($listen, $unlisten, $bridge, $host, $console).
+ */
+export declare const MEMBER_NAME: RegExp;
+/** Method names the plugin object uses itself, or that JavaScript and React look for on any object. */
+export declare const RESERVED_MEMBERS: readonly string[];
+export declare const CANCEL_REASONS: readonly CancelReason[];
+/** The app's capabilities do not grant a call: NOT_ALLOWED (PL-11). PERMISSION_DENIED is the OS or the user saying no. */
+export type ErrorCode = (typeof CONTRACT_ERROR_CODES)[number];
+export declare const ERROR_CODES: readonly ErrorCode[];
+/** JS → host */
+export interface BridgeRequest {
+    v: 1;
+    id: number;
+    plugin: string;
+    method: string;
+    args?: unknown;
+    /** The calling document (v1.1 `doc`). The page runtime always sends it. */
+    doc?: string;
+}
+export interface BridgeErrorBody {
+    code: ErrorCode;
+    message: string;
+    /** Details a caller can act on, e.g. `{ reason: "packageManaged" }` (v1.1 `cancel`). */
+    data?: unknown;
+    /** The same call may work later (a plugin still starting, the network, a busy database). */
+    retryable?: boolean;
+}
+/** Where a host message goes and its place in the document's order (v1.1 `doc`, `seq`). */
+export interface Delivery {
+    doc?: string;
+    seq?: number;
+}
+/** host → JS, answers one request */
+export type BridgeResponse = ({
+    v: 1;
+    id: number;
+    ok: true;
+    result?: unknown;
+} & Delivery) | ({
+    v: 1;
+    id: number;
+    ok: false;
+    error: BridgeErrorBody;
+} & Delivery);
+/** host → JS, push */
+export interface BridgeEvent extends Delivery {
+    v: 1;
+    plugin: string;
+    event: string;
+    data?: unknown;
+}
+/** Arguments of the reserved $listen / $unlisten methods. */
+export interface ListenArgs {
+    event: string;
+}
+/** Large results (photos, files) are returned as a URL served by the host (PL-7). */
+export interface FileRef {
+    url: string;
+    mime: string;
+    size: number;
+}
+/** A document id: the page runtime makes 32 hex digits; hosts accept 8 to 64 of [A-Za-z0-9_-] (contract.json). */
+export declare const DOC_ID: RegExp;
+/** Validates an incoming request (SEC-3). Returns an error message or null. */
+export declare function validateRequest(value: unknown): string | null;
+export declare function isResponse(value: unknown): value is BridgeResponse;
+export declare function isEvent(value: unknown): value is BridgeEvent;
+export declare function okResponse(id: number, result?: unknown): BridgeResponse;
+export declare function errorResponse(id: number, code: ErrorCode, message: string, extra?: {
+    data?: unknown;
+    retryable?: boolean;
+}): BridgeResponse;
+export { INIT_PREFIX, INIT_SUFFIX };
+export declare function renderInitScript(bootJson: string, envJson: string): string;
+/** Reserved plugin id for forwarding page console output to the host log in dev builds (WV-3). */
+export declare const CONSOLE_PLUGIN = "$console";
+/** Reserved plugin id for shell built-ins the page runtime calls itself, e.g. `print` (plugins.md D8). */
+export declare const HOST_PLUGIN = "$host";

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

@@ -0,0 +1,66 @@
+import { type AkanNativeBoot } from "./boot.ts";
+import { type BridgeEvent, type BridgeRequest, type BridgeResponse, type CancelReason } from "./protocol.ts";
+/** One way to reach the host. Events always come back through `__AKAN_NATIVE__.receive`. */
+export interface Transport {
+    send(request: BridgeRequest): Promise<BridgeResponse>;
+    /** Internal diagnostics for the self-test (e.g. how many bridge ports the page adopted). */
+    info?(): Record<string, unknown>;
+}
+type Listener = (data: unknown) => void;
+interface Pending {
+    resolve(response: BridgeResponse): void;
+}
+export interface Runtime {
+    boot: AkanNativeBoot;
+    transport: Transport | null;
+    nextId: number;
+    /** Calls waiting for their response, which always comes through receive(). */
+    pending: Map<number, Pending>;
+    /** "plugin\0event" → listeners, shared by native and web event sources. */
+    listeners: Map<string, Set<Listener>>;
+    /** This document's id (bridge v1.1 `doc`), sent with every request. */
+    doc: string;
+    /** The runtime's timers (the gap timer, the next-task deferrals); tests replace them with a virtual clock. */
+    timers: Timers;
+    /** In-order delivery of host messages (v1.1 `seq`): see receive(). */
+    order: {
+        /** The next number to deliver, and later ones that came early. */
+        next: number;
+        held: Map<number, BridgeResponse | BridgeEvent>;
+        timer: unknown;
+        /** A response was delivered in this task: events wait for the next one. */
+        answered: boolean;
+        /** Messages in order that wait for the next task. */
+        later: (BridgeResponse | BridgeEvent)[];
+    };
+}
+export interface Timers {
+    set(fn: () => void, ms: number): unknown;
+    clear(handle: unknown): void;
+}
+export declare function eventKey(plugin: string, event: string): string;
+export declare function runtime(): Runtime;
+/**
+ * macOS: WKWebView ignores window.print(), so the page asks the shell to print its window
+ * (plugins.md D8; Tauri replaces window.print the same way, tauri/crates/tauri/src/webview/scripts/print.js).
+ * Runs when @akanjs/native/core loads; init.js has already set the platform by then. Returns whether it replaced print.
+ */
+export declare function installPrint(): boolean;
+/**
+ * Dev builds: errors the page had before this module ran, collected by the snippet the build puts
+ * after init.js (__AKAN_NATIVE__.early). They go to the host log once, marked "[before runtime]"; the
+ * snippet stops collecting and does not report them itself.
+ */
+export declare function flushEarlyErrors(): void;
+/** Drops all runtime state. Only for tests. */
+export declare function resetRuntime(): void;
+export declare function dispatchEvent(rt: Runtime, plugin: string, event: string, data: unknown): void;
+/** How long later messages wait for a missing number before they are delivered anyway. */
+export declare const SEQ_GAP_MS = 500;
+/**
+ * The page gave up on a call that has no answer yet (its AbortSignal fired, v1.1 `cancel`): it stops
+ * waiting now, and the host is told so that the plugin can stop and the call's resources go. The
+ * host's late answer finds no pending call and is dropped.
+ */
+export declare function cancelCall(rt: Runtime, id: number, reason: CancelReason): void;
+export {};

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

@@ -0,0 +1,28 @@
+import type { AppInfo, Platform } from "./boot.ts";
+/**
+ * The PUBLIC_ keys the app's config and .env files define. `akan-native build` writes akan-native-env.d.ts next
+ * to akan-native.config.ts, which adds them to this interface (ENV-7).
+ */
+export interface AkanNativeEnv {
+}
+/**
+ * Known keys from AkanNativeEnv; other keys (set only at run time through AKAN_NATIVE_PUBLIC_*) stay a plain
+ * index signature, so with noUncheckedIndexedAccess they read as string | undefined.
+ */
+export type Env = Readonly<AkanNativeEnv> & Readonly<Record<string, string>>;
+export declare let platform: Platform;
+export declare let env: Env;
+export declare let runtimeVersion: string;
+export declare let app: AppInfo | null;
+export declare let isDev: boolean;
+/** True inside an akan-native app shell (macOS, iOS, Android ...), false on the web. */
+export declare let isNative: boolean;
+/** Desktop: this page's window (1 = the window the app opened, SH-6). null elsewhere. */
+export declare let windowId: number | null;
+/**
+ * Native hosts: a fingerprint of what this app binary provides natively (bridge protocol, akan-native
+ * runtime minor, plugins, capabilities, permissions). A web bundle runs only in a binary with the
+ * same value (UP-3). null on the web.
+ */
+export declare let nativeApi: string | null;
+export declare function refreshBoot(): void;

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

@@ -0,0 +1,41 @@
+import { type CallScope, type ResolvedAcl } from "./acl.ts";
+import type { Platform } from "./boot.ts";
+import { type BridgeRequest } from "./protocol.ts";
+/**
+ * `scope`: what the app's capabilities allow this call (PL-11), as a real host passes it. `signal`
+ * fires when the page cancels the call ($bridge.cancel), like a desktop plugin's ctx.signal.
+ */
+export type MockMethod = (args: any, host: MockHost, scope?: CallScope, signal?: AbortSignal) => unknown;
+export interface MockPlugin {
+    methods?: Record<string, MockMethod>;
+    events?: string[];
+    /** The other methods and events use the web implementation (a native subset with `web: true`). */
+    web?: true;
+}
+export interface MockHostOptions {
+    platform?: Platform;
+    env?: Record<string, string>;
+    dev?: boolean;
+    /** "web" makes the page use the plugin's web implementation, as a desktop host may declare. */
+    plugins?: Record<string, MockPlugin | "web">;
+    /** Capabilities (PL-11): the mock host enforces them like a real host, and the page sees them in boot. */
+    acl?: ResolvedAcl;
+    /** The page's window id (desktop multi-window). Default 1. */
+    windowId?: number;
+}
+export interface MockHost {
+    readonly requests: BridgeRequest[];
+    /** $bridge.cancel requests the page sent: the call id and the reason. */
+    readonly cancels: {
+        id: number;
+        reason: string;
+        cancelled: boolean;
+    }[];
+    /** $bridge.release requests: the FileRef URLs (answered released: true). */
+    readonly releases: string[];
+    /** Pushes an event the way a native host would. Delivered only while subscribed. */
+    emit(plugin: string, event: string, data?: unknown): boolean;
+    subscriptions(plugin: string, event: string): number;
+    uninstall(): void;
+}
+export declare function installMockHost(options?: MockHostOptions): MockHost;

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

@@ -0,0 +1,2 @@
+/** The runtime version (UP-3): builtin plugins share it, and OTA updates compare its line. */
+export declare const VERSION = "0.1.0";

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

@@ -0,0 +1,17 @@
+export interface VetoEvent {
+    /** Keeps the window open / the app running. Call it before the handler returns (await first if needed). */
+    preventDefault(): void;
+    readonly defaultPrevented: boolean;
+}
+export type VetoHandler<E> = (event: E & VetoEvent) => void | Promise<void>;
+/**
+ * Builds an `onX(handler)` registration for a cancelable event.
+ * `listen` subscribes to the plugin event; `answer` is the plugin method the host waits for.
+ * Registering is a no-op where the event is not supported (it simply never fires).
+ */
+export declare function vetoable<E extends object>(listen: (listener: (data: E & {
+    id: number;
+}) => void) => () => void, answer: (args: {
+    id: number;
+    allow?: boolean;
+}) => Promise<unknown>): (handler: VetoHandler<E>) => () => void;

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

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

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

@@ -0,0 +1,24 @@
+type Env = Record<string, string | undefined>;
+type Runner = (argv: string[]) => Promise<{
+    code: number;
+    stdout: string;
+}>;
+/** The links in a launch's arguments (without the executable): one argument, of an app scheme. */
+export declare function linkArguments(args: readonly string[], schemes: readonly string[]): string[];
+/** Exec= of a desktop entry: the path quoted, with the characters the spec reserves escaped. */
+export declare function desktopExec(exe: string): string;
+export declare function desktopEntry(name: string, exe: string, schemes: readonly string[]): string;
+/** mimeapps.list with `x-scheme-handler/<scheme>=<desktop file>` set in [Default Applications]. */
+export declare function withDefaults(list: string, desktopFile: string, schemes: readonly string[]): string;
+/** Makes this executable the current user's handler of the app's schemes (Windows, Linux). */
+export declare function registerDeepLinks(app: {
+    id: string;
+    name: string;
+}, schemes: readonly string[], options?: {
+    exe?: string;
+    platform?: NodeJS.Platform;
+    env?: Env;
+    home?: string;
+    run?: Runner;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,2 @@
+export declare function createDelta(oldData: Uint8Array, newData: Uint8Array): Uint8Array<ArrayBuffer>;
+export declare function applyDelta(oldData: Uint8Array, delta: Uint8Array): Uint8Array<ArrayBuffer>;