@statewalker/webrun-http-browser 0.12.1 → 0.12.2

package/dist/index.js

@@ -1747,7 +1747,7 @@ const LAST_CHUNK = /* @__PURE__ */ new Uint8Array([
 	13,
 	10
 ]);
-const encoder = /* @__PURE__ */ new TextEncoder();
+const encoder$2 = /* @__PURE__ */ new TextEncoder();
 /**
 * Chunk sizes are written in HEXADECIMAL — a 21-byte chunk is `15`. Writing
 * them in decimal is the defect note 15 found in @libp2p/http, and it is the
@@ -1760,7 +1760,7 @@ const encoder = /* @__PURE__ */ new TextEncoder();
 async function* encodeChunked(body) {
 	for await (const chunk of body) {
 		if (chunk.byteLength === 0) continue;
-		yield encoder.encode(`${chunk.byteLength.toString(16)}\r\n`);
+		yield encoder$2.encode(`${chunk.byteLength.toString(16)}\r\n`);
 		yield chunk;
 		yield CRLF;
 	}
@@ -3331,7 +3331,7 @@ const STREAM_ABORT = "webrun-rpc:stream-abort";
 * request, sent only on a port where both ends agreed `pipeline`. The window's
 * credit is its confirmation.
 */
-const CHUNK = "webrun-rpc:chunk";
+const CHUNK$1 = "webrun-rpc:chunk";
 /**
 * What a pipelined chunk counts beyond its bytes, against the window, on the
 * receiving side. Both codecs' windows count more for the chunk's envelope
@@ -3662,7 +3662,7 @@ function receiveChunks(port, channelName, controller, touch, notice) {
 	const watcher = (event) => {
 		const data = event.data;
 		if (data?.channelName !== channelName) return;
-		const chunk = data.type === CHUNK ? data.chunk : data.type === "request" ? data.params : void 0;
+		const chunk = data.type === CHUNK$1 ? data.chunk : data.type === "request" ? data.params : void 0;
 		if (!chunk) return;
 		if (!watchPeerEnd()) {
 			port.removeEventListener("message", watcher);
@@ -3697,7 +3697,7 @@ function receiveChunks(port, channelName, controller, touch, notice) {
 	}, { channelName });
 	const onChunk = (event) => {
 		const data = event.data;
-		if (data?.type !== CHUNK || data.channelName !== channelName || !data.chunk) return;
+		if (data?.type !== CHUNK$1 || data.channelName !== channelName || !data.chunk) return;
 		if (poison) return;
 		const agreement = portAgreement(port);
 		if (!agreement?.caps.has("pipeline")) {
@@ -3810,7 +3810,7 @@ async function sendChunks(port, channelName, output, { maxMessageSize, log }, si
 			});
 			if (mayPipeline(port)) {
 				port.postMessage({
-					type: CHUNK,
+					type: CHUNK$1,
 					channelName,
 					chunk
 				});
@@ -5104,20 +5104,24 @@ function postFrame(port, frame) {
 function messageSize(data) {
 	return typeof data === "string" ? utf8Length(data) : data.byteLength;
 }
-/** The UTF-8 length of `text`, without encoding it. */
+const encoder = new TextEncoder();
+/** Characters encoded per `encodeInto` call: at most 3 bytes each, so the scratch stays at 96 KiB. */
+const CHUNK = 32768;
+const scratch = new Uint8Array(CHUNK * 3);
+/**
+* The UTF-8 length of `text`, as `TextEncoder` would encode it (a lone surrogate counts as the 3
+* bytes of U+FFFD). Every message is measured on both ends (`bufferedAmount` and the byte acks), so
+* this runs natively: `encodeInto` a reused buffer, a chunk at a time, never splitting a surrogate
+* pair across two chunks. A loop over the characters in JavaScript took about 30 times as long.
+*/
 function utf8Length(text) {
 	let length = 0;
-	for (let i = 0; i < text.length; i++) {
-		const code = text.charCodeAt(i);
-		if (code < 128) length += 1;
-		else if (code < 2048) length += 2;
-		else if (code >= 55296 && code <= 56319 && i + 1 < text.length) {
-			const next = text.charCodeAt(i + 1);
-			if (next >= 56320 && next <= 57343) {
-				length += 4;
-				i++;
-			} else length += 3;
-		} else length += 3;
+	for (let start = 0; start < text.length;) {
+		let end = Math.min(start + CHUNK, text.length);
+		const last = text.charCodeAt(end - 1);
+		if (end < text.length && last >= 55296 && last <= 56319) end--;
+		length += encoder.encodeInto(text.slice(start, end), scratch).written;
+		start = end;
 	}
 	return length;
 }

package/dist/sw.js

@@ -706,7 +706,7 @@ const LAST_CHUNK = /* @__PURE__ */ new Uint8Array([
 	13,
 	10
 ]);
-const encoder = /* @__PURE__ */ new TextEncoder();
+const encoder$2 = /* @__PURE__ */ new TextEncoder();
 /**
 * Chunk sizes are written in HEXADECIMAL — a 21-byte chunk is `15`. Writing
 * them in decimal is the defect note 15 found in @libp2p/http, and it is the
@@ -719,7 +719,7 @@ const encoder = /* @__PURE__ */ new TextEncoder();
 async function* encodeChunked(body) {
 	for await (const chunk of body) {
 		if (chunk.byteLength === 0) continue;
-		yield encoder.encode(`${chunk.byteLength.toString(16)}\r\n`);
+		yield encoder$2.encode(`${chunk.byteLength.toString(16)}\r\n`);
 		yield chunk;
 		yield CRLF;
 	}
@@ -2089,7 +2089,7 @@ const STREAM_ABORT = "webrun-rpc:stream-abort";
 * request, sent only on a port where both ends agreed `pipeline`. The window's
 * credit is its confirmation.
 */
-const CHUNK = "webrun-rpc:chunk";
+const CHUNK$1 = "webrun-rpc:chunk";
 /**
 * What a pipelined chunk counts beyond its bytes, against the window, on the
 * receiving side. Both codecs' windows count more for the chunk's envelope
@@ -2420,7 +2420,7 @@ function receiveChunks(port, channelName, controller, touch, notice) {
 	const watcher = (event) => {
 		const data = event.data;
 		if (data?.channelName !== channelName) return;
-		const chunk = data.type === CHUNK ? data.chunk : data.type === "request" ? data.params : void 0;
+		const chunk = data.type === CHUNK$1 ? data.chunk : data.type === "request" ? data.params : void 0;
 		if (!chunk) return;
 		if (!watchPeerEnd()) {
 			port.removeEventListener("message", watcher);
@@ -2455,7 +2455,7 @@ function receiveChunks(port, channelName, controller, touch, notice) {
 	}, { channelName });
 	const onChunk = (event) => {
 		const data = event.data;
-		if (data?.type !== CHUNK || data.channelName !== channelName || !data.chunk) return;
+		if (data?.type !== CHUNK$1 || data.channelName !== channelName || !data.chunk) return;
 		if (poison) return;
 		const agreement = portAgreement(port);
 		if (!agreement?.caps.has("pipeline")) {
@@ -2568,7 +2568,7 @@ async function sendChunks(port, channelName, output, { maxMessageSize, log }, si
 			});
 			if (mayPipeline(port)) {
 				port.postMessage({
-					type: CHUNK,
+					type: CHUNK$1,
 					channelName,
 					chunk
 				});
@@ -3867,20 +3867,24 @@ function postFrame(port, frame) {
 function messageSize(data) {
 	return typeof data === "string" ? utf8Length(data) : data.byteLength;
 }
-/** The UTF-8 length of `text`, without encoding it. */
+const encoder = new TextEncoder();
+/** Characters encoded per `encodeInto` call: at most 3 bytes each, so the scratch stays at 96 KiB. */
+const CHUNK = 32768;
+const scratch = new Uint8Array(CHUNK * 3);
+/**
+* The UTF-8 length of `text`, as `TextEncoder` would encode it (a lone surrogate counts as the 3
+* bytes of U+FFFD). Every message is measured on both ends (`bufferedAmount` and the byte acks), so
+* this runs natively: `encodeInto` a reused buffer, a chunk at a time, never splitting a surrogate
+* pair across two chunks. A loop over the characters in JavaScript took about 30 times as long.
+*/
 function utf8Length(text) {
 	let length = 0;
-	for (let i = 0; i < text.length; i++) {
-		const code = text.charCodeAt(i);
-		if (code < 128) length += 1;
-		else if (code < 2048) length += 2;
-		else if (code >= 55296 && code <= 56319 && i + 1 < text.length) {
-			const next = text.charCodeAt(i + 1);
-			if (next >= 56320 && next <= 57343) {
-				length += 4;
-				i++;
-			} else length += 3;
-		} else length += 3;
+	for (let start = 0; start < text.length;) {
+		let end = Math.min(start + CHUNK, text.length);
+		const last = text.charCodeAt(end - 1);
+		if (end < text.length && last >= 55296 && last <= 56319) end--;
+		length += encoder.encodeInto(text.slice(start, end), scratch).written;
+		start = end;
 	}
 	return length;
 }

package/dist/worker.js

@@ -647,7 +647,7 @@ const LAST_CHUNK = /* @__PURE__ */ new Uint8Array([
 	13,
 	10
 ]);
-const encoder = /* @__PURE__ */ new TextEncoder();
+const encoder$2 = /* @__PURE__ */ new TextEncoder();
 /**
 * Chunk sizes are written in HEXADECIMAL — a 21-byte chunk is `15`. Writing
 * them in decimal is the defect note 15 found in @libp2p/http, and it is the
@@ -660,7 +660,7 @@ const encoder = /* @__PURE__ */ new TextEncoder();
 async function* encodeChunked(body) {
 	for await (const chunk of body) {
 		if (chunk.byteLength === 0) continue;
-		yield encoder.encode(`${chunk.byteLength.toString(16)}\r\n`);
+		yield encoder$2.encode(`${chunk.byteLength.toString(16)}\r\n`);
 		yield chunk;
 		yield CRLF;
 	}
@@ -1975,7 +1975,7 @@ const STREAM_ABORT = "webrun-rpc:stream-abort";
 * request, sent only on a port where both ends agreed `pipeline`. The window's
 * credit is its confirmation.
 */
-const CHUNK = "webrun-rpc:chunk";
+const CHUNK$1 = "webrun-rpc:chunk";
 /**
 * What a pipelined chunk counts beyond its bytes, against the window, on the
 * receiving side. Both codecs' windows count more for the chunk's envelope
@@ -2306,7 +2306,7 @@ function receiveChunks(port, channelName, controller, touch, notice) {
 	const watcher = (event) => {
 		const data = event.data;
 		if (data?.channelName !== channelName) return;
-		const chunk = data.type === CHUNK ? data.chunk : data.type === "request" ? data.params : void 0;
+		const chunk = data.type === CHUNK$1 ? data.chunk : data.type === "request" ? data.params : void 0;
 		if (!chunk) return;
 		if (!watchPeerEnd()) {
 			port.removeEventListener("message", watcher);
@@ -2341,7 +2341,7 @@ function receiveChunks(port, channelName, controller, touch, notice) {
 	}, { channelName });
 	const onChunk = (event) => {
 		const data = event.data;
-		if (data?.type !== CHUNK || data.channelName !== channelName || !data.chunk) return;
+		if (data?.type !== CHUNK$1 || data.channelName !== channelName || !data.chunk) return;
 		if (poison) return;
 		const agreement = portAgreement(port);
 		if (!agreement?.caps.has("pipeline")) {
@@ -2454,7 +2454,7 @@ async function sendChunks(port, channelName, output, { maxMessageSize, log }, si
 			});
 			if (mayPipeline(port)) {
 				port.postMessage({
-					type: CHUNK,
+					type: CHUNK$1,
 					channelName,
 					chunk
 				});
@@ -3678,20 +3678,24 @@ function postFrame(port, frame) {
 function messageSize(data) {
 	return typeof data === "string" ? utf8Length(data) : data.byteLength;
 }
-/** The UTF-8 length of `text`, without encoding it. */
+const encoder = new TextEncoder();
+/** Characters encoded per `encodeInto` call: at most 3 bytes each, so the scratch stays at 96 KiB. */
+const CHUNK = 32768;
+const scratch = new Uint8Array(CHUNK * 3);
+/**
+* The UTF-8 length of `text`, as `TextEncoder` would encode it (a lone surrogate counts as the 3
+* bytes of U+FFFD). Every message is measured on both ends (`bufferedAmount` and the byte acks), so
+* this runs natively: `encodeInto` a reused buffer, a chunk at a time, never splitting a surrogate
+* pair across two chunks. A loop over the characters in JavaScript took about 30 times as long.
+*/
 function utf8Length(text) {
 	let length = 0;
-	for (let i = 0; i < text.length; i++) {
-		const code = text.charCodeAt(i);
-		if (code < 128) length += 1;
-		else if (code < 2048) length += 2;
-		else if (code >= 55296 && code <= 56319 && i + 1 < text.length) {
-			const next = text.charCodeAt(i + 1);
-			if (next >= 56320 && next <= 57343) {
-				length += 4;
-				i++;
-			} else length += 3;
-		} else length += 3;
+	for (let start = 0; start < text.length;) {
+		let end = Math.min(start + CHUNK, text.length);
+		const last = text.charCodeAt(end - 1);
+		if (end < text.length && last >= 55296 && last <= 56319) end--;
+		length += encoder.encodeInto(text.slice(start, end), scratch).written;
+		start = end;
 	}
 	return length;
 }

package/dist/ws/frames.d.ts

@@ -63,6 +63,11 @@ export declare function readFrame(data: unknown): WsFrame | undefined;
 export declare function postFrame(port: MessagePort, frame: WsFrame): void;
 /** The size a message counts for in `bufferedAmount`: UTF-8 bytes, or the buffer's length. */
 export declare function messageSize(data: string | ArrayBuffer): number;
-/** The UTF-8 length of `text`, without encoding it. */
+/**
+ * The UTF-8 length of `text`, as `TextEncoder` would encode it (a lone surrogate counts as the 3
+ * bytes of U+FFFD). Every message is measured on both ends (`bufferedAmount` and the byte acks), so
+ * this runs natively: `encodeInto` a reused buffer, a chunk at a time, never splitting a surrogate
+ * pair across two chunks. A loop over the characters in JavaScript took about 30 times as long.
+ */
 export declare function utf8Length(text: string): number;
 //# sourceMappingURL=frames.d.ts.map

package/dist/ws/frames.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../../src/ws/frames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,qDAAqD;AACrD,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAE3C,oEAAoE;AACpE,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAE9C,MAAM,MAAM,OAAO,GACf;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAA;CAAE,GACnC;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACtB;IAAE,CAAC,EAAE,GAAG,CAAA;CAAE,GACV;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1B;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAChD,YAAY,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,WAAW,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IACjD,aAAa,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;CAClC;AAED,eAAO,MAAM,aAAa,EAAE,QAK3B,CAAC;AAEF,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CA2B5D;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAGjE;AAED,8FAA8F;AAC9F,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,CAE9D;AAED,uDAAuD;AACvD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAe/C"}
+{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../../src/ws/frames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,qDAAqD;AACrD,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAE3C,oEAAoE;AACpE,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAE9C,MAAM,MAAM,OAAO,GACf;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAA;CAAE,GACnC;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACtB;IAAE,CAAC,EAAE,GAAG,CAAA;CAAE,GACV;IAAE,CAAC,EAAE,GAAG,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1B;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,UAAU,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAChD,YAAY,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,WAAW,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IACjD,aAAa,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;CAClC;AAED,eAAO,MAAM,aAAa,EAAE,QAK3B,CAAC;AAEF,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CA2B5D;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAGjE;AAED,8FAA8F;AAC9F,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,CAE9D;AAOD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW/C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statewalker/webrun-http-browser",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "private": false,
   "type": "module",
   "description": "ServiceWorker-based HTTP and WebSocket server for browsers: handlers in pages and Dedicated Workers, same-origin and relay modes, streams with backpressure",
@@ -58,9 +58,9 @@
   ],
   "dependencies": {
     "idb-keyval": "^6.3.0",
-    "@statewalker/webrun-streams": "^0.2.3",
+    "@statewalker/webrun-http-streams": "^0.4.0",
     "@statewalker/webrun-rpc": "^0.10.0",
-    "@statewalker/webrun-http-streams": "^0.4.0"
+    "@statewalker/webrun-streams": "^0.2.3"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.15",

package/src/ws/frames.ts

@@ -100,20 +100,26 @@ export function messageSize(data: string | ArrayBuffer): number {
   return typeof data === "string" ? utf8Length(data) : data.byteLength;
 }
 
-/** The UTF-8 length of `text`, without encoding it. */
+const encoder = new TextEncoder();
+/** Characters encoded per `encodeInto` call: at most 3 bytes each, so the scratch stays at 96 KiB. */
+const CHUNK = 32_768;
+const scratch = new Uint8Array(CHUNK * 3);
+
+/**
+ * The UTF-8 length of `text`, as `TextEncoder` would encode it (a lone surrogate counts as the 3
+ * bytes of U+FFFD). Every message is measured on both ends (`bufferedAmount` and the byte acks), so
+ * this runs natively: `encodeInto` a reused buffer, a chunk at a time, never splitting a surrogate
+ * pair across two chunks. A loop over the characters in JavaScript took about 30 times as long.
+ */
 export function utf8Length(text: string): number {
   let length = 0;
-  for (let i = 0; i < text.length; i++) {
-    const code = text.charCodeAt(i);
-    if (code < 0x80) length += 1;
-    else if (code < 0x800) length += 2;
-    else if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) {
-      const next = text.charCodeAt(i + 1);
-      if (next >= 0xdc00 && next <= 0xdfff) {
-        length += 4;
-        i++;
-      } else length += 3;
-    } else length += 3;
+  for (let start = 0; start < text.length; ) {
+    let end = Math.min(start + CHUNK, text.length);
+    // A high surrogate ending the chunk goes with its low surrogate into the next one.
+    const last = text.charCodeAt(end - 1);
+    if (end < text.length && last >= 0xd800 && last <= 0xdbff) end--;
+    length += encoder.encodeInto(text.slice(start, end), scratch).written;
+    start = end;
   }
   return length;
 }