@fkn/lib 0.3.6 → 0.3.8

package/index.d.ts

@@ -1,11 +1,36 @@
 import * as ip_address from 'ip-address';
 import { Address4, Address6 } from 'ip-address';
-import { Server as Server$1, ServerOpts, Socket as Socket$2, SocketConstructorOpts, SocketConnectOpts, AddressInfo, ListenOptions } from 'net';
+import { Socket as Socket$2, SocketConstructorOpts, SocketConnectOpts, AddressInfo, Server as Server$2, ServerOpts, ListenOptions } from 'net';
 import { Stream, DuplexOptions } from 'stream';
 import { EventEmitter } from 'events';
 import { Socket as Socket$3, SocketOptions, BindOptions, SocketType, RemoteInfo } from 'dgram';
 import { Buffer } from 'buffer';
+import { OutgoingHttpHeaders, IncomingHttpHeaders, RequestOptions } from 'http';
+import * as osra from 'osra';
 import { BoxBase, Capable, UnderlyingType, RevivableContext } from 'osra';
+import * as osra_build_revivables_event_target from 'osra/build/revivables/event-target';
+import * as osra_build_revivables_fallbacks from 'osra/build/revivables/fallbacks';
+import * as osra_build_revivables_event from 'osra/build/revivables/event';
+import * as osra_build_revivables_symbol from 'osra/build/revivables/symbol';
+import * as osra_build_revivables_bigint from 'osra/build/revivables/bigint';
+import * as osra_build_revivables_set from 'osra/build/revivables/set';
+import * as osra_build_revivables_map from 'osra/build/revivables/map';
+import * as osra_build_revivables_request from 'osra/build/revivables/request';
+import * as osra_build_revivables_response from 'osra/build/revivables/response';
+import * as osra_build_revivables_abort_signal from 'osra/build/revivables/abort-signal';
+import * as osra_build_revivables_writable_stream from 'osra/build/revivables/writable-stream';
+import * as osra_build_revivables_readable_stream from 'osra/build/revivables/readable-stream';
+import * as osra_build_revivables_message_port from 'osra/build/revivables/message-port';
+import * as osra_build_revivables_function from 'osra/build/revivables/function';
+import * as osra_build_revivables_promise from 'osra/build/revivables/promise';
+import * as osra_build_revivables_blob from 'osra/build/revivables/blob';
+import * as osra_build_revivables_typed_array from 'osra/build/revivables/typed-array';
+import * as osra_build_revivables_error from 'osra/build/revivables/error';
+import * as osra_build_revivables_headers from 'osra/build/revivables/headers';
+import * as osra_build_revivables_date from 'osra/build/revivables/date';
+import * as osra_build_revivables_array_buffer from 'osra/build/revivables/array-buffer';
+import * as osra_build_revivables_identity from 'osra/build/revivables/identity';
+import * as osra_build_revivables_transfer from 'osra/build/revivables/transfer';
 
 declare const parseServerMetadataUdpSocketBoundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
     readonly _type: "ServerMetadataUdpSocketBoundPacket";
@@ -205,6 +230,7 @@ declare const makeWebVPNWebTransport: () => Promise<{
     getPacketForId: (packetId: number) => Promise<ServerMetadataPacket>;
     getMetadataReadableStreamForSocketId: (socketId: number) => ReadableStream<ServerMetadataPacket>;
     getMetadataReadableStreamForLocalAddress: (address: Address4 | Address6) => ReadableStream<ServerMetadataPacket>;
+    getMetadataReadableStreamForLocalPort: (port: number) => ReadableStream<ServerMetadataPacket>;
     getMetadataWritableStream: () => WritableStream<Uint8Array<ArrayBufferLike>>;
     getDatagramWritableStream: () => WritableStream<Uint8Array<ArrayBufferLike>>;
 }>;
