@petezah-games/scramjet-controller 0.0.9 → 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# Scramjet Controller
+
+The controller package manages the coordination between the main application, service workers, and proxy transports in the Scramjet proxy. It handles RPC communication, request routing, and resource management across different execution contexts.
+
+## Overview
+
+This package provides the core orchestration layer for Scramjet, enabling:
+
+- **RPC Communication**: Two-way RPC communication between the main thread, service workers, and transport layers
+- **Request Routing**: Handling and forwarding HTTP/HTTPS requests through configured proxy transports
+- **Resource Injection**: Injecting Scramjet utilities into web pages
+- **Service Worker Integration**: Managing multiple service worker instances and their lifecycle
+- **Cookie Management**: Centralized cookie jar for maintaining session state across requests
+
+## Structure
+
+### Core Modules
+
+- **`index.ts`** - Main Controller class that coordinates between transports and service workers. Handles request processing, frame management, and RPC setup.
+- **`inject.ts`** - Injection script that runs in the service worker context. Implements RemoteTransport to communicate back to the main controller via MessagePort.
+- **`sw.ts`** - Service worker hooks that manage controller registration, request interception, and service worker lifecycle.
+- **`types.d.ts`** - Type definitions for RPC messages and communication interfaces between different contexts.
+- **`typesEntry.ts`** - Type entry point for the package exports.
+
+## Exports
+
+The package exports three main entry points:
+
+- **`@petezah-games/scramjet-controller`** - Main Controller API
+- **`@petezah-games/scramjet-controller/inject`** - Injection utilities for service workers
+- **`@petezah-games/scramjet-controller/worker`** - Service worker
+
+## Key Features
+
+### Controller Class
+
+The main `Controller` class manages:
+- Connection to proxy transports
+- Service worker lifecycle and registration
+- Frame management for multiple contexts
+- RPC communication with service workers
+- Request interception and routing via Scramjet
+
+### Configuration
+
+Default configuration includes:
+- `prefix`: `/~/sj/` - URL prefix for controller routes
+- `virtualWasmPath`: `scramjet.wasm.js` - Virtual path for WASM module
+- `injectPath`: `/controller/controller.inject.js` - Path to injection script
+- `scramjetPath`: `/scramjet/scramjet.js` - Path to main Scramjet library
+- `wasmPath`: `/scramjet/scramjet.wasm` - Path to WASM binary
+
+### RPC Methods
+
+The controller exposes RPC methods for:
+- `ready` - Signals when the service worker is ready
+- `request` - Processes HTTP requests
+- Additional transport initialization and management
+
+## Dependencies
+
+- `@mercuryworkshop/scramjet` - Core proxy rewriting library
+- `@mercuryworkshop/proxy-transports` - Transport abstraction layer
+- `@mercuryworkshop/rpc` - RPC helper for inter-context communication
+
+## Usage
+
+The controller is typically initialized by the bootstrap package, which sets up the service worker registration and injects the controller into the page context. Applications should interact with the controller through the RPC interface for request handling and configuration.

package/package.json

@@ -1,9 +1,43 @@
 {
   "name": "@petezah-games/scramjet-controller",
-  "version": "0.0.9",
+  "version": "0.1.0",
+  "description": "Controller for Scramjet proxy, it manages coordination between application, service workers, and proxy transports",
   "type": "module",
-  "main": "./dist/controller.api.js",
-  "types": "./dist/types/typesEntry.d.ts",
+  "license": "AGPL-3.0-only",
+  "author": "PeteZah Games",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/petezah-games/scramjet"
+  },
+  "bugs": {
+    "url": "https://github.com/petezah-games/scramjet/issues"
+  },
+  "homepage": "https://github.com/petezah-games/scramjet#readme",
+  "keywords": [
+    "proxy",
+    "scramjet",
+    "web-proxy",
+    "service-worker",
+    "rpc",
+    "transport"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/controller.api.js",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./inject": {
+      "import": "./dist/controller.inject.js",
+      "types": "./dist/types/inject.d.ts"
+    },
+    "./worker": {
+      "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"]
-}