@fkn/lib 0.5.5 → 0.6.0

package/lib/packages.d.ts

@@ -0,0 +1,69 @@
+import type { Remote } from 'osra';
+import type { ConnectOptions, InstallOptions, InstalledPackage, PackageQuery, PackageResult, PackagesErrorCode, PickOptions } from '../api/packages';
+export type { PackageQuery, PackageResult, InstalledPackage, PickOptions, InstallOptions, ConnectOptions, PackagesErrorCode, } from '../api/packages';
+export type PackagesError = Error & {
+    code: PackagesErrorCode;
+};
+/** Search npm for FKN packages, e.g. `search({ type: 'plugin', id: 'stub' })`. */
+export declare const search: (query: PackageQuery) => Promise<PackageResult[]>;
+/** FKN-rendered picker over the same search; resolves the user's selection, already installed. [] on cancel. */
+export declare const pick: (query: PackageQuery, options?: PickOptions) => Promise<PackageResult[]>;
+/** Install a package for this app behind an FKN-rendered confirm. Resolves null when the user declines. */
+export declare const install: (uri: string, options?: InstallOptions) => Promise<InstalledPackage | null>;
+/** The packages installed by this app. */
+export declare const list: () => Promise<InstalledPackage[]>;
+/** Uninstall a package from this app; its frames and connections are torn down. */
+export declare const uninstall: (uri: string) => Promise<void>;
+export type PackageConnection<T = unknown> = {
+    /** the package's exposed payload */
+    remote: Remote<T>;
+    /** settles when the package side of the connection dies (uninstall, reload, crash) - reconnect by calling connect() again */
+    closed: Promise<void>;
+    /** the raw channel under `remote`, for direct messaging (osra envelopes ride it too - filter by your own message shape) */
+    port: MessagePort;
+};
+export type AppConnectOptions = ConnectOptions & {
+    /** exposed to the package as ITS `remote` */
+    payload?: unknown;
+    signal?: AbortSignal;
+    /** skip the osra handshake and hand back the untouched port - e.g. to transfer it into a worker and attach() there */
+    raw?: boolean;
+};
+export type RawPackageConnection = Omit<PackageConnection<never>, 'remote'>;
+type Connect = {
+    <T = unknown>(uri: string, options?: AppConnectOptions & {
+        raw?: false;
+    }): Promise<PackageConnection<T>>;
+    (uri: string, options: AppConnectOptions & {
+        raw: true;
+    }): Promise<RawPackageConnection>;
+};
+/** Connect to an installed package. Throws a PackagesError with code 'not-installed' when it is not. */
+export declare const connect: Connect;
+/** Run this end of an already-brokered connection port, e.g. after transferring it into a worker. */
+export declare const attach: <T = unknown>(port: MessagePort, payload?: unknown, options?: {
+    signal?: AbortSignal;
+}) => Promise<Remote<T>>;
+export type IncomingConnectionInfo = {
+    /** the connecting app's identity: its package uri when it runs on a sandbox origin, else its page origin */
+    from: string;
+    /** the contract tag the app passed to connect(), e.g. 'stub-source@1' */
+    protocol: string | null;
+    /** this package's canonical uri per the connecting app's install record, e.g. 'npm:@banou/stub-source-example' */
+    uri: string;
+    /** this package's npm name */
+    name: string;
+    /** the exact version this frame runs - the pin is encoded into the sandbox origin, immutable per version */
+    version: string;
+};
+export type IncomingConnection<T = unknown> = IncomingConnectionInfo & PackageConnection<T>;
+/** produces the payload exposed to a connecting app - called once per incoming connection */
+export type ConnectPayload = (info: IncomingConnectionInfo) => unknown;
+/**
+ * Serve connections from apps that installed this package. The first argument is called once per
+ * incoming connection with the connection info and returns the payload exposed to that app (its
+ * `remote`). The latest registration receives new connections; existing connections are unaffected.
+ */
+export declare const onConnect: <T = unknown>(createPayload: ConnectPayload, handler?: (connection: IncomingConnection<T>) => void) => {
+    unsubscribe: () => void;
+};