@@ -241,6 +267,8 @@ type AddressLookupResult = {
 };
 
 declare const resolvers: {
+    readonly showInstallPrompt: (reason?: string) => Promise<void>;
+    readonly hideInstallPrompt: () => Promise<void>;
     readonly dnsLookup: <T extends boolean = false>(hostname: string, options?: {
         all?: T;
         family: 0 | 4 | 6;
@@ -310,6 +338,41 @@ type ProxyFetch = Resolvers['proxyFetch'];
 type FetchParameters = Parameters<ProxyFetch>;
 declare const serverProxyFetch: (input: FetchParameters[0], init?: FetchParameters[1]) => Promise<Response>;
 
+declare const relayWorker: (worker: Worker, options?: {
+    unregisterSignal?: AbortSignal;
+    originA?: string;
+    originB?: string;
+}) => void;
+
+declare const promptInstall: (reason?: string) => Promise<boolean>;
+
+declare const changeIframeStyle: (style: Record<string, string>) => void;
+declare const resetIframeStyle: () => void;
+
+type StorageListItem = {
+    key: string;
+    updatedAt: string;
+};
+type StorageListResult = {
+    items: StorageListItem[];
+    nextCursor: string | null;
+};
+type StorageListOptions = {
+    limit?: number;
+    cursor?: string;
+};
+declare const storage: {
+    set: (namespace: string, key: string, value: Uint8Array) => Promise<void>;
+    get: (namespace: string, key: string) => Promise<Uint8Array | null>;
+    list: (namespace: string, opts?: StorageListOptions) => Promise<StorageListResult>;
+    remove: (namespace: string, key: string) => Promise<void>;
+};
+
+declare const refillPremiumTokens: () => Promise<void>;
+
+declare const countTokens: () => Promise<number>;
+declare const clearTokens: () => Promise<void>;
+
 declare const isIPv4: (input: string) => boolean;
 declare const isIPv6: (input: string) => boolean;
 declare const isIP: (input: string) => 0 | 4 | 6;
@@ -399,7 +462,7 @@ interface EventEmitterOptions$1 {
      */
     captureRejections?: boolean | undefined;
 }
-declare class Server extends EventEmitter implements Server$1 {
+declare class Server$1 extends EventEmitter implements Server$2 {
     _localAddress?: {
         address: string;
         family: string;
@@ -437,37 +500,33 @@ declare class Server extends EventEmitter implements Server$1 {
 }
 declare const connect: (options: SocketConnectOpts, connectionListener?: () => void) => Socket$1;
 declare const createConnection: (options: SocketConnectOpts, connectionListener?: () => void) => Socket$1;
-declare const createServer: (options: ServerOpts, connectionListener?: (socket: Socket$1) => void) => Server;
+declare const createServer$1: (options?: ServerOpts | ((socket: Socket$1) => void), connectionListener?: (socket: Socket$1) => void) => Server$1;
 
-declare const _default: {
+declare const _default$1: {
     Socket: typeof Socket$1;
-    Server: typeof Server;
+    Server: typeof Server$1;
     connect: (options: SocketConnectOpts, connectionListener?: () => void) => Socket$1;
     createConnection: (options: SocketConnectOpts, connectionListener?: () => void) => Socket$1;
-    createServer: (options: ServerOpts, connectionListener?: (socket: Socket$1) => void) => Server;
+    createServer: (options?: ServerOpts | ((socket: Socket$1) => void), connectionListener?: (socket: Socket$1) => void) => Server$1;
     isIP: (input: string) => 0 | 4 | 6;
     isIPv4: (input: string) => boolean;
     isIPv6: (input: string) => boolean;
 };
 
-type net_Server = Server;
-declare const net_Server: typeof Server;
-declare const net__default: typeof _default;
 declare const net_connect: typeof connect;
 declare const net_createConnection: typeof createConnection;
-declare const net_createServer: typeof createServer;
 declare const net_isIP: typeof isIP;
 declare const net_isIPv4: typeof isIPv4;
 declare const net_isIPv6: typeof isIPv6;
 declare namespace net {
   export {
-    net_Server as Server,
+    Server$1 as Server,
     Socket$1 as Socket,
-    net__default as _default,
+    _default$1 as _default,
     net_connect as connect,
     net_createConnection as createConnection,
-    net_createServer as createServer,
-    _default as default,
+    createServer$1 as createServer,
+    _default$1 as default,
     net_isIP as isIP,
     net_isIPv4 as isIPv4,
     net_isIPv6 as isIPv6,
@@ -550,6 +609,283 @@ declare namespace dgram {
   };
 }
 
+declare const METHODS: string[];
+declare const STATUS_CODES: Record<number, string>;
+interface ParsedHead {
+    /** request only */
+    method?: string;
+    /** request only */
+    url?: string;
+    /** response only */
+    statusCode?: number;
+    /** response only */
+    statusMessage?: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    httpVersion: string;
+    headers: IncomingHttpHeaders;
+    rawHeaders: string[];
+}
+interface ParserHandlers {
+    onHeaders: (head: ParsedHead) => void;
+    onBody: (chunk: Uint8Array) => void;
+    onComplete: () => void;
+}
+declare class HTTPParser {
+    private readonly mode;
+    private readonly handlers;
+    private buf;
+    private state;
+    private framing;
+    private bodyRemaining;
+    private chunkState;
+    skipBody: boolean;
+    constructor(mode: 'request' | 'response', handlers: ParserHandlers);
+    execute(chunk: Uint8Array): void;
+    finish(): void;
+    private reset;
+    private parseHead;
+    private applyVersion;
+    private addHeader;
+    private setupBody;
+    private consumeBody;
+    private consumeChunked;
+}
+declare class IncomingMessage extends Stream.Readable {
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    headers: IncomingHttpHeaders;
+    rawHeaders: string[];
+    trailers: Record<string, string>;
+    rawTrailers: string[];
+    /** request only */
+    method?: string;
+    /** request only */
+    url?: string;
+    /** response only */
+    statusCode?: number;
+    /** response only */
+    statusMessage?: string;
+    complete: boolean;
+    socket: Socket$1;
+    constructor(socket: Socket$1);
+    get connection(): Socket$1;
+    _applyHead(head: ParsedHead): void;
+    _read(): void;
+    setTimeout(msecs: number, callback?: () => void): this;
+}
+declare abstract class OutgoingMessage extends Stream.Writable {
+    private _headerStore;
+    headersSent: boolean;
+    chunkedEncoding: boolean;
+    finished: boolean;
+    protected _bodyWritten: boolean;
+    abstract socket: Socket$1 | null;
+    setHeader(name: string, value: number | string | readonly string[]): this;
+    getHeader(name: string): number | string | string[] | undefined;
+    getHeaderNames(): string[];
+    getHeaders(): OutgoingHttpHeaders;
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    protected _storeHeader(startLine: string): string;
+    protected abstract _shouldSendBody(): boolean;
+    protected abstract _implicitHeader(): void;
+    protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+    write(chunk: unknown, encoding?: BufferEncoding | ((error: Error | null | undefined) => void), callback?: (error: Error | null | undefined) => void): boolean;
+    _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
+    protected _headBlock?: string;
+}
+interface ServerResponseOptions {
+    req: IncomingMessage;
+}
+declare class ServerResponse extends OutgoingMessage {
+    statusCode: number;
+    statusMessage?: string;
+    private _writeHeadCalled;
+    sendDate: boolean;
+    req: IncomingMessage;
+    socket: Socket$1 | null;
+    _keepAlive: boolean;
+    constructor(req: IncomingMessage);
+    protected _shouldSendBody(): boolean;
+    writeHead(statusCode: number, statusMessage?: string | OutgoingHttpHeaders | OutgoingHttpHeaders[keyof OutgoingHttpHeaders][], headers?: OutgoingHttpHeaders): this;
+    private _appendHeader;
+    protected _implicitHeader(): void;
+    writeContinue(): void;
+    setTimeout(msecs: number, callback?: () => void): this;
+}
+interface ClientRequestArgs extends RequestOptions {
+    host?: string;
+    hostname?: string;
+    port?: number | string;
+    path?: string;
+}
+declare class ClientRequest extends OutgoingMessage {
+    method: string;
+    path: string;
+    host: string;
+    protocol: string;
+    socket: Socket$1;
+    /** alias retained for Node compatibility */
+    get connection(): Socket$1;
+    res: IncomingMessage | null;
+    aborted: boolean;
+    private _aborted;
+    constructor(options: ClientRequestArgs, callback?: (res: IncomingMessage) => void);
+    protected _shouldSendBody(): boolean;
+    protected _implicitHeader(): void;
+    private _attachResponseParser;
+    abort(): void;
+    destroy(error?: Error): this;
+    end(chunk?: unknown, encoding?: unknown, callback?: unknown): this;
+    protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+    setTimeout(timeout: number, callback?: () => void): this;
+    setNoDelay(noDelay?: boolean): void;
+    setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+}
+type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
+declare class ServerImpl extends Server$1 {
+    constructor(options?: object | RequestListener, requestListener?: RequestListener);
+    private _handleConnection;
+}
+declare const Server: typeof ServerImpl;
+type Server = ServerImpl;
+declare class Agent {
+    maxSockets: number;
+    maxFreeSockets: number;
+    keepAlive: boolean;
+    options: Record<string, unknown>;
+    constructor(options?: Record<string, unknown>);
+    getName(options?: {
+        host?: string;
+        port?: number;
+        localAddress?: string;
+    }): string;
+    destroy(): void;
+}
+declare const globalAgent: Agent;
+declare const request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+declare const get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+declare const createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
+declare const _default: {
+    METHODS: string[];
+    STATUS_CODES: Record<number, string>;
+    Agent: typeof Agent;
+    globalAgent: Agent;
+    Server: typeof ServerImpl;
+    ServerResponse: typeof ServerResponse;
+    IncomingMessage: typeof IncomingMessage;
+    ClientRequest: typeof ClientRequest;
+    OutgoingMessage: typeof OutgoingMessage;
+    createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
+    request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+    get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+};
+
+type http_Agent = Agent;
+declare const http_Agent: typeof Agent;
+type http_ClientRequest = ClientRequest;
+declare const http_ClientRequest: typeof ClientRequest;
+type http_ClientRequestArgs = ClientRequestArgs;
+type http_HTTPParser = HTTPParser;
+declare const http_HTTPParser: typeof HTTPParser;
+type http_IncomingMessage = IncomingMessage;
+declare const http_IncomingMessage: typeof IncomingMessage;
+declare const http_METHODS: typeof METHODS;
+type http_ParsedHead = ParsedHead;
+type http_RequestListener = RequestListener;
+declare const http_STATUS_CODES: typeof STATUS_CODES;
+type http_Server = Server;
+type http_ServerResponse = ServerResponse;
+declare const http_ServerResponse: typeof ServerResponse;
+type http_ServerResponseOptions = ServerResponseOptions;
+declare const http__default: typeof _default;
+declare const http_createServer: typeof createServer;
+declare const http_get: typeof get;
+declare const http_globalAgent: typeof globalAgent;
+declare const http_request: typeof request;
+declare namespace http {
+  export { http_Agent as Agent, http_ClientRequest as ClientRequest, http_HTTPParser as HTTPParser, http_IncomingMessage as IncomingMessage, http_METHODS as METHODS, http_STATUS_CODES as STATUS_CODES, http_ServerResponse as ServerResponse, http__default as _default, http_createServer as createServer, _default as default, http_get as get, http_globalAgent as globalAgent, http_request as request };
+  export type { http_ClientRequestArgs as ClientRequestArgs, http_ParsedHead as ParsedHead, http_RequestListener as RequestListener, http_Server as Server, http_ServerResponseOptions as ServerResponseOptions };
+}
+
+declare const fetchPermission: {
+    readonly scope: "network.fetch";
+    readonly category: "network";
+    readonly severity: 0;
+    readonly title: "Fetch data from other sites";
+    readonly description: "Lets the app download public data from other websites directly, past the usual cross-origin limits.";
+};
+declare const fetchCredentialedPermission: {
+    readonly scope: "network.fetchCredentialed";
+    readonly category: "network";
+    readonly severity: 3;
+    readonly unsafe: true;
+    readonly title: "Fetch from other sites — signed in as you";
+    readonly description: "Lets the app fetch other sites using your logged-in session cookies, so it can read data only you should see.";
+};
+type ProxyFetchRequest = {
+    url: string;
+    method: string;
+    headers: [string, string][];
+    body: ArrayBuffer | null;
+    credentials: 'include' | 'omit';
+    redirect: RequestRedirect;
+    unsafeHeaders?: [string, string][];
+    reason?: string;
+    signal?: AbortSignal;
+};
+type FetchInit = RequestInit & {
+    reason?: string;
+};
+declare const fetch: (input: URL | RequestInfo, init?: FetchInit | undefined) => Promise<Response>;
+
+declare const readCookiePermission: {
+    readonly scope: "network.readCookie";
+    readonly category: "network";
+    readonly severity: 3;
+    readonly unsafe: true;
+    readonly title: "Read a site’s cookie";
+    readonly description: "Lets the app read a named cookie from another site, which can include the login token only that site should see.";
+};
+type CookieDetails = {
+    url: string;
+    name: string;
+};
+type SiteCookie = {
+    name: string;
+    value: string;
+};
+declare const cookies: {
+    get: (details: CookieDetails) => Promise<SiteCookie | null>;
+};
+
+declare const modifyRequestHeadersPermission: {
+    readonly scope: "network.modifyRequestHeaders";
+    readonly category: "network";
+    readonly severity: 2;
+    readonly unsafe: true;
+    readonly title: "Rewrite request headers to other sites";
+    readonly description: "Lets the app set or remove headers (like Origin and Referer) on this page’s own requests to the listed sites.";
+};
+type HeaderOperation = {
+    header: string;
+    operation: 'set' | 'remove';
+    value?: string;
+};
+type RequestHeaderRule = {
+    domains: string[];
+    requestHeaders: HeaderOperation[];
+    reason?: string;
+};
+declare const setRequestHeaderRule: (rule: RequestHeaderRule) => Promise<{
+    ruleId: number;
+}>;
+declare const removeRequestHeaderRule: (ruleId: number) => Promise<void>;
+
 type ExtractType<M> = M extends {
     type: infer T extends string;
 } ? T : never;
@@ -563,7 +899,7 @@ type ExtractResolverReturn<M> = M extends {
     resolve: (context: any, ...args: any[]) => infer R;
 } ? R : never;
 
-declare const type$i: 'locator';
+declare const type$i: "locator";
 declare const resolve$h: (context: LocatorContext, selector: string) => Element[];
 declare const render$7: SelectorRenderer;
 
@@ -575,7 +911,7 @@ declare namespace locatorSel {
   };
 }
 
-declare const type$h: 'getByRole';
+declare const type$h: "getByRole";
 declare const resolve$g: (context: LocatorContext, role: string) => Element[];
 declare const render$6: SelectorRenderer;
 
@@ -587,7 +923,7 @@ declare namespace getByRole {
   };
 }
 
-declare const type$g: 'getByText';
+declare const type$g: "getByText";
 declare const resolve$f: (context: LocatorContext, text: string) => Element[];
 declare const render$5: SelectorRenderer;
 
@@ -599,7 +935,7 @@ declare namespace getByText {
   };
 }
 
-declare const type$f: 'getByTestId';
+declare const type$f: "getByTestId";
 declare const resolve$e: (context: LocatorContext, testId: string) => Element[];
 declare const render$4: SelectorRenderer;
 
@@ -611,7 +947,7 @@ declare namespace getByTestId {
   };
 }
 
-declare const type$e: 'first';
+declare const type$e: "first";
 declare const resolve$d: (context: LocatorContext) => Element[];
 declare const render$3: SelectorRenderer;
 
@@ -623,7 +959,7 @@ declare namespace first {
   };
 }
 
-declare const type$d: 'nth';
+declare const type$d: "nth";
 declare const resolve$c: (context: LocatorContext, index: number) => Element[];
 declare const render$2: SelectorRenderer;
 
@@ -635,125 +971,168 @@ declare namespace nth {
   };
 }
 
-declare const type$c: 'click';
+declare const type$c: "click";
+declare const permission$9: {
+    readonly scope: "act.click";
+    readonly category: "act";
+    readonly severity: 3;
+    readonly title: "Click on the page";
+    readonly description: "Lets the app press buttons or links for you.";
+};
 declare const resolve$b: (context: LocatorContext, options?: OperationTimeoutOptions & {
     position?: {
-        x?: number;
-        y?: number;
-    };
+        x?: number | undefined;
+        y?: number | undefined;
+    } | undefined;
 }) => void;
 
 declare namespace click {
   export {
+    permission$9 as permission,
     resolve$b as resolve,
     type$c as type,
   };
 }
 
-declare const type$b: 'fill';
+declare const type$b: "fill";
+declare const permission$8: {
+    readonly scope: "act.type";
+    readonly category: "act";
+    readonly severity: 1;
+    readonly title: "Type into a text field";
+    readonly description: "Lets the app fill in form fields on your behalf.";
+};
 declare const resolve$a: (context: LocatorContext, value: string, _options?: OperationTimeoutOptions) => void;
 
 declare namespace fill {
   export {
+    permission$8 as permission,
     resolve$a as resolve,
     type$b as type,
   };
 }
 
-declare const type$a: 'hover';
+declare const type$a: "hover";
+declare const permission$7: {
+    readonly scope: "act.hover";
+    readonly category: "act";
+    readonly severity: 1;
+    readonly title: "Hover over the page";
+    readonly description: "Lets the app point at things to reveal menus or tooltips.";
+};
 declare const resolve$9: (context: LocatorContext, _options?: OperationTimeoutOptions) => void;
 
 declare namespace hover {
   export {
+    permission$7 as permission,
     resolve$9 as resolve,
     type$a as type,
   };
 }
 
-declare const type$9: 'textContent';
+declare const type$9: "textContent";
+declare const permission$6: {
+    readonly scope: "read.text";
+    readonly category: "read";
+    readonly severity: 1;
+    readonly title: "Read text from the page";
+    readonly description: "Lets the app see the text shown on this page.";
+};
 declare const resolve$8: (context: LocatorContext, _options?: OperationTimeoutOptions) => string;
 
 declare namespace textContent {
   export {
+    permission$6 as permission,
     resolve$8 as resolve,
     type$9 as type,
   };
 }
 
-declare const type$8: 'isVisible';
+declare const type$8: "isVisible";
+declare const permission$5: {
+    readonly scope: "read.visible";
+    readonly category: "read";
+    readonly severity: 0;
+    readonly title: "See what’s visible on the page";
+    readonly description: "Lets the app check which elements are currently on screen.";
+};
 declare const resolve$7: (context: LocatorContext, _options?: OperationTimeoutOptions) => boolean;
 
 declare namespace isVisible {
   export {
+    permission$5 as permission,
     resolve$7 as resolve,
     type$8 as type,
   };
 }
 
-declare const type$7: 'count';
+declare const type$7: "count";
+declare const permission$4: {
+    readonly scope: "read.count";
+    readonly category: "read";
+    readonly severity: 0;
+    readonly title: "Count items on the page";
+    readonly description: "Lets the app count how many matching elements are present.";
+};
 declare const resolve$6: (context: LocatorContext, _options?: OperationTimeoutOptions) => number;
 
 declare namespace count {
   export {
+    permission$4 as permission,
     resolve$6 as resolve,
     type$7 as type,
   };
 }
 
-declare const type$6: 'exists';
+declare const type$6: "exists";
+declare const permission$3: {
+    readonly scope: "read.check";
+    readonly category: "read";
+    readonly severity: 0;
+    readonly title: "Check if something is on the page";
+    readonly description: "Lets the app test whether a specific element exists.";
+};
 declare const resolve$5: (context: LocatorContext, _options?: OperationTimeoutOptions) => boolean;
 
 declare namespace exists {
   export {
+    permission$3 as permission,
     resolve$5 as resolve,
     type$6 as type,
   };
 }
 
-declare const type$5: 'getAttribute';
+declare const type$5: "getAttribute";
+declare const permission$2: {
+    readonly scope: "read.info";
+    readonly category: "read";
+    readonly severity: 1;
+    readonly title: "Read info from the page";
+    readonly description: "Lets the app read the href value from a part of the page.";
+};
 declare const resolve$4: (context: LocatorContext, name: string, _options?: OperationTimeoutOptions) => string | null;
 
 declare namespace getAttribute {
   export {
+    permission$2 as permission,
     resolve$4 as resolve,
     type$5 as type,
   };
 }
 
-type RemoteVideoElement$1 = EventTarget & {
-    currentTime: number;
-    volume: number;
-    muted: boolean;
-    playbackRate: number;
-    src: string;
-    loop: boolean;
-    autoplay: boolean;
-    preload: string;
-    poster: string;
-    disableRemotePlayback: boolean;
-    readonly duration: number;
-    readonly paused: boolean;
-    readonly ended: boolean;
-    readonly seeking: boolean;
-    readonly readyState: number;
-    readonly currentSrc: string;
-    readonly error: MediaError | null;
-    readonly buffered: TimeRanges;
-    readonly seekable: TimeRanges;
-    play(): Promise<void>;
-    pause(): void;
-    load(): void;
-    requestPictureInPicture(): Promise<void>;
-    exitPictureInPicture(): Promise<void>;
-    readonly HAVE_FUTURE_DATA: 3;
-    readonly HAVE_ENOUGH_DATA: 4;
+declare const type$4: "videoElement";
+declare const permission$1: {
+    readonly scope: "media.video";
+    readonly category: "media";
+    readonly severity: 0;
+    readonly title: "Control video playback";
+    readonly description: "Lets the app play, pause, seek, and read the video on the page.";
 };
+declare const resolve$3: (context: LocatorContext, _options?: OperationTimeoutOptions) => RemoteVideoElement;
 
-declare const type$4: 'videoElement';
-declare const resolve$3: (context: LocatorContext, _options?: OperationTimeoutOptions) => RemoteVideoElement$1;
-
-declare namespace videoElement {
+declare namespace videoElement$1 {
   export {
+    permission$1 as permission,
     resolve$3 as resolve,
     type$4 as type,
   };
@@ -762,19 +1141,19 @@ declare namespace videoElement {
 declare const locatorModule: {
     readonly type: "locator";
     readonly selectorModules: readonly [typeof locatorSel, {
-        readonly type: 'frameLocator';
+        readonly type: "frameLocator";
         readonly resolve: (context: LocatorContext, selector: string) => HTMLIFrameElement[];
         readonly resolvePeer: BarrierResolver;
         readonly render: SelectorRenderer;
-        readonly nextLocatorType: 'frameLocator';
+        readonly nextLocatorType: "frameLocator";
     }, typeof getByRole, typeof getByText, typeof getByTestId, typeof first, typeof nth];
-    readonly operationModules: readonly [typeof click, typeof fill, typeof hover, typeof textContent, typeof isVisible, typeof count, typeof exists, typeof getAttribute, typeof videoElement];
+    readonly operationModules: readonly [typeof click, typeof fill, typeof hover, typeof textContent, typeof isVisible, typeof count, typeof exists, typeof getAttribute, typeof videoElement$1];
 };
 type LocatorModule = typeof locatorModule;
 interface Locator extends LocatorChain<LocatorModule, Locator> {
 }
 
-declare const type$3: 'frameLocator';
+declare const type$3: "frameLocator";
 declare const resolve$2: (context: LocatorContext, selector: string) => HTMLIFrameElement[];
 declare const resolvePeer$1: BarrierResolver;
 declare const render$1: SelectorRenderer;
@@ -788,7 +1167,7 @@ declare namespace frameLocatorSel {
   };
 }
 
-declare const type$2: 'owner';
+declare const type$2: "owner";
 declare const resolve$1: (_: LocatorContext) => never;
 declare const resolvePeer: BarrierResolver;
 declare const render: SelectorRenderer;
@@ -804,27 +1183,61 @@ declare namespace owner {
   };
 }
 
-declare const type$1: 'addStyleTag';
+declare const type$1: "addStyleTag";
 type AddStyleTagOptions = OperationTimeoutOptions & {
     content: string;
     noSanitize?: boolean;
 };
+declare const appearPermission: {
+    readonly scope: "media.appear";
+    readonly category: "media";
+    readonly severity: 0;
+    readonly title: "Change page appearance";
+    readonly description: "Lets the app restyle parts of the page — safely filtered.";
+};
+declare const appearUnsafePermission: {
+    readonly scope: "media.appearU";
+    readonly category: "media";
+    readonly severity: 2;
+    readonly unsafe: true;
+    readonly title: "Change page appearance (unsafe)";
+    readonly description: "Lets the app restyle the page WITHOUT safety filtering — could be used to leak data over the network.";
+};
+declare const permission: (options?: AddStyleTagOptions | undefined) => {
+    readonly scope: "media.appear";
+    readonly category: "media";
+    readonly severity: 0;
+    readonly title: "Change page appearance";
+    readonly description: "Lets the app restyle parts of the page — safely filtered.";
+} | {
+    readonly scope: "media.appearU";
+    readonly category: "media";
+    readonly severity: 2;
+    readonly unsafe: true;
+    readonly title: "Change page appearance (unsafe)";
+    readonly description: "Lets the app restyle the page WITHOUT safety filtering — could be used to leak data over the network.";
+};
+declare const setInjectedStylesDisabled: (disabled: boolean) => void;
 declare const resolve: (_context: LocatorContext, options: AddStyleTagOptions) => Promise<void>;
 
 type addStyleTag_AddStyleTagOptions = AddStyleTagOptions;
+declare const addStyleTag_appearPermission: typeof appearPermission;
+declare const addStyleTag_appearUnsafePermission: typeof appearUnsafePermission;
+declare const addStyleTag_permission: typeof permission;
 declare const addStyleTag_resolve: typeof resolve;
+declare const addStyleTag_setInjectedStylesDisabled: typeof setInjectedStylesDisabled;
 declare namespace addStyleTag {
-  export { addStyleTag_resolve as resolve, type$1 as type };
+  export { addStyleTag_appearPermission as appearPermission, addStyleTag_appearUnsafePermission as appearUnsafePermission, addStyleTag_permission as permission, addStyleTag_resolve as resolve, addStyleTag_setInjectedStylesDisabled as setInjectedStylesDisabled, type$1 as type };
   export type { addStyleTag_AddStyleTagOptions as AddStyleTagOptions };
 }
 
 declare const frameLocatorModule: {
     readonly type: "frameLocator";
     readonly selectorModules: readonly [{
-        readonly type: 'locator';
+        readonly type: "locator";
         readonly resolve: (context: LocatorContext, selector: string) => Element[];
         readonly render: SelectorRenderer;
-        readonly nextLocatorType: 'locator';
+        readonly nextLocatorType: "locator";
     }, typeof frameLocatorSel, typeof owner];
     readonly operationModules: readonly [typeof addStyleTag];
 };
@@ -834,11 +1247,23 @@ interface FrameLocator extends LocatorChain<FrameLocatorModule, FrameLocator> {
 
 type FrameId = `${number}-${number}`;
 
+type PermissionCategory = 'read' | 'act' | 'media' | 'embed' | 'network';
+type PermissionSeverity = 0 | 1 | 2 | 3 | 4;
+type Permission = {
+    scope: string;
+    category: PermissionCategory;
+    severity: PermissionSeverity;
+    title: string;
+    description: string;
+    unsafe?: boolean;
+};
+
 type LocatorContext = {
     elements: Element[];
 };
 type OperationTimeoutOptions = {
     timeout?: number;
+    reason?: string;
 };
 type BarrierContext = {
     parts: SelectorPart[];
@@ -858,9 +1283,11 @@ type SelectorModule = {
     resolvePeer?: BarrierResolver;
     render?: SelectorRenderer;
 };
+type OperationPermission = Permission | ((...args: any[]) => Permission);
 type OperationModule = {
     type: string;
     resolve: (context: LocatorContext, ...args: any[]) => unknown;
+    permission: OperationPermission;
 };
 type LocatorKindModule = {
     readonly type: string;
@@ -888,6 +1315,20 @@ type LocatorChain<L extends LocatorKindModule, Self> = {
 };
 
 declare const ATTACH_FRAME_EVENT_KEY = "FKN_WEB_EXTENSION_ATTACH_FRAME_EVENT_KEY";
+declare const attachFramePermission: {
+    readonly scope: "embed.iframe";
+    readonly category: "embed";
+    readonly severity: 0;
+    readonly title: "Load another website inside this app";
+    readonly description: "Lets the app embed external pages directly inside its own view.";
+};
+declare const gotoPermission: {
+    readonly scope: "embed.open";
+    readonly category: "embed";
+    readonly severity: 0;
+    readonly title: "Open a website inside this app";
+    readonly description: "Lets the app navigate to another site without leaving its window.";
+};
 type GotoOptions = {
     waitUntil?: 'documentstart' | 'load';
     domains?: string[];
@@ -902,7 +1343,130 @@ type AttachFrameOptions = {
 };
 declare const attachFrame: ({ iframe, domains }: AttachFrameOptions) => Promise<Frame>;
 
-declare const type: 'videoElement';
+declare const PERMISSIONS: readonly [{
+    readonly scope: "read.text";
+    readonly category: "read";
+    readonly severity: 1;
+    readonly title: "Read text from the page";
+    readonly description: "Lets the app see the text shown on this page.";
+}, {
+    readonly scope: "read.info";
+    readonly category: "read";
+    readonly severity: 1;
+    readonly title: "Read info from the page";
+    readonly description: "Lets the app read the href value from a part of the page.";
+}, {
+    readonly scope: "read.visible";
+    readonly category: "read";
+    readonly severity: 0;
+    readonly title: "See what’s visible on the page";
+    readonly description: "Lets the app check which elements are currently on screen.";
+}, {
+    readonly scope: "read.check";
+    readonly category: "read";
+    readonly severity: 0;
+    readonly title: "Check if something is on the page";
+    readonly description: "Lets the app test whether a specific element exists.";
+}, {
+    readonly scope: "read.count";
+    readonly category: "read";
+    readonly severity: 0;
+    readonly title: "Count items on the page";
+    readonly description: "Lets the app count how many matching elements are present.";
+}, {
+    readonly scope: "act.click";
+    readonly category: "act";
+    readonly severity: 3;
+    readonly title: "Click on the page";
+    readonly description: "Lets the app press buttons or links for you.";
+}, {
+    readonly scope: "act.type";
+    readonly category: "act";
+    readonly severity: 1;
+    readonly title: "Type into a text field";
+    readonly description: "Lets the app fill in form fields on your behalf.";
+}, {
+    readonly scope: "act.hover";
+    readonly category: "act";
+    readonly severity: 1;
+    readonly title: "Hover over the page";
+    readonly description: "Lets the app point at things to reveal menus or tooltips.";
+}, {
+    readonly scope: "media.video";
+    readonly category: "media";
+    readonly severity: 0;
+    readonly title: "Control video playback";
+    readonly description: "Lets the app play, pause, seek, and read the video on the page.";
+}, {
+    readonly scope: "media.appear";
+    readonly category: "media";
+    readonly severity: 0;
+    readonly title: "Change page appearance";
+    readonly description: "Lets the app restyle parts of the page — safely filtered.";
+}, {
+    readonly scope: "media.appearU";
+    readonly category: "media";
+    readonly severity: 2;
+    readonly unsafe: true;
+    readonly title: "Change page appearance (unsafe)";
+    readonly description: "Lets the app restyle the page WITHOUT safety filtering — could be used to leak data over the network.";
+}, {
+    readonly scope: "embed.iframe";
+    readonly category: "embed";
+    readonly severity: 0;
+    readonly title: "Load another website inside this app";
+    readonly description: "Lets the app embed external pages directly inside its own view.";
+}, {
+    readonly scope: "embed.open";
+    readonly category: "embed";
+    readonly severity: 0;
+    readonly title: "Open a website inside this app";
+    readonly description: "Lets the app navigate to another site without leaving its window.";
+}, {
+    readonly scope: "network.fetch";
+    readonly category: "network";
+    readonly severity: 0;
+    readonly title: "Fetch data from other sites";
+    readonly description: "Lets the app download public data from other websites directly, past the usual cross-origin limits.";
+}, {
+    readonly scope: "network.fetchCredentialed";
+    readonly category: "network";
+    readonly severity: 3;
+    readonly unsafe: true;
+    readonly title: "Fetch from other sites — signed in as you";
+    readonly description: "Lets the app fetch other sites using your logged-in session cookies, so it can read data only you should see.";
+}, {
+    readonly scope: "network.readCookie";
+    readonly category: "network";
+    readonly severity: 3;
+    readonly unsafe: true;
+    readonly title: "Read a site’s cookie";
+    readonly description: "Lets the app read a named cookie from another site, which can include the login token only that site should see.";
+}, {
+    readonly scope: "network.modifyRequestHeaders";
+    readonly category: "network";
+    readonly severity: 2;
+    readonly unsafe: true;
+    readonly title: "Rewrite request headers to other sites";
+    readonly description: "Lets the app set or remove headers (like Origin and Referer) on this page’s own requests to the listed sites.";
+}];
+type PermissionScope = (typeof PERMISSIONS)[number]['scope'];
+
+type PermissionRequest = {
+    key: PermissionScope;
+    scope?: string;
+    reason?: string;
+};
+type PermissionGrant = {
+    key: PermissionScope;
+    scope: string;
+    allow: boolean;
+};
+declare const permissions: {
+    request: (requests: PermissionRequest[]) => Promise<PermissionGrant[]>;
+};
+
+declare const type: "videoElement";
 type TimeRangesTuple = [number, number][];
 type VideoElementState = {
     currentTime: number;
@@ -965,9 +1529,67 @@ type BoxedVideoElement = BoxBase<typeof type> & {
 declare const createVideoElementHandle: (element: HTMLVideoElement) => RemoteVideoElement;
 declare const isType: (value: unknown) => value is RemoteVideoElement;
 declare const box: <T extends RemoteVideoElement, T2 extends RevivableContext>(value: T, context: T2) => BoxedVideoElement;
-declare const revive: <T extends BoxedVideoElement, T2 extends RevivableContext>(value: T, context: T2) => T[UnderlyingType];
+declare const revive: <T extends BoxedVideoElement, T2 extends RevivableContext>(value: T, context: T2) => T[typeof UnderlyingType];
 
-declare const handleRevivableModules: any;
+type videoElement_BoxedVideoElement = BoxedVideoElement;
+type videoElement_RemoteVideoElement = RemoteVideoElement;
+type videoElement_VideoElementState = VideoElementState;
+declare const videoElement_box: typeof box;
+declare const videoElement_createVideoElementHandle: typeof createVideoElementHandle;
+declare const videoElement_isType: typeof isType;
+declare const videoElement_revive: typeof revive;
+declare const videoElement_type: typeof type;
+declare namespace videoElement {
+  export { videoElement_box as box, videoElement_createVideoElementHandle as createVideoElementHandle, videoElement_isType as isType, videoElement_revive as revive, videoElement_type as type };
+  export type { videoElement_BoxedVideoElement as BoxedVideoElement, videoElement_RemoteVideoElement as RemoteVideoElement, videoElement_VideoElementState as VideoElementState };
+}
+
+declare const handleRevivableModules: (defaults: readonly [typeof osra_build_revivables_transfer, typeof osra_build_revivables_identity, typeof osra_build_revivables_array_buffer, typeof osra_build_revivables_date, typeof osra_build_revivables_headers, typeof osra_build_revivables_error, typeof osra_build_revivables_typed_array, typeof osra_build_revivables_blob, typeof osra_build_revivables_promise, typeof osra_build_revivables_function, typeof osra_build_revivables_message_port, typeof osra_build_revivables_readable_stream, typeof osra_build_revivables_writable_stream, typeof osra_build_revivables_abort_signal, typeof osra_build_revivables_response, typeof osra_build_revivables_request, typeof osra_build_revivables_map, typeof osra_build_revivables_set, typeof osra_build_revivables_bigint, typeof osra_build_revivables_symbol, typeof osra_build_revivables_event, {
+    readonly type: "clonable";
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is osra_build_revivables_fallbacks.Clonable;
+    readonly box: (value: osra_build_revivables_fallbacks.Clonable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Clonable;
+    readonly revive: (value: osra_build_revivables_fallbacks.BoxedClonable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Clonable;
+}, {
+    readonly type: "transferable";
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is osra_build_revivables_fallbacks.Transferable;
+    readonly box: (value: osra_build_revivables_fallbacks.Transferable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Transferable;
+    readonly revive: (value: osra_build_revivables_fallbacks.BoxedTransferable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Transferable;
+}, typeof osra_build_revivables_event_target, {
+    readonly type: "unclonable";
+    readonly isType: (value: unknown) => value is never;
+    readonly box: (_value: never, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.BoxedUnclonable;
+    readonly revive: (_value: osra_build_revivables_fallbacks.BoxedUnclonable, _context: osra.RevivableContext<any>) => Record<string, never>;
+}]) => readonly [typeof videoElement, typeof osra_build_revivables_transfer, typeof osra_build_revivables_identity, typeof osra_build_revivables_array_buffer, typeof osra_build_revivables_date, typeof osra_build_revivables_headers, typeof osra_build_revivables_error, typeof osra_build_revivables_typed_array, typeof osra_build_revivables_blob, typeof osra_build_revivables_promise, typeof osra_build_revivables_function, typeof osra_build_revivables_message_port, typeof osra_build_revivables_readable_stream, typeof osra_build_revivables_writable_stream, typeof osra_build_revivables_abort_signal, typeof osra_build_revivables_response, typeof osra_build_revivables_request, typeof osra_build_revivables_map, typeof osra_build_revivables_set, typeof osra_build_revivables_bigint, typeof osra_build_revivables_symbol, typeof osra_build_revivables_event, {
+    readonly type: "clonable";
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is osra_build_revivables_fallbacks.Clonable;
+    readonly box: (value: osra_build_revivables_fallbacks.Clonable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Clonable;
+    readonly revive: (value: osra_build_revivables_fallbacks.BoxedClonable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Clonable;
+}, {
+    readonly type: "transferable";
+    readonly capableOnly: true;
+    readonly isType: (value: unknown) => value is osra_build_revivables_fallbacks.Transferable;
+    readonly box: (value: osra_build_revivables_fallbacks.Transferable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Transferable;
+    readonly revive: (value: osra_build_revivables_fallbacks.BoxedTransferable, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.Transferable;
+}, typeof osra_build_revivables_event_target, {
+    readonly type: "unclonable";
+    readonly isType: (value: unknown) => value is never;
+    readonly box: (_value: never, _context: osra.RevivableContext<any>) => osra_build_revivables_fallbacks.BoxedUnclonable;
+    readonly revive: (_value: osra_build_revivables_fallbacks.BoxedUnclonable, _context: osra.RevivableContext<any>) => Record<string, never>;
+}];
+
+type ExtensionEventMap = {
+    statuschange: CustomEvent<{
+        enabled: boolean;
+    }>;
+};
+declare const extension: osra.TypedEventTarget<ExtensionEventMap>;
+declare const isExtensionExposed: () => boolean;
+type MissingExtensionHandler = () => Promise<void>;
+declare const setMissingExtensionHandler: (handler: MissingExtensionHandler | null) => void;
+declare const waitForExtensionExposure: (timeout?: number) => Promise<void>;
 
-export { ATTACH_FRAME_EVENT_KEY, attachFrame, box, createVideoElementHandle, dgram, handleRevivableModules, isType, net, revive, serverProxyFetch, type };
-export type { AttachFrameOptions, BoxedVideoElement, Frame, GotoOptions, RemoteVideoElement, VideoElementState };
+export { ATTACH_FRAME_EVENT_KEY, attachFrame, attachFramePermission, box, changeIframeStyle, clearTokens as clearPremiumTokens, cookies, countTokens as countPremiumTokens, createVideoElementHandle, dgram, extension, fetch, fetchCredentialedPermission, fetchPermission, gotoPermission, handleRevivableModules, http, isExtensionExposed, isType, modifyRequestHeadersPermission, net, permissions, promptInstall, readCookiePermission, refillPremiumTokens, relayWorker, removeRequestHeaderRule, resetIframeStyle, revive, serverProxyFetch, setMissingExtensionHandler, setRequestHeaderRule, storage, type, waitForExtensionExposure };
+export type { AttachFrameOptions, BoxedVideoElement, CookieDetails, FetchInit, Frame, GotoOptions, HeaderOperation, PermissionGrant, PermissionRequest, ProxyFetchRequest, RemoteVideoElement, RequestHeaderRule, SiteCookie, VideoElementState };