fullstacked 1.0.0-alpha.1783 → 1.0.0-alpha.1789

package/index.js

@@ -6541,8 +6541,9 @@ async function BridgeNodeInit() {
   webSocketUrl.protocol = webSocketUrl.protocol === "https:" ? "wss:" : "ws:";
   const ctx = await (await fetch("/ctx")).json();
   let ws;
+  const NativeWebSocket = globalThis.fullstacked?.WebSocket || WebSocket;
   const webSocketForCallback = new Promise((res) => {
-    ws = new WebSocket(webSocketUrl);
+    ws = new NativeWebSocket(webSocketUrl);
     ws.binaryType = "arraybuffer";
     ws.onmessage = (e) => {
       globalThis.fullstacked.onStreamData(
@@ -6905,7 +6906,9 @@ async function BridgeLinuxInit() {
       }
     };
     globalThis.fullstacked.window = globalThis.fullstacked.window || {};
-    globalThis.fullstacked.window.getSize = () => (globalThis.fullstacked.fetch || fetch)("/resize").then((r) => r.text());
+    globalThis.fullstacked.window.getSize = () => (globalThis.fullstacked.fetch || fetch)("/resize").then(
+      (r) => r.text()
+    );
     globalThis.fullstacked.window.resize = function(size) {
       (globalThis.fullstacked.fetch || fetch)(`/resize?size=${size}`);
     };
@@ -7053,6 +7056,7 @@ var Fetch = 8;
 var Bundle = 9;
 var Packages = 12;
 var Plugin = 14;
+var WebSocket2 = 15;
 var CoreResponseError = 0;
 var CoreResponseData = 1;
 var CoreResponseStream = 2;
@@ -7820,6 +7824,237 @@ async function fetchCore(request, init2) {
 }
 var fetch_default = fetchCore;
 
+// ../../core/internal/bundle/lib/@types/websocket.ts
+var Connect = 0;
+
+// ../../core/internal/bundle/lib/websocket/index.ts
+var GlobalCloseEvent = typeof CloseEvent !== "undefined" ? CloseEvent : class CloseEvent2 extends Event {
+  code;
+  reason;
+  wasClean;
+  constructor(type2, eventInitDict) {
+    super(type2, eventInitDict);
+    this.code = eventInitDict?.code ?? 0;
+    this.reason = eventInitDict?.reason ?? "";
+    this.wasClean = eventInitDict?.wasClean ?? false;
+  }
+};
+var WebSocketCore = class _WebSocketCore extends EventTarget {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSING = 2;
+  CLOSED = 3;
+  url;
+  readyState = _WebSocketCore.CONNECTING;
+  bufferedAmount = 0;
+  protocol = "";
+  extensions = "";
+  binaryType = "blob";
+  onopen = null;
+  onerror = null;
+  onclose = null;
+  onmessage = null;
+  #duplex = null;
+  #ee = null;
+  constructor(url2, protocols) {
+    super();
+    let parsedUrl;
+    try {
+      if (url2 instanceof URL) {
+        parsedUrl = url2;
+      } else if (typeof url2 === "string") {
+        if (url2.startsWith("/") && typeof globalThis.location !== "undefined") {
+          const origin = globalThis.location.origin || globalThis.location.href || "http://localhost";
+          parsedUrl = new URL(url2, origin);
+          if (parsedUrl.protocol === "http:") {
+            parsedUrl.protocol = "ws:";
+          } else if (parsedUrl.protocol === "https:") {
+            parsedUrl.protocol = "wss:";
+          }
+        } else {
+          parsedUrl = new URL(url2);
+        }
+      } else {
+        throw new Error("Invalid URL");
+      }
+    } catch {
+      throw new DOMException(
+        `The URL '${url2}' is invalid.`,
+        "SyntaxError"
+      );
+    }
+    if (parsedUrl.protocol !== "ws:" && parsedUrl.protocol !== "wss:") {
+      throw new DOMException(
+        `The URL's scheme must be either 'ws' or 'wss'. '${parsedUrl.protocol}' is not allowed.`,
+        "SyntaxError"
+      );
+    }
+    this.url = parsedUrl.toString();
+    let parsedProtocols = [];
+    if (typeof protocols === "string") {
+      parsedProtocols = [protocols];
+    } else if (Array.isArray(protocols)) {
+      parsedProtocols = [...protocols];
+    }
+    this.#init(parsedProtocols);
+  }
+  async #init(protocols) {
+    try {
+      this.#duplex = await globalThis.fullstacked.bridge({
+        mod: WebSocket2,
+        fn: Connect,
+        data: [this.url, protocols]
+      });
+      this.#ee = this.#duplex.eventEmitter();
+      this.#ee.on("open", (selectedProtocol) => {
+        if (this.readyState === _WebSocketCore.CONNECTING) {
+          this.readyState = _WebSocketCore.OPEN;
+          this.protocol = selectedProtocol || "";
+          const event = new Event("open");
+          this.dispatchEvent(event);
+          this.onopen?.(event);
+        }
+      });
+      this.#ee.on(
+        "message",
+        (data, isBinary) => {
+          if (this.readyState !== _WebSocketCore.OPEN && this.readyState !== _WebSocketCore.CLOSING) {
+            return;
+          }
+          let messageData = data;
+          if (isBinary && data instanceof Uint8Array) {
+            if (this.binaryType === "arraybuffer") {
+              messageData = data.buffer.slice(
+                data.byteOffset,
+                data.byteOffset + data.byteLength
+              );
+            } else {
+              messageData = typeof Blob !== "undefined" ? new Blob([data]) : data.buffer.slice(
+                data.byteOffset,
+                data.byteOffset + data.byteLength
+              );
+            }
+          }
+          const event = new MessageEvent("message", {
+            data: messageData,
+            origin: this.url
+          });
+          this.dispatchEvent(event);
+          this.onmessage?.(event);
+        }
+      );
+      this.#ee.on("error", (errorMsg) => {
+        const event = new Event("error");
+        event.message = errorMsg;
+        this.dispatchEvent(event);
+        this.onerror?.(event);
+      });
+      this.#ee.on(
+        "close",
+        (code3, reason, wasClean) => {
+          if (this.readyState === _WebSocketCore.CLOSED) return;
+          this.readyState = _WebSocketCore.CLOSED;
+          const event = new GlobalCloseEvent("close", {
+            code: code3 || 1e3,
+            reason: reason || "",
+            wasClean: wasClean ?? code3 === 1e3
+          });
+          this.dispatchEvent(event);
+          this.onclose?.(event);
+        }
+      );
+      this.#duplex.on("close", () => {
+        if (this.readyState !== _WebSocketCore.CLOSED) {
+          this.readyState = _WebSocketCore.CLOSED;
+          const event = new GlobalCloseEvent("close", {
+            code: 1006,
+            reason: "",
+            wasClean: false
+          });
+          this.dispatchEvent(event);
+          this.onclose?.(event);
+        }
+      });
+    } catch (err) {
+      queueMicrotask(() => {
+        this.readyState = _WebSocketCore.CLOSED;
+        const errorEvent = new Event("error");
+        errorEvent.message = err?.message || String(err);
+        this.dispatchEvent(errorEvent);
+        this.onerror?.(errorEvent);
+        const closeEvent = new GlobalCloseEvent("close", {
+          code: 1006,
+          reason: err?.message || String(err),
+          wasClean: false
+        });
+        this.dispatchEvent(closeEvent);
+        this.onclose?.(closeEvent);
+      });
+    }
+  }
+  send(data) {
+    if (this.readyState === _WebSocketCore.CONNECTING) {
+      throw new DOMException(
+        "WebSocket is still in CONNECTING state.",
+        "InvalidStateError"
+      );
+    }
+    if (this.readyState !== _WebSocketCore.OPEN) {
+      return;
+    }
+    if (typeof data === "string") {
+      this.#duplex?.writeEvent("send", data, false);
+    } else if (data instanceof Uint8Array) {
+      this.#duplex?.writeEvent("send", data, true);
+    } else if (data instanceof ArrayBuffer) {
+      this.#duplex?.writeEvent("send", new Uint8Array(data), true);
+    } else if (ArrayBuffer.isView(data)) {
+      this.#duplex?.writeEvent(
+        "send",
+        new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+        true
+      );
+    } else if (typeof Blob !== "undefined" && data instanceof Blob) {
+      data.arrayBuffer().then((buf) => {
+        if (this.readyState === _WebSocketCore.OPEN) {
+          this.#duplex?.writeEvent("send", new Uint8Array(buf), true);
+        }
+      });
+    } else {
+      this.#duplex?.writeEvent("send", String(data), false);
+    }
+  }
+  close(code3, reason) {
+    if (code3 !== void 0) {
+      if (code3 !== 1e3 && (code3 < 3e3 || code3 > 4999)) {
+        throw new DOMException(
+          `The code must be either 1000, or between 3000 and 4999. Received ${code3}`,
+          "InvalidAccessError"
+        );
+      }
+    }
+    if (reason !== void 0) {
+      const byteLength = new TextEncoder().encode(reason).byteLength;
+      if (byteLength > 123) {
+        throw new DOMException(
+          "The reason must not be longer than 123 bytes.",
+          "SyntaxError"
+        );
+      }
+    }
+    if (this.readyState === _WebSocketCore.CLOSING || this.readyState === _WebSocketCore.CLOSED) {
+      return;
+    }
+    this.readyState = _WebSocketCore.CLOSING;
+    this.#duplex?.writeEvent("close", code3 ?? 1e3, reason ?? "");
+  }
+};
+var websocket_default = WebSocketCore;
+
 // ../../core/internal/bundle/lib/@types/fs.ts
 var Exists = 0;
 var Stats = 1;
@@ -7855,7 +8090,7 @@ var Exit = 5;
 init_isWorker();
 
 // ../../core/internal/bundle/lib/process/version.json
-var version_default = { major: "1", minor: "0", patch: "0-alpha", branch: "v1", build: "1783", hash: "58f6546ee36a4629ac9a7e4ffba71d768b42fdbb" };
+var version_default = { major: "1", minor: "0", patch: "0-alpha", branch: "v1", build: "1789", hash: "336ec864b0e31ab815591b388cfb5acd72a40612" };
 
 // ../../core/internal/bundle/lib/timers/index.ts
 var setTimeout2 = globalThis.setTimeout.bind(globalThis);
@@ -7871,12 +8106,12 @@ globalThis.clearImmediate = ((id) => {
 
 // ../../core/internal/bundle/lib/process/index.ts
 var Item = class {
+  fun;
+  array;
   constructor(fun, array) {
     this.fun = fun;
     this.array = array;
   }
-  fun;
-  array;
   run() {
     this.fun.apply(null, this.array);
   }
@@ -8850,8 +9085,14 @@ async function init() {
   globalThis.fullstacked.platformBridge = platformBridge2;
   globalThis.fullstacked.bridge = bridge;
   globalThis.fullstacked.fetch = fetch.bind(globalThis);
+  if (typeof WebSocket !== "undefined") {
+    globalThis.fullstacked.WebSocket = WebSocket;
+  }
   globalThis.fullstacked.onStreamData = duplex_default;
   globalThis.fetch = fetch_default;
+  if (typeof window !== "undefined" || !globalThis.process?.versions?.node) {
+    globalThis.WebSocket = websocket_default;
+  }
   await Promise.all([import("timers"), import("buffer")]);
   if (!globalThis.process) {
     globalThis.process = (await import("process")).default;
@@ -9374,19 +9615,58 @@ async function bundleAndImportFile(file, startDir, writeErr, extraArgs) {
   }
 }
 async function runFile(file, extraArgs, writeOut, writeErr) {
-  const res = await bundleAndImportFile(
-    file,
-    process.cwd(),
-    writeErr,
-    extraArgs
-  );
-  if (!res) return 1;
+  const originalWebSocket = globalThis.WebSocket;
+  const hasOriginalWindow = "window" in globalThis;
+  const hasOriginalBuffer = "Buffer" in globalThis;
+  const originalBuffer = globalThis.Buffer;
+  const hasOriginalFullstacked = "fullstacked" in globalThis;
+  const originalFullstackedWebSocket = globalThis.fullstacked?.WebSocket;
+  if (!globalThis.fullstacked) {
+    globalThis.fullstacked = {};
+  }
+  if (originalWebSocket && !globalThis.fullstacked.WebSocket) {
+    globalThis.fullstacked.WebSocket = originalWebSocket;
+  }
+  globalThis.WebSocket = websocket_default;
+  if (!hasOriginalWindow) {
+    globalThis.window = globalThis;
+  }
   try {
-    await waitForInterfaces();
+    const res = await bundleAndImportFile(
+      file,
+      process.cwd(),
+      writeErr,
+      extraArgs
+    );
+    if (!res) return 1;
+    try {
+      await waitForInterfaces();
+    } finally {
+      await res.cleanup();
+    }
+    return 0;
   } finally {
-    await res.cleanup();
+    if (originalWebSocket) {
+      globalThis.WebSocket = originalWebSocket;
+    } else {
+      delete globalThis.WebSocket;
+    }
+    if (!hasOriginalWindow) {
+      delete globalThis.window;
+    }
+    if (!hasOriginalBuffer) {
+      delete globalThis.Buffer;
+    } else {
+      globalThis.Buffer = originalBuffer;
+    }
+    if (!hasOriginalFullstacked) {
+      delete globalThis.fullstacked;
+    } else if (originalFullstackedWebSocket) {
+      globalThis.fullstacked.WebSocket = originalFullstackedWebSocket;
+    } else {
+      delete globalThis.fullstacked.WebSocket;
+    }
   }
-  return 0;
 }
 async function runDirectory(positionals, pluginsArgs, buildOnly, noOpen, env2, writeOut, writeErr) {
   const targetDirectory = path_default.resolve(positionals.at(-1) || ".");

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "fullstacked",
-    "version": "1.0.0-alpha.1783",
+    "version": "1.0.0-alpha.1789",
     "bin": {
         "fullstacked": "index.js"
     },
     "type": "module",
     "scripts": {
-        "build": "node -r @nitrogql/esbuild-register build",
+        "build": "node build.ts",
         "prepack": "npm run build"
     },
     "dependencies": {
@@ -14,18 +14,17 @@
         "ws": "^8.21.1"
     },
     "devDependencies": {
-        "@nitrogql/esbuild-register": "^1.7.2",
         "@types/ws": "^8.18.1",
         "esbuild": "^0.28.1",
         "node-addon-api": "^8.9.0"
     },
     "optionalDependencies": {
-        "@fullstacked/darwin-arm64": "1.0.0-alpha.1783",
-        "@fullstacked/darwin-x64": "1.0.0-alpha.1783",
-        "@fullstacked/linux-arm64": "1.0.0-alpha.1783",
-        "@fullstacked/linux-x64": "1.0.0-alpha.1783",
-        "@fullstacked/win32-arm64": "1.0.0-alpha.1783",
-        "@fullstacked/win32-x64": "1.0.0-alpha.1783"
+        "@fullstacked/darwin-arm64": "1.0.0-alpha.1789",
+        "@fullstacked/darwin-x64": "1.0.0-alpha.1789",
+        "@fullstacked/linux-arm64": "1.0.0-alpha.1789",
+        "@fullstacked/linux-x64": "1.0.0-alpha.1789",
+        "@fullstacked/win32-arm64": "1.0.0-alpha.1789",
+        "@fullstacked/win32-x64": "1.0.0-alpha.1789"
     },
     "author": "FullStacked",
     "license": "MIT",

package/types/@types/index.d.ts

@@ -14,6 +14,7 @@ export declare const Git: CoreModule;
 export declare const Packages: CoreModule;
 export declare const Dgram: CoreModule;
 export declare const Plugin: CoreModule;
+export declare const WebSocket: CoreModule;
 export type ModuleSwitch = any;
 export type CoreCallResponseType = number;
 export declare const CoreResponseError: CoreCallResponseType;

package/types/@types/packages.d.ts

@@ -53,25 +53,38 @@ export interface PackageMetadata {
 export interface PackageVersion {
     name: string;
     version: string;
-    dependencies: {
+    dependencies?: {
+        [key: string]: string;
+    };
+    devDependencies?: {
         [key: string]: string;
     };
     optionalDependencies?: {
         [key: string]: string;
     };
-    /**
-     * DevDependencies removed as unused in sub-deps logic
-     */
-    dist: PackageDist;
-    license?: any;
-    engines?: any;
     peerDependencies?: {
         [key: string]: string;
     };
+    peerDependenciesMeta?: {
+        [key: string]: {
+            optional?: boolean;
+        };
+    };
     bundleDependencies?: BundleDependenciesWrapper;
     bundledDependencies?: BundleDependenciesWrapper;
+    dist: PackageDist;
+    license?: any;
+    funding?: any;
+    bin?: any;
+    engines?: any;
     os?: string[];
     cpu?: string[];
+    libc?: string[];
+    deprecated?: any;
+    hasInstallScript?: boolean;
+    scripts?: {
+        [key: string]: string;
+    };
 }
 export type BundleDependenciesWrapper = string[];
 export interface PackageDist {
@@ -89,41 +102,54 @@ export interface PackageLock {
     };
 }
 export interface LockDependency {
+    name?: string;
     version?: string;
     resolved?: string;
     integrity?: string;
-    dependencies?: {
+    dev?: boolean;
+    optional?: boolean;
+    devOptional?: boolean;
+    peer?: boolean;
+    inBundle?: boolean;
+    hasInstallScript?: boolean;
+    hasShrinkwrap?: boolean;
+    license?: string;
+    funding?: any;
+    bin?: {
         [key: string]: string;
     };
-    optionalDependencies?: {
+    dependencies?: {
         [key: string]: string;
     };
-    license?: string;
-    engines?: {
+    devDependencies?: {
         [key: string]: string;
     };
     peerDependencies?: {
         [key: string]: string;
     };
-    peer?: boolean;
-    optional?: boolean;
-    os?: string[];
-    cpu?: string[];
-}
-/**
- * Queue for BFS
- */
-export interface QueueItem {
-    ParentPath: string;
-    Deps: {
-        [key: string]: string;
+    peerDependenciesMeta?: {
+        [key: string]: any;
     };
-    OptionalDeps: {
+    optionalDependencies?: {
         [key: string]: string;
     };
-    PeerDeps: {
+    bundleDependencies?: string[];
+    engines?: {
         [key: string]: string;
     };
+    os?: string[];
+    cpu?: string[];
+    libc?: string[];
+    deprecated?: string;
+}
+export interface DepItem {
+    Name: string;
+    Range: string;
+    Optional: boolean;
+}
+export interface QueueItem {
+    ParentPath: string;
+    Items: DepItem[];
 }
 export interface ProgressReader {
     Reader: any;

package/types/@types/websocket.d.ts

@@ -0,0 +1,2 @@
+export type WebSocketFn = number;
+export declare const Connect: WebSocketFn;

package/types/bridge/duplex.d.ts

@@ -1,4 +1,4 @@
-import { SerializableData } from "../@types/index.ts";
+import { type SerializableData } from "../@types/index.ts";
 import { createEventEmitter } from "./eventEmitter.ts";
 declare function onStreamData(id: number, payload: ArrayBuffer | string): void;
 type StreamData = string | Buffer | Uint8Array | DataView;

package/types/bridge/index.d.ts

@@ -1,4 +1,4 @@
-import { CoreModule, SerializableData } from "../@types/index.ts";
+import { type CoreModule, type SerializableData } from "../@types/index.ts";
 import type platformBridgeType from "./platform/index.ts";
 import type { JSPlugin } from "../plugin/index.ts";
 declare global {
@@ -24,6 +24,7 @@ type FullStacked = {
         respondGetSize?: (response: any) => void;
     };
     fetch: typeof fetch;
+    WebSocket: typeof WebSocket;
     open?: (ctx: number) => void;
 };
 type BridgeOpts = {

package/types/bridge/platform/android.d.ts

@@ -1,4 +1,4 @@
-import { PlatformBridge } from "./index.ts";
+import type { PlatformBridge } from "./index.ts";
 declare global {
     var android: {
         coreCall?: (payloadBase64: string) => string;

package/types/bridge/platform/apple.d.ts

@@ -1,2 +1,2 @@
-import { PlatformBridge } from "./index.ts";
+import type { PlatformBridge } from "./index.ts";
 export declare function BridgeAppleInit(): Promise<PlatformBridge>;

package/types/bridge/platform/linux.d.ts

@@ -1,4 +1,4 @@
-import { PlatformBridge } from "./index.ts";
+import type { PlatformBridge } from "./index.ts";
 declare global {
     var webkit: any;
     var chrome: any;

package/types/bridge/platform/windows.d.ts

@@ -1,2 +1,2 @@
-import { PlatformBridge } from "./index.ts";
+import type { PlatformBridge } from "./index.ts";
 export declare function BridgeWindowsInit(): Promise<PlatformBridge>;

package/types/bridge/serialization.d.ts

@@ -1,4 +1,4 @@
-import { SerializableData, SerializableDataType } from "../@types/index.ts";
+import { type SerializableData, type SerializableDataType } from "../@types/index.ts";
 export declare function numberToUint4Bytes(num: number): Uint8Array<ArrayBuffer>;
 export declare function uint4BytesToNumber(bytes: Uint8Array): number;
 export declare function serializeUndefined(): Uint8Array<ArrayBuffer>;

package/types/bundle/index.d.ts

@@ -1,4 +1,4 @@
-import { EsbuildResult } from "../@types/bundle.ts";
+import { type EsbuildResult } from "../@types/bundle.ts";
 export declare function esbuildVersion(): Promise<string>;
 export declare function bundle(entryPoint?: string): Promise<EsbuildResult>;
 export declare function bundleFile(entryPoint: string): Promise<EsbuildResult>;

package/types/fs/common.d.ts

@@ -1,4 +1,4 @@
-import { GoFileInfo } from "../@types/fs";
+import type { GoFileInfo } from "../@types/fs.ts";
 export type PathLike = string | URL | Buffer;
 export declare function formatPathLike(path: PathLike): string;
 export type ReadFileOpts = string | {

package/types/fs/index.d.ts

@@ -1,5 +1,5 @@
 import { Writable } from "stream";
-import { Dirent, PathLike, ReadFileOpts, StatOpts, Stats as StatsInterface } from "./common.ts";
+import { type Dirent, type PathLike, type ReadFileOpts, type StatOpts, type Stats as StatsInterface } from "./common.ts";
 export declare function existsSync(path: PathLike): boolean;
 export declare function statSync(path: PathLike, options?: StatOpts): StatsInterface;
 type StatCallback = (err: Error, stat: StatsInterface) => void;

package/types/fs/promises.d.ts

@@ -1,4 +1,4 @@
-import { Dirent, PathLike, ReadFileOpts, StatOpts, Stats as StatsInterface } from "./common.ts";
+import { type Dirent, type PathLike, type ReadFileOpts, type StatOpts, type Stats as StatsInterface } from "./common.ts";
 export declare function readFile(path: PathLike): Promise<Buffer<ArrayBuffer>>;
 export declare function readFile(path: PathLike, options: ReadFileOpts): Promise<string>;
 export declare function readdir(path: PathLike, options: {

package/types/git/index.d.ts

@@ -1,4 +1,4 @@
-import { GitAuthor, GitBranch, GitCommit, GitHead, GitProxy, GitStatus, GitTag } from "../@types/git.ts";
+import { type GitAuthor, type GitBranch, type GitCommit, type GitHead, type GitProxy, type GitStatus, type GitTag } from "../@types/git.ts";
 import type { Duplex } from "../bridge/duplex.ts";
 export declare function createGitAuthManager(): Promise<{
     on(): void;

package/types/packages/index.d.ts

@@ -1,5 +1,5 @@
-import { Progress } from "../@types/packages.ts";
-import { EventEmitter } from "../bridge/eventEmitter.ts";
+import { type Progress } from "../@types/packages.ts";
+import type { EventEmitter } from "../bridge/eventEmitter.ts";
 export declare function install(directory: string, saveDev: boolean, ...packages: string[]): Promise<EventEmitter<{
     progress: Progress[];
 }>>;

package/types/path/index.d.ts

@@ -1,4 +1,4 @@
-import { ParsedPath } from "../@types/path.ts";
+import { type ParsedPath } from "../@types/path.ts";
 export declare let sep: string;
 export declare function isAbsolute(path: string): boolean;
 export declare function resolve(...paths: string[]): string;

package/types/plugin/index.d.ts

@@ -1,5 +1,5 @@
-import { GitAuth, PluginTypeGitAuth, PluginTypeBuild } from "../@types/index.ts";
-import { PluginBuildData, PluginParams } from "../@types/bundle.ts";
+import { type GitAuth, PluginTypeGitAuth, PluginTypeBuild } from "../@types/index.ts";
+import type { PluginBuildData, PluginParams } from "../@types/bundle.ts";
 type CommonPluginData = {
     name?: string;
 };

package/types/tunnel/index.d.ts

@@ -1,4 +1,4 @@
-import { Tunnel } from "../@types/tunnel.ts";
+import { type Tunnel } from "../@types/tunnel.ts";
 export declare function register(tunnel: Tunnel): Promise<string>;
 declare const tunnel: {
     register: typeof register;

package/types/websocket/index.d.ts

@@ -0,0 +1,25 @@
+export declare class WebSocketCore extends EventTarget {
+    #private;
+    static readonly CONNECTING = 0;
+    static readonly OPEN = 1;
+    static readonly CLOSING = 2;
+    static readonly CLOSED = 3;
+    readonly CONNECTING = 0;
+    readonly OPEN = 1;
+    readonly CLOSING = 2;
+    readonly CLOSED = 3;
+    readonly url: string;
+    readyState: number;
+    bufferedAmount: number;
+    protocol: string;
+    extensions: string;
+    binaryType: "blob" | "arraybuffer";
+    onopen: ((this: WebSocketCore, ev: Event) => any) | null;
+    onerror: ((this: WebSocketCore, ev: Event) => any) | null;
+    onclose: ((this: WebSocketCore, ev: CloseEvent) => any) | null;
+    onmessage: ((this: WebSocketCore, ev: MessageEvent) => any) | null;
+    constructor(url: string | URL, protocols?: string | string[]);
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+}
+export default WebSocketCore;