package/lib/proxy.d.ts

@@ -0,0 +1,5 @@
+import type { Resolvers } from './api';
+type ProxyFetch = Resolvers['cloud']['fetch'];
+type FetchParameters = Parameters<ProxyFetch>;
+export declare const cloudFetch: (input: FetchParameters[0], init?: FetchParameters[1]) => Promise<Response>;
+export {};

package/lib/quota.d.ts

@@ -0,0 +1,20 @@
+export type QuotaStatus = {
+    /** the user has a paid subscription, throttle never applies */
+    premium: boolean;
+    /** today's free-tier volume is spent (true even for premium, see `throttled`) */
+    overQuota: boolean;
+    /** transfers are actually being rate-limited right now (overQuota and not premium) */
+    throttled: boolean;
+    /** bytes egressed through FKN relays today (per anonymized IP), saturates at limitBytes:
+     *  consumption past the free-tier volume is private and never reported */
+    usedBytes: number;
+    /** free-tier daily volume before throttling kicks in */
+    limitBytes: number;
+    /** bytes of free-tier volume left today */
+    remainingBytes: number;
+    /** current effective egress rate cap, bytes per second */
+    bytesPerSecond: number;
+    /** current effective egress rate cap, bits per second (for display) */
+    bitsPerSecond: number;
+};
+export declare const quota: () => Promise<QuotaStatus>;

package/lib/react.d.ts

@@ -0,0 +1,7 @@
+import type { CSSProperties, ReactElement } from 'react';
+export { connectButtonUrl } from './connect-button';
+export type ConnectButtonProps = {
+    className?: string;
+    style?: CSSProperties;
+};
+export declare const ConnectButton: ({ className, style }?: ConnectButtonProps) => ReactElement;

package/lib/relay.d.ts

@@ -0,0 +1,5 @@
+export declare const relayWorker: (worker: Worker, options?: {
+    unregisterSignal?: AbortSignal;
+    originA?: string;
+    originB?: string;
+}) => void;

package/lib/storage.d.ts

@@ -0,0 +1,22 @@
+export type FileEntry = {
+    path: string;
+    size: number;
+    contentType: string | null;
+    updatedAt: string;
+};
+export type StorageQuota = {
+    usedBytes: number;
+    limitBytes: number;
+    remaining: number;
+    objects: number;
+    maxObjects: number;
+};
+export type WriteData = Blob | ArrayBuffer | Uint8Array | string;
+export declare const available: () => Promise<boolean>;
+export declare const list: () => Promise<FileEntry[]>;
+export declare const quota: () => Promise<StorageQuota>;
+export declare const readFile: (path: string) => Promise<Blob>;
+export declare const writeFile: (path: string, data: WriteData, opts?: {
+    contentType?: string;
+}) => Promise<void>;
+export declare const remove: (path: string) => Promise<void>;

package/lib/webvpn/dgram.d.ts

