@fkn/lib 0.6.0 → 0.6.2

package/account.d.ts

@@ -0,0 +1,15 @@
+declare namespace account_d_exports {
+  export { AccountInfo, info, login, logout, onChange };
+}
+type AccountInfo = {
+  /** the account's display name (a username, not necessarily a real name) */name: string; /** profile image URL, or null if none is set */
+  image: string | null; /** the account has an active paid subscription */
+  premium: boolean; /** when the current subscription lapses, as a ms epoch, or null when not subscribed */
+  premiumUntil: number | null;
+};
+declare const login: () => Promise<boolean>;
+declare const logout: () => Promise<void>;
+declare const info: () => Promise<AccountInfo | null>;
+declare const onChange: (callback: () => void) => Promise<() => void>;
+//#endregion
+export { AccountInfo, info, login, logout, onChange, account_d_exports as t };

package/api-B0jZnr_N.d.ts

@@ -0,0 +1,554 @@
+import { C as PackagesFail, _ as ConnectOptions, b as PackageQuery, v as InstallOptions, w as PickOptions, x as PackageResult, y as InstalledPackage } from "./packages-D36R2vBv.js";
+import { t as AddressLookupResult } from "./lookup-BtwWaCZJ.js";
+import { Address4, Address6 } from "ip-address";
+
+//#region src/api/storage.d.ts
+type StorageEntry = {
+  path: string;
+  size: number;
+  contentType: string | null;
+  updatedAt: string;
+};
+type StorageQuota = {
+  usedBytes: number;
+  limitBytes: number;
+  remaining: number;
+  objects: number;
+  maxObjects: number;
+};
+type WriteData = ArrayBuffer | Uint8Array | string;
+//#endregion
+//#region src/api/webvpn/packets/tcp.d.ts
+declare const parseServerMetadataTcpSocketConnectedPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  readonly _type: 'ServerMetadataTcpSocketConnectedPacket';
+  readonly offset: number;
+  readonly id: number;
+  readonly socketId: number;
+  readonly localAddressType: 0 | 1;
+  readonly localAddress: import("ip-address").Address4 | import("ip-address").Address6;
+  readonly localPort: number;
+  readonly remoteAddressType: 0 | 1;
+  readonly remoteAddress: import("ip-address").Address4 | import("ip-address").Address6;
+  readonly remotePort: number;
+  readonly errorLength: number;
+  readonly error: string;
+};
+type ServerMetadataTcpSocketConnectedPacket = ReturnType<typeof parseServerMetadataTcpSocketConnectedPacket>;
+declare const parseServerMetadataTcpSocketShutdownPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  readonly _type: 'ServerMetadataTcpSocketShutdownPacket';
+  readonly offset: number;
+  readonly id: number;
+  readonly socketId: number;
+};
+type ServerMetadataTcpSocketShutdownPacket = ReturnType<typeof parseServerMetadataTcpSocketShutdownPacket>;
+declare const TCP_OPTION_NODELAY: 0;
+declare const TCP_OPTION_TTL: 1;
+declare const TCP_OPTION_KEEPALIVE: 2;
+declare const TCP_OPTION_SEND_BUFFER_SIZE: 3;
+declare const TCP_OPTION_RECV_BUFFER_SIZE: 4;
+type TcpSocketOption = {
+  type: typeof TCP_OPTION_NODELAY;
+  value: boolean;
+} | {
+  type: typeof TCP_OPTION_TTL;
+  value: number;
+} | {
+  type: typeof TCP_OPTION_KEEPALIVE;
+  enabled: boolean;
+  initialDelaySeconds: number;
+} | {
+  type: typeof TCP_OPTION_SEND_BUFFER_SIZE;
+  value: number;
+} | {
+  type: typeof TCP_OPTION_RECV_BUFFER_SIZE;
+  value: number;
+};
+declare const parseServerMetadataTcpSetOptionAckPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  _type: 'ServerMetadataTcpSetOptionAckPacket';
+  offset: number;
+  id: number;
+  socketId: number;
+  errorLength: number;
+  error: string;
+};
+type ServerMetadataTcpSetOptionAckPacket = ReturnType<typeof parseServerMetadataTcpSetOptionAckPacket>;
+//#endregion
+//#region src/api/local-net/index.d.ts
+type LocalTcpSocket = {
+  localAddress: string;
+  localFamily: 'IPv4' | 'IPv6';
+  localPort: number;
+  remoteAddress: string;
+  remoteFamily: 'IPv4' | 'IPv6';
+  remotePort: number;
+  dataReadableStream: ReadableStream<Uint8Array>;
+  dataWritableStream: WritableStream<Uint8Array>;
+  end: () => Promise<void>;
+  destroy: () => Promise<void>;
+  destroySoon: () => Promise<void>;
+  resetAndDestroy: () => Promise<void>;
+  setOption: (option: TcpSocketOption) => Promise<void>;
+};
+//#endregion
+//#region src/api/webvpn/packets/udp.d.ts
+declare const parseServerMetadataUdpSocketBoundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  readonly _type: 'ServerMetadataUdpSocketBoundPacket';
+  readonly offset: number;
+  readonly id: number;
+  readonly socketId: number;
+  readonly localAddressType: 0 | 1;
+  readonly localAddress: import("ip-address").Address4 | import("ip-address").Address6;
+  readonly localPort: number;
+  readonly errorLength: number;
+  readonly error: string;
+};
+type ServerMetadataUdpSocketBoundPacket = ReturnType<typeof parseServerMetadataUdpSocketBoundPacket>;
+declare const parseServerMetadataUdpSocketUnboundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  readonly _type: 'ServerMetadataUdpSocketUnboundPacket';
+  readonly offset: number;
+  readonly id: number;
+  readonly socketId: number;
+};
+type ServerMetadataUdpSocketUnboundPacket = ReturnType<typeof parseServerMetadataUdpSocketUnboundPacket>;
+declare const parseServerMetadataUdpSocketConnectedPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  readonly _type: 'ServerMetadataUdpSocketConnectedPacket';
+  readonly offset: number;
+  readonly id: number;
+  readonly socketId: number;
+  readonly remoteAddressType: 0 | 1;
+  readonly remoteAddress: import("ip-address").Address4 | import("ip-address").Address6;
+  readonly remotePort: number;
+  readonly errorLength: number;
+  readonly error: string;
+};
+type ServerMetadataUdpSocketConnectedPacket = ReturnType<typeof parseServerMetadataUdpSocketConnectedPacket>;
+declare const parseServerUdpDataPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  readonly _type: 'ServerUdpDataPacket';
+  readonly offset: number;
+  readonly socketId: number;
+  readonly remoteAddressType: 0 | 1 | 2;
+  readonly remoteAddress: import("ip-address").Address4 | import("ip-address").Address6 | undefined;
+  readonly remotePort: number | undefined;
+  readonly dataLength: number;
+  readonly data: ArrayBuffer;
+};
+type ServerUdpDataPacket = ReturnType<typeof parseServerUdpDataPacket>;
+declare const UDP_OPTION_BROADCAST: 0;
+declare const UDP_OPTION_TTL: 1;
+declare const UDP_OPTION_MULTICAST_TTL_V4: 2;
+declare const UDP_OPTION_MULTICAST_LOOP_V4: 3;
+declare const UDP_OPTION_MULTICAST_LOOP_V6: 4;
+declare const UDP_OPTION_ADD_MEMBERSHIP_V4: 5;
+declare const UDP_OPTION_DROP_MEMBERSHIP_V4: 6;
+declare const UDP_OPTION_ADD_MEMBERSHIP_V6: 7;
+declare const UDP_OPTION_DROP_MEMBERSHIP_V6: 8;
+declare const UDP_OPTION_SEND_BUFFER_SIZE: 9;
+declare const UDP_OPTION_RECV_BUFFER_SIZE: 10;
+type UdpSocketOption = {
+  type: typeof UDP_OPTION_BROADCAST;
+  value: boolean;
+} | {
+  type: typeof UDP_OPTION_TTL;
+  value: number;
+} | {
+  type: typeof UDP_OPTION_MULTICAST_TTL_V4;
+  value: number;
+} | {
+  type: typeof UDP_OPTION_MULTICAST_LOOP_V4;
+  value: boolean;
+} | {
+  type: typeof UDP_OPTION_MULTICAST_LOOP_V6;
+  value: boolean;
+} | {
+  type: typeof UDP_OPTION_ADD_MEMBERSHIP_V4;
+  group: Uint8Array;
+  interface: Uint8Array;
+} | {
+  type: typeof UDP_OPTION_DROP_MEMBERSHIP_V4;
+  group: Uint8Array;
+  interface: Uint8Array;
+} | {
+  type: typeof UDP_OPTION_ADD_MEMBERSHIP_V6;
+  group: Uint8Array;
+  ifIndex: number;
+} | {
+  type: typeof UDP_OPTION_DROP_MEMBERSHIP_V6;
+  group: Uint8Array;
+  ifIndex: number;
+} | {
+  type: typeof UDP_OPTION_SEND_BUFFER_SIZE;
+  value: number;
+} | {
+  type: typeof UDP_OPTION_RECV_BUFFER_SIZE;
+  value: number;
+};
+declare const parseServerMetadataUdpSetOptionAckPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  _type: 'ServerMetadataUdpSetOptionAckPacket';
+  offset: number;
+  id: number;
+  socketId: number;
+  errorLength: number;
+  error: string;
+};
+type ServerMetadataUdpSetOptionAckPacket = ReturnType<typeof parseServerMetadataUdpSetOptionAckPacket>;
+//#endregion
+//#region src/api/webvpn/packets/tcp-listener.d.ts
+declare const parseServerMetadataTcpSocketListenerBoundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  readonly _type: 'ServerMetadataTcpSocketListenerBoundPacket';
+  readonly offset: number;
+  readonly id: number;
+  readonly socketId: number;
+  readonly localAddressType: 0 | 1;
+  readonly localAddress: import("ip-address").Address4 | import("ip-address").Address6;
+  readonly localPort: number;
+  readonly errorLength: number;
+  readonly error: string;
+};
+type ServerMetadataTcpSocketListenerBoundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerBoundPacket>;
+declare const parseServerMetadataTcpSocketListenerUnboundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  readonly _type: 'ServerMetadataTcpSocketListenerUnboundPacket';
+  readonly offset: number;
+  readonly id: number;
+  readonly socketId: number;
+};
+type ServerMetadataTcpSocketListenerUnboundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerUnboundPacket>;
+//#endregion
+//#region src/api/webvpn/packets/metadata.d.ts
+declare const parseServerMetadataHeaderPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
+  readonly _type: 'ServerMetadataHeaderPacket';
+  readonly offset: number;
+  readonly agentLength: number;
+  readonly agent: string;
+  readonly versionLength: number;
+  readonly version: string;
+};
+type ServerMetadataHeaderPacket = ReturnType<typeof parseServerMetadataHeaderPacket>;
+type ServerMetadataPacket = ServerMetadataHeaderPacket | ServerMetadataTcpSocketConnectedPacket | ServerMetadataTcpSocketShutdownPacket | ServerMetadataTcpSocketListenerBoundPacket | ServerMetadataTcpSocketListenerUnboundPacket | ServerMetadataUdpSocketBoundPacket | ServerMetadataUdpSocketUnboundPacket | ServerMetadataUdpSocketConnectedPacket | ServerMetadataTcpSetOptionAckPacket | ServerMetadataUdpSetOptionAckPacket;
+//#endregion
+//#region src/api/webvpn/session-core.d.ts
+type BidirectionalStreams = {
+  readable: ReadableStream<Uint8Array>;
+  writable: WritableStream<Uint8Array>;
+};
+type TransportPrimitives = {
+  metadataReadable: ReadableStream<Uint8Array>;
+  metadataWriter: WritableStreamDefaultWriter<Uint8Array>;
+  datagramWriter: WritableStreamDefaultWriter<Uint8Array>;
+  incomingBidi: ReadableStream<BidirectionalStreams>;
+  incomingUni: ReadableStream<ReadableStream<Uint8Array>>;
+  serverDatagrams?: ReadableStream<ServerUdpDataPacket>;
+  closed: Promise<{
+    reason: string;
+  }>;
+  close: (reason: string) => void;
+};
+declare const makeWebVpnSession: (primitives: TransportPrimitives) => Promise<{
+  closed: Promise<{
+    reason: string;
+  }>;
+  isClosed: () => boolean;
+  getNewPacketId: () => number;
+  getTcpDataReadableStreamForSocketId: (socketId: number, options?: {
+    signal?: AbortSignal;
+  }) => Promise<BidirectionalStreams>;
+  getUdpDataReadableStreamForSocketId: (socketId: number) => ReadableStream<{
+    readonly _type: 'ServerUdpDataPacket';
+    readonly offset: number;
+    readonly socketId: number;
+    readonly remoteAddressType: 0 | 1 | 2;
+    readonly remoteAddress: Address4 | Address6 | undefined;
+    readonly remotePort: number | undefined;
+    readonly dataLength: number;
+    readonly data: ArrayBuffer;
+  }>;
+  claimUdpRawStream: (socketId: number, sink: (packetBytes: Uint8Array) => void) => void;
+  releaseUdpRawStream: (socketId: number) => void;
+  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>>;
+  presentRateToken: () => Promise<void>;
+}>;
+type WebVPNSession = Awaited<ReturnType<typeof makeWebVpnSession>>;
+//#endregion
+//#region src/api/webvpn/transport.d.ts
+type WebVPNWebTransport = WebVPNSession;
+//#endregion
+//#region src/api/webvpn/tcp.d.ts
+declare const processTcpSocket: ({
+  connectedPacket,
+  dataReadableStream,
+  dataWritableStream,
+  metadataReadableStream,
+  metadataWriter,
+  dataStreamAbort,
+  webVpnWebTransport,
+  ownsMetadataWriter
+}: {
+  connectedPacket: ServerMetadataTcpSocketConnectedPacket;
+  dataReadableStream: ReadableStream<Uint8Array>;
+  dataWritableStream: WritableStream<Uint8Array>;
+  metadataReadableStream: ReadableStream<ServerMetadataPacket>;
+  metadataWriter: WritableStreamDefaultWriter<Uint8Array>;
+  dataStreamAbort?: AbortController;
+  webVpnWebTransport: WebVPNWebTransport;
+  ownsMetadataWriter?: boolean;
+}) => Promise<{
+  localAddress: string;
+  localFamily: "IPv4" | "IPv6";
+  localPort: number;
+  remoteAddress: string;
+  remoteFamily: "IPv4" | "IPv6";
+  remotePort: number;
+  dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
+  dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
+  end: () => Promise<void>;
+  destroy: () => Promise<void>;
+  destroySoon: () => Promise<void>;
+  resetAndDestroy: () => Promise<void>;
+  setOption: (option: TcpSocketOption) => Promise<void>;
+}>;
+type TcpSocketResult = Awaited<ReturnType<typeof processTcpSocket>>;
+//#endregion
+//#region src/api/quota.d.ts
+type Quota = {
+  overQuota: boolean;
+  remaining: number;
+  usedBytes: number;
+  limitBytes: number;
+  premium: boolean;
+  bytesPerSecond: number;
+};
+//#endregion
+//#region src/api/account.d.ts
+type Account = {
+  name: string;
+  image: string | null;
+  premium: boolean;
+  premiumUntil: string | null;
+};
+//#endregion
+//#region src/api/index.d.ts
+declare const resolvers: {
+  readonly cloud: {
+    readonly fetch: (input: string | Request | URL, init?: (RequestInit | undefined) & {
+      render?: boolean;
+    }) => Promise<Response>;
+    readonly quota: () => Promise<Quota>;
+    readonly dns: {
+      readonly lookup: <T extends boolean = false>(hostname: string, options?: {
+        all?: T;
+        family?: 0 | 4 | 6;
+      }) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;
+    };
+    readonly fs: {
+      readonly available: () => Promise<boolean>;
+      readonly list: () => Promise<StorageEntry[]>;
+      readonly quota: () => Promise<StorageQuota>;
+      readonly readFile: (path: string) => Promise<Uint8Array>;
+      readonly writeFile: (path: string, data: WriteData, contentType: string | null) => Promise<void>;
+      readonly remove: (path: string) => Promise<void>;
+    };
+    readonly webvpn: {
+      readonly tcpSocket: ({
+        remoteAddress: _remoteAddress,
+        remotePort
+      }: {
+        remoteAddress: string;
+        remotePort: number;
+      }) => Promise<LocalTcpSocket>;
+      readonly tcpSocketListener: ({
+        localAddress: _localAddress,
+        localPort,
+        onConnection
+      }: {
+        localAddress: string;
+        localPort: number;
+        onConnection: (connection: TcpSocketResult) => void;
+      }) => Promise<{
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        close: () => Promise<void>;
+      }>;
+      readonly udpSocket: ({
+        type,
+        port,
+        address,
+        dataPort
+      }: {
+        type: 'udp4' | 'udp6';
+        port: number;
+        address: string;
+        dataPort?: boolean;
+      }) => Promise<{
+        socketId: number;
+        dataPort: MessagePort | undefined;
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        dataReadableStream: ReadableStream<{
+          data: ArrayBuffer;
+          size: number;
+          family: 'IPv4' | 'IPv6';
+          address: string;
+          port: number;
+        }>;
+        connect: ({
+          remoteAddress: _remoteAddress,
+          remotePort
+        }: {
+          remoteAddress: string;
+          remotePort: number;
+        }) => Promise<void>;
+        send: ({
+          message,
+          address: _remoteAddress,
+          port: remotePort
+        }: {
+          message: ArrayBuffer;
+          address?: string;
+          port?: number;
+        }) => Promise<void>;
+        close: () => Promise<void>;
+        setOption: (option: UdpSocketOption) => Promise<void>;
+      }>;
+    };
+  };
+  readonly overlay: {
+    readonly setHost: (push: (state: {
+      modal: boolean;
+      rects: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+      }[];
+    }) => unknown) => void;
+  };
+  readonly installPrompt: {
+    readonly show: (reason?: string) => Promise<void>;
+    readonly hide: () => void;
+  };
+  readonly connect: {
+    readonly prompt: (consumerOrigin: string) => Promise<boolean>;
+  };
+  readonly packages: {
+    search: (query: PackageQuery) => Promise<{
+      results: PackageResult[];
+    } | PackagesFail>;
+    pick: (query: PackageQuery, options?: PickOptions) => Promise<{
+      results: PackageResult[];
+      failed: string[];
+    } | {
+      declined: true;
+    } | PackagesFail>;
+    install: (uri: string, options?: InstallOptions) => Promise<{
+      installed: InstalledPackage;
+    } | {
+      declined: true;
+    } | PackagesFail>;
+    list: () => Promise<{
+      results: InstalledPackage[];
+    }>;
+    uninstall: (uri: string) => Promise<{
+      ok: true;
+    } | PackagesFail>;
+    connect: (uri: string, options?: ConnectOptions) => Promise<{
+      port: MessagePort;
+      closed: Promise<void>;
+    } | PackagesFail>;
+  };
+  readonly account: {
+    readonly info: () => Promise<Account | null>;
+    readonly login: (consumerOrigin: string) => Promise<boolean>;
+    readonly logout: () => void;
+    readonly onChange: (listener: () => void) => (() => void);
+  };
+  readonly proxyFetch: (input: string | Request | URL, init?: (RequestInit | undefined) & {
+    render?: boolean;
+  }) => Promise<Response>;
+  readonly webVpnTcpSocket: ({
+    remoteAddress: _remoteAddress,
+    remotePort
+  }: {
+    remoteAddress: string;
+    remotePort: number;
+  }) => Promise<LocalTcpSocket>;
+  readonly webVpnTcpSocketListener: ({
+    localAddress: _localAddress,
+    localPort,
+    onConnection
+  }: {
+    localAddress: string;
+    localPort: number;
+    onConnection: (connection: TcpSocketResult) => void;
+  }) => Promise<{
+    localAddress: string;
+    localFamily: "IPv4" | "IPv6";
+    localPort: number;
+    close: () => Promise<void>;
+  }>;
+  readonly webVpnUdpSocket: ({
+    type,
+    port,
+    address,
+    dataPort
+  }: {
+    type: 'udp4' | 'udp6';
+    port: number;
+    address: string;
+    dataPort?: boolean;
+  }) => Promise<{
+    socketId: number;
+    dataPort: MessagePort | undefined;
+    localAddress: string;
+    localFamily: "IPv4" | "IPv6";
+    localPort: number;
+    dataReadableStream: ReadableStream<{
+      data: ArrayBuffer;
+      size: number;
+      family: 'IPv4' | 'IPv6';
+      address: string;
+      port: number;
+    }>;
+    connect: ({
+      remoteAddress: _remoteAddress,
+      remotePort
+    }: {
+      remoteAddress: string;
+      remotePort: number;
+    }) => Promise<void>;
+    send: ({
+      message,
+      address: _remoteAddress,
+      port: remotePort
+    }: {
+      message: ArrayBuffer;
+      address?: string;
+      port?: number;
+    }) => Promise<void>;
+    close: () => Promise<void>;
+    setOption: (option: UdpSocketOption) => Promise<void>;
+  }>;
+  readonly dnsLookup: <T extends boolean = false>(hostname: string, options?: {
+    all?: T;
+    family?: 0 | 4 | 6;
+  }) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;
+  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;
+};
+type Resolvers = typeof resolvers;
+//#endregion
+export { TcpSocketOption as i, UdpSocketOption as n, LocalTcpSocket as r, Resolvers as t };

