@deslop/workbench 0.0.320 → 0.0.321

package/dist/server.js

@@ -6250,6 +6250,96 @@ function isOutOfBounds(i, as) {
 }
 const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
 /**
+* Reads an element at the given index safely, returning `Option.some` or
+* `Option.none` if the index is out of bounds.
+*
+* **When to use**
+*
+* Use when you need to read an array element by index and handle an
+* out-of-bounds index as `Option.none`.
+*
+* **Details**
+*
+* - The index is floored to an integer.
+* - Never throws.
+*
+* **Example** (Safe index access)
+*
+* ```ts
+* import { Array } from "effect"
+*
+* console.log(Array.get([1, 2, 3], 1)) // Some(2)
+* console.log(Array.get([1, 2, 3], 10)) // None
+* ```
+*
+* @see {@link getUnsafe} for indexed access that throws when the index is out of bounds
+* @see {@link head} for reading the first element as an `Option`
+* @see {@link last} for reading the last element as an `Option`
+*
+* @category getters
+* @since 2.0.0
+*/
+const get$10 = /*#__PURE__*/ dual(2, (self, index) => {
+	const i = Math.floor(index);
+	return isOutOfBounds(i, self) ? none() : some$1(self[i]);
+});
+/**
+* Reads an element at the given index, throwing if the index is out of bounds.
+*
+* **When to use**
+*
+* Use to read an element at a known valid index when out-of-bounds would be a
+* programming error.
+*
+* **Details**
+*
+* - Throws an `Error` with the message `"Index out of bounds: <i>"`.
+* - Prefer {@link get} for safe access.
+*
+* **Example** (Unsafe index access)
+*
+* ```ts
+* import { Array } from "effect"
+*
+* console.log(Array.getUnsafe([1, 2, 3], 1)) // 2
+* // Array.getUnsafe([1, 2, 3], 10) // throws Error
+* ```
+*
+* @see {@link get} — safe version returning `Option`
+*
+* @category unsafe
+* @since 4.0.0
+*/
+const getUnsafe$1 = /*#__PURE__*/ dual(2, (self, index) => {
+	const i = Math.floor(index);
+	if (isOutOfBounds(i, self)) throw new Error(`Index out of bounds: ${i}`);
+	return self[i];
+});
+/**
+* Returns the first element of an array safely wrapped in `Option.some`, or
+* `Option.none` if the array is empty.
+*
+* **When to use**
+*
+* Use to safely get the first element of an array that may be empty.
+*
+* **Example** (Getting the first element)
+*
+* ```ts
+* import { Array } from "effect"
+*
+* console.log(Array.head([1, 2, 3])) // Some(1)
+* console.log(Array.head([])) // None
+* ```
+*
+* @see {@link headNonEmpty} — direct access when array is known non-empty
+* @see {@link last} — get the last element
+*
+* @category getters
+* @since 2.0.0
+*/
+const head = /*#__PURE__*/ get$10(0);
+/**
 * Returns the first element of a `NonEmptyReadonlyArray` directly (no `Option`
 * wrapper).
 *
@@ -6271,11 +6361,7 @@ const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
 * @category getters
 * @since 2.0.0
 */
-const headNonEmpty = /*#__PURE__*/ (/* @__PURE__ */ dual(2, (self, index) => {
-	const i = Math.floor(index);
-	if (isOutOfBounds(i, self)) throw new Error(`Index out of bounds: ${i}`);
-	return self[i];
-}))(0);
+const headNonEmpty = /*#__PURE__*/ getUnsafe$1(0);
 /**
 * Returns the last element of an array safely wrapped in `Option.some`, or
 * `Option.none` if the array is empty.
@@ -32223,6 +32309,28 @@ function decodeUnknownEffect$1(schema, options) {
 	return options === void 0 ? parser : (input, overrideOptions) => parser(input, mergeParseOptions(options, overrideOptions));
 }
 /**
+* Creates a decoder for `unknown` input that returns an `Option` safely.
+*
+* **When to use**
+*
+* Use when you need a synchronous yes/no decode from untyped input and do not
+* need schema issue details.
+*
+* **Details**
+*
+* The returned function produces `Option.some` with the decoded `Type` on success
+* or `Option.none` on failure, discarding issue details.
+*
+* @see {@link decodeOption} for input already typed as the schema's `Encoded` type
+* @see {@link decodeUnknownResult} for retaining schema issues as data
+*
+* @category decoding
+* @since 3.10.0
+*/
+function decodeUnknownOption$1(schema, options) {
+	return asOption(decodeUnknownEffect$1(schema, options));
+}
+/**
 * Creates an effectful encoder for `unknown` input.
 *
 * **When to use**
@@ -32306,6 +32414,11 @@ function run(ast) {
 function asExit(parser) {
 	return (input, options) => runSyncExit(parser(input, options));
 }
+/** @internal */
+function asOption(parser) {
+	const parserExit = asExit(parser);
+	return (input, options) => getSuccess(parserExit(input, options));
+}
 function asSync(parser) {
 	return (input, options) => runSync(mapErrorEager(parser(input, options), (issue) => new Error(issue.toString(), { cause: issue })));
 }