@@ -0,0 +1,86 @@
+import type { BindOptions, Socket as DgramSocket, RemoteInfo, SocketOptions, SocketType } from 'dgram';
+import type { AddressInfo } from 'net';
+import type { Resolvers } from '../api';
+import { EventEmitter } from 'events';
+import { Buffer } from 'buffer';
+import type { UdpSocketOption } from '../../api/webvpn/packets/udp';
+type WebVpnUdpSocket = Resolvers['cloud']['webvpn']['udpSocket'];
+interface EventEmitterOptions {
+    /**
+     * Enables automatic capturing of promise rejection.
+     */
+    captureRejections?: boolean | undefined;
+}
+export declare class Socket extends EventEmitter implements DgramSocket {
+    _type: 'udp4' | 'udp6';
+    _localAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _remoteAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _webVPNUdpSocketPromise?: Promise<Awaited<ReturnType<WebVpnUdpSocket>> | undefined>;
+    _dataPort?: MessagePort;
+    _socketId?: number;
+    _sendQueue: Uint8Array[];
+    _sendQueueBytes: number;
+    _sendFlushScheduled: boolean;
+    _peerTailCache: Map<string, Uint8Array<ArrayBufferLike>>;
+    constructor(options: SocketOptions & EventEmitterOptions & {
+        connection?: ReturnType<WebVpnUdpSocket>;
+    });
+    _lastRecvBufferSize: number;
+    _lastSendBufferSize: number;
+    _lastTtl: number;
+    _lastMulticastTtl: number;
+    _lastMulticastLoopback: boolean;
+    _setUdpOption(option: UdpSocketOption): void;
+    _onDataPortBatch(buffer: ArrayBuffer): void;
+    _peerTail(address: string | undefined, port: number | undefined): Uint8Array;
+    _portSend(message: Uint8Array, address: string | undefined, port: number | undefined): void;
+    addMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+    address(): AddressInfo;
+    bind(port?: number | undefined, address?: string | undefined, callback?: (() => void) | undefined): this;
+    bind(port?: number | undefined, callback?: (() => void) | undefined): this;
+    bind(callback?: (() => void) | undefined): this;
+    bind(options: BindOptions, callback?: (() => void) | undefined): this;
+    close(callback?: (() => void) | undefined): this;
+    connect(port: number, address?: string, callback?: () => void): void;
+    connect(port: number, callback: () => void): void;
+    disconnect(): void;
+    dropMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+    getRecvBufferSize(): number;
+    getSendBufferSize(): number;
+    getSendQueueSize(): number;
+    getSendQueueCount(): number;
+    ref(): this;
+    remoteAddress(): AddressInfo;
+    send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | readonly any[] | Uint8Array, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: unknown, offset?: unknown, length?: unknown, port?: unknown, address?: unknown, callback?: unknown): void;
+    setBroadcast(flag: boolean): void;
+    setMulticastInterface(multicastInterface: string): void;
+    setMulticastLoopback(flag: boolean): boolean;
+    setMulticastTTL(ttl: number): number;
+    setRecvBufferSize(size: number): void;
+    setSendBufferSize(size: number): void;
+    setTTL(ttl: number): number;
+    unref(): this;
+    addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+    dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare const createSocket: (options: SocketType | SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void) => Socket;
+declare const _default: {
+    Socket: typeof Socket;
+    createSocket: typeof createSocket;
+};
+export default _default;

package/lib/webvpn/http.d.ts

@@ -0,0 +1,180 @@
+import type { IncomingHttpHeaders, OutgoingHttpHeaders, RequestOptions } from 'http';
+import { Stream } from 'stream';
+import { Buffer } from 'buffer';
+import { Socket as NetSocket, Server as NetServer } from './net';
+export declare const METHODS: string[];
+export declare const STATUS_CODES: Record<number, string>;
+export 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;
+}
+export 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;
+}
+export 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: NetSocket;
+    constructor(socket: NetSocket);
+    get connection(): NetSocket;
+    _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: NetSocket | 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;
+}
+export interface ServerResponseOptions {
+    req: IncomingMessage;
+}
+export declare class ServerResponse extends OutgoingMessage {
+    statusCode: number;
+    statusMessage?: string;
+    private _writeHeadCalled;
+    sendDate: boolean;
+    req: IncomingMessage;
+    socket: NetSocket | 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;
+}
+export interface ClientRequestArgs extends RequestOptions {
+    host?: string;
+    hostname?: string;
+    port?: number | string;
+    path?: string;
+}
+export declare class ClientRequest extends OutgoingMessage {
+    method: string;
+    path: string;
+    host: string;
+    protocol: string;
+    socket: NetSocket;
+    /** alias retained for Node compatibility */
+    get connection(): NetSocket;
+    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;
+}
+export type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
+declare class ServerImpl extends NetServer {
+    constructor(options?: object | RequestListener, requestListener?: RequestListener);
+    private _handleConnection;
+}
+export declare const Server: typeof ServerImpl;
+export type Server = ServerImpl;
+export 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;
+}
+export declare const globalAgent: Agent;
+export declare const request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+export declare const get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+export declare const createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
+export 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: typeof createServer;
+    request: typeof request;
+    get: typeof get;
+};
+export default _default;