package/cloud/dgram.d.ts

@@ -0,0 +1,2 @@
+import _default, { Socket, createSocket } from "../dgram.js";
+export { Socket, createSocket, _default as default };

package/cloud/dns.d.ts

@@ -0,0 +1,3 @@
+import { t as AddressLookupResult } from "../lookup-BtwWaCZJ.js";
+import { lookup } from "../dns.js";
+export { type AddressLookupResult, lookup };

package/cloud/fs/promises.d.ts

@@ -0,0 +1,9 @@
+import { a as WriteData, i as Stats, n as MakeOptions, o as WriteOptions, r as ReadOptions } from "../../index-C6ZoDJg8.js";
+//#region src/lib/cloud/fs-promises.d.ts
+declare const readFile: (path: import("node:fs").PathLike, options?: ReadOptions) => Promise<Buffer | string>, writeFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>, unlink: (path: import("node:fs").PathLike) => Promise<void>, rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => Promise<void>, readdir: (path: import("node:fs").PathLike) => Promise<string[]>, mkdir: (_path?: import("node:fs").PathLike, _options?: MakeOptions) => Promise<void>, rm: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+  }) => Promise<void>, rmdir: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+  }) => Promise<void>, stat: (path: import("node:fs").PathLike) => Promise<Stats>, lstat: (path: import("node:fs").PathLike) => Promise<Stats>, access: (path: import("node:fs").PathLike) => Promise<void>;
+//#endregion
+export { access, lstat, mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile };

package/cloud/fs.d.ts

@@ -0,0 +1,3 @@
+import { i as Stats } from "../index-C6ZoDJg8.js";
+import { a as readFile, c as rm, d as writeFile, f as FileEntry, i as promises, l as stat, m as quota, o as readdir, p as StorageQuota, r as mkdir, s as rename, t as available, u as unlink } from "../fs-K7ROdxDx.js";
+export { type FileEntry, type Stats, type StorageQuota, available, mkdir, promises, quota, readFile, readdir, rename, rm, stat, unlink, writeFile };

package/cloud/http.d.ts

@@ -0,0 +1,2 @@
+import { Agent, ClientRequest, ClientRequestArgs, HTTPParser, IncomingMessage, METHODS, ParsedHead, RequestListener, STATUS_CODES, Server, ServerResponse, ServerResponseOptions, _default, createServer, get, globalAgent, request } from "../http.js";
+export { Agent, ClientRequest, ClientRequestArgs, HTTPParser, IncomingMessage, METHODS, ParsedHead, RequestListener, STATUS_CODES, Server, ServerResponse, ServerResponseOptions, _default, _default as default, createServer, get, globalAgent, request };

package/cloud/net.d.ts

@@ -0,0 +1,2 @@
+import { a as createConnection, c as isIP, i as connect, l as isIPv4, n as Socket, o as createServer, r as _default, t as Server, u as isIPv6 } from "../net-5SVFcuzM.js";
+export { Server, Socket, _default, _default as default, connect, createConnection, createServer, isIP, isIPv4, isIPv6 };

