@petezah-games/scramjet-controller 0.0.9 → 0.0.10

package/package.json

@@ -1,9 +1,24 @@
 {
   "name": "@petezah-games/scramjet-controller",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "type": "module",
-  "main": "./dist/controller.api.js",
-  "types": "./dist/types/typesEntry.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/controller.api.js",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./inject": {
+      "import": "./dist/controller.inject.js",
+      "types": "./dist/types/inject.d.ts"
+    },
+    "./hooks": {
+      "import": "./dist/controller.sw.js",
+      "types": "./dist/types/sw.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "dependencies": {
     "@mercuryworkshop/proxy-transports": "1.0.2",
     "@mercuryworkshop/scramjet": "2.0.2-alpha"

package/src/index.ts

@@ -1,437 +0,0 @@
-import { type MethodsDefinition, RpcHelper } from "@mercuryworkshop/rpc";
-import type * as ScramjetGlobal from "@mercuryworkshop/scramjet";
-
-import {
-	type TransportToController,
-	type Controllerbound,
-	type ControllerToTransport,
-	type SWbound,
-	type WebSocketMessage,
-} from "./types";
-import {
-	BareCompatibleClient,
-	BareResponse,
-	type ProxyTransport,
-} from "@mercuryworkshop/proxy-transports";
-import * as $scramjet from '@mercuryworkshop/scramjet';
-
-const cookieJar = new $scramjet.CookieJar();
-
-type Config = {
-	wasmPath: string;
-	injectPath: string;
-	scramjetPath: string;
-	virtualWasmPath: string;
-	prefix: string;
-};
-
-export const config: Config = {
-	prefix: "/~/sj/",
-	virtualWasmPath: "scramjet.wasm.js",
-	injectPath: "/controller/controller.inject.js",
-	scramjetPath: "/scramjet/scramjet.js",
-	wasmPath: "/scramjet/scramjet.wasm",
-};
-
-const cfg = {
-	flags: {
-		...$scramjet.defaultConfig.flags,
-		allowFailedIntercepts: true,
-	},
-	maskedfiles: ["inject.js", "scramjet.wasm.js"],
-};
-
-const frames: Record<string, Frame> = {};
-
-let wasmPayload: string | null = null;
-
-function makeId(): string {
-	return Math.random().toString(36).substring(2, 10);
-}
-
-const codecEncode = (url: string) => {
-	if (!url) return url;
-
-	return encodeURIComponent(url);
-};
-
-const codecDecode = (url: string) => {
-	if (!url) return url;
-
-	return decodeURIComponent(url);
-};
-
-type ControllerInit = {
-	serviceworker: ServiceWorker;
-	transport: ProxyTransport;
-};
-
-let wasmAlreadyFetched = false;
-
-async function loadScramjetWasm() {
-	if (wasmAlreadyFetched) {
-		return;
-	}
-
-	let resp = await fetch(config.wasmPath);
-	$scramjet.setWasm(await resp.arrayBuffer());
-	wasmAlreadyFetched = true;
-}
-
-export class Controller {
-	id: string;
-	prefix: string;
-	frames: Frame[] = [];
-	cookieJar = new $scramjet.CookieJar();
-
-	rpc: RpcHelper<Controllerbound, SWbound>;
-	private ready: Promise<[void, void]>;
-	private readyResolve!: () => void;
-	public isReady: boolean = false;
-
-	transport: ProxyTransport;
-
-	private methods: MethodsDefinition<Controllerbound> = {
-		ready: async () => {
-			this.readyResolve();
-		},
-		request: async (data) => {
-			try {
-				let path = new URL(data.rawUrl).pathname;
-				const frame = this.frames.find((f) => path.startsWith(f.prefix));
-				if (!frame) throw new Error("No frame found for request");
-
-				if (path === frame.prefix + config.virtualWasmPath) {
-					if (!wasmPayload) {
-						const resp = await fetch(config.wasmPath);
-						const buf = await resp.arrayBuffer();
-						const b64 = btoa(
-							new Uint8Array(buf)
-								.reduce(
-									(data, byte) => (data.push(String.fromCharCode(byte)), data),
-									[] as any
-								)
-								.join("")
-						);
-
-						let payload = "";
-						payload +=
-							"if ('document' in self && document.currentScript) { document.currentScript.remove(); }\n";
-						payload += `self.WASM = '${b64}';`;
-						wasmPayload = payload;
-					}
-
-					return [
-						{
-							body: wasmPayload,
-							status: 200,
-							statusText: "OK",
-							headers: [["Content-Type", "application/javascript"]],
-						},
-						[],
-					];
-				}
-
-				let sjheaders = $scramjet.ScramjetHeaders.fromRawHeaders(
-					data.initialHeaders
-				);
-
-				const fetchresponse = await frame.fetchHandler.handleFetch({
-					initialHeaders: sjheaders,
-					rawClientUrl: data.rawClientUrl
-						? new URL(data.rawClientUrl)
-						: undefined,
-					rawUrl: new URL(data.rawUrl),
-					destination: data.destination,
-					method: data.method,
-					mode: data.mode,
-					referrer: data.referrer,
-					body: data.body,
-					cache: data.cache,
-				});
-
-				return [
-					{
-						body: fetchresponse.body,
-						status: fetchresponse.status,
-						statusText: fetchresponse.statusText,
-						headers: fetchresponse.headers.toRawHeaders(),
-					},
-					fetchresponse.body instanceof ReadableStream ||
-						fetchresponse.body instanceof ArrayBuffer
-						? [fetchresponse.body]
-						: [],
-				];
-			} catch (e) {
-				console.error("Error in controller request handler:", e);
-				throw e;
-			}
-		},
-		initRemoteTransport: async (port) => {
-			const rpc = new RpcHelper<TransportToController, ControllerToTransport>(
-				{
-					request: async ({ remote, method, body, headers }) => {
-						let response = await this.transport.request(
-							new URL(remote),
-							method,
-							body,
-							headers,
-							undefined
-						);
-						return [response, [response.body]];
-					},
-					connect: async ({ url, protocols, requestHeaders, port }) => {
-						let resolve: (arg: TransportToController["connect"][1]) => void;
-						let promise = new Promise<TransportToController["connect"][1]>(
-							(res) => (resolve = res)
-						);
-						const [send, close] = this.transport.connect(
-							new URL(url),
-							protocols,
-							requestHeaders,
-							(protocol, extensions) => {
-								resolve({
-									result: "success",
-									protocol: protocol,
-									extensions: extensions,
-								});
-							},
-							(data) => {
-								port.postMessage(
-									{
-										type: "data",
-										data: data,
-									} as WebSocketMessage,
-									data instanceof ArrayBuffer ? [data] : []
-								);
-							},
-							(close, reason) => {
-								port.postMessage({
-									type: "close",
-									code: close,
-									reason: reason,
-								} as WebSocketMessage);
-							},
-							(error) => {
-								resolve({
-									result: "failure",
-									error: error,
-								});
-							}
-						);
-						port.onmessageerror = (ev) => {
-							console.error(
-								"Transport port messageerror (this should never happen!)",
-								ev
-							);
-						};
-						port.onmessage = ({ data }: { data: WebSocketMessage }) => {
-							if (data.type === "data") {
-								send(data.data);
-							} else if (data.type === "close") {
-								close(data.code, data.reason);
-							}
-						};
-
-						return [await promise, []];
-					},
-				},
-				"transport",
-				(data, transfer) => port.postMessage(data, transfer)
-			);
-			port.onmessageerror = (ev) => {
-				console.error(
-					"Transport port messageerror (this should never happen!)",
-					ev
-				);
-			};
-			port.onmessage = (e) => {
-				rpc.recieve(e.data);
-			};
-			rpc.call("ready", undefined, []);
-		},
-		sendSetCookie: async ({ url, cookie }) => { },
-	};
-
-	constructor(public init: ControllerInit) {
-		this.transport = init.transport;
-		this.id = makeId();
-		this.prefix = config.prefix + this.id + "/";
-
-		this.ready = Promise.all([
-			new Promise<void>((resolve) => {
-				this.readyResolve = resolve;
-			}),
-			loadScramjetWasm(),
-		]);
-
-		let channel = new MessageChannel();
-		this.rpc = new RpcHelper<Controllerbound, SWbound>(
-			this.methods,
-			"tabchannel-" + this.id,
-			(data, transfer) => {
-				channel.port1.postMessage(data, transfer);
-			}
-		);
-		channel.port1.addEventListener("message", (e) => {
-			this.rpc.recieve(e.data);
-		});
-		channel.port1.start();
-
-		init.serviceworker.postMessage(
-			{
-				$controller$init: {
-					prefix: config.prefix + this.id,
-					id: this.id,
-				},
-			},
-			[channel.port2]
-		);
-	}
-
-	createFrame(element?: HTMLIFrameElement): Frame {
-		if (!this.ready) {
-			throw new Error(
-				"Controller is not ready! Try awaiting controller.wait()"
-			);
-		}
-		element ??= document.createElement("iframe");
-		const frame = new Frame(this, element);
-		this.frames.push(frame);
-		return frame;
-	}
-
-	wait(): Promise<void> {
-		return this.ready;
-	}
-}
-
-function yieldGetInjectScripts(
-	cookieJar: ScramjetGlobal.CookieJar,
-	config: Config,
-	sjconfig: ScramjetGlobal.ScramjetConfig,
-	prefix: URL
-) {
-	let getInjectScripts: ScramjetGlobal.ScramjetInterface["getInjectScripts"] = (
-		meta,
-		handler,
-		script
-	) => {
-		return [
-			script(config.scramjetPath),
-			script(config.injectPath),
-			script(prefix.href + config.virtualWasmPath),
-			script(
-				"data:text/javascript;base64," +
-				btoa(`
-					document.currentScript.remove();
-					$scramjetController.load({
-						config: ${JSON.stringify(config)},
-						sjconfig: ${JSON.stringify(sjconfig)},
-						cookies: ${cookieJar.dump()},
-						prefix: new URL("${prefix.href}"),
-						yieldGetInjectScripts: ${yieldGetInjectScripts.toString()},
-						codecEncode: ${codecEncode.toString()},
-						codecDecode: ${codecDecode.toString()},
-					})
-				`)
-			),
-		];
-	};
-	return getInjectScripts;
-}
-
-class Frame {
-	fetchHandler: ScramjetGlobal.ScramjetFetchHandler;
-	id: string;
-	prefix: string;
-
-	get context(): ScramjetGlobal.ScramjetContext {
-		let sjcfg = {
-			...$scramjet.defaultConfig,
-			...cfg,
-		};
-		return {
-			cookieJar,
-			prefix: new URL(this.prefix, location.href),
-			config: sjcfg,
-			interface: {
-				getInjectScripts: yieldGetInjectScripts(
-					this.controller.cookieJar,
-					config,
-					{ ...$scramjet.defaultConfig, ...cfg },
-					new URL(this.prefix, location.href)
-				),
-				getWorkerInjectScripts: (meta, type, script) => {
-					let str = "";
-
-					str += script(config.scramjetPath);
-					str += script(this.prefix + config.virtualWasmPath);
-					str += `
-					(()=>{
-						const { ScramjetClient, CookieJar, setWasm } = $scramjet;
-
-						setWasm(Uint8Array.from(atob(self.WASM), (c) => c.charCodeAt(0)));
-						delete self.WASM;
-
-						const sjconfig = ${JSON.stringify(sjcfg)};
-						const prefix = new URL("${this.prefix}", location.href);
-
-						const context = {
-							interface: {
-								codecEncode: ${codecEncode.toString()},
-								codecDecode: ${codecDecode.toString()},
-							},
-							prefix,
-							config: sjconfig
-						};
-
-						const client = new ScramjetClient(globalThis, {
-							context,
-							transport: null,
-							shouldPassthroughWebsocket: (url) => {
-								return url === "wss://anura.pro/";
-							}
-						});
-
-						client.hook();
-					})();
-					`;
-
-					return str;
-				},
-				codecEncode,
-				codecDecode,
-			},
-		};
-	}
-
-	constructor(
-		public controller: Controller,
-		public element: HTMLIFrameElement
-	) {
-		this.id = makeId();
-		this.prefix = this.controller.prefix + this.id + "/";
-
-		this.fetchHandler = new $scramjet.ScramjetFetchHandler({
-			crossOriginIsolated: self.crossOriginIsolated,
-			context: this.context,
-			transport: controller.transport,
-			async sendSetCookie(url, cookie) { },
-			async fetchBlobUrl(url) {
-				return BareResponse.fromNativeResponse(await fetch(url));
-			},
-			async fetchDataUrl(url) {
-				return BareResponse.fromNativeResponse(await fetch(url));
-			},
-		});
-	}
-
-	go(url: string) {
-		const encoded = $scramjet.rewriteUrl(url, this.context, {
-			origin: new URL(location.href),
-			base: new URL(location.href),
-		});
-		this.element.src = encoded;
-	}
-}

package/src/inject.ts

@@ -1,245 +0,0 @@
-import type { CookieJar, ScramjetConfig } from "@mercuryworkshop/scramjet";
-import * as $scramjet from "@mercuryworkshop/scramjet";
-
-import type {
-	RawHeaders,
-	ProxyTransport,
-	TransferrableResponse,
-} from "@mercuryworkshop/proxy-transports";
-
-import { RpcHelper } from "@mercuryworkshop/rpc";
-import type {
-	ControllerToTransport,
-	TransportToController,
-	WebSocketData,
-	WebSocketMessage,
-} from "./types";
-
-const MessagePort_postMessage = MessagePort.prototype.postMessage;
-const postMessage = (
-	port: MessagePort,
-	data: any,
-	transfer?: Transferable[]
-) => {
-	MessagePort_postMessage.call(port, data, transfer as any);
-};
-
-class RemoteTransport implements ProxyTransport {
-	private readyResolve!: () => void;
-	private readyPromise: Promise<void> = new Promise((resolve) => {
-		this.readyResolve = resolve;
-	});
-
-	public ready = false;
-	async init() {
-		await this.readyPromise;
-		this.ready = true;
-	}
-
-	private rpc: RpcHelper<ControllerToTransport, TransportToController>;
-	constructor(public port: MessagePort) {
-		this.rpc = new RpcHelper<ControllerToTransport, TransportToController>(
-			{
-				ready: async () => {
-					this.readyResolve();
-				},
-			},
-			"transport",
-			(data, transfer) => {
-				postMessage(port, data, transfer);
-			}
-		);
-		port.onmessageerror = (ev) => {
-			console.error("onmessageerror (this should never happen!)", ev);
-		};
-		port.onmessage = (ev) => {
-			this.rpc.recieve(ev.data);
-		};
-		port.start();
-	}
-	connect(
-		url: URL,
-		protocols: string[],
-		requestHeaders: RawHeaders,
-		onopen: (protocol: string, extensions: string) => void,
-		onmessage: (data: Blob | ArrayBuffer | string) => void,
-		onclose: (code: number, reason: string) => void,
-		onerror: (error: string) => void
-	): [
-			(data: Blob | ArrayBuffer | string) => void,
-			(code: number, reason: string) => void,
-		] {
-		const channel = new MessageChannel();
-		let port = channel.port1;
-		console.warn("connecting");
-		this.rpc
-			.call(
-				"connect",
-				{
-					url: url.href,
-					protocols,
-					requestHeaders,
-					port: channel.port2,
-				},
-				[channel.port2]
-			)
-			.then((response) => {
-				console.log(response);
-				if (response.result === "success") {
-					onopen(response.protocol, response.extensions);
-				} else {
-					onerror(response.error);
-				}
-			});
-		port.onmessage = (ev) => {
-			const message = ev.data as WebSocketMessage;
-			if (message.type === "data") {
-				onmessage(message.data);
-			} else if (message.type === "close") {
-				onclose(message.code, message.reason);
-			}
-		};
-		port.onmessageerror = (ev) => {
-			console.error("onmessageerror (this should never happen!)", ev);
-			onerror("Message error in transport port");
-		};
-
-		return [
-			(data) => {
-				postMessage(
-					port,
-					{
-						type: "data",
-						data: data,
-					},
-					data instanceof ArrayBuffer ? [data] : []
-				);
-			},
-			(code) => {
-				postMessage(port, {
-					type: "close",
-					code: code,
-				});
-			},
-		];
-	}
-
-	async request(
-		remote: URL,
-		method: string,
-		body: BodyInit | null,
-		headers: RawHeaders,
-		signal: AbortSignal | undefined
-	): Promise<TransferrableResponse> {
-		return await this.rpc.call("request", {
-			remote: remote.href,
-			method,
-			body,
-			headers,
-		});
-	}
-
-	meta() {
-		return {};
-	}
-}
-
-const sw = navigator.serviceWorker.controller;
-const { SCRAMJETCLIENT, ScramjetClient, CookieJar, setWasm } = $scramjet;
-
-type Config = any;
-type Init = {
-	config: Config;
-	sjconfig: ScramjetConfig;
-	cookies: string;
-	prefix: URL;
-	yieldGetInjectScripts: (
-		cookieJar: CookieJar,
-		config: Config,
-		sjconfig: ScramjetConfig,
-		prefix: URL
-	) => any;
-	codecEncode: (input: string) => string;
-	codecDecode: (input: string) => string;
-};
-
-export function load({
-	config,
-	sjconfig,
-	cookies,
-	prefix,
-	yieldGetInjectScripts,
-	codecEncode,
-	codecDecode,
-}: Init) {
-	let client;
-	if (SCRAMJETCLIENT in globalThis) {
-		client = globalThis[SCRAMJETCLIENT];
-	} else {
-		setWasm(Uint8Array.from(atob(self.WASM), (c) => c.charCodeAt(0)));
-		delete self.WASM;
-
-		const channel = new MessageChannel();
-		const transport = new RemoteTransport(channel.port1);
-		sw?.postMessage(
-			{
-				$sw$initRemoteTransport: {
-					port: channel.port2,
-					prefix: prefix.href,
-				},
-			},
-			[channel.port2]
-		);
-
-		const cookieJar = new CookieJar();
-		cookieJar.load(cookies);
-
-		const context = {
-			interface: {
-				getInjectScripts: yieldGetInjectScripts(
-					cookieJar,
-					config,
-					sjconfig,
-					prefix
-				),
-				codecEncode,
-				codecDecode,
-			},
-			prefix,
-			cookieJar,
-			config: sjconfig,
-		};
-		function createFrameId() {
-			return `${Array(8)
-				.fill(0)
-				.map(() => Math.floor(Math.random() * 36).toString(36))
-				.join("")}`;
-		}
-
-		const frame = globalThis.frameElement as HTMLIFrameElement | null;
-		if (frame && !frame.name) {
-			frame.name = createFrameId();
-		}
-
-		client = new ScramjetClient(globalThis, {
-			context,
-			transport,
-			sendSetCookie: async (url, cookie) => {
-				// sw.postMessage({
-				// 	$controller$setCookie: {
-				// 		url,
-				// 		cookie
-				// 	}
-				// });
-			},
-			shouldPassthroughWebsocket: (url) => {
-				return url === "wss://anura.pro/";
-			},
-			shouldBlockMessageEvent(i) {
-				return false;
-			},
-		});
-
-		client.hook();
-	}
-}

package/src/sw.ts

@@ -1,159 +0,0 @@
-declare var clients: Clients;
-import { RpcHelper } from "@mercuryworkshop/rpc";
-import type { Controllerbound, SWbound } from "./types";
-import type { RawHeaders } from "@mercuryworkshop/proxy-transports";
-import { ScramjetHeaders } from "@mercuryworkshop/scramjet";
-
-function makeId(): string {
-	return Math.random().toString(36).substring(2, 10);
-}
-
-let cookieResolvers: Record<string, (value: void) => void> = {};
-addEventListener("message", (e) => {
-	if (!e.data) return;
-	if (typeof e.data != "object") return;
-	if (e.data.$sw$setCookieDone && typeof e.data.$sw$setCookieDone == "object") {
-		const done = e.data.$sw$setCookieDone;
-
-		const resolver = cookieResolvers[done.id];
-		if (resolver) {
-			resolver();
-			delete cookieResolvers[done.id];
-		}
-	}
-
-	if (
-		e.data.$sw$initRemoteTransport &&
-		typeof e.data.$sw$initRemoteTransport == "object"
-	) {
-		const { port, prefix } = e.data.$sw$initRemoteTransport;
-
-		const relevantcontroller = tabs.find((tab) =>
-			new URL(prefix).pathname.startsWith(tab.prefix)
-		);
-		if (!relevantcontroller) {
-			console.error("No relevant controller found for transport init");
-			return;
-		}
-		relevantcontroller.rpc.call("initRemoteTransport", port, [port]);
-	}
-});
-
-class ControllerReference {
-	rpc: RpcHelper<SWbound, Controllerbound>;
-
-	constructor(
-		public prefix: string,
-		public id: string,
-		port: MessagePort
-	) {
-		this.rpc = new RpcHelper(
-			{
-				sendSetCookie: async ({ url, cookie }) => {
-					let clients = await self.clients.matchAll();
-					let promises = [];
-
-					for (const client of clients) {
-						let id = makeId();
-						client.postMessage({
-							$controller$setCookie: {
-								url,
-								cookie,
-								id,
-							},
-						});
-						promises.push(
-							new Promise<void>((resolve) => {
-								cookieResolvers[id] = resolve;
-							})
-						);
-					}
-					await Promise.race([
-						new Promise<void>((resolve) =>
-							setTimeout(() => {
-								console.error(
-									"timed out waiting for set cookie response (deadlock?)"
-								);
-								resolve();
-							}, 1000)
-						),
-						promises,
-					]);
-				},
-			},
-			"tabchannel-" + id,
-			(data, transfer) => {
-				port.postMessage(data, transfer);
-			}
-		);
-		port.addEventListener("message", (e) => {
-			this.rpc.recieve(e.data);
-		});
-		port.onmessageerror = console.error;
-
-		this.rpc.call("ready", null);
-	}
-}
-
-const tabs: ControllerReference[] = [];
-
-addEventListener("message", (e) => {
-	if (!e.data) return;
-	if (typeof e.data != "object") return;
-	if (!e.data.$controller$init) return;
-	if (typeof e.data.$controller$init != "object") return;
-	const init = e.data.$controller$init;
-
-	tabs.push(new ControllerReference(init.prefix, init.id, e.ports[0]));
-});
-
-export function shouldRoute(event: FetchEvent): boolean {
-	const url = new URL(event.request.url);
-	const tab = tabs.find((tab) => url.pathname.startsWith(tab.prefix));
-	return tab !== undefined;
-}
-
-export async function route(event: FetchEvent): Promise<Response> {
-	try {
-		const url = new URL(event.request.url);
-		const tab = tabs.find((tab) => url.pathname.startsWith(tab.prefix))!;
-		const client = await clients.get(event.clientId);
-
-		const rawheaders: RawHeaders = [...event.request.headers];
-
-		const response = await tab.rpc.call(
-			"request",
-			{
-				rawUrl: event.request.url,
-				destination: event.request.destination,
-				mode: event.request.mode,
-				referrer: event.request.referrer,
-				method: event.request.method,
-				body: event.request.body,
-				cache: event.request.cache,
-				forceCrossOriginIsolated: false,
-				initialHeaders: rawheaders,
-				rawClientUrl: client ? client.url : undefined,
-			},
-			event.request.body instanceof ReadableStream ||
-				// @ts-expect-error the types for fetchevent are messed up
-				event.request.body instanceof ArrayBuffer
-				? [event.request.body]
-				: undefined
-		);
-
-		return new Response(response.body, {
-			status: response.status,
-			statusText: response.statusText,
-			headers: response.headers,
-		});
-	} catch (e) {
-		console.error("Service Worker error:", e);
-		return new Response(
-			"Internal Service Worker Error: " + (e as Error).message,
-			{
-				status: 500,
-			}
-		);
-	}
-}

package/src/types.d.ts

@@ -1,95 +0,0 @@
-import type { RawHeaders } from "@mercuryworkshop/proxy-transports";
-
-export type BodyType =
-	| string
-	| ArrayBuffer
-	| Blob
-	| ReadableStream<Uint8Array<ArrayBufferLike>>;
-
-export type TransferRequest = {
-	rawUrl: string;
-	destination: RequestDestination;
-	mode: RequestMode;
-	referrer: string;
-	method: string;
-	body: BodyType | null;
-	cache: RequestCache;
-	forceCrossOriginIsolated: boolean;
-	initialHeaders: RawHeaders;
-	rawClientUrl?: string;
-};
-
-export type TransferResponse = {
-	body: BodyType;
-	headers: RawHeaders;
-	status: number;
-	statusText: string;
-};
-
-export type Controllerbound = {
-	ready: [];
-	request: [TransferRequest, TransferResponse];
-	sendSetCookie: [
-		{
-			url: string;
-			cookie: string;
-		},
-	];
-	initRemoteTransport: [MessagePort];
-};
-
-export type SWbound = {
-	sendSetCookie: [
-		{
-			url: string;
-			cookie: string;
-		},
-	];
-};
-
-export type TransportToController = {
-	request: [
-		{
-			remote: string;
-			method: string;
-			body: BodyInit | null;
-			headers: RawHeaders;
-			// signal: AbortSignal | undefined
-		},
-		TransferrableResponse,
-	];
-	connect: [
-		{
-			url: string;
-			protocols: string[];
-			requestHeaders: RawHeaders;
-			port: MessagePort;
-		},
-		(
-			| {
-					result: "success";
-					protocol: string;
-					extensions: string;
-			  }
-			| {
-					result: "failure";
-					error: string;
-			  }
-		),
-	];
-};
-
-export type ControllerToTransport = {
-	ready: [];
-};
-export type WebSocketData = string | ArrayBuffer | Blob;
-export type WebSocketMessage =
-	| {
-			type: "data";
-			data: WebSocketData;
-	  }
-	| {
-			type: "close";
-			code: number;
-			reason: string;
-	  };

package/src/typesEntry.ts

@@ -1,6 +0,0 @@
-import * as Types from "./index";
-export * from "./index";
-
-declare global {
-	const $scramjetController: typeof Types;
-}

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2022",
-		"useDefineForClassFields": true,
-		"module": "ESNext",
-		"lib": ["ES2022", "webworker", "DOM", "DOM.Iterable"],
-		"types": [],
-		"skipLibCheck": true,
-		/* Bundler mode */
-		"moduleResolution": "bundler",
-		"allowImportingTsExtensions": true,
-		"verbatimModuleSyntax": true,
-		"moduleDetection": "force",
-		"noEmit": true,
-		/* Linting */
-		"strict": true,
-		"noUnusedLocals": true,
-		"noUnusedParameters": false,
-		"erasableSyntaxOnly": false,
-		"noFallthroughCasesInSwitch": true,
-		"noUncheckedSideEffectImports": true
-	},
-	"include": ["src"]
-}

package/tsconfig.types.json

@@ -1,16 +0,0 @@
-{
-	"extends": "./tsconfig.json",
-	"compilerOptions": {
-		"declaration": true,
-		"emitDeclarationOnly": true,
-		"declarationDir": "./dist/types",
-		"removeComments": false,
-		"skipLibCheck": true,
-		"noEmitOnError": false,
-		"noEmit": false,
-		"strict": false,
-		"noUnusedLocals": false,
-		"noUnusedParameters": false
-	},
-	"include": ["src"]
-}