package/lib/webvpn/index.d.ts

@@ -0,0 +1 @@
+export * from './utils';

package/lib/webvpn/net.d.ts

@@ -0,0 +1,132 @@
+import type { Socket as NetSocket, SocketConnectOpts, SocketConstructorOpts, Server as TCPServer, ServerOpts, ListenOptions, AddressInfo } from 'net';
+import type { Resolvers } from '../api';
+import { DuplexOptions, Stream } from 'stream';
+type WebVpnTcpSocket = Resolvers['cloud']['webvpn']['tcpSocket'];
+type WebVpnTcpSocketListener = Resolvers['cloud']['webvpn']['tcpSocketListener'];
+import { EventEmitter } from 'events';
+import { isIP, isIPv4, isIPv6 } from './utils';
+export declare class Socket extends Stream.Duplex implements NetSocket {
+    _localAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _remoteAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _webVPNTcpSocketPromise?: Promise<(Awaited<ReturnType<WebVpnTcpSocket>> & {
+        reader: ReadableStreamDefaultReader<Uint8Array>;
+        writer: WritableStreamDefaultWriter<Uint8Array>;
+    }) | undefined>;
+    constructor(options?: SocketConstructorOpts & DuplexOptions & {
+        connection?: ReturnType<WebVpnTcpSocket>;
+    });
+    __webvpn_tcp_socket_init__(connection: ReturnType<WebVpnTcpSocket>): Promise<(import("../../api/local-net").LocalTcpSocket & {
+        reader: ReadableStreamDefaultReader<Uint8Array>;
+        writer: WritableStreamDefaultWriter<Uint8Array>;
+    }) | undefined>;
+    /** STREAM IMPL */
+    _read(size: number): void;
+    _write(chunk: Uint8Array, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    /** SOCKET IMPL */
+    connect(options: SocketConnectOpts, connectionListener?: (() => void) | undefined): this;
+    connect(port: number, host: string, connectionListener?: (() => void) | undefined): this;
+    connect(port: number, connectionListener?: (() => void) | undefined): this;
+    connect(path: string, connectionListener?: (() => void) | undefined): this;
+    connect(port: unknown, host?: unknown, connectionListener?: unknown): this;
+    _end(chunk: any, cb?: () => void): this;
+    _end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this;
+    _destroy(error?: Error | null | undefined): this;
+    destroySoon(): void;
+    resetAndDestroy(): this;
+    _timeoutMs?: number;
+    _timeoutTimer?: ReturnType<typeof setTimeout>;
+    _restartTimeoutTimer(): void;
+    setTimeout(timeout: number, callback?: (() => void) | undefined): this;
+    setNoDelay(noDelay?: boolean | undefined): this;
+    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: import('../../api/webvpn/tcp').TcpSocketOption): void;
+    write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+    write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
+    address(): AddressInfo | {};
+    unref(): this;
+    ref(): this;
+    autoSelectFamilyAttemptedAddresses: string[];
+    bufferSize: number;
+    bytesRead: number;
+    bytesWritten: number;
+    connecting: boolean;
+    pending: boolean;
+    get localAddress(): string;
+    get localPort(): number;
+    get localFamily(): string;
+    readyState: 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
+    get remoteAddress(): string;
+    get remotePort(): number;
+    get remoteFamily(): string;
+    timeout?: number | undefined;
+}
+interface EventEmitterOptions {
+    /**
+     * Enables automatic capturing of promise rejection.
+     */
+    captureRejections?: boolean | undefined;
+}
+export declare class Server extends EventEmitter implements TCPServer {
+    _localAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _webVPNTcpSocketListenerPromise?: Promise<Awaited<ReturnType<WebVpnTcpSocketListener>> | undefined>;
+    constructor(options?: ServerOpts & EventEmitterOptions & {
+        connection?: ReturnType<WebVpnTcpSocketListener>;
+    }, connectionListener?: (socket: Socket) => void);
+    __webvpn_tcp_socket_listener_init__(connection: ReturnType<WebVpnTcpSocketListener>): Promise<{
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        close: () => Promise<void>;
+    } | undefined>;
+    listen(port?: number | undefined, hostname?: string | undefined, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(port?: number | undefined, hostname?: string | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(port?: number | undefined, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(port?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(path: string, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(path: string, listeningListener?: (() => void) | undefined): this;
+    listen(options: ListenOptions, listeningListener?: (() => void) | undefined): this;
+    listen(handle: any, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
+    listen(handle: any, listeningListener?: (() => void) | undefined): this;
+    listen(port?: unknown, hostname?: unknown, backlog?: unknown, listeningListener?: unknown): this;
+    close(callback?: ((err?: Error | undefined) => void) | undefined): this;
+    address(): string | AddressInfo | null;
+    getConnections(cb: (error: Error | null, count: number) => void): this;
+    ref(): this;
+    unref(): this;
+    maxConnections: number;
+    connections: number;
+    listening: boolean;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare const connect: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
+export declare const createConnection: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
+export declare const createServer: (options?: ServerOpts | ((socket: Socket) => void), connectionListener?: (socket: Socket) => void) => Server;
+export { isIP, isIPv4, isIPv6 };
+export declare const _default: {
+    Socket: typeof Socket;
+    Server: typeof Server;
+    connect: typeof connect;
+    createConnection: typeof createConnection;
+    createServer: typeof createServer;
+    isIP: typeof isIP;
+    isIPv4: typeof isIPv4;
+    isIPv6: typeof isIPv6;
+};
+export default _default;

package/lib/webvpn/utils.d.ts

@@ -0,0 +1,32 @@
+import type { ListenOptions, SocketConnectOpts } from 'net';
+import { BindOptions } from 'dgram';
+export declare const textEncoder: TextEncoder;
+export declare const textDecoder: TextDecoder;
+export declare const isIPv4: (input: string) => boolean;
+export declare const isIPv6: (input: string) => boolean;
+export declare const isIP: (input: string) => 0 | 4 | 6;
+type TcpConnectArgs = [options: SocketConnectOpts, connectionListener?: () => void] | [port: number, host: string, connectionListener?: () => void] | [port: number, connectionListener?: () => void] | [path: string, connectionListener?: () => void];
+type TcpListenArgs = [port?: number, hostname?: string, backlog?: number, listeningListener?: (() => void)] | [port?: number, hostname?: string, listeningListener?: (() => void)] | [port?: number, backlog?: number, listeningListener?: (() => void)] | [port?: number, listeningListener?: (() => void)] | [path: string, backlog?: number, listeningListener?: (() => void)] | [path: string, listeningListener?: (() => void)] | [options: ListenOptions, listeningListener?: (() => void)] | [handle: any, backlog?: number, listeningListener?: (() => void)] | [handle: any, listeningListener?: (() => void)];
+export declare const normalizeNetArgs: <T extends TcpConnectArgs | TcpListenArgs>(...args: T) => {
+    port: number;
+    host: string | undefined;
+    callback: (() => void) | undefined;
+} | ((T[0] extends object ? T[0] : never) & {
+    callback: (() => void) | undefined;
+});
+export declare const normalizeDgramBindArgs: (...args: [port?: number, address?: string, callback?: () => void] | [port?: number, callback?: () => void] | [callback?: () => void] | [options: BindOptions, callback?: () => void]) => {
+    exclusive?: boolean | undefined;
+    fd?: number | undefined;
+    address: string | undefined;
+    port: number;
+    callback: (() => void) | undefined;
+};
+export declare const normalizeDgramSendArgs: (...args: [msg: string | readonly any[] | Uint8Array, port: number, address: string, callback: (error: Error | null, bytes: number) => void] | [msg: string | readonly any[] | Uint8Array, port: number, callback: (error: Error | null, bytes: number) => void] | [msg: string | readonly any[] | Uint8Array, callback: (error: Error | null, bytes: number) => void] | [msg: string | Uint8Array, offset: number, length: number, port: number, address: string, callback: (error: Error | null, bytes: number) => void] | [msg: string | Uint8Array, offset: number, length: number, port: number, callback: (error: Error | null, bytes: number) => void] | [msg: string | Uint8Array, offset: number, length: number, callback: (error: Error | null, bytes: number) => void]) => {
+    message: string | readonly any[] | Uint8Array<ArrayBufferLike>;
+    offset: number | ((error: Error | null, bytes: number) => void);
+    length: number;
+    port: number;
+    address: string | undefined;
+    callback: (() => void) | undefined;
+};
+export {};

package/net-CpuAhaQC.cjs

@@ -0,0 +1 @@
+const e=require("./rolldown-runtime-Doa5O59j.cjs"),t=require("./api-DD5v1qP9.cjs"),n=require("./utils-CoimMjf9.cjs");let r=require("stream"),i=require("events");var a=e.n({Server:()=>s,Socket:()=>o,_default:()=>d,connect:()=>c,createConnection:()=>l,createServer:()=>u,default:()=>d,isIP:()=>n.t,isIPv4:()=>n.n,isIPv6:()=>n.r}),o=class extends r.Stream.Duplex{_localAddress;_remoteAddress;_webVPNTcpSocketPromise;constructor(e){if(e?.fd!==void 0)throw Error(`FKN WebVPN does not support file descriptors`);super(e),e?.connection&&this.__webvpn_tcp_socket_init__(e.connection)}__webvpn_tcp_socket_init__(e){if(this._webVPNTcpSocketPromise=e.then(e=>{let t=e.dataReadableStream.getReader(),n=e.dataWritableStream.getWriter();return this._localAddress={address:e.localAddress,family:e.localFamily,port:e.localPort},this._remoteAddress={address:e.remoteAddress,family:e.remoteFamily,port:e.remotePort},{...e,reader:t,writer:n}}).catch(e=>{this.emit(`error`,e)}),!this._webVPNTcpSocketPromise)throw Error(`Socket not connected`);return this._webVPNTcpSocketPromise.then(e=>{e&&this.emit(`connect`)}),this._webVPNTcpSocketPromise}_read(e){if(!this._webVPNTcpSocketPromise)throw Error(`Socket not connected`);this._webVPNTcpSocketPromise.then(e=>{if(!e){this.push(null);return}e.reader.read().then(({value:e,done:t})=>{if(t){this.push(null);return}this._restartTimeoutTimer(),this.push(e)}).catch(e=>{this.destroy(e)})})}_write(e,t,n){if(!this._webVPNTcpSocketPromise){n(Error(`Socket not connected`));return}this._webVPNTcpSocketPromise.then(async t=>{if(!t)throw Error(`Socket not connected`);await t.writer.ready,await t.writer.write(e),this._restartTimeoutTimer(),n()}).catch(n)}connect(...e){let r=n.o(...e),i=this.__webvpn_tcp_socket_init__(t.t.then(e=>e.cloud.webvpn.tcpSocket({remoteAddress:r.host??`localhost`,remotePort:r.port})));return r.callback&&i.then(e=>{e&&r.callback.call(this)}),this}_end(...e){return this._webVPNTcpSocketPromise?(e.length!==0&&this.write(e[0],e[1],e[2]),this._webVPNTcpSocketPromise.then(async e=>{e&&await e.end()}),this):this}_destroy(e){return this._timeoutTimer&&clearTimeout(this._timeoutTimer),this._webVPNTcpSocketPromise&&this._webVPNTcpSocketPromise.then(async e=>{e&&await e.destroy()}),this}destroySoon(){this._webVPNTcpSocketPromise&&this._webVPNTcpSocketPromise.then(async e=>{e&&await e.destroySoon()})}resetAndDestroy(){return this._webVPNTcpSocketPromise&&this._webVPNTcpSocketPromise.then(async e=>{e&&await e.resetAndDestroy()}),this}_timeoutMs;_timeoutTimer;_restartTimeoutTimer(){this._timeoutTimer&&clearTimeout(this._timeoutTimer),this._timeoutMs&&(this._timeoutTimer=setTimeout(()=>this.emit(`timeout`),this._timeoutMs))}setTimeout(e,t){return t&&this.on(`timeout`,t),this._timeoutMs=e,this._restartTimeoutTimer(),this}setNoDelay(e){let t=e??!0;return this._setTcpOption({type:0,value:t}),this}setKeepAlive(e,t){let n=e??!1,r=t!==void 0&&t>0?Math.max(1,Math.round(t/1e3)):0;return this._setTcpOption({type:2,enabled:n,initialDelaySeconds:r}),this}setSendBufferSize(e){return this._setTcpOption({type:3,value:e}),this}setRecvBufferSize(e){return this._setTcpOption({type:4,value:e}),this}_typeOfService;getTypeOfService(){return this._typeOfService??0}setTypeOfService(e){return this._typeOfService=e,this}_setTcpOption(e){if(!this._webVPNTcpSocketPromise){this.emit(`error`,Error(`Cannot set socket option before connect`));return}this._webVPNTcpSocketPromise.then(async t=>{if(t)try{await t.setOption(e)}catch(e){this.emit(`error`,e)}})}write(e,t,...n){return super.write(e,t,...n)}address(){return this._localAddress??{}}unref(){return this}ref(){return this}autoSelectFamilyAttemptedAddresses;bufferSize;bytesRead;bytesWritten;connecting;pending;get localAddress(){if(!this._localAddress)throw Error(`Socket is not connected`);return this._localAddress.address}get localPort(){if(!this._localAddress)throw Error(`Socket is not connected`);return this._localAddress.port}get localFamily(){if(!this._localAddress)throw Error(`Socket is not connected`);return this._localAddress.family}readyState;get remoteAddress(){if(!this._remoteAddress)throw Error(`Socket is not connected`);return this._remoteAddress.address}get remotePort(){if(!this._remoteAddress)throw Error(`Socket is not connected`);return this._remoteAddress.port}get remoteFamily(){if(!this._remoteAddress)throw Error(`Socket is not connected`);return this._remoteAddress.family}timeout},s=class extends i.EventEmitter{_localAddress;_webVPNTcpSocketListenerPromise;constructor(e,t){super(e),t&&this.on(`connection`,t),e?.connection&&this.__webvpn_tcp_socket_listener_init__(e.connection)}__webvpn_tcp_socket_listener_init__(e){return this._webVPNTcpSocketListenerPromise=e.then(e=>(this._localAddress={address:e.localAddress,family:e.localFamily,port:e.localPort},e)).catch(e=>{this.emit(`error`,e)}),this._webVPNTcpSocketListenerPromise.then(e=>{e&&this.emit(`listening`)}),this._webVPNTcpSocketListenerPromise}listen(...e){let r=n.o(...e),i=e=>{let t=new o({connection:Promise.resolve(e)});this.emit(`connection`,t)},a=e=>t.t.then(t=>t.cloud.webvpn.tcpSocketListener({localAddress:e,localPort:r.port,onConnection:i})),s=r.host?a(r.host):a(`::`).catch(()=>a(`0.0.0.0`)),c=this.__webvpn_tcp_socket_listener_init__(s);return r.callback&&c.then(e=>{e&&r.callback.call(this)}),this}close(e){return this._webVPNTcpSocketListenerPromise&&this._webVPNTcpSocketListenerPromise.then(async t=>{if(t)try{await t.close(),this._localAddress=void 0,this.emit(`close`),e&&e()}catch(t){this._localAddress=void 0,this.emit(`close`),e&&e(t)}}),this}address(){return this._localAddress??null}getConnections(e){throw Error(`Method not implemented.`)}ref(){return this}unref(){return this}maxConnections;connections;listening;async[Symbol.asyncDispose](){}},c=(e,t)=>new o().connect(e,t),l=(e,t)=>new o().connect(e,t),u=(e,t)=>{typeof e==`function`&&(t=e,e=void 0);let n=new s(e);return t&&n.on(`connection`,t),n},d={Socket:o,Server:s,connect:c,createConnection:l,createServer:u,isIP:n.t,isIPv4:n.n,isIPv6:n.r};Object.defineProperty(exports,"a",{enumerable:!0,get:function(){return l}}),Object.defineProperty(exports,"i",{enumerable:!0,get:function(){return c}}),Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return o}}),Object.defineProperty(exports,"o",{enumerable:!0,get:function(){return u}}),Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return d}}),Object.defineProperty(exports,"s",{enumerable:!0,get:function(){return a}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return s}});