package/cloud-B4KIFGwa.cjs

@@ -0,0 +1 @@
+const e=require("./rolldown-runtime-Doa5O59j.cjs"),t=require("./proxy-bPaU3-Cz.cjs"),n=require("./api-DD5v1qP9.cjs"),r=require("./dns.cjs"),i=require("./cloud/fs.cjs"),a=require("./net-CpuAhaQC.cjs"),o=require("./dgram-CE43gJq9.cjs"),s=require("./http.cjs");let c=require("osra");var l=`autoplay; fullscreen; encrypted-media; picture-in-picture; clipboard-read; clipboard-write`,u=2e4,d=65e3,f=3e4,p=5e3,m=new Set([`videoElement`]),h=()=>`https://fkn.app`,g=e=>!e||e===`about:blank`,_=e=>e?``:`incognito-${crypto.randomUUID()}`,v=({target:e,session:t})=>{let n=new URL(`/attach-frame`,h());return e&&n.searchParams.set(`url`,e),t&&n.searchParams.set(`session`,t),n.href},y=(e,t,n)=>{let r,i=new Promise((e,i)=>{r=setTimeout(()=>i(Error(n)),t)});return Promise.race([e,i]).finally(()=>clearTimeout(r))},b=(e,t)=>{let n=()=>{a(),t()},r=e.parentNode,i=new MutationObserver(()=>{(!e.isConnected||e.parentNode!==r)&&(a(),t())}),a=()=>{window.removeEventListener(`pagehide`,n),i.disconnect()};window.addEventListener(`pagehide`,n,{once:!0}),r&&i.observe(r,{childList:!0}),e.isConnected||(a(),t())},x=()=>Object.assign(Error(`cloud.attachFrame: the attached iframe left the document or was reloaded; attach a fresh iframe`),{name:t.v}),S=(e,t)=>{let n=[...e.split(`;`),...t.split(`;`)].map(e=>e.trim()).filter(Boolean);return[...new Set(n)].join(`; `)},C=[300,1200,4e3],w=e=>{let t=()=>{if(!e.isConnected)return;let t=e.style.height,n=e.getBoundingClientRect();n.height&&(e.style.height=`${n.height-1}px`,setTimeout(()=>{e.style.height=t},50))};t();for(let e of C)setTimeout(t,e)},T=e=>{let t=e.getAttribute(`sandbox`);if(t===null)return;let n=new Set(t.toLowerCase().split(/\s+/).filter(Boolean)),r=[`allow-scripts`,`allow-same-origin`].filter(e=>!n.has(e));if(r.length)throw Error(`cloud.attachFrame: the iframe's sandbox attribute must include ${r.join(` and `)} for the render proxy to load`)},E=async({iframe:e,domains:n=[],syncCookies:r=!0,lockdown:i=!1})=>{if(typeof window>`u`)throw Error(`cloud.attachFrame needs a window realm`);if(i)throw Error(`cloud.attachFrame does not support lockdown; use the extension backend for a sealed frame`);if(!e.isConnected)throw Error(`cloud.attachFrame: the iframe must be connected to the document before attaching`);T(e);let a=e.getAttribute(`src`)??``,o=(()=>{if(g(a))return null;try{return new URL(e.src||a,location.href)}catch{throw Error(`cloud.attachFrame: the iframe src is not a valid URL: ${a}`)}})();if(o){let e=new URL(`/attach-frame`,h());if(o.origin===e.origin&&o.pathname===e.pathname)throw Error(`cloud.attachFrame: this iframe is already attached; navigate with the Frame returned by that attach or use a fresh iframe`)}let s=o?.href??``;s&&t.l(s);let C=s,E=_(r),D=new AbortController;if(e.referrerPolicy=`origin`,e.allow=S(l,e.allow),e.src=v({target:s,session:E}),!e.contentWindow)throw Error(`cloud.attachFrame: the iframe window is not available`);try{let n=await y((0,c.expose)({},{key:`fkn-attach-frame`,origin:h(),transport:{receive:window,emit:e.contentWindow},unregisterSignal:D.signal}),u,`cloud.attachFrame: timed out connecting to the render proxy page`);await y(n.ready(),d,`cloud.attachFrame: the render proxy never became ready`),s&&w(e),b(e,()=>D.abort());let r=e.contentWindow,i=()=>{if(!(!D.signal.aborted&&e.isConnected&&e.contentWindow===r))throw D.abort(),x()};return t.s({executeLocator:(e,r,a)=>m.has(r)?Promise.reject(t.y(r,`cloud`)):(i(),n.executeLocator(e,r,a)),ensurePermission:async()=>{},goto:async(t,r={})=>{let a=new URL(t,location.href).href;i();let{timeoutMs:o}=r;await y(n.goto(a,r),(o??f)+p,`cloud.attachFrame: the render proxy did not answer goto; the frame may have been detached or its page reloaded`),C=a,w(e)},url:()=>C})}catch(t){throw D.abort(),e.src=s||`about:blank`,t}},D=async()=>{let e=await n.t.then(e=>e.cloud.quota());return{premium:e.premium,overQuota:e.overQuota,throttled:e.overQuota&&!e.premium,usedBytes:e.usedBytes,limitBytes:e.limitBytes,remainingBytes:e.remaining,bytesPerSecond:e.bytesPerSecond,bitsPerSecond:e.bytesPerSecond*8}},O=e.n({attachFrame:()=>E,available:()=>k,dgram:()=>o.i,dns:()=>r.t,fetch:()=>t.t,fs:()=>i.t,http:()=>s.t,net:()=>a.s,quota:()=>D}),k=()=>n.n;Object.defineProperty(exports,"i",{enumerable:!0,get:function(){return E}}),Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return O}}),Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return D}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return k}});