@@ -32597,6 +32710,26 @@ function decodeUnknownEffect(schema, options) {
 */
 const decodeEffect = decodeUnknownEffect;
 /**
+* Decodes an `unknown` input against a schema, returning an `Option` that is
+* `Some` with the decoded value on success or `None` on failure.
+*
+* **When to use**
+*
+* Use when the input type is not statically known and you only need to know
+* whether decoding succeeded.
+*
+* **Details**
+*
+* Prefer this over {@link decodeUnknownExit} or {@link decodeUnknownEffect}
+* when you don't need error details. For typed input use {@link decodeOption}.
+* Options may be provided either when creating the decoder or when applying it;
+* application options override creation options.
+*
+* @category decoding
+* @since 3.10.0
+*/
+const decodeUnknownOption = decodeUnknownOption$1;
+/**
 * Encodes an `unknown` input against a schema, returning an `Effect` that
 * succeeds with the encoded value or fails with a {@link SchemaError}.
 *
@@ -52449,6 +52582,7 @@ var GitWorktree = class extends Service()("@deslop/git/service/GitWorktree", { m
 };
 //#endregion
 //#region ../../packages/portless/src/lib/utils.ts
+const PackageJson = Struct({ scripts: optional(Record(String$1, String$1)) });
 function command(script, port) {
 	return make$40("vp", [
 		"run",
@@ -52474,23 +52608,23 @@ const discover = fnUntraced(function* (cwd, input) {
 		"package.json",
 		"**/package.json"
 	], { cwd }));
-	return yield* pipe(pipe(split$1("\n")(output), filter$2((path) => path === "package.json" || endsWith("/package.json")(path))), map$7((packagePath) => pipe(pipe(fs.readFileString(path.join(cwd, packagePath)), map$4((source) => ({
-		packageJson: JSON.parse(source),
-		packagePath
-	})), catch_$2(() => succeed$3(void 0))), flatMap$2((result) => {
-		if (result === void 0) return succeed$3([]);
-		const packageDirectory = result.packagePath === "package.json" ? cwd : path.join(cwd, path.dirname(result.packagePath));
+	return yield* pipe(pipe(split$1("\n")(output), filter$2((path) => path === "package.json" || endsWith("/package.json")(path))), map$7((packagePath) => pipe(fs.readFileString(path.join(cwd, packagePath)), flatMap$2((source) => try_({
+		catch: (error) => error,
+		try: () => pipe(JSON.parse(source), decodeUnknownOption(PackageJson))
+	})), catch_$2(() => succeed$3(none())), flatMap$2((packageJson) => {
+		if (isNone(packageJson)) return succeed$3([]);
+		const packageDirectory = packagePath === "package.json" ? cwd : path.join(cwd, path.dirname(packagePath));
 		const folder = path.basename(packageDirectory);
-		const scriptEntries = pipe(Object.entries(result.packageJson.scripts ?? {}), filter$2((entry) => entry[0] === "dev" || startsWith("dev:")(entry[0])));
-		const packageOrigin = `http://${[
+		const scriptEntries = pipe(Object.entries(packageJson.value.scripts ?? {}), filter$2((entry) => entry[0] === "dev" || startsWith("dev:")(entry[0])));
+		const packageOrigin = input.origin([
 			folder,
 			path.basename(cwd),
 			"localhost"
-		].join(".")}:${input.proxyPort}`;
+		].join("."));
 		return pipe(scriptEntries, map$7((entry) => {
 			const name = entry[0];
 			const scriptCommand = entry[1];
-			return map$4(input.port(`${result.packagePath}:${name}`), (port) => {
+			return map$4(input.port(`${packagePath}:${name}`), (port) => {
 				const service = /^dev:(.+)$/u.exec(name)?.[1] ?? "dev";
 				const host = [
 					service,
@@ -52498,7 +52632,7 @@ const discover = fnUntraced(function* (cwd, input) {
 					path.basename(cwd),
 					"localhost"
 				].join(".");
-				const origin = `http://${host}:${input.proxyPort}`;
+				const origin = input.origin(host);
 				return {
 					host,
 					port,
@@ -52517,9 +52651,9 @@ const discover = fnUntraced(function* (cwd, input) {
 						name,
 						origin,
 						packageFolder: folder,
-						packagePath: result.packagePath,
+						packagePath,
 						service,
-						sessionId: `${result.packagePath}:${name}:${Date.now()}:${Math.random()}`
+						sessionId: `${packagePath}:${name}:${Date.now()}:${Math.random()}`
 					}
 				};
 			});
@@ -52587,9 +52721,9 @@ const INJECTED_HEAD = `<script>
 <\/script>
 <script crossorigin="anonymous" src="//unpkg.com/react-scan/dist/auto.global.js" onload="window.reactScan?.({allowInIframe: true, _debug: 'verbose'})"><\/script>
 <script src="https://unpkg.com/react-grab/dist/index.global.js"><\/script>`;
-const injectScripts = fnUntraced(function* (html) {
+function injectScripts(html) {
 	return /<head[^>]*>/i.test(html) ? html.replace(/<head[^>]*>/i, (match) => `${match}\n${INJECTED_HEAD}`) : `${INJECTED_HEAD}\n${html}`;
-});
+}
 const proxy = fnUntraced(function* (request, origin) {
 	const webRequest = yield* toWeb(request);
 	const [pathname = "/", search = ""] = request.url.split("?");
@@ -52613,7 +52747,7 @@ const proxy = fnUntraced(function* (request, origin) {
 	}));
 	const body = yield* tryPromise(() => upstreamResponse.text());
 	headers.set("content-type", "text/html; charset=utf-8");
-	return fromWeb(new Response(yield* injectScripts(body), {
+	return fromWeb(new Response(injectScripts(body), {
 		headers,
 		status: upstreamResponse.status,
 		statusText: upstreamResponse.statusText
@@ -52621,41 +52755,46 @@ const proxy = fnUntraced(function* (request, origin) {
 });
 const proxyWebSocket = fnUntraced(function* (request, origin) {
 	const [pathname = "/", search = ""] = request.url.split("?");
-	const protocols = request.headers["sec-websocket-protocol"]?.split(",").map((protocol) => protocol.trim()).filter((protocol) => protocol.length > 0);
+	const protocols = pipe(fromUndefinedOr(request.headers["sec-websocket-protocol"]), map$9((protocols) => pipe(protocols, split$1(","), map$7(trim), filter$2(isNonEmpty$1))));
 	const inbound = yield* request.upgrade;
 	const upstreamUrl = new URL(origin);
 	upstreamUrl.protocol = upstreamUrl.protocol === "https:" ? "wss:" : "ws:";
 	upstreamUrl.pathname = pathname;
 	upstreamUrl.search = search;
-	const outbound = yield* makeWebSocket(upstreamUrl.toString(), { protocols }).pipe(provide(layerWebSocketConstructorGlobal));
+	const outbound = yield* makeWebSocket(upstreamUrl.toString(), { protocols: getOrUndefined$1(protocols) }).pipe(provide(layerWebSocketConstructorGlobal));
 	const writeInbound = yield* inbound.writer;
 	const writeOutbound = yield* outbound.writer;
 	yield* outbound.runRaw((message) => writeInbound(message)).pipe(catchReason("SocketError", "SocketCloseError", (reason) => writeInbound(new CloseEvent(reason.code, reason.closeReason)).pipe(catch_$2(() => void_$1))), catch_$2(() => writeInbound(new CloseEvent(1011, "proxy error")).pipe(catch_$2(() => void_$1))), forkScoped);
-	yield* inbound.runRaw((message) => writeOutbound(typeof message === "string" ? message : message.slice())).pipe(catch_$2(() => void_$1), ensuring$2(writeOutbound(new CloseEvent()).pipe(catch_$2(() => void_$1))));
+	yield* inbound.runRaw((message) => writeOutbound(isString(message) ? message : message.slice())).pipe(catch_$2(() => void_$1), ensuring$2(writeOutbound(new CloseEvent()).pipe(catch_$2(() => void_$1))));
 	return empty();
 });
-const requestHostname = fnUntraced(function* (host) {
-	return fromUndefinedOr(host?.split(":")[0]);
-});
+function requestHostname(host) {
+	return pipe(fromUndefinedOr(host), flatMap$6((host) => pipe(host, split$1(":"), head)));
+}
 function isLocalHostname(hostname) {
 	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
 }
-var Portless = class Portless extends Service()("@deslop/portless/Portless", { make: sync(() => {
+var Portless = class Portless extends Service()("@deslop/portless/Portless", { make: gen(function* () {
+	const server = yield* HttpServer;
+	const proxyPort = server.address._tag === "TcpAddress" ? server.address.port.toString() : yield* die$1(/* @__PURE__ */ new Error("portless requires a TCP HTTP server address"));
 	const ports = /* @__PURE__ */ new Map();
 	const routes = /* @__PURE__ */ new Map();
+	function origin(host) {
+		return `http://${host}:${proxyPort}`;
+	}
 	const middleware = fnUntraced(function* (app) {
 		const request = yield* HttpServerRequest;
-		const hostname = yield* requestHostname(request.headers["host"]);
+		const hostname = requestHostname(request.headers["host"]);
 		if (isNone(hostname) || isLocalHostname(hostname.value)) return yield* app;
 		if (!hostname.value.endsWith(".localhost")) return yield* app;
-		const route = yield* lookup(request.headers["host"]);
+		const route = lookup(request.headers["host"]);
 		if (isNone(route)) return empty({ status: 404 });
 		if (request.headers["upgrade"]?.toLowerCase() === "websocket") return yield* proxyWebSocket(request, route.value);
 		return yield* proxy(request, route.value);
 	});
-	const lookup = fnUntraced(function* (host) {
-		return pipe(yield* requestHostname(host), flatMap$6((hostname) => fromUndefinedOr(routes.get(hostname))));
-	});
+	function lookup(host) {
+		return pipe(requestHostname(host), flatMap$6((hostname) => fromUndefinedOr(routes.get(hostname))));
+	}
 	const port = fnUntraced(function* (key) {
 		const existing = ports.get(key);
 		if (existing !== void 0) return existing;
@@ -52671,15 +52810,13 @@ var Portless = class Portless extends Service()("@deslop/portless/Portless", { m
 	});
 	return {
 		middleware,
-		port,
-		register: fnUntraced(function* (host, port) {
-			routes.set(host, `http://127.0.0.1:${port}`);
-		}),
-		scripts: fnUntraced(function* (cwd, input) {
+		scripts: fnUntraced(function* (cwd) {
 			return yield* pipe(discover(cwd, {
-				port: (sessionId) => port(`${cwd}:${sessionId}`),
-				proxyPort: input.proxyPort
-			}), map$4((routes) => routes.map((route) => ({
+				origin,
+				port: (sessionId) => port(`${cwd}:${sessionId}`)
+			}), tap((discovered) => sync(() => {
+				for (const route of discovered) routes.set(route.host, `http://127.0.0.1:${route.port}`);
+			})), map$4((routes) => routes.map((route) => ({
 				host: route.host,
 				port: route.port,
 				script: {
@@ -53055,11 +53192,11 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 	const portlessWorktrees = yield* make$46({
 		idleTimeToLive: infinity,
 		lookup: fnUntraced(function* (cwd) {
-			const scripts = yield* pipe(portless.scripts(cwd, { proxyPort: process.env["PORT"] ?? "4010" }), mapError$2((cause) => new TerminalError({
+			const scripts = yield* pipe(portless.scripts(cwd), mapError$2((cause) => new TerminalError({
 				cause,
 				message: `failed to discover portless scripts in ${cwd}`
 			})));
-			yield* all(pipe(scripts, map$7((script) => all([portless.register(script.host, script.port), update$1(portlessScripts, (current) => set$2(current, script.script.sessionId, script.script))], { discard: true }))), { discard: true });
+			yield* all(pipe(scripts, map$7((script) => update$1(portlessScripts, (current) => set$2(current, script.script.sessionId, script.script)))), { discard: true });
 			return pipe(scripts, map$7((route) => ({
 				baseOrigin: route.script.baseOrigin,
 				command: route.script.command,

package/package.json

@@ -2,7 +2,7 @@
 	"type": "module",
 	"sideEffects": false,
 	"name": "@deslop/workbench",
-	"version": "0.0.320",
+	"version": "0.0.321",
 	"files": [
 		"dist"
 	],