package/{net-Bl6_W3bd.js → net-DKMWPXb_.js}

@@ -1,6 +1,6 @@
-import { n as e } from "./chunk-CPXzm0be.js";
-import { t } from "./api-ByfayMm1.js";
-import { n, o as r, r as i, t as a } from "./utils-CNydj3OT.js";
+import { n as e } from "./rolldown-runtime-DF993M8W.js";
+import { t } from "./api--bnCFd4w.js";
+import { n, o as r, r as i, t as a } from "./utils-DPtyxGQu.js";
 import { Stream as o } from "stream";
 import { EventEmitter as s } from "events";
 //#region src/lib/webvpn/net.ts

package/net.cjs

@@ -1 +1 @@
-Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}}),require(`./api-CDb2pv7C.cjs`);const e=require(`./utils-BsNRWMfl.cjs`),t=require(`./net-C5kWnI4C.cjs`);exports.Server=t.t,exports.Socket=t.n,exports._default=t.r,exports.default=t.r,exports.connect=t.i,exports.createConnection=t.a,exports.createServer=t.o,exports.isIP=e.t,exports.isIPv4=e.n,exports.isIPv6=e.r;
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("./utils-CoimMjf9.cjs"),t=require("./net-CpuAhaQC.cjs");exports.Server=t.t,exports.Socket=t.n,exports._default=t.r,exports.default=t.r,exports.connect=t.i,exports.createConnection=t.a,exports.createServer=t.o,exports.isIP=e.t,exports.isIPv4=e.n,exports.isIPv6=e.r;

package/net.js

@@ -1,4 +1,3 @@
-import "./api-ByfayMm1.js";
-import { n as e, r as t, t as n } from "./utils-CNydj3OT.js";
-import { a as r, i, n as a, o, r as s, t as c } from "./net-Bl6_W3bd.js";
+import { n as e, r as t, t as n } from "./utils-DPtyxGQu.js";
+import { a as r, i, n as a, o, r as s, t as c } from "./net-DKMWPXb_.js";
 export { c as Server, a as Socket, s as _default, s as default, i as connect, r as createConnection, o as createServer, n as isIP, e as isIPv4, t as isIPv6 };