@deslop/coding-standards 0.1.1257 → 0.1.1258

package/dist/upgrade-B6wL9Y5m.mjs

@@ -0,0 +1,615 @@
+import { $a as ensure, Bn as fail, Dt as optional, Fr as suspend, Ir as sync, Ni as provide, Oi as addFinalizer, Pr as succeed, Qs as hasProperty, Vr as timeoutOrElse, Wo as Service, Yr as void_, Zo as merge, Zr as withFiber, bt as Union, er as gen, ft as Literals, gn as acquireRelease, gt as String, hc as identity, kr as scope, kt as tag, on as value, ot as Defect, qr as updateContext, st as Error$1, ut as Int, vo as map, vt as TaggedError, wn as callback, xn as as } from "./rules-DTNpsy5k.mjs";
+import { t as makeUnsafe } from "./main.cli.js";
+import { Readable, finished } from "node:stream";
+import { Buffer as Buffer$1 } from "node:buffer";
+import * as Tls from "node:tls";
+// ../../node_modules/.pnpm/effect@4.1.2/node_modules/effect/dist/socket/Socket.js
+/**
+* Runtime type identifier attached to `Socket` services.
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect/socket/Socket";
+/**
+* Service tag for bidirectional socket transports.
+*
+* **When to use**
+*
+* Use to access or provide the socket implementation used by programs that
+* read and write frames through the Effect environment.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const Socket = /*#__PURE__*/ Service("effect/socket/Socket");
+/**
+* Constructs a `Socket` from a reader acquisition and a scoped writer.
+*
+* **Details**
+*
+* The reader must fail a suspended pull when its acquisition scope closes; see
+* `Socket` for why. A reader that leaves a pull blocked forever will hang any
+* consumer that shuts the socket down by closing that scope.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make = (options) => Socket.of({
+	[TypeId]: TypeId,
+	reader: options.reader,
+	writer: options.writer
+});
+const CloseEventTypeId = "~effect/socket/Socket/CloseEvent";
+/**
+* Returns `true` when a value is a `CloseEvent`.
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isCloseEvent = (u) => hasProperty(u, CloseEventTypeId);
+/**
+* Runtime type identifier attached to `SocketError` values.
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const SocketErrorTypeId = "~effect/socket/Socket/SocketError";
+/**
+* Returns `true` when a value is a `SocketError`.
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isSocketError = (u) => hasProperty(u, SocketErrorTypeId);
+/**
+* Typed error for failures that occur while reading from a socket.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketReadError = class extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketReadError")({
+	_tag: /*#__PURE__*/ tag("SocketReadError"),
+	cause: /*#__PURE__*/ Defect()
+})) {
+	/**
+	* Default message used for socket read failures.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	message = `An error occurred during Read`;
+};
+/**
+* Typed error for failures that occur while writing to a socket.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketWriteError = class extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketWriteError")({
+	_tag: /*#__PURE__*/ tag("SocketWriteError"),
+	cause: /*#__PURE__*/ Defect()
+})) {
+	/**
+	* Default message used for socket write failures.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	message = `An error occurred during Write`;
+};
+/**
+* Typed error for failures that occur while opening a socket, including
+* unknown open failures and open timeouts.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketOpenError = class extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketOpenError")({
+	_tag: /*#__PURE__*/ tag("SocketOpenError"),
+	kind: /*#__PURE__*/ Literals(["Unknown", "Timeout"]),
+	cause: /*#__PURE__*/ Defect()
+})) {
+	/**
+	* Formats timeout and unknown open failures for display.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	get message() {
+		return this.kind === "Timeout" ? `timeout waiting for "open"` : `An error occurred during Open`;
+	}
+};
+/**
+* Typed error for an unsupported or failed in-place TLS upgrade.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketUpgradeError = class SocketUpgradeError extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketUpgradeError")({
+	_tag: /*#__PURE__*/ tag("SocketUpgradeError"),
+	cause: /*#__PURE__*/ optional(/*#__PURE__*/ Defect())
+})) {
+	/**
+	* An upgrade implementation for transports that cannot wrap the connection
+	* with TLS.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	static unsupported = () => fail(new SocketError({ reason: new SocketUpgradeError({}) }));
+	get message() {
+		return this.cause === void 0 ? `Socket does not support TLS upgrade` : `An error occurred during TLS upgrade`;
+	}
+};
+/**
+* Typed error for a socket close, carrying the close code and optional close
+* reason.
+*
+* **Details**
+*
+* Sockets never classify closes: any close, whatever the code, fails the
+* reader with a `SocketError` wrapping this reason. Consumers that treat a
+* close as normal catch it.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketCloseError = class extends (/*#__PURE__*/ Error$1("effect/socket/Socket/SocketCloseError")({
+	_tag: /*#__PURE__*/ tag("SocketCloseError"),
+	code: Int,
+	closeReason: /*#__PURE__*/ optional(String)
+})) {
+	get message() {
+		if (this.closeReason) return `${this.code}: ${this.closeReason}`;
+		return `${this.code}`;
+	}
+};
+/**
+* Schema for all socket-specific error reasons.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+const SocketErrorReason = /*#__PURE__*/ Union([
+	SocketReadError,
+	SocketWriteError,
+	SocketOpenError,
+	SocketUpgradeError,
+	SocketCloseError
+]);
+/**
+* Tagged error that wraps socket read, write, open, upgrade, and close failures
+* while preserving the underlying reason.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SocketError = class extends (/*#__PURE__*/ TaggedError(SocketErrorTypeId)("SocketError", {
+	_tag: /*#__PURE__*/ tag("SocketError"),
+	reason: SocketErrorReason
+})) {
+	constructor(props) {
+		if ("cause" in props.reason) super({
+			...props,
+			cause: props.reason.cause
+		});
+		else super(props);
+	}
+	/**
+	* Marks this value as a socket error wrapper for runtime guards.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	[SocketErrorTypeId] = SocketErrorTypeId;
+	/**
+	* Returns `true` when the value is a `SocketError`.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	static is(u) {
+		return isSocketError(u);
+	}
+	message = this.reason.message;
+};
+// ../../node_modules/.pnpm/@effect+platform-node-shared@4.1.2_effect@4.1.2/node_modules/@effect/platform-node-shared/dist/NodeSocket.js
+/**
+* Node socket adapters for Effect sockets.
+*
+* This module opens `node:net` or `node:tls` connections, or wraps existing
+* Node `Duplex` streams, and presents them as `Socket.Socket` values, socket
+* channels, or layers. It also exposes the `NetSocket` service tag for the
+* underlying Node socket.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+const isDeno = "Deno" in globalThis;
+const readAvailable = (conn, chunkSize) => {
+	const first = conn.read();
+	if (first === null) return void 0;
+	const out = [first];
+	let chunk;
+	while (out.length < chunkSize && (chunk = conn.read()) !== null) out.push(chunk);
+	return out;
+};
+const toBuffers = (input) => map(ensure(input), (value) => Buffer$1.from(value));
+/**
+* Adapts a Node `Duplex` into a `Socket.Socket`.
+*
+* **Details**
+*
+* Reader acquisition opens the duplex and keeps it paused: each pull reads at
+* most `chunkSize` chunks (default 4096) with `stream.read()`. On Node 26+ that
+* yields each buffered chunk as a separate batch element with no copy. Earlier Node
+* concatenates the buffer into one chunk. The stream is never resumed, so once
+* Node's buffer reaches its `highWaterMark` the kernel receive window closes
+* and the peer blocks: backpressure is end-to-end with no buffering above
+* Node's own.
+*
+* Writes use `write()` return-value backpressure, awaiting one `drain` when
+* the internal buffer is full. `writeAll` corks the stream around the batch.
+* Releasing the writer scope half-closes the stream (`end()`).
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromDuplex = (open, options) => withFiber((fiber) => {
+	let currentSocket;
+	const latch = makeUnsafe(false);
+	const openServices = fiber.context;
+	const isServer = options?.tlsServer === true;
+	const requestedChunkSize = options?.chunkSize ?? 4096;
+	const chunkSize = requestedChunkSize === Infinity || Number.isSafeInteger(requestedChunkSize) && requestedChunkSize > 0 ? requestedChunkSize : 4096;
+	const secureEvent = isServer ? "secure" : "secureConnect";
+	const reader = gen(function* () {
+		const scope$1 = yield* scope;
+		let conn = yield* provide(open, scope$1).pipe(options?.openTimeout !== void 0 ? timeoutOrElse({
+			duration: options.openTimeout,
+			orElse: () => fail(new SocketError({ reason: new SocketOpenError({
+				kind: "Timeout",
+				cause: /* @__PURE__ */ new Error("Connection timed out")
+			}) }))
+		}) : identity);
+		let error;
+		let waiter;
+		let pending;
+		let reading = false;
+		let closed = false;
+		let upgradeAvailable = true;
+		function drain() {
+			if (waiter === void 0 || reading) return;
+			let chunk = pending;
+			pending = void 0;
+			if (chunk === void 0 && !closed) {
+				reading = true;
+				try {
+					chunk = readAvailable(conn, chunkSize);
+				} finally {
+					reading = false;
+				}
+			}
+			if (closed) chunk = void 0;
+			if (waiter === void 0) {
+				pending = chunk;
+				return;
+			}
+			const result = chunk !== void 0 ? succeed(chunk) : error !== void 0 ? fail(error) : void 0;
+			if (result === void 0) return;
+			const resume = waiter;
+			waiter = void 0;
+			resume(result);
+		}
+		function end(err) {
+			error ??= err;
+			drain();
+		}
+		function close(err) {
+			error ??= err;
+			closed = true;
+			pending = void 0;
+			drain();
+		}
+		function onEnd() {
+			end(new SocketError({ reason: new SocketCloseError({ code: 1e3 }) }));
+		}
+		function onError(cause) {
+			close(new SocketError({ reason: new SocketReadError({ cause }) }));
+		}
+		function onClose(hadError) {
+			const err = new SocketError({ reason: new SocketCloseError({ code: hadError ? 1006 : 1e3 }) });
+			if (hadError) close(err);
+			else end(err);
+		}
+		function attachReadListeners(conn) {
+			conn.on("readable", drain);
+			conn.on("end", onEnd);
+			conn.on("error", onError);
+			conn.on("close", onClose);
+		}
+		function detachReadListeners(conn) {
+			conn.off("readable", drain);
+			conn.off("end", onEnd);
+			conn.off("error", onError);
+			conn.off("close", onClose);
+		}
+		if (!isDeno) conn.pause();
+		attachReadListeners(conn);
+		yield* addFinalizer(scope$1, sync(() => {
+			close(new SocketError({ reason: new SocketCloseError({ code: 1006 }) }));
+			detachReadListeners(conn);
+			latch.closeUnsafe();
+			currentSocket = void 0;
+			upgradeAvailable = false;
+		}));
+		currentSocket = conn;
+		latch.openUnsafe();
+		const pull = callback((resume) => {
+			waiter = resume;
+			drain();
+			if (waiter !== resume) return;
+			return sync(() => {
+				if (waiter === resume) waiter = void 0;
+			});
+		});
+		const upgrade = (upgradeOptions = {}) => suspend(() => {
+			if (!upgradeAvailable) return fail(new SocketError({ reason: new SocketUpgradeError({ cause: /* @__PURE__ */ new Error("socket is already upgraded or closed") }) }));
+			const hasKey = upgradeOptions.key !== void 0;
+			const hasCert = upgradeOptions.cert !== void 0;
+			if (isServer && (!hasKey || !hasCert) || hasKey !== hasCert) return fail(new SocketError({ reason: new SocketUpgradeError({ cause: /* @__PURE__ */ new Error(isServer ? "server TLS upgrade requires both key and cert" : "TLS upgrade credentials must include both key and cert") }) }));
+			return callback((resume) => {
+				const raw = conn;
+				detachReadListeners(raw);
+				let tls;
+				try {
+					const tlsOptions = {
+						secureContext: Tls.createSecureContext({
+							key: upgradeOptions.key === void 0 ? void 0 : map(ensure(upgradeOptions.key), (value$1) => Buffer$1.from(value(value$1))),
+							cert: upgradeOptions.cert === void 0 ? void 0 : toBuffers(upgradeOptions.cert),
+							ca: upgradeOptions.ca === void 0 ? void 0 : toBuffers(upgradeOptions.ca),
+							passphrase: upgradeOptions.passphrase === void 0 ? void 0 : value(upgradeOptions.passphrase)
+						}),
+						ALPNProtocols: upgradeOptions.alpnProtocols === void 0 ? void 0 : [...upgradeOptions.alpnProtocols],
+						requestCert: upgradeOptions.requestCert,
+						rejectUnauthorized: upgradeOptions.rejectUnauthorized
+					};
+					tls = isServer ? new Tls.TLSSocket(raw, {
+						...tlsOptions,
+						isServer: true
+					}) : Tls.connect({
+						...tlsOptions,
+						servername: upgradeOptions.servername,
+						socket: raw
+					});
+				} catch (cause) {
+					attachReadListeners(raw);
+					resume(fail(new SocketError({ reason: new SocketUpgradeError({ cause }) })));
+					return;
+				}
+				conn = tls;
+				currentSocket = tls;
+				tls.pause();
+				function cleanup() {
+					tls.off(secureEvent, succeed);
+					tls.off("error", failUpgrade);
+					tls.off("close", onUpgradeClose);
+				}
+				function succeed() {
+					cleanup();
+					upgradeAvailable = false;
+					attachReadListeners(tls);
+					resume(void_);
+				}
+				function failUpgrade(cause) {
+					cleanup();
+					const upgradeError = new SocketError({ reason: new SocketUpgradeError({ cause }) });
+					close(upgradeError);
+					resume(fail(upgradeError));
+				}
+				function onUpgradeClose() {
+					failUpgrade(/* @__PURE__ */ new Error("socket closed during TLS upgrade"));
+				}
+				tls.once(secureEvent, succeed);
+				tls.once("error", failUpgrade);
+				tls.once("close", onUpgradeClose);
+				return sync(() => {
+					cleanup();
+					close(new SocketError({ reason: new SocketCloseError({ code: 1006 }) }));
+					tls.destroy();
+				});
+			});
+		});
+		return {
+			pull,
+			upgrade
+		};
+	}).pipe(updateContext((input) => merge(openServices, input)));
+	const awaitDrain = (conn) => callback((resume) => {
+		function cleanup() {
+			conn.off("drain", onDrain);
+			conn.off("error", onError);
+			conn.off("close", onClose);
+		}
+		function onDrain() {
+			cleanup();
+			resume(void_);
+		}
+		function onError(cause) {
+			cleanup();
+			resume(fail(new SocketError({ reason: new SocketWriteError({ cause }) })));
+		}
+		function onClose() {
+			cleanup();
+			resume(fail(new SocketError({ reason: new SocketWriteError({ cause: /* @__PURE__ */ new Error("socket closed") }) })));
+		}
+		conn.on("drain", onDrain);
+		conn.on("error", onError);
+		conn.on("close", onClose);
+		return sync(cleanup);
+	});
+	const write = (chunk) => suspend(() => {
+		const conn = currentSocket;
+		if (conn === void 0) return latch.whenOpen(write(chunk));
+		if (isCloseEvent(chunk)) {
+			conn.destroy(chunk.code > 1e3 ? /* @__PURE__ */ new Error(`closed with code ${chunk.code}`) : void 0);
+			return void_;
+		}
+		try {
+			return conn.write(chunk) ? void_ : awaitDrain(conn);
+		} catch (cause) {
+			return fail(new SocketError({ reason: new SocketWriteError({ cause }) }));
+		}
+	});
+	const writeAll = (chunks) => suspend(() => {
+		const conn = currentSocket;
+		if (conn === void 0) return latch.whenOpen(writeAll(chunks));
+		let needsDrain = false;
+		try {
+			if (chunks.length === 1) needsDrain = !conn.write(chunks[0]);
+			else {
+				conn.cork();
+				try {
+					for (let i = 0; i < chunks.length; i++) needsDrain = !conn.write(chunks[i]) || needsDrain;
+				} finally {
+					conn.uncork();
+				}
+			}
+		} catch (cause) {
+			return fail(new SocketError({ reason: new SocketWriteError({ cause }) }));
+		}
+		return needsDrain ? awaitDrain(conn) : void_;
+	});
+	const writer = acquireRelease(succeed({
+		write,
+		writeAll
+	}), () => sync(() => {
+		if (!currentSocket || currentSocket.writableEnded) return;
+		currentSocket.end();
+	}));
+	return succeed(make({
+		reader,
+		writer
+	}));
+});
+// ../../node_modules/.pnpm/@effect+platform-node@4.1.2_effect@4.1.2_redis@6.3.1/node_modules/@effect/platform-node/dist/internal/upgrade.js
+/**
+* Wraps an upgraded connection. Acquiring the reader runs `open`; releasing
+* its scope closes the connection.
+*
+* No `data` listener is attached before acquisition, so early bytes stay buffered.
+*
+* @internal
+*/
+const toSocket = (conn, open = void_) => fromDuplex(acquireRelease(suspend(() => conn.destroyed ? fail(openError("The upgraded connection closed before it was read")) : as(open, conn)), (conn) => sync(() => {
+	if (conn.destroyed) return;
+	if ("destroySoon" in conn) conn.destroySoon();
+	else conn.destroy();
+})));
+const openError = (cause) => new SocketError({ reason: new SocketOpenError({
+	kind: "Unknown",
+	cause: typeof cause === "string" ? new Error(cause) : cause
+}) });
+/**
+* Node 25 and older stop parsing at the head of an upgrade request, leaving
+* the body in `head` and on the connection. Reads a `Content-Length` body
+* from them on demand and returns the bytes after it.
+*
+* @internal
+*/
+const frameBody = (conn, head, length) => {
+	if (head.length >= length) return {
+		body: Readable.from(length === 0 ? [] : [head.subarray(0, length)], { objectMode: false }),
+		rest: head.subarray(length)
+	};
+	let remaining = length - head.length;
+	let reading = false;
+	const stop = () => {
+		conn.off("readable", onReadable);
+		conn.off("end", onEnd);
+	};
+	const onReadable = () => {
+		while (remaining > 0) {
+			let chunk = conn.read();
+			if (chunk === null) return;
+			if (chunk.length > remaining) {
+				conn.unshift(chunk.subarray(remaining));
+				chunk = chunk.subarray(0, remaining);
+			}
+			remaining -= chunk.length;
+			if (!body.push(chunk) && remaining > 0) return;
+		}
+		stop();
+		body.push(null);
+	};
+	const onEnd = () => {
+		stop();
+		body.destroy(/* @__PURE__ */ new Error("The connection closed before the request body ended"));
+	};
+	const body = new Readable({
+		read() {
+			if (reading) return onReadable();
+			reading = true;
+			if (head.length > 0) this.push(head);
+			if (conn.readableEnded) return onEnd();
+			conn.on("readable", onReadable);
+			conn.on("end", onEnd);
+		},
+		destroy(error, callback) {
+			stop();
+			callback(error);
+		}
+	});
+	body.on("error", () => {});
+	return {
+		body,
+		rest: Buffer.alloc(0)
+	};
+};
+/**
+* Waits for the request body to end before the `101` is written, discarding
+* any of it the handler did not read, up to `maxBytes`.
+*
+* @internal
+*/
+const drainBody = (body, maxBytes) => callback((resume) => {
+	if (body.readableEnded) return resume(void_);
+	let bytes = 0;
+	const cleanup = finished(body, {
+		readable: true,
+		writable: false
+	}, (error) => {
+		done();
+		resume(error ? fail(openError(error)) : void_);
+	});
+	function onData(chunk) {
+		bytes += chunk.length;
+		if (maxBytes !== void 0 && bytes > maxBytes) {
+			done();
+			resume(fail(openError("The request body exceeds the maximum body size")));
+		}
+	}
+	function done() {
+		body.off("data", onData);
+		cleanup();
+	}
+	body.on("data", onData);
+	body.resume();
+	return sync(done);
+});
+export { drainBody, frameBody, toSocket };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deslop/coding-standards",
-  "version": "0.1.1257",
+  "version": "0.1.1258",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MP281X/deslop.git",
@@ -28,14 +28,13 @@
     "access": "public"
   },
   "dependencies": {
+    "@effect/platform-node": "latest",
     "@shadcn/lint": "latest",
     "@typeonce/oxlint-plugin-effect-machine": "latest",
     "effect": "latest",
+    "oxc-parser": "latest",
     "oxlint-plugin-react-doctor": "latest"
   },
-  "devDependencies": {
-    "@effect/platform-node": "latest"
-  },
   "peerDependencies": {
     "@effect/tsgo": ">=0.67",
     "vite-plus": "^1.3"