@fkn/lib 0.1.0 → 0.2.1

package/build/api.d.ts

@@ -1,4 +1,72 @@
-import type { Target } from 'osra';
-export declare const setApiTarget: (messagePort: Target | Promise<Target>) => Promise<void>;
-export declare const apiTargetIsReady: () => Promise<Target>;
-export declare const getApiTargetPort: () => Promise<any>;
+export declare const apiPromise: Promise<{
+    readonly WEBVPN_TCP_SOCKET: ({ remoteAddress: _remoteAddress, remotePort }: {
+        remoteAddress: string;
+        remotePort: number;
+    }) => Promise<{
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        remoteAddress: string;
+        remoteFamily: "IPv4" | "IPv6";
+        remotePort: number;
+        dataReadableStream: ReadableStream<Uint8Array<ArrayBuffer>>;
+        dataWritableStream: WritableStream<Uint8Array<ArrayBuffer>>;
+        end: () => Promise<void>;
+        destroy: () => Promise<void>;
+        destroySoon: () => Promise<void>;
+        resetAndDestroy: () => Promise<void>;
+    }>;
+    readonly WEBVPN_TCP_SOCKET_LISTENER: ({ localAddress: _localAddress, localPort, onConnection }: {
+        localAddress: string;
+        localPort: number;
+        onConnection: (connection: import('@mfkn/web/src/api/webvpn/tcp').TcpSocketResult) => void;
+    }) => Promise<{
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        close: () => Promise<void>;
+    }>;
+    readonly WEBVPN_UDP_SOCKET: ({ type, port, address }: {
+        type: "udp4" | "udp6";
+        port: number;
+        address: string;
+    }) => Promise<{
+        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>;
+    }>;
+    readonly DNS_LOOKUP: (hostname: string, options: {
+        all?: boolean;
+        family: 0 | 4 | 6;
+    }, callback: (err: Error | undefined, addresses: import('@mfkn/web/src/api/dns').AddressLookupResult | import('@mfkn/web/src/api/dns').AddressLookupResult[] | undefined) => void) => Promise<void>;
+    readonly SERVER_PROXY_FETCH: ({ input, init }: {
+        input: import('@mfkn/web/src/api/proxy/server-proxy-fetch').ProxyFetchRequestInfo;
+        init?: import('@mfkn/web/src/api/proxy/server-proxy-fetch').ProxyFetchRequestInit;
+    }) => Promise<{
+        headers: any;
+        body: ReadableStream<Uint8Array<ArrayBufferLike>> | null;
+        type: ResponseType;
+        url: string;
+        ok: boolean;
+        redirected: boolean;
+        status: number;
+        statusText: string;
+    }>;
+}>;

package/build/dom.d.ts

@@ -1,3 +1,2 @@
-export declare const isWorker: boolean;
 export declare const iframe: HTMLIFrameElement;
-export declare const targetWindow: Window | null;
+export declare const targetWindow: Window;

package/build/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const V=require("osra"),v=require("stream"),_=require("events"),p=require("ip-address"),w="https://fkn.app",l=globalThis?.document.querySelector(`iframe[src="${w}/api"]`),c=globalThis.document?.createElement("iframe");!l&&c&&(c.src=`${w}/api`,c.style.display="none",document.body.appendChild(c));const P=l||c,g=P.contentWindow;if(!P.contentWindow)throw new Error("Missing iframe content window");const z=()=>new Promise((r,e)=>{V.expose({},{key:"fkn-api",local:window,remote:g}).then(r).catch(e),setTimeout(()=>{e(new Error("Timeout waiting for api to be exposed"))},50)}),S=()=>z().then(r=>r).catch(r=>{if(r.message==="Timeout waiting for api to be exposed")return S();throw r}),a=S(),C=async(r,e)=>{const t=r,o=e,{body:s,...n}=await(await a).SERVER_PROXY_FETCH({input:t,init:o});return new Response(s,{...n,headers:{...n.headers,...n.headers&&{setCookie:n.headers["set-cookie"]}}})},M=new TextEncoder;new TextDecoder;const h=r=>p.Address4.isValid(r),m=r=>p.Address6.isValid(r),b=r=>h(r)?4:m(r)?6:0,y=(...r)=>{if(typeof r[0]=="string")throw new Error("FKN WebVPN does not support IPC connections");const e=typeof r.at(-1)=="function"?r.at(-1):void 0;return r[0]&&typeof r[0]=="object"?{...r[0],callback:e}:{port:r[0]??0,host:typeof r[1]=="string"?r[1]:"localhost",callback:e}},I=(...r)=>{const e=typeof r.at(-1)=="function"?r.at(-1):void 0,t=r[0]??0,o=typeof r[1]=="string"?r[1]:"localhost";return typeof r[0]=="object"?{...r[0],address:r[0].address??o,port:r[0].port??t,callback:e}:{address:o,port:t,callback:e}},R=(...r)=>{const e=typeof r.at(-1)=="function"?r.at(-1):void 0,t=r[0];if(typeof r[2]=="number"){const o=r[1],s=r[2],n=typeof r[3]=="number"?r[3]:0,i=typeof r[4]=="string"?r[4]:"localhost";return{message:t,offset:o,length:s,port:n,address:i,callback:e}}else{const o=typeof r[1]=="number"?r[1]:0,s=typeof r[2]=="string"?r[2]:"localhost";return{message:t,offset:0,length:t.length,port:o,address:s,callback:e}}};class d extends v.Stream.Duplex{_localAddress;_remoteAddress;_webVPNTcpSocketPromise;constructor(e){if(e?.fd!==void 0)throw new 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(t=>{const o=t.dataReadableStream.getReader(),s=t.dataWritableStream.getWriter();return this._localAddress={address:t.localAddress,family:t.localFamily,port:t.localPort},this._remoteAddress={address:t.remoteAddress,family:t.remoteFamily,port:t.remotePort},{...t,reader:o,writer:s}}).catch(t=>{this.emit("error",t)}),!this._webVPNTcpSocketPromise)throw new Error("Socket not connected");return this._webVPNTcpSocketPromise.then(t=>{!t||this.emit("connect")}),this._webVPNTcpSocketPromise}_read(e){if(!this._webVPNTcpSocketPromise)throw new Error("Socket not connected");this._webVPNTcpSocketPromise.then(t=>{if(!t)throw new Error("Socket not connected");t.reader.read().then(({value:o,done:s})=>{if(s){this.push(null);return}this.push(o)}).catch(o=>{this.emit("error",o),this.destroy(o)})})}_write(e,t,o){if(!this._webVPNTcpSocketPromise)throw new Error("Socket not connected");this._webVPNTcpSocketPromise.then(s=>{if(!s)throw new Error("Socket not connected");s.writer.write(e),o&&o()})}connect(...e){const t=y(...e),o=this.__webvpn_tcp_socket_init__(a.then(s=>s.WEBVPN_TCP_SOCKET({remoteAddress:t.host,remotePort:t.port})));return t.callback&&o.then(s=>{!s||t.callback()}),this}_end(...e){return this._webVPNTcpSocketPromise?(e.length!==0&&this.write(e[0],e[1],e[2]),this._webVPNTcpSocketPromise.then(async t=>{!t||await t.end()}),this):this}_destroy(e){return this._webVPNTcpSocketPromise?(this._webVPNTcpSocketPromise.then(async t=>{!t||await t.destroy()}),this):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):this}setTimeout(e,t){return this}setNoDelay(e){return this}setKeepAlive(e,t){return this}write(e,t,...o){return super.write(e,t,...o)}address(){return this._localAddress??{}}unref(){return this}ref(){return this}autoSelectFamilyAttemptedAddresses;bufferSize;bytesRead;bytesWritten;connecting;pending;get localAddress(){if(!this._localAddress)throw new Error("Socket is not connected");return this._localAddress.address}get localPort(){if(!this._localAddress)throw new Error("Socket is not connected");return this._localAddress.port}get localFamily(){if(!this._localAddress)throw new Error("Socket is not connected");return this._localAddress.family}readyState;get remoteAddress(){if(!this._remoteAddress)throw new Error("Socket is not connected");return this._remoteAddress.address}get remotePort(){if(!this._remoteAddress)throw new Error("Socket is not connected");return this._remoteAddress.port}get remoteFamily(){if(!this._remoteAddress)throw new Error("Socket is not connected");return this._remoteAddress.family}timeout}class u extends _.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(t=>(this._localAddress={address:t.localAddress,family:t.localFamily,port:t.localPort},t)).catch(t=>{this.emit("error",t)}),this._webVPNTcpSocketListenerPromise.then(t=>{!t||this.emit("listening")}),this._webVPNTcpSocketListenerPromise}listen(...e){const t=y(...e),o=this.__webvpn_tcp_socket_listener_init__(a.then(s=>s.WEBVPN_TCP_SOCKET_LISTENER({localAddress:t.host,localPort:t.port,onConnection:n=>{const i=new d({connection:Promise.resolve(n)});this.emit("connection",i)}})));return t.callback&&o.then(s=>{!s||t.callback()}),this}close(e){return this._webVPNTcpSocketListenerPromise?(this._webVPNTcpSocketListenerPromise.then(t=>{!t||(t.close(),this.emit("close"),this._localAddress=void 0,e&&e())}),this):this}address(){return this._localAddress??null}getConnections(e){throw new Error("Method not implemented.")}ref(){throw new Error("Method not implemented.")}unref(){throw new Error("Method not implemented.")}maxConnections;connections;listening;async[Symbol.asyncDispose](){}}const k=(r,e)=>new d().connect(r,e),A=(r,e)=>new d().connect(r,e),E=(r,e)=>{const t=new u(r);return e&&t.on("connection",e),t},f={Socket:d,Server:u,connect:k,createConnection:A,createServer:E,isIP:b,isIPv4:h,isIPv6:m},D=Object.freeze(Object.defineProperty({__proto__:null,Socket:d,Server:u,connect:k,createConnection:A,createServer:E,isIP:b,isIPv4:h,isIPv6:m,_default:f,default:f},Symbol.toStringTag,{value:"Module"}));class N extends _.EventEmitter{_type;_localAddress;_remoteAddress;_webVPNUdpSocketPromise;constructor(e){if(super(e),!e)throw new Error("Missing options");this._type=e.type}addMembership(e,t){}address(){if(!this._localAddress)throw new Error("EBADF");return this._localAddress}bind(...e){const t=I(...e);return this._webVPNUdpSocketPromise=a.then(o=>o.WEBVPN_UDP_SOCKET({type:this._type,address:t.address,port:t.port})).then(o=>{const s=o.dataReadableStream.getReader(),n=async()=>{const{value:i,done:T}=await s.read();T||(this.emit("message",{data:i.data,rinfo:{address:i.address,family:i.family,port:i.port,size:i.size}}),n())};return n(),this._localAddress={address:o.localAddress,family:o.localFamily,port:o.localPort},o}).catch(o=>{this.emit("error",o)}),this._webVPNUdpSocketPromise.then(o=>{!o||this.emit("listening")}),t.callback&&this._webVPNUdpSocketPromise.then(o=>{!o||t.callback()}),this}close(e){if(!this._webVPNUdpSocketPromise)throw new Error("Socket not bound");return this._webVPNUdpSocketPromise.then(async t=>{if(!t)throw new Error("Socket not bound");await t.close(),e&&e(),this.emit("close")}),this}connect(...e){if(!this._webVPNUdpSocketPromise)throw new Error("Socket not bound");this._webVPNUdpSocketPromise.then(async t=>{if(!t)throw new Error("Socket not bound");const o=e[0],s=typeof e[1]=="string"?e[1]:"localhost",n=typeof e.at(-1)=="function"?e.at(-1):void 0;await t.connect({remotePort:o,remoteAddress:s}),n&&n()})}disconnect(){if(!this._webVPNUdpSocketPromise)throw new Error("Socket not bound");this._webVPNUdpSocketPromise.then(async e=>{if(!e)throw new Error("Socket not bound");await e.connect({remotePort:0,remoteAddress:this._type==="udp4"?"0.0.0.0":"::"})})}dropMembership(e,t){}getRecvBufferSize(){return 0}getSendBufferSize(){return 0}getSendQueueSize(){return 0}getSendQueueCount(){return 0}ref(){return this}remoteAddress(){if(!this._remoteAddress)throw new Error("ERR_SOCKET_DGRAM_NOT_CONNECTED");return{address:this._remoteAddress.address,family:this._remoteAddress.family,port:this._remoteAddress.port}}send(...e){this._webVPNUdpSocketPromise||this.bind();const t=R(...e);if(!this._webVPNUdpSocketPromise)throw new Error("Socket not bound");this._webVPNUdpSocketPromise.then(o=>{if(!o)throw new Error("Socket not bound");const s=typeof t.message=="string"?M.encode(t.message):t.message;o.send({...t,message:s.buffer})})}setBroadcast(e){}setMulticastInterface(e){}setMulticastLoopback(e){return!0}setMulticastTTL(e){return e}setRecvBufferSize(e){}setSendBufferSize(e){}setTTL(e){return e}unref(){return this}addSourceSpecificMembership(e,t,o){}dropSourceSpecificMembership(e,t,o){}async[Symbol.asyncDispose](){await new Promise(e=>{this.close(e)})}}const U=(r,e)=>{const t=new N(typeof r=="string"?{type:r}:r);return e&&t.on("message",e),t},x=Object.freeze(Object.defineProperty({__proto__:null,Socket:N,createSocket:U},Symbol.toStringTag,{value:"Module"}));exports.dgram=x;exports.net=D;exports.serverProxyFetch=C;

package/build/index.d.ts

@@ -1,3 +1,3 @@
 export { serverProxyFetch } from './proxy';
-export { WebVPNWebTransport } from './webvpn';
-export { setApiTarget, apiTargetIsReady as getApiTarget, getApiTargetPort } from './api';
+export * as net from './webvpn/net';
+export * as dgram from './webvpn/dgram';

package/build/index.js

@@ -1,127 +1,480 @@
-import { call as g } from "osra";
-let c, i;
-const d = () => (i = new Promise((t, e) => {
-  c = t;
-}), i), p = d(), m = async (t) => {
-  t === p && d(), c(await t);
-}, h = "https://fkn.app", f = globalThis.window === void 0, o = globalThis?.document.querySelector(`iframe[src="${h}/sandbox-api"]`), n = globalThis.document?.createElement("iframe");
-!o && n && (n.src = `${h}/sandbox-api`, n.style.display = "none", document.body.appendChild(n));
-const w = o || n, l = w?.contentWindow, b = (t) => m(t), u = () => i, x = async () => g(await u(), { key: "fkn-sandbox-api" })("API_PORT", {});
-if (f) {
-  let t = !1;
-  i.then(() => {
-    t = !0;
-  }), setTimeout(() => {
-    t || console.warn("@fkn/lib's api target has not resolved after 250ms while in a worker, make sure to call `setApiTarget(messagePort)`");
-  }, 250);
-} else {
-  if (!w)
-    throw new Error("Missing appended iframe");
-  const t = setInterval(
-    () => g(l, { key: "fkn-sandbox" })("APP_READY", {}).then(() => {
-      m(l), clearInterval(t);
-    }).catch(() => {
-      console.warn("Failed to connect to sandbox, trying again in 10ms");
-    }),
-    10
-  );
-}
-const _ = (t, e) => u().then(
-  (a) => g(a, { key: "fkn-sandbox-api" })(t, e)
-), y = async (t, e) => {
-  const a = t, s = e, { body: I, ...r } = await _("SERVER_PROXY_FETCH", { input: a, init: s });
+import { expose as T } from "osra";
+import { Stream as V } from "stream";
+import { EventEmitter as p } from "events";
+import { Address4 as g, Address6 as v } from "ip-address";
+const _ = "https://fkn.app", l = globalThis?.document.querySelector(`iframe[src="${_}/api"]`), c = globalThis.document?.createElement("iframe");
+!l && c && (c.src = `${_}/api`, c.style.display = "none", document.body.appendChild(c));
+const w = l || c, z = w.contentWindow;
+if (!w.contentWindow)
+  throw new Error("Missing iframe content window");
+const C = () => new Promise((r, e) => {
+  T({}, { key: "fkn-api", local: window, remote: z }).then(r).catch(e), setTimeout(() => {
+    e(new Error("Timeout waiting for api to be exposed"));
+  }, 50);
+}), P = () => C().then((r) => r).catch((r) => {
+  if (r.message === "Timeout waiting for api to be exposed")
+    return P();
+  throw r;
+}), a = P(), W = async (r, e) => {
+  const t = r, o = e, { body: s, ...n } = await (await a).SERVER_PROXY_FETCH({ input: t, init: o });
   return new Response(
-    I,
+    s,
     {
-      ...r,
+      ...n,
       headers: {
-        ...r.headers,
-        ...r.headers && {
-          setCookie: r.headers["set-cookie"]
+        ...n.headers,
+        ...n.headers && {
+          setCookie: n.headers["set-cookie"]
         }
       }
     }
   );
+}, I = new TextEncoder();
+new TextDecoder();
+const h = (r) => g.isValid(r), m = (r) => v.isValid(r), S = (r) => h(r) ? 4 : m(r) ? 6 : 0, b = (...r) => {
+  if (typeof r[0] == "string")
+    throw new Error("FKN WebVPN does not support IPC connections");
+  const e = typeof r.at(-1) == "function" ? r.at(-1) : void 0;
+  return r[0] && typeof r[0] == "object" ? {
+    ...r[0],
+    callback: e
+  } : {
+    port: r[0] ?? 0,
+    host: typeof r[1] == "string" ? r[1] : "localhost",
+    callback: e
+  };
+}, R = (...r) => {
+  const e = typeof r.at(-1) == "function" ? r.at(-1) : void 0, t = r[0] ?? 0, o = typeof r[1] == "string" ? r[1] : "localhost";
+  return typeof r[0] == "object" ? {
+    ...r[0],
+    address: r[0].address ?? o,
+    port: r[0].port ?? t,
+    callback: e
+  } : {
+    address: o,
+    port: t,
+    callback: e
+  };
+}, D = (...r) => {
+  const e = typeof r.at(-1) == "function" ? r.at(-1) : void 0, t = r[0];
+  if (typeof r[2] == "number") {
+    const o = r[1], s = r[2], n = typeof r[3] == "number" ? r[3] : 0, i = typeof r[4] == "string" ? r[4] : "localhost";
+    return {
+      message: t,
+      offset: o,
+      length: s,
+      port: n,
+      address: i,
+      callback: e
+    };
+  } else {
+    const o = typeof r[1] == "number" ? r[1] : 0, s = typeof r[2] == "string" ? r[2] : "localhost";
+    return {
+      message: t,
+      offset: 0,
+      length: t.length,
+      port: o,
+      address: s,
+      callback: e
+    };
+  }
 };
-class M {
-  _internals;
-  _awaitedInternals;
-  closed;
-  constructor() {
-    this.closed = new Promise((e) => {
-      this._internals = _(
-        "WEBVPN_WEBTRANSPORT",
-        {
-          close: ({ closeCode: a, reason: s }) => e({ closeCode: a, reason: s })
+class d extends V.Duplex {
+  _localAddress;
+  _remoteAddress;
+  _webVPNTcpSocketPromise;
+  constructor(e) {
+    if (e?.fd !== void 0)
+      throw new 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((t) => {
+      const o = t.dataReadableStream.getReader(), s = t.dataWritableStream.getWriter();
+      return this._localAddress = {
+        address: t.localAddress,
+        family: t.localFamily,
+        port: t.localPort
+      }, this._remoteAddress = {
+        address: t.remoteAddress,
+        family: t.remoteFamily,
+        port: t.remotePort
+      }, {
+        ...t,
+        reader: o,
+        writer: s
+      };
+    }).catch((t) => {
+      this.emit("error", t);
+    }), !this._webVPNTcpSocketPromise)
+      throw new Error("Socket not connected");
+    return this._webVPNTcpSocketPromise.then((t) => {
+      !t || this.emit("connect");
+    }), this._webVPNTcpSocketPromise;
+  }
+  _read(e) {
+    if (!this._webVPNTcpSocketPromise)
+      throw new Error("Socket not connected");
+    this._webVPNTcpSocketPromise.then((t) => {
+      if (!t)
+        throw new Error("Socket not connected");
+      t.reader.read().then(({ value: o, done: s }) => {
+        if (s) {
+          this.push(null);
+          return;
         }
-      ), this._internals.then((a) => {
-        this._awaitedInternals = a;
+        this.push(o);
+      }).catch((o) => {
+        this.emit("error", o), this.destroy(o);
       });
     });
   }
+  _write(e, t, o) {
+    if (!this._webVPNTcpSocketPromise)
+      throw new Error("Socket not connected");
+    this._webVPNTcpSocketPromise.then((s) => {
+      if (!s)
+        throw new Error("Socket not connected");
+      s.writer.write(e), o && o();
+    });
+  }
+  connect(...e) {
+    const t = b(...e), o = this.__webvpn_tcp_socket_init__(
+      a.then(
+        (s) => s.WEBVPN_TCP_SOCKET({
+          remoteAddress: t.host,
+          remotePort: t.port
+        })
+      )
+    );
+    return t.callback && o.then((s) => {
+      !s || t.callback();
+    }), this;
+  }
+  _end(...e) {
+    return this._webVPNTcpSocketPromise ? (e.length !== 0 && this.write(e[0], e[1], e[2]), this._webVPNTcpSocketPromise.then(async (t) => {
+      !t || await t.end();
+    }), this) : this;
+  }
+  _destroy(e) {
+    return this._webVPNTcpSocketPromise ? (this._webVPNTcpSocketPromise.then(async (t) => {
+      !t || await t.destroy();
+    }), this) : 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) : this;
+  }
+  setTimeout(e, t) {
+    return this;
+  }
+  setNoDelay(e) {
+    return this;
+  }
+  setKeepAlive(e, t) {
+    return this;
+  }
+  write(e, t, ...o) {
+    return super.write(e, t, ...o);
+  }
+  address() {
+    return this._localAddress ?? {};
+  }
+  unref() {
+    return this;
+  }
+  ref() {
+    return this;
+  }
+  autoSelectFamilyAttemptedAddresses;
+  bufferSize;
+  bytesRead;
+  bytesWritten;
+  connecting;
+  pending;
+  get localAddress() {
+    if (!this._localAddress)
+      throw new Error("Socket is not connected");
+    return this._localAddress.address;
+  }
+  get localPort() {
+    if (!this._localAddress)
+      throw new Error("Socket is not connected");
+    return this._localAddress.port;
+  }
+  get localFamily() {
+    if (!this._localAddress)
+      throw new Error("Socket is not connected");
+    return this._localAddress.family;
+  }
+  readyState;
+  get remoteAddress() {
+    if (!this._remoteAddress)
+      throw new Error("Socket is not connected");
+    return this._remoteAddress.address;
+  }
+  get remotePort() {
+    if (!this._remoteAddress)
+      throw new Error("Socket is not connected");
+    return this._remoteAddress.port;
+  }
+  get remoteFamily() {
+    if (!this._remoteAddress)
+      throw new Error("Socket is not connected");
+    return this._remoteAddress.family;
+  }
+  timeout;
+}
+class u extends p {
+  _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((t) => (this._localAddress = {
+      address: t.localAddress,
+      family: t.localFamily,
+      port: t.localPort
+    }, t)).catch((t) => {
+      this.emit("error", t);
+    }), this._webVPNTcpSocketListenerPromise.then((t) => {
+      !t || this.emit("listening");
+    }), this._webVPNTcpSocketListenerPromise;
+  }
+  listen(...e) {
+    const t = b(...e), o = this.__webvpn_tcp_socket_listener_init__(
+      a.then(
+        (s) => s.WEBVPN_TCP_SOCKET_LISTENER({
+          localAddress: t.host,
+          localPort: t.port,
+          onConnection: (n) => {
+            const i = new d({ connection: Promise.resolve(n) });
+            this.emit("connection", i);
+          }
+        })
+      )
+    );
+    return t.callback && o.then((s) => {
+      !s || t.callback();
+    }), this;
+  }
   close(e) {
-    this._internals.then(({ close: a }) => a(e ?? {}));
+    return this._webVPNTcpSocketListenerPromise ? (this._webVPNTcpSocketListenerPromise.then((t) => {
+      !t || (t.close(), this.emit("close"), this._localAddress = void 0, e && e());
+    }), this) : this;
   }
-  get ready() {
-    return this._internals.then(() => {
+  address() {
+    return this._localAddress ?? null;
+  }
+  getConnections(e) {
+    throw new Error("Method not implemented.");
+  }
+  ref() {
+    throw new Error("Method not implemented.");
+  }
+  unref() {
+    throw new Error("Method not implemented.");
+  }
+  maxConnections;
+  connections;
+  listening;
+  async [Symbol.asyncDispose]() {
+  }
+}
+const y = (r, e) => new d().connect(r, e), k = (r, e) => new d().connect(r, e), A = (r, e) => {
+  const t = new u(r);
+  return e && t.on("connection", e), t;
+}, f = {
+  Socket: d,
+  Server: u,
+  connect: y,
+  createConnection: k,
+  createServer: A,
+  isIP: S,
+  isIPv4: h,
+  isIPv6: m
+}, B = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Socket: d,
+  Server: u,
+  connect: y,
+  createConnection: k,
+  createServer: A,
+  isIP: S,
+  isIPv4: h,
+  isIPv6: m,
+  _default: f,
+  default: f
+}, Symbol.toStringTag, { value: "Module" }));
+class E extends p {
+  _type;
+  _localAddress;
+  _remoteAddress;
+  _webVPNUdpSocketPromise;
+  constructor(e) {
+    if (super(e), !e)
+      throw new Error("Missing options");
+    this._type = e.type;
+  }
+  addMembership(e, t) {
+  }
+  address() {
+    if (!this._localAddress)
+      throw new Error("EBADF");
+    return this._localAddress;
+  }
+  bind(...e) {
+    const t = R(...e);
+    return this._webVPNUdpSocketPromise = a.then(
+      (o) => o.WEBVPN_UDP_SOCKET({
+        type: this._type,
+        address: t.address,
+        port: t.port
+      })
+    ).then((o) => {
+      const s = o.dataReadableStream.getReader(), n = async () => {
+        const { value: i, done: N } = await s.read();
+        N || (this.emit("message", {
+          data: i.data,
+          rinfo: {
+            address: i.address,
+            family: i.family,
+            port: i.port,
+            size: i.size
+          }
+        }), n());
+      };
+      return n(), this._localAddress = {
+        address: o.localAddress,
+        family: o.localFamily,
+        port: o.localPort
+      }, o;
+    }).catch((o) => {
+      this.emit("error", o);
+    }), this._webVPNUdpSocketPromise.then((o) => {
+      !o || this.emit("listening");
+    }), t.callback && this._webVPNUdpSocketPromise.then((o) => {
+      !o || t.callback();
+    }), this;
+  }
+  close(e) {
+    if (!this._webVPNUdpSocketPromise)
+      throw new Error("Socket not bound");
+    return this._webVPNUdpSocketPromise.then(async (t) => {
+      if (!t)
+        throw new Error("Socket not bound");
+      await t.close(), e && e(), this.emit("close");
+    }), this;
+  }
+  connect(...e) {
+    if (!this._webVPNUdpSocketPromise)
+      throw new Error("Socket not bound");
+    this._webVPNUdpSocketPromise.then(async (t) => {
+      if (!t)
+        throw new Error("Socket not bound");
+      const o = e[0], s = typeof e[1] == "string" ? e[1] : "localhost", n = typeof e.at(-1) == "function" ? e.at(-1) : void 0;
+      await t.connect({ remotePort: o, remoteAddress: s }), n && n();
+    });
+  }
+  disconnect() {
+    if (!this._webVPNUdpSocketPromise)
+      throw new Error("Socket not bound");
+    this._webVPNUdpSocketPromise.then(async (e) => {
+      if (!e)
+        throw new Error("Socket not bound");
+      await e.connect({ remotePort: 0, remoteAddress: this._type === "udp4" ? "0.0.0.0" : "::" });
     });
   }
-  get incomingBidirectionalStreams() {
-    return this._awaitedInternals.incomingBidirectionalStreams;
+  dropMembership(e, t) {
+  }
+  getRecvBufferSize() {
+    return 0;
   }
-  get incomingUnidirectionalStreams() {
-    return this._awaitedInternals.incomingUnidirectionalStreams;
+  getSendBufferSize() {
+    return 0;
   }
-  async createBidirectionalStream() {
-    const { readable: e, writable: a } = await this._awaitedInternals.createBidirectionalStream();
-    return { readable: e, writable: a };
+  getSendQueueSize() {
+    return 0;
   }
-  createUnidirectionalStream() {
-    return this._awaitedInternals.createUnidirectionalStream();
+  getSendQueueCount() {
+    return 0;
   }
-  get datagrams() {
-    const e = this;
+  ref() {
+    return this;
+  }
+  remoteAddress() {
+    if (!this._remoteAddress)
+      throw new Error("ERR_SOCKET_DGRAM_NOT_CONNECTED");
     return {
-      get incomingHighWaterMark() {
-        return e._awaitedInternals.datagrams.incomingHighWaterMark;
-      },
-      set incomingHighWaterMark(a) {
-        e._awaitedInternals.datagrams.setIncomingHighWaterMark(a);
-      },
-      get incomingMaxAge() {
-        return e._awaitedInternals.datagrams.incomingMaxAge;
-      },
-      set incomingMaxAge(a) {
-        e._awaitedInternals.datagrams.setIncomingMaxAge(a);
-      },
-      get maxDatagramSize() {
-        return e._awaitedInternals.datagrams.maxDatagramSize;
-      },
-      get outgoingHighWaterMark() {
-        return e._awaitedInternals.datagrams.outgoingHighWaterMark;
-      },
-      set outgoingHighWaterMark(a) {
-        e._awaitedInternals.datagrams.setOutgoingHighWaterMark(a);
-      },
-      get outgoingMaxAge() {
-        return e._awaitedInternals.datagrams.outgoingMaxAge;
-      },
-      set outgoingMaxAge(a) {
-        e._awaitedInternals.datagrams.setOutgoingMaxAge(a);
-      },
-      get readable() {
-        return e._awaitedInternals.datagrams.readable;
-      },
-      get writable() {
-        return e._awaitedInternals.datagrams.writable;
-      }
+      address: this._remoteAddress.address,
+      family: this._remoteAddress.family,
+      port: this._remoteAddress.port
     };
   }
+  send(...e) {
+    this._webVPNUdpSocketPromise || this.bind();
+    const t = D(...e);
+    if (!this._webVPNUdpSocketPromise)
+      throw new Error("Socket not bound");
+    this._webVPNUdpSocketPromise.then((o) => {
+      if (!o)
+        throw new Error("Socket not bound");
+      const s = typeof t.message == "string" ? I.encode(t.message) : t.message;
+      o.send({
+        ...t,
+        message: s.buffer
+      });
+    });
+  }
+  setBroadcast(e) {
+  }
+  setMulticastInterface(e) {
+  }
+  setMulticastLoopback(e) {
+    return !0;
+  }
+  setMulticastTTL(e) {
+    return e;
+  }
+  setRecvBufferSize(e) {
+  }
+  setSendBufferSize(e) {
+  }
+  setTTL(e) {
+    return e;
+  }
+  unref() {
+    return this;
+  }
+  addSourceSpecificMembership(e, t, o) {
+  }
+  dropSourceSpecificMembership(e, t, o) {
+  }
+  async [Symbol.asyncDispose]() {
+    await new Promise((e) => {
+      this.close(e);
+    });
+  }
 }
+const M = (r, e) => {
+  const t = new E(
+    typeof r == "string" ? { type: r } : r
+  );
+  return e && t.on("message", e), t;
+}, K = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Socket: E,
+  createSocket: M
+}, Symbol.toStringTag, { value: "Module" }));
 export {
-  M as WebVPNWebTransport,
-  u as getApiTarget,
-  x as getApiTargetPort,
-  y as serverProxyFetch,
-  b as setApiTarget
+  K as dgram,
+  B as net,
+  W as serverProxyFetch
 };

package/build/webvpn/dgram.d.ts

@@ -0,0 +1,64 @@
+import { BindOptions, Socket as DgramSocket, RemoteInfo, SocketOptions, SocketType } from 'dgram';
+import { AddressInfo } from 'net';
+import { ApiResolvers } from '@mfkn/web/src/api/resolvers';
+import { EventEmitter } from 'events';
+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<ApiResolvers['WEBVPN_UDP_SOCKET']>> | undefined>;
+    constructor(options: SocketOptions & EventEmitterOptions & {
+        connection?: ReturnType<ApiResolvers['WEBVPN_UDP_SOCKET']>;
+    });
+    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;
+export {};

package/build/webvpn/index.d.ts

@@ -1,52 +1 @@
-type WebVPNWebTransportResponse = {
-    ready: undefined;
-    close: ({ closeCode, reason }: {
-        closeCode?: number;
-        reason?: string;
-    }) => void;
-    incomingBidirectionalStreams: ReadableStream<any>;
-    incomingUnidirectionalStreams: ReadableStream<any>;
-    createBidirectionalStream: () => Promise<{
-        readable: ReadableStream<any>;
-        writable: WritableStream<any>;
-    }>;
-    createUnidirectionalStream: () => Promise<WritableStream<any>>;
-    datagrams: {
-        incomingHighWaterMark: number;
-        setIncomingHighWaterMark: (value: number) => void;
-        incomingMaxAge: number;
-        setIncomingMaxAge: (value: number) => void;
-        maxDatagramSize: number;
-        outgoingHighWaterMark: number;
-        setOutgoingHighWaterMark: (value: number) => void;
-        outgoingMaxAge: number;
-        setOutgoingMaxAge: (value: number) => void;
-        readable: ReadableStream<any>;
-        writable: WritableStream<any>;
-    };
-};
-export declare class WebVPNWebTransport implements WebTransport {
-    _internals: Promise<WebVPNWebTransportResponse>;
-    _awaitedInternals: WebVPNWebTransportResponse;
-    closed: Promise<WebTransportCloseInfo>;
-    constructor();
-    close(closeInfo?: WebTransportCloseInfo): void;
-    get ready(): Promise<undefined>;
-    get incomingBidirectionalStreams(): ReadableStream<any>;
-    get incomingUnidirectionalStreams(): ReadableStream<any>;
-    createBidirectionalStream(): Promise<{
-        readable: ReadableStream<any>;
-        writable: WritableStream<any>;
-    }>;
-    createUnidirectionalStream(): Promise<WritableStream<any>>;
-    get datagrams(): {
-        incomingHighWaterMark: number;
-        incomingMaxAge: number;
-        readonly maxDatagramSize: number;
-        outgoingHighWaterMark: number;
-        outgoingMaxAge: number;
-        readonly readable: ReadableStream<any>;
-        readonly writable: WritableStream<any>;
-    };
-}
-export {};
+export * from './utils';

package/build/webvpn/net.d.ts

@@ -0,0 +1,134 @@
+import { Socket as NetSocket, SocketConnectOpts, SocketConstructorOpts, Server as TCPServer, ServerOpts, ListenOptions, AddressInfo } from 'net';
+import { ApiResolvers } from '@mfkn/web/src/api/resolvers';
+import { DuplexOptions, Stream } from 'stream';
+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<ApiResolvers['WEBVPN_TCP_SOCKET']>> & {
+        reader: ReadableStreamDefaultReader<Uint8Array>;
+        writer: WritableStreamDefaultWriter<Uint8Array>;
+    }) | undefined>;
+    constructor(options?: SocketConstructorOpts & DuplexOptions & {
+        connection?: ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET']>;
+    });
+    __webvpn_tcp_socket_init__(connection: ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET']>): Promise<({
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        remoteAddress: string;
+        remoteFamily: "IPv4" | "IPv6";
+        remotePort: number;
+        dataReadableStream: ReadableStream<Uint8Array<ArrayBuffer>>;
+        dataWritableStream: WritableStream<Uint8Array<ArrayBuffer>>;
+        end: () => Promise<void>;
+        destroy: () => Promise<void>;
+        destroySoon: () => Promise<void>;
+        resetAndDestroy: () => Promise<void>;
+    } & {
+        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;
+    setTimeout(timeout: number, callback?: (() => void) | undefined): this;
+    setNoDelay(noDelay?: boolean | undefined): this;
+    setKeepAlive(enable?: boolean | undefined, initialDelay?: number | undefined): this;
+    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: SocketReadyState;
+    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<ApiResolvers['WEBVPN_TCP_SOCKET_LISTENER']>> | undefined>;
+    constructor(options?: ServerOpts & EventEmitterOptions & {
+        connection?: ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET_LISTENER']>;
+    }, connectionListener?: (socket: Socket) => void);
+    __webvpn_tcp_socket_listener_init__(connection: ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET_LISTENER']>): 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): void;
+    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, connectionListener?: (socket: Socket) => void) => Server;
+export { isIP, isIPv4, isIPv6 };
+export declare const _default: {
+    Socket: typeof Socket;
+    Server: typeof Server;
+    connect: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
+    createConnection: (options: SocketConnectOpts, connectionListener?: () => void) => Socket;
+    createServer: (options: ServerOpts, connectionListener?: (socket: Socket) => void) => Server;
+    isIP: (input: string) => 0 | 4 | 6;
+    isIPv4: (input: string) => boolean;
+    isIPv6: (input: string) => boolean;
+};
+export default _default;

package/build/webvpn/utils.d.ts

@@ -0,0 +1,32 @@
+import { 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) => ((T[0] extends object ? T[0] : never) & {
+    callback: (() => void) | undefined;
+}) | {
+    port: number;
+    host: string;
+    callback: (() => void) | undefined;
+};
+export declare const normalizeDgramBindArgs: (...args: [port?: number, address?: string, callback?: () => void] | [port?: number, callback?: () => void] | [callback?: () => void] | [options: BindOptions, callback?: () => void]) => {
+    address: string;
+    port: number;
+    callback: (() => void) | undefined;
+    exclusive?: boolean | undefined;
+    fd?: number | 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;
+    callback: (() => void) | undefined;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fkn/lib",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "type": "module",
@@ -10,21 +10,28 @@
   "devDependencies": {
     "@mfkn/web": "file:../web",
     "@mfkn/web-extension": "git+https://github.com/MFKN/web-extension.git",
+    "@rollup/plugin-inject": "^5.0.5",
+    "@types/node": "^22.7.5",
     "concurrently": "^7.6.0",
+    "node-stdlib-browser": "^1.2.1",
     "parse-torrent-file": "^4.2.2",
-    "typescript": "^5.5.4",
+    "typescript": "^5.7.2",
     "vite": "^3.2.5",
+    "vite-plugin-dts": "^4.2.3",
     "webextension-polyfill": "^0.10.0"
   },
   "scripts": {
     "dev": "concurrently \"vite build --watch --mode development\" \"tsc --watch\"",
-    "build": "vite build && tsc",
-    "build-watch": "vite build --watch --mode production && tsc",
-    "build-dev": "vite build --mode development && tsc",
+    "build": "vite build",
+    "build-watch": "vite build --watch --mode production",
+    "build-dev": "vite build --mode development",
     "dev-watch": "vite build --watch --mode development",
-    "build-types": "tsc"
+    "build-types": "tsc",
+    "dev-web": "vite --port 4560 --host 0.0.0.0"
   },
   "dependencies": {
-    "osra": "^0.0.9"
+    "events": "^3.3.0",
+    "ip-address": "^10.0.1",
+    "osra": "^0.1.2"
   }
 }

package/build/plugin/index.d.ts

@@ -1 +0,0 @@
-export declare const showPluginBrowser: () => Promise<any>;

package/build/target.d.ts

@@ -1,6 +0,0 @@
-import { Target } from 'osra';
-export declare let _resolve: any, _reject: any;
-export declare let target: Promise<Target>;
-export declare const initTargetPromise: () => Promise<Target>;
-export declare const initialTargetPromise: Promise<Target>;
-export declare const setTarget: (newTarget: Target | Promise<Target>) => Promise<void>;

package/build/utils/call.d.ts

@@ -1,3 +0,0 @@
-import type { SandboxApiResolvers } from '@mfkn/fkn-web/src/api/resolvers';
-declare const readyCall: <T2 extends SandboxApiResolvers, T3 extends keyof T2>(type: T3, data?: Parameters<T2[T3]>[0] | undefined) => Promise<any>;
-export { readyCall as call, };

package/build/utils/index.d.ts

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