@fkn/lib 0.3.7 → 0.3.9

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,17 @@ type AddressLookupResult = {
 };
 
 declare const resolvers: {
+    readonly setOverlayHost: (push: (state: {
+        modal: boolean;
+        rects: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }[];
+    }) => unknown) => void;
+    readonly showInstallPrompt: (reason?: string) => Promise<void>;
+    readonly hideInstallPrompt: () => void;
     readonly dnsLookup: <T extends boolean = false>(hostname: string, options?: {
         all?: T;
         family: 0 | 4 | 6;
@@ -310,6 +347,14 @@ 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 isIPv4: (input: string) => boolean;
 declare const isIPv6: (input: string) => boolean;
 declare const isIP: (input: string) => 0 | 4 | 6;
@@ -372,6 +417,9 @@ declare class Socket$1 extends Stream.Duplex implements Socket$2 {
     setKeepAlive(enable?: boolean | undefined, initialDelay?: number | undefined): this;
     setSendBufferSize(size: number): this;
     setRecvBufferSize(size: number): this;
+    _typeOfService?: number;
+    getTypeOfService(): number;
+    setTypeOfService(tos: number): this;
     _setTcpOption(option: TcpSocketOption): void;
     write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
     write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
@@ -399,7 +447,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 +485,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 +594,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 +884,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 +896,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 +908,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 +920,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 +932,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 +944,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 +956,173 @@ 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 resolve$9: (context: LocatorContext, _options?: OperationTimeoutOptions) => void;
+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 & {
+    position?: {
+        x?: number | undefined;
+        y?: number | undefined;
+    } | undefined;
+}) => 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 +1131,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 +1157,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 +1173,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 +1237,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 +1273,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;
@@ -885,9 +1302,30 @@ type LocatorChain<L extends LocatorKindModule, Self> = {
     ] extends [never] ? (...args: ExtractResolverArgs<M>) => Self : (...args: ExtractResolverArgs<M>) => NextLocator<M>;
 } & {
     [M in L['operationModules'][number] as ExtractType<M>]: (...args: ExtractOperationArgs<M>) => Promise<Awaited<ExtractResolverReturn<M>>>;
+} & {
+    ensure: (operation: ExtractType<L['operationModules'][number]>, options?: {
+        reason?: string;
+        timeout?: number;
+    } & Record<string, unknown>) => Promise<void>;
 };
 
 declare const ATTACH_FRAME_EVENT_KEY = "FKN_WEB_EXTENSION_ATTACH_FRAME_EVENT_KEY";
+declare const isBlockedFrameUrl: (raw: string) => boolean;
+declare const assertAttachableFrameUrl: (raw: string) => void;
+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 +1340,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 +1526,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, assertAttachableFrameUrl, attachFrame, attachFramePermission, box, cookies, createVideoElementHandle, dgram, extension, fetch, fetchCredentialedPermission, fetchPermission, gotoPermission, handleRevivableModules, http, isBlockedFrameUrl, isExtensionExposed, isType, modifyRequestHeadersPermission, net, permissions, promptInstall, readCookiePermission, relayWorker, removeRequestHeaderRule, revive, serverProxyFetch, setMissingExtensionHandler, setRequestHeaderRule, type, waitForExtensionExposure };
+export type { AttachFrameOptions, BoxedVideoElement, CookieDetails, FetchInit, Frame, GotoOptions, HeaderOperation, PermissionGrant, PermissionRequest, ProxyFetchRequest, RemoteVideoElement, RequestHeaderRule, SiteCookie, VideoElementState };