wawesome 0.19.0 → 0.20.1

package/dist/{guest-parity-B5GLO6LA.mjs → guest-parity-W61MH7Fb.mjs}

@@ -1,4 +1,4 @@
-import { a as unsupportedGlobals, i as shimmedGlobals, n as methodRemedy, r as polyfilledGlobals, t as declaredMethods } from "./guest-surface-4bHyTMIy.mjs";
+import { a as unsupportedGlobals, i as shimmedGlobals, n as methodRemedy, r as polyfilledGlobals, t as declaredMethods } from "./guest-surface-D5X-IMAN.mjs";
 //#region ../../server/guest-surface/message-channel.js
 const ENTANGLED = Symbol("entangled");
 const QUEUE = Symbol("queue");
@@ -6,6 +6,39 @@ const STARTED = Symbol("started");
 const CLOSED = Symbol("closed");
 const LISTENERS = Symbol("listeners");
 const ONMESSAGE = Symbol("onmessage");
+var MessageEvent = class extends Event {
+	#data;
+	#origin;
+	#lastEventId;
+	#source;
+	#ports;
+	constructor(type, init = {}) {
+		super(type, init);
+		this.#data = init.data ?? null;
+		this.#origin = init.origin ?? "";
+		this.#lastEventId = init.lastEventId ?? "";
+		this.#source = init.source ?? null;
+		this.#ports = init.ports ?? [];
+	}
+	get data() {
+		return this.#data;
+	}
+	get origin() {
+		return this.#origin;
+	}
+	get lastEventId() {
+		return this.#lastEventId;
+	}
+	get source() {
+		return this.#source;
+	}
+	get ports() {
+		return this.#ports;
+	}
+	get [Symbol.toStringTag]() {
+		return "MessageEvent";
+	}
+};
 var MessagePort = class {
 	constructor() {
 		this[ENTANGLED] = null;
@@ -59,15 +92,18 @@ function drain(port) {
 	const data = port[QUEUE].shift();
 	setTimeout(() => {
 		if (port[CLOSED]) return;
-		deliver(port, {
-			type: "message",
-			data,
-			target: port,
-			ports: []
-		});
+		deliver(port, messageEvent(port, data));
 		drain(port);
 	}, 0);
 }
+function messageEvent(port, data) {
+	const event = new MessageEvent("message", { data });
+	Object.defineProperty(event, "target", {
+		value: port,
+		enumerable: true
+	});
+	return event;
+}
 function deliver(port, event) {
 	if (typeof port.onmessage === "function") port.onmessage(event);
 	for (const listener of port[LISTENERS].slice()) if (typeof listener === "function") listener.call(port, event);
@@ -82,6 +118,84 @@ var MessageChannel = class {
 	}
 };
 //#endregion
+//#region ../../server/guest-surface/text-streams.js
+const READABLE = Symbol("readable");
+const WRITABLE = Symbol("writable");
+const DECODER = Symbol("decoder");
+var TextEncoderStream = class {
+	constructor() {
+		const encoder = new TextEncoder();
+		let held = "";
+		const pipe = new TransformStream({
+			transform(chunk, controller) {
+				const text = held + String(chunk);
+				held = endsInHighSurrogate(text) ? text.slice(-1) : "";
+				const bytes = encoder.encode(held === "" ? text : text.slice(0, -1));
+				if (bytes.length > 0) controller.enqueue(bytes);
+			},
+			flush(controller) {
+				if (held === "") return;
+				controller.enqueue(encoder.encode(held));
+				held = "";
+			}
+		});
+		this[READABLE] = pipe.readable;
+		this[WRITABLE] = pipe.writable;
+	}
+	get encoding() {
+		return "utf-8";
+	}
+	get readable() {
+		return this[READABLE];
+	}
+	get writable() {
+		return this[WRITABLE];
+	}
+	get [Symbol.toStringTag]() {
+		return "TextEncoderStream";
+	}
+};
+function endsInHighSurrogate(text) {
+	const last = text.charCodeAt(text.length - 1);
+	return last >= 55296 && last <= 56319;
+}
+var TextDecoderStream = class {
+	constructor(label = "utf-8", options = {}) {
+		const decoder = new TextDecoder(label, options);
+		const pipe = new TransformStream({
+			transform(chunk, controller) {
+				const text = decoder.decode(chunk, { stream: true });
+				if (text !== "") controller.enqueue(text);
+			},
+			flush(controller) {
+				const text = decoder.decode();
+				if (text !== "") controller.enqueue(text);
+			}
+		});
+		this[DECODER] = decoder;
+		this[READABLE] = pipe.readable;
+		this[WRITABLE] = pipe.writable;
+	}
+	get encoding() {
+		return this[DECODER].encoding;
+	}
+	get fatal() {
+		return this[DECODER].fatal;
+	}
+	get ignoreBOM() {
+		return this[DECODER].ignoreBOM;
+	}
+	get readable() {
+		return this[READABLE];
+	}
+	get writable() {
+		return this[WRITABLE];
+	}
+	get [Symbol.toStringTag]() {
+		return "TextDecoderStream";
+	}
+};
+//#endregion
 //#region ../../server/guest-surface/locale-methods.js
 function installUnsupportedLocaleMethods(scope, methods, remedy) {
 	const replaced = [];
@@ -118,7 +232,10 @@ function resolve(scope, target) {
 //#region src/guest-parity.ts
 const SHIMS = {
 	MessageChannel,
-	MessagePort
+	MessageEvent,
+	MessagePort,
+	TextDecoderStream,
+	TextEncoderStream
 };
 function applyGuestParity(options = {}) {
 	const scope = globalThis;
@@ -126,11 +243,16 @@ function applyGuestParity(options = {}) {
 	const undo = [];
 	const removed = [];
 	const exempted = [];
+	const neededByHost = [];
 	for (const entry of unsupportedGlobals()) {
 		if (polyfilled.has(entry.name)) {
 			exempted.push(entry.name);
 			continue;
 		}
+		if (entry.neededByHost) {
+			neededByHost.push(entry.name);
+			continue;
+		}
 		const descriptor = Object.getOwnPropertyDescriptor(scope, entry.name);
 		if (!descriptor) continue;
 		undo.push(() => Object.defineProperty(scope, entry.name, descriptor));
@@ -158,6 +280,7 @@ function applyGuestParity(options = {}) {
 		shimmed,
 		replacedMethods: replaced.map(({ target, name }) => `${target}.${name}`),
 		exempted,
+		neededByHost,
 		restore() {
 			for (const step of undo.reverse()) step();
 			undo.length = 0;

package/dist/guest-parity.d.mts

@@ -9,6 +9,8 @@ interface GuestParity {
   replacedMethods: string[];
   /** Left in place because the project bundles a polyfill for them. */
   exempted: string[];
+  /** Left in place because this process needs them. The guest still has none. */
+  neededByHost: string[];
   restore(): void;
 }
 declare function applyGuestParity(options?: GuestParityOptions): GuestParity;

package/dist/guest-parity.mjs

@@ -1,2 +1,2 @@
-import { t as applyGuestParity } from "./guest-parity-B5GLO6LA.mjs";
+import { t as applyGuestParity } from "./guest-parity-W61MH7Fb.mjs";
 export { applyGuestParity };

package/dist/{guest-surface-4bHyTMIy.mjs → guest-surface-D5X-IMAN.mjs}

@@ -14,6 +14,24 @@ var globals = [
 		"shim": "message-channel",
 		"why": "The other half of the pair: a port handed to code that checks what it received has to be a real constructor."
 	},
+	{
+		"name": "MessageEvent",
+		"status": "shim",
+		"shim": "message-channel",
+		"why": "What the pair above carries. Without it, code that checks `event instanceof MessageEvent` fails against our own shim."
+	},
+	{
+		"name": "TextEncoderStream",
+		"status": "shim",
+		"shim": "text-streams",
+		"why": "The engine has TransformStream and TextEncoder and not this wrapper over them. Every other stream class is there, so the gap is easy to walk into while piping a body."
+	},
+	{
+		"name": "TextDecoderStream",
+		"status": "shim",
+		"shim": "text-streams",
+		"why": "The other direction, and the one a streamed request body is read through."
+	},
 	{
 		"name": "Intl",
 		"status": "unsupported",
@@ -38,6 +56,78 @@ var globals = [
 		"name": "WebSocket",
 		"status": "unsupported",
 		"remedy": "the sandbox has no sockets, so nothing can supply this one; open the connection from the browser instead, or reach a realtime service over HTTPS"
+	},
+	{
+		"name": "EventSource",
+		"status": "unsupported",
+		"remedy": "a run is bounded by the invocation clock, so nothing here can hold a subscription open for a client; subscribe from the browser instead, or poll with fetch"
+	},
+	{
+		"name": "BroadcastChannel",
+		"status": "unsupported",
+		"remedy": "each invocation runs on its own and shares no memory with any other, so there is nobody here to broadcast to; pass the message over fetch to a service that holds it"
+	},
+	{
+		"name": "caches",
+		"status": "unsupported",
+		"remedy": "the platform has no Cache API; keep the value in a service you reach over fetch"
+	},
+	{
+		"name": "FileReader",
+		"status": "unsupported",
+		"remedy": "read the Blob directly: await blob.text(), await blob.arrayBuffer(), or blob.stream()"
+	},
+	{
+		"name": "WebAssembly",
+		"status": "unsupported",
+		"neededByHost": true,
+		"why": "Node compiles its own HTTP parser from WebAssembly the first time anything calls fetch, so a suite that had this taken away would fail inside undici rather than in the code under test.",
+		"remedy": "the guest is itself WebAssembly and cannot load more of it; do the work in JavaScript, or call a service that does it"
+	},
+	{
+		"name": "XMLHttpRequest",
+		"status": "unsupported",
+		"remedy": "use fetch, which the guest has"
+	},
+	{
+		"name": "navigator",
+		"status": "unsupported",
+		"remedy": "nothing here is a browser, so nothing can supply it; ask with typeof navigator and take the other path"
+	},
+	{
+		"name": "localStorage",
+		"status": "unsupported",
+		"remedy": "nothing written in one invocation survives into the next; keep the value in a store you reach over fetch, or hand it back to the caller"
+	},
+	{
+		"name": "sessionStorage",
+		"status": "unsupported",
+		"remedy": "nothing written in one invocation survives into the next; keep the value in a store you reach over fetch, or hand it back to the caller"
+	},
+	{
+		"name": "indexedDB",
+		"status": "unsupported",
+		"remedy": "the sandbox has no database; reach one over fetch"
+	},
+	{
+		"name": "setImmediate",
+		"status": "unsupported",
+		"remedy": "call setTimeout(fn, 0), or queueMicrotask(fn) where the callback must run before the host is yielded to"
+	},
+	{
+		"name": "reportError",
+		"status": "unsupported",
+		"remedy": "throw, or write the error yourself with console.error"
+	},
+	{
+		"name": "Atomics",
+		"status": "unsupported",
+		"remedy": "the guest runs one thread and shares memory with nothing, so there is nothing here to synchronise against; take the single-threaded path"
+	},
+	{
+		"name": "SharedArrayBuffer",
+		"status": "unsupported",
+		"remedy": "the guest runs one thread and shares memory with nothing; use an ArrayBuffer"
 	}
 ];
 var methods = [