@venn-lang/http 0.1.0

package/dist/index.js

@@ -0,0 +1,577 @@
+import { arg, defineAction, defineMatcher, definePlugin, optionalArg, z } from "@venn-lang/sdk";
+import { t } from "@venn-lang/types";
+import { VennError } from "@venn-lang/contracts";
+//#region src/clients/fake-client.ts
+/**
+* A 200 response with a small JSON body, for tests that only care about a field
+* or two.
+*
+* @param overrides Fields to replace on the default response.
+* @returns A complete {@link HttpResponse}.
+*/
+function okResponse(overrides = {}) {
+	return {
+		status: 200,
+		ok: true,
+		headers: {},
+		body: "{\"ok\":true}",
+		json: { ok: true },
+		time: 0,
+		...overrides
+	};
+}
+/**
+* The double: answers from a table keyed by the request's full URL.
+*
+* A URL with no entry gets {@link okResponse}, so a test only has to name the
+* responses it cares about. Never touches the network.
+*
+* @param args.responses Canned responses, keyed by the URL the flow requests.
+*/
+function createFakeClient(args = {}) {
+	const responses = args.responses ?? {};
+	return { request: async (req) => responses[req.url] ?? okResponse() };
+}
+//#endregion
+//#region src/clients/fetch-client.ts
+/**
+* The real client, over the global `fetch`. Requires the `net` capability.
+*
+* The body is always read as text and parsed afterwards, so a reply that claims
+* JSON but is not still arrives whole in `body` instead of throwing.
+*/
+function createFetchClient() {
+	return { async request(req) {
+		const response = await fetch(req.url, {
+			method: req.method,
+			headers: req.headers,
+			body: req.body,
+			signal: req.signal
+		});
+		const body = await response.text();
+		return mapResponse({
+			status: response.status,
+			ok: response.ok,
+			headers: response.headers,
+			body
+		});
+	} };
+}
+function mapResponse(args) {
+	return {
+		status: args.status,
+		ok: args.ok,
+		headers: toObject(args.headers),
+		body: args.body,
+		json: tryJson(args.body),
+		time: 0
+	};
+}
+function toObject(headers) {
+	const out = {};
+	headers.forEach((value, key) => {
+		out[key] = value;
+	});
+	return out;
+}
+function tryJson(body) {
+	try {
+		return JSON.parse(body);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/server/on-action.ts
+/**
+* `http.on server handler`: say what the server answers with.
+*
+* The handler is an ordinary `fn`, so everything the language already does
+* applies inside it: it can call any verb, and it waits for what it reaches for
+* without saying so. Whatever it returns becomes the reply. Calling `http.on`
+* again replaces the handler.
+*/
+function onAction() {
+	return defineAction({
+		name: "on",
+		doc: "Answer this server's requests with a function. `fn (req) => { … }` is the reply.",
+		args: [arg("server", t.ref("http.Server"), "The handle `http.serve` gave back."), arg("handler", t.callback([t.ref("http.Request")], t.dynamic, 1), "Called for every request. What it returns is the reply.")],
+		result: t.void,
+		run: (ctx, input) => {
+			const server = asServer(input.args[0]);
+			const handler = input.args[1];
+			if (!server) throw new Error("`http.on` needs a server, as `http.serve` returns.");
+			if (handler === void 0) throw new Error("`http.on` needs a function to answer with.");
+			server.onRequest((request) => ctx.invoke(handler, [request]));
+		}
+	});
+}
+function asServer(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	return value.kind === "http-server" ? value : void 0;
+}
+//#endregion
+//#region src/server/http-server.port.ts
+/**
+* The port descriptor `http.serve` resolves through `ctx.port(...)`.
+*
+* Declares the `net` capability, so a host that cannot bind a socket refuses the
+* binding at load time rather than mid-flow.
+*/
+const HttpServerPort = {
+	id: "venn.port.http-server",
+	version: 1,
+	requires: ["net"],
+	methods: ["listen"]
+};
+//#endregion
+//#region src/server/serve-action.ts
+const serveParams = z.object({
+	port: z.number().optional().describe("Which port to bind. 0 asks for any free one."),
+	host: z.string().optional().describe("Which interface to bind. Defaults to 127.0.0.1.")
+});
+/**
+* `let api = http.serve { port: 8080 }`: start listening.
+*
+* The handler starts as a 404 and `http.on` replaces it, so a request arriving
+* before the flow has said what to do with it gets an answer instead of hanging.
+*/
+function serveAction() {
+	return defineAction({
+		name: "serve",
+		doc: "Start an HTTP server and hand back a handle. `http.on` says what to answer.",
+		params: serveParams.optional(),
+		result: t.ref("http.Server"),
+		run: async (ctx, input) => {
+			const params = input.params ?? {};
+			const state = { handle: notFound };
+			return handle(await ctx.port(HttpServerPort).listen({
+				port: params.port ?? 0,
+				host: params.host,
+				handle: (request) => state.handle(request)
+			}), state);
+		}
+	});
+}
+function handle(running, state) {
+	return {
+		kind: "http-server",
+		port: running.port,
+		close: () => running.close(),
+		deliver: async (request) => state.handle(fill$1(request)),
+		onRequest: (given) => {
+			state.handle = async (request) => asReply(await given(request));
+		}
+	};
+}
+/**
+* Whatever the flow answered, as a reply. A map with a `status` is taken at its
+* word; anything else is the body, so `=> { ok: true }` does the obvious thing.
+*/
+function asReply(value) {
+	if (value === void 0 || value === null) return { status: 204 };
+	if (isReplyShape(value)) return value;
+	return {
+		status: 200,
+		body: value
+	};
+}
+function isReplyShape(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const shape = value;
+	return "status" in shape || "headers" in shape || "body" in shape;
+}
+function notFound() {
+	return {
+		status: 404,
+		body: { error: "This server has no handler yet." }
+	};
+}
+function fill$1(request) {
+	return {
+		method: request.method ?? "GET",
+		url: request.url ?? "/",
+		headers: request.headers ?? {},
+		body: request.body ?? ""
+	};
+}
+//#endregion
+//#region src/port/http-client.port.ts
+/**
+* The port descriptor an http verb resolves through `ctx.port(...)`.
+*
+* Declares the `net` capability, so a host that cannot open sockets refuses the
+* binding at load time with a readable diagnostic.
+*/
+const HttpClientPort = {
+	id: "venn.port.http-client",
+	version: 1,
+	requires: ["net"],
+	methods: ["request"]
+};
+//#endregion
+//#region src/actions/build-request.ts
+/** Turn one action call into the request the HttpClient port sends. */
+function buildRequest(args) {
+	const payload = bodyOf(args.params);
+	return {
+		method: args.method,
+		url: withQuery(absoluteUrl(String(args.url ?? ""), args.baseUrl), args.params.query),
+		headers: headersOf(args.params, payload.contentType),
+		body: payload.body,
+		signal: args.signal
+	};
+}
+const BOUNDARY = "----vennFormBoundary";
+/** A map means JSON and a string means raw, unless `encode` says otherwise. */
+function bodyOf(params) {
+	if (params.body === void 0) return {};
+	switch (params.encode ?? defaultEncoding(params.body)) {
+		case "raw": return { body: String(params.body) };
+		case "form": return {
+			body: encode(asMap(params.body)),
+			contentType: FORM_TYPE
+		};
+		case "multipart": return multipart(asMap(params.body));
+		default: return {
+			body: JSON.stringify(params.body),
+			contentType: "application/json"
+		};
+	}
+}
+function defaultEncoding(body) {
+	return typeof body === "string" ? "raw" : "json";
+}
+const FORM_TYPE = "application/x-www-form-urlencoded";
+function multipart(values) {
+	return {
+		body: `${Object.entries(values).map(([key, value]) => `--${BOUNDARY}\r\nContent-Disposition: form-data; name="${key}"\r\n\r\n${value}\r\n`).join("")}--${BOUNDARY}--\r\n`,
+		contentType: `multipart/form-data; boundary=${BOUNDARY}`
+	};
+}
+function asMap(body) {
+	return body ?? {};
+}
+function headersOf(params, contentType) {
+	const headers = {};
+	for (const [key, value] of Object.entries(params.headers ?? {})) headers[key] = String(value);
+	if (contentType && !hasHeader$1(headers, "content-type")) headers["Content-Type"] = contentType;
+	const auth = authorization(params);
+	if (auth && !hasHeader$1(headers, "authorization")) headers.Authorization = auth;
+	return headers;
+}
+function authorization(params) {
+	if (params.bearer) return `Bearer ${params.bearer}`;
+	if (!params.basic) return void 0;
+	return `Basic ${base64(`${params.basic.user}:${params.basic.pass}`)}`;
+}
+function withQuery(url, query) {
+	const encoded = query ? encode(query) : "";
+	if (!encoded) return url;
+	return `${url}${url.includes("?") ? "&" : "?"}${encoded}`;
+}
+function encode(values) {
+	const search = new URLSearchParams();
+	for (const [key, value] of Object.entries(values)) search.append(key, String(value));
+	return search.toString();
+}
+function hasHeader$1(headers, name) {
+	return Object.keys(headers).some((key) => key.toLowerCase() === name);
+}
+function base64(text) {
+	return btoa(text);
+}
+/** Resolve a relative path against `config.baseUrl`; absolute URLs pass through. */
+function absoluteUrl(url, baseUrl) {
+	if (typeof baseUrl !== "string" || baseUrl === "" || hasScheme(url)) return url;
+	return `${baseUrl.replace(/\/+$/, "")}/${url.replace(/^\/+/, "")}`;
+}
+function hasScheme(url) {
+	return /^[a-z][a-z0-9+.-]*:\/\//i.test(url);
+}
+//#endregion
+//#region src/actions/request-params.ts
+const scalar = z.union([
+	z.string(),
+	z.number(),
+	z.boolean()
+]);
+const scalarMap = z.record(z.string(), scalar);
+/**
+* Validation for {@link RequestParams}, the options map every http verb accepts.
+*
+* Each key carries its own `.describe()` because the editor reads this schema to
+* offer the keys, document them and reject the ones that do not exist. Keeping
+* the wording here keeps it beside the rule it describes.
+*/
+const requestParams = z.object({
+	headers: scalarMap.optional().describe("Extra headers. Anything you set here wins over what Venn would infer."),
+	query: scalarMap.optional().describe("Appended to the URL as a query string, encoded for you."),
+	body: z.unknown().optional().describe("What to send. A map becomes JSON; a string is sent as written."),
+	encode: z.enum([
+		"json",
+		"form",
+		"multipart",
+		"raw"
+	]).optional().describe("How to serialise `body`. Defaults to `json` for a map, `raw` for a string."),
+	bearer: z.string().optional().describe("Shorthand for `Authorization: Bearer …`."),
+	basic: z.object({
+		user: z.string(),
+		pass: z.string()
+	}).optional().describe("Shorthand for HTTP basic auth.")
+});
+//#endregion
+//#region src/actions/http-action.ts
+/**
+* Build the action for one HTTP verb.
+*
+* Every verb has the same shape: the URL is the single positional argument and
+* everything else rides in the options map, so `http.get` and `http.post` read
+* alike at the call site.
+*
+* @param config.name The verb as a flow writes it, such as `get`.
+* @param config.method The method put on the wire, such as `GET`.
+*/
+function httpAction(config) {
+	return defineAction({
+		name: config.name,
+		doc: `HTTP ${config.method} request.`,
+		params: requestParams.optional(),
+		args: [arg("url", t.string, "Where to send it. Relative paths join the configured base URL.")],
+		result: t.ref("http.Response"),
+		run: (ctx, input) => ctx.port(HttpClientPort).request(buildRequest({
+			method: config.method,
+			url: input.args[0],
+			params: input.params ?? {},
+			baseUrl: ctx.config.baseUrl,
+			signal: ctx.signal
+		}))
+	});
+}
+//#endregion
+//#region src/actions/index.ts
+/** The http namespace's verbs. Adding one is a single line here. */
+const httpActions = [
+	httpAction({
+		name: "get",
+		method: "GET"
+	}),
+	httpAction({
+		name: "post",
+		method: "POST"
+	}),
+	httpAction({
+		name: "put",
+		method: "PUT"
+	}),
+	httpAction({
+		name: "patch",
+		method: "PATCH"
+	}),
+	httpAction({
+		name: "delete",
+		method: "DELETE"
+	}),
+	httpAction({
+		name: "head",
+		method: "HEAD"
+	}),
+	httpAction({
+		name: "options",
+		method: "OPTIONS"
+	}),
+	serveAction(),
+	onAction()
+];
+//#endregion
+//#region src/matchers/header.ts
+/**
+* `expect res header "content-type"`: passes if the response carries the header.
+*
+* The lookup is case-insensitive, because header casing is whatever the far end
+* happened to send.
+*/
+const header = defineMatcher({
+	name: "header",
+	args: [arg("name", t.string, "Which header to read."), optionalArg("value", t.string, "What it should say. Omit it to check the header is merely present.")],
+	appliesTo: "Response",
+	test: ({ subject, args }) => hasHeader(subject, String(args[0])),
+	message: ({ args }) => `expected the response to carry header "${String(args[0])}"`
+});
+function hasHeader(subject, name) {
+	const headers = subject.headers ?? {};
+	const target = name.toLowerCase();
+	return Object.keys(headers).some((key) => key.toLowerCase() === target);
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* The `http` namespace: the request verbs, `http.serve`/`http.on`, the `header`
+* matcher and the types they trade in.
+*
+* Requires the `net` capability, so a host without it refuses the plugin at load
+* time rather than failing mid-flow. The compiler treats it exactly as it treats
+* a third-party plugin.
+*/
+const httpPlugin = definePlugin({
+	name: "venn/http",
+	version: "0.0.0",
+	namespace: "http",
+	requires: ["net"],
+	actions: httpActions,
+	matchers: [header],
+	typeDefs: {
+		/** One request, as the handler receives it. */
+		Request: t.record({
+			method: t.string,
+			url: t.string,
+			headers: t.map(t.string),
+			body: t.string
+		}),
+		/** What a handler may answer with. Anything else is taken as the body. */
+		Reply: t.record({
+			status: t.number,
+			headers: t.map(t.string),
+			body: t.dynamic
+		}, {
+			optional: [
+				"status",
+				"headers",
+				"body"
+			],
+			open: true
+		}),
+		/**
+		* A bound socket: the port it got, and how to give it back.
+		*
+		* Attaching a handler is `http.on`, so the handle does not offer that itself.
+		* The type names only what a program may do with the value, which is why it is
+		* opaque with two visible members rather than fully opaque.
+		*/
+		Server: t.opaque("http.Server", {
+			port: t.number,
+			close: t.fn([], t.void)
+		}),
+		/**
+		* One response, as the client verbs give it back.
+		*
+		* `body` is the raw text, always a string whatever came over the wire. `json`
+		* is that text parsed, and is the one field nothing can know the shape of: it
+		* is whatever the far end chose to send. Name a shape for it, as in
+		* `const price: Price = res.json`, and everything after reads as that shape.
+		*/
+		Response: t.record({
+			status: t.number,
+			ok: t.bool,
+			headers: t.map(t.string),
+			body: t.string,
+			json: t.dynamic,
+			time: t.number
+		}, { open: true })
+	}
+});
+//#endregion
+//#region src/server/http-server.errors.ts
+/** VN7020: the address the flow asked for is already taken by something else. */
+function portInUse(args) {
+	return new VennError({
+		code: "VN7020",
+		message: `Port ${args.port} is already in use — stop whatever is listening on ${args.host}:${args.port}, or ask for "port: 0" to take any free one.`,
+		detail: {
+			port: args.port,
+			host: args.host,
+			cause: "EADDRINUSE"
+		}
+	});
+}
+/** VN7021: the socket refused to bind for any other reason. */
+function listenFailed(args) {
+	return new VennError({
+		code: "VN7021",
+		message: `Could not listen on ${args.host}:${args.port} — ${args.cause}.`,
+		detail: {
+			port: args.port,
+			host: args.host,
+			cause: args.cause
+		}
+	});
+}
+/**
+* Whatever the socket threw, as a Venn error: VN7020 for `EADDRINUSE`, VN7021
+* for anything else.
+*
+* The translation lives at the producer so no caller has to read a `node:net`
+* errno to know what went wrong.
+*/
+function asListenError(args) {
+	const error = args.error;
+	if (error?.code === "EADDRINUSE") return portInUse({
+		port: args.port,
+		host: args.host
+	});
+	return listenFailed({
+		port: args.port,
+		host: args.host,
+		cause: error?.message ?? String(args.error)
+	});
+}
+//#endregion
+//#region src/server/memory-server.ts
+/** Where the double starts handing out ports when a flow asks for any free one. */
+const EPHEMERAL_START = 49152;
+/**
+* The double: no socket, no network, no waiting.
+*
+* A test starts the flow that serves, hands it a request and reads the reply,
+* running the same handler the real server would call. Ports are book-kept here
+* rather than by the operating system, so tests beside each other never collide.
+*/
+function createMemoryServer() {
+	const started = [];
+	const bound = /* @__PURE__ */ new Set();
+	let next = EPHEMERAL_START;
+	return {
+		started,
+		listen: async ({ port, host, handle }) => {
+			const chosen = port === 0 ? next++ : port;
+			if (bound.has(chosen)) throw portInUse({
+				port: chosen,
+				host: host ?? "127.0.0.1"
+			});
+			bound.add(chosen);
+			const server = memoryServer({
+				port: chosen,
+				handle,
+				release: () => bound.delete(chosen)
+			});
+			started.push(server);
+			return server;
+		}
+	};
+}
+function memoryServer(args) {
+	const state = { closed: false };
+	return {
+		port: args.port,
+		get closed() {
+			return state.closed;
+		},
+		close: async () => {
+			state.closed = true;
+			args.release();
+		},
+		deliver: async (request) => await args.handle(fill(request)) ?? { status: 204 }
+	};
+}
+function fill(request) {
+	return {
+		method: request.method ?? "GET",
+		url: request.url ?? "/",
+		headers: request.headers ?? {},
+		body: request.body ?? ""
+	};
+}
+//#endregion
+export { HttpClientPort, HttpServerPort, asListenError, createFakeClient, createFetchClient, createMemoryServer, httpPlugin as default, httpPlugin, listenFailed, okResponse, onAction, portInUse, serveAction };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["fill","hasHeader"],"sources":["../src/clients/fake-client.ts","../src/clients/fetch-client.ts","../src/server/on-action.ts","../src/server/http-server.port.ts","../src/server/serve-action.ts","../src/port/http-client.port.ts","../src/actions/build-request.ts","../src/actions/request-params.ts","../src/actions/http-action.ts","../src/actions/index.ts","../src/matchers/header.ts","../src/matchers/index.ts","../src/types.ts","../src/plugin.ts","../src/server/http-server.errors.ts","../src/server/memory-server.ts"],"sourcesContent":["import type { HttpClient, HttpResponse } from \"../port/index.js\";\n\n/**\n * A 200 response with a small JSON body, for tests that only care about a field\n * or two.\n *\n * @param overrides Fields to replace on the default response.\n * @returns A complete {@link HttpResponse}.\n */\nexport function okResponse(overrides: Partial<HttpResponse> = {}): HttpResponse {\n  return {\n    status: 200,\n    ok: true,\n    headers: {},\n    body: '{\"ok\":true}',\n    json: { ok: true },\n    time: 0,\n    ...overrides,\n  };\n}\n\n/**\n * The double: answers from a table keyed by the request's full URL.\n *\n * A URL with no entry gets {@link okResponse}, so a test only has to name the\n * responses it cares about. Never touches the network.\n *\n * @param args.responses Canned responses, keyed by the URL the flow requests.\n */\nexport function createFakeClient(\n  args: { responses?: Record<string, HttpResponse> } = {},\n): HttpClient {\n  const responses = args.responses ?? {};\n  return {\n    request: async (req) => responses[req.url] ?? okResponse(),\n  };\n}\n","import type { HttpClient, HttpResponse } from \"../port/index.js\";\n\n/**\n * The real client, over the global `fetch`. Requires the `net` capability.\n *\n * The body is always read as text and parsed afterwards, so a reply that claims\n * JSON but is not still arrives whole in `body` instead of throwing.\n */\nexport function createFetchClient(): HttpClient {\n  return {\n    async request(req): Promise<HttpResponse> {\n      const response = await fetch(req.url, {\n        method: req.method,\n        headers: req.headers,\n        body: req.body,\n        signal: req.signal,\n      });\n      const body = await response.text();\n      return mapResponse({\n        status: response.status,\n        ok: response.ok,\n        headers: response.headers,\n        body,\n      });\n    },\n  };\n}\n\nfunction mapResponse(args: {\n  status: number;\n  ok: boolean;\n  headers: Headers;\n  body: string;\n}): HttpResponse {\n  return {\n    status: args.status,\n    ok: args.ok,\n    headers: toObject(args.headers),\n    body: args.body,\n    json: tryJson(args.body),\n    time: 0,\n  };\n}\n\nfunction toObject(headers: Headers): Record<string, string> {\n  const out: Record<string, string> = {};\n  headers.forEach((value, key) => {\n    out[key] = value;\n  });\n  return out;\n}\n\nfunction tryJson(body: string): unknown {\n  try {\n    return JSON.parse(body);\n  } catch {\n    return undefined;\n  }\n}\n","import { type ActionDefinition, arg, defineAction } from \"@venn-lang/sdk\";\nimport { t } from \"@venn-lang/types\";\nimport type { ServeHandle } from \"./serve-action.js\";\n\n/**\n * `http.on server handler`: say what the server answers with.\n *\n * The handler is an ordinary `fn`, so everything the language already does\n * applies inside it: it can call any verb, and it waits for what it reaches for\n * without saying so. Whatever it returns becomes the reply. Calling `http.on`\n * again replaces the handler.\n */\nexport function onAction(): ActionDefinition {\n  return defineAction({\n    name: \"on\",\n    doc: \"Answer this server's requests with a function. `fn (req) => { … }` is the reply.\",\n    // The callback type is what gives `req` its shape, so `http.on api req => …`\n    // needs no annotation in the flow.\n    args: [\n      arg(\"server\", t.ref(\"http.Server\"), \"The handle `http.serve` gave back.\"),\n      arg(\n        \"handler\",\n        t.callback([t.ref(\"http.Request\")], t.dynamic, 1),\n        \"Called for every request. What it returns is the reply.\",\n      ),\n    ],\n    result: t.void,\n    run: (ctx, input) => {\n      const server = asServer(input.args[0]);\n      const handler = input.args[1];\n      if (!server) throw new Error(\"`http.on` needs a server, as `http.serve` returns.\");\n      if (handler === undefined) throw new Error(\"`http.on` needs a function to answer with.\");\n      server.onRequest((request) => ctx.invoke(handler, [request]));\n      return undefined;\n    },\n  });\n}\n\nfunction asServer(value: unknown): ServeHandle | undefined {\n  if (typeof value !== \"object\" || value === null) return undefined;\n  return (value as ServeHandle).kind === \"http-server\" ? (value as ServeHandle) : undefined;\n}\n","import type { Port } from \"@venn-lang/contracts\";\nimport type { HttpServer } from \"./http-server.types.js\";\n\n/**\n * The port descriptor `http.serve` resolves through `ctx.port(...)`.\n *\n * Declares the `net` capability, so a host that cannot bind a socket refuses the\n * binding at load time rather than mid-flow.\n */\nexport const HttpServerPort: Port<HttpServer> = {\n  id: \"venn.port.http-server\",\n  version: 1,\n  requires: [\"net\"],\n  methods: [\"listen\"],\n};\n","import { type ActionDefinition, defineAction, z } from \"@venn-lang/sdk\";\nimport { t } from \"@venn-lang/types\";\nimport { HttpServerPort } from \"./http-server.port.js\";\nimport type { ServerReply, ServerRequest } from \"./http-server.types.js\";\n\nconst serveParams = z.object({\n  port: z.number().optional().describe(\"Which port to bind. 0 asks for any free one.\"),\n  host: z.string().optional().describe(\"Which interface to bind. Defaults to 127.0.0.1.\"),\n});\n\n/**\n * The value `http.serve` hands back, seen by flows as `http.Server`.\n *\n * A server is not a request-response verb: it stays, and the requests arrive\n * afterwards. So the verb returns something the program holds on to: the port it\n * got, and what it may do with it.\n */\nexport interface ServeHandle {\n  kind: \"http-server\";\n  port: number;\n  /** Deliver one request to whatever `handle` was last given. Used by tests. */\n  deliver: (request: Partial<ServerRequest>) => Promise<ServerReply>;\n  close: () => Promise<void>;\n  /** Replace the handler. `http.on` is how a flow reaches this. */\n  onRequest: (handle: (request: ServerRequest) => unknown) => void;\n}\n\n/**\n * `let api = http.serve { port: 8080 }`: start listening.\n *\n * The handler starts as a 404 and `http.on` replaces it, so a request arriving\n * before the flow has said what to do with it gets an answer instead of hanging.\n */\nexport function serveAction(): ActionDefinition {\n  return defineAction({\n    name: \"serve\",\n    doc: \"Start an HTTP server and hand back a handle. `http.on` says what to answer.\",\n    params: serveParams.optional(),\n    result: t.ref(\"http.Server\"),\n    run: async (ctx, input) => {\n      const params = (input.params ?? {}) as { port?: number; host?: string };\n      const state: HandlerState = { handle: notFound };\n      const running = await ctx.port(HttpServerPort).listen({\n        port: params.port ?? 0,\n        host: params.host,\n        handle: (request: ServerRequest) => state.handle(request),\n      });\n      return handle(running, state);\n    },\n  });\n}\n\ninterface HandlerState {\n  handle: (request: ServerRequest) => ServerReply | Promise<ServerReply>;\n}\n\nfunction handle(\n  running: { port: number; close: () => Promise<void> },\n  state: HandlerState,\n): ServeHandle {\n  return {\n    kind: \"http-server\",\n    port: running.port,\n    close: () => running.close(),\n    deliver: async (request) => state.handle(fill(request)),\n    onRequest: (given) => {\n      state.handle = async (request) => asReply(await given(request));\n    },\n  };\n}\n\n/**\n * Whatever the flow answered, as a reply. A map with a `status` is taken at its\n * word; anything else is the body, so `=> { ok: true }` does the obvious thing.\n */\nfunction asReply(value: unknown): ServerReply {\n  if (value === undefined || value === null) return { status: 204 };\n  if (isReplyShape(value)) return value as ServerReply;\n  return { status: 200, body: value };\n}\n\nfunction isReplyShape(value: unknown): boolean {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) return false;\n  const shape = value as Record<string, unknown>;\n  return \"status\" in shape || \"headers\" in shape || \"body\" in shape;\n}\n\nfunction notFound(): ServerReply {\n  return { status: 404, body: { error: \"This server has no handler yet.\" } };\n}\n\nfunction fill(request: Partial<ServerRequest>): ServerRequest {\n  return {\n    method: request.method ?? \"GET\",\n    url: request.url ?? \"/\",\n    headers: request.headers ?? {},\n    body: request.body ?? \"\",\n  };\n}\n","import type { Port } from \"@venn-lang/contracts\";\nimport type { HttpClient } from \"./http-client.types.js\";\n\n/**\n * The port descriptor an http verb resolves through `ctx.port(...)`.\n *\n * Declares the `net` capability, so a host that cannot open sockets refuses the\n * binding at load time with a readable diagnostic.\n */\nexport const HttpClientPort: Port<HttpClient> = {\n  id: \"venn.port.http-client\",\n  version: 1,\n  requires: [\"net\"],\n  methods: [\"request\"],\n};\n","import type { HttpRequest } from \"../port/index.js\";\nimport type { RequestParams } from \"./request.types.js\";\n\ninterface Payload {\n  body?: string;\n  contentType?: string;\n}\n\nexport interface BuildArgs {\n  method: string;\n  url: unknown;\n  params: RequestParams;\n  baseUrl: unknown;\n  signal?: AbortSignal;\n}\n\n/** Turn one action call into the request the HttpClient port sends. */\nexport function buildRequest(args: BuildArgs): HttpRequest {\n  const payload = bodyOf(args.params);\n  return {\n    method: args.method,\n    url: withQuery(absoluteUrl(String(args.url ?? \"\"), args.baseUrl), args.params.query),\n    headers: headersOf(args.params, payload.contentType),\n    body: payload.body,\n    signal: args.signal,\n  };\n}\n\nconst BOUNDARY = \"----vennFormBoundary\";\n\n/** A map means JSON and a string means raw, unless `encode` says otherwise. */\nfunction bodyOf(params: RequestParams): Payload {\n  if (params.body === undefined) return {};\n  switch (params.encode ?? defaultEncoding(params.body)) {\n    case \"raw\":\n      return { body: String(params.body) };\n    case \"form\":\n      return { body: encode(asMap(params.body)), contentType: FORM_TYPE };\n    case \"multipart\":\n      return multipart(asMap(params.body));\n    default:\n      return { body: JSON.stringify(params.body), contentType: \"application/json\" };\n  }\n}\n\nfunction defaultEncoding(body: unknown): string {\n  return typeof body === \"string\" ? \"raw\" : \"json\";\n}\n\nconst FORM_TYPE = \"application/x-www-form-urlencoded\";\n\nfunction multipart(values: Record<string, string | number | boolean>): Payload {\n  const parts = Object.entries(values).map(\n    ([key, value]) =>\n      `--${BOUNDARY}\\r\\nContent-Disposition: form-data; name=\"${key}\"\\r\\n\\r\\n${value}\\r\\n`,\n  );\n  return {\n    body: `${parts.join(\"\")}--${BOUNDARY}--\\r\\n`,\n    contentType: `multipart/form-data; boundary=${BOUNDARY}`,\n  };\n}\n\nfunction asMap(body: unknown): Record<string, string | number | boolean> {\n  return (body ?? {}) as Record<string, string | number | boolean>;\n}\n\nfunction headersOf(params: RequestParams, contentType: string | undefined): Record<string, string> {\n  const headers: Record<string, string> = {};\n  for (const [key, value] of Object.entries(params.headers ?? {})) headers[key] = String(value);\n  if (contentType && !hasHeader(headers, \"content-type\")) headers[\"Content-Type\"] = contentType;\n  const auth = authorization(params);\n  if (auth && !hasHeader(headers, \"authorization\")) headers.Authorization = auth;\n  return headers;\n}\n\nfunction authorization(params: RequestParams): string | undefined {\n  if (params.bearer) return `Bearer ${params.bearer}`;\n  if (!params.basic) return undefined;\n  return `Basic ${base64(`${params.basic.user}:${params.basic.pass}`)}`;\n}\n\nfunction withQuery(url: string, query: RequestParams[\"query\"]): string {\n  const encoded = query ? encode(query) : \"\";\n  if (!encoded) return url;\n  return `${url}${url.includes(\"?\") ? \"&\" : \"?\"}${encoded}`;\n}\n\nfunction encode(values: Record<string, string | number | boolean>): string {\n  const search = new URLSearchParams();\n  for (const [key, value] of Object.entries(values)) search.append(key, String(value));\n  return search.toString();\n}\n\nfunction hasHeader(headers: Record<string, string>, name: string): boolean {\n  return Object.keys(headers).some((key) => key.toLowerCase() === name);\n}\n\nfunction base64(text: string): string {\n  return btoa(text);\n}\n\n/** Resolve a relative path against `config.baseUrl`; absolute URLs pass through. */\nfunction absoluteUrl(url: string, baseUrl: unknown): string {\n  if (typeof baseUrl !== \"string\" || baseUrl === \"\" || hasScheme(url)) return url;\n  return `${baseUrl.replace(/\\/+$/, \"\")}/${url.replace(/^\\/+/, \"\")}`;\n}\n\nfunction hasScheme(url: string): boolean {\n  return /^[a-z][a-z0-9+.-]*:\\/\\//i.test(url);\n}\n","import { type ZodType, z } from \"@venn-lang/sdk\";\nimport type { RequestParams } from \"./request.types.js\";\n\nconst scalar = z.union([z.string(), z.number(), z.boolean()]);\nconst scalarMap = z.record(z.string(), scalar);\n\n/**\n * Validation for {@link RequestParams}, the options map every http verb accepts.\n *\n * Each key carries its own `.describe()` because the editor reads this schema to\n * offer the keys, document them and reject the ones that do not exist. Keeping\n * the wording here keeps it beside the rule it describes.\n */\nexport const requestParams: ZodType<RequestParams> = z.object({\n  headers: scalarMap\n    .optional()\n    .describe(\"Extra headers. Anything you set here wins over what Venn would infer.\"),\n  query: scalarMap.optional().describe(\"Appended to the URL as a query string, encoded for you.\"),\n  body: z\n    .unknown()\n    .optional()\n    .describe(\"What to send. A map becomes JSON; a string is sent as written.\"),\n  encode: z\n    .enum([\"json\", \"form\", \"multipart\", \"raw\"])\n    .optional()\n    .describe(\"How to serialise `body`. Defaults to `json` for a map, `raw` for a string.\"),\n  bearer: z.string().optional().describe(\"Shorthand for `Authorization: Bearer …`.\"),\n  basic: z\n    .object({ user: z.string(), pass: z.string() })\n    .optional()\n    .describe(\"Shorthand for HTTP basic auth.\"),\n});\n","import { type ActionDefinition, arg, defineAction } from \"@venn-lang/sdk\";\nimport { t } from \"@venn-lang/types\";\nimport { HttpClientPort } from \"../port/index.js\";\nimport { buildRequest } from \"./build-request.js\";\nimport type { RequestParams } from \"./request.types.js\";\nimport { requestParams } from \"./request-params.js\";\n\n/**\n * Build the action for one HTTP verb.\n *\n * Every verb has the same shape: the URL is the single positional argument and\n * everything else rides in the options map, so `http.get` and `http.post` read\n * alike at the call site.\n *\n * @param config.name The verb as a flow writes it, such as `get`.\n * @param config.method The method put on the wire, such as `GET`.\n */\nexport function httpAction(config: { name: string; method: string }): ActionDefinition {\n  return defineAction({\n    name: config.name,\n    doc: `HTTP ${config.method} request.`,\n    params: requestParams.optional(),\n    args: [arg(\"url\", t.string, \"Where to send it. Relative paths join the configured base URL.\")],\n    result: t.ref(\"http.Response\"),\n    run: (ctx, input) =>\n      ctx.port(HttpClientPort).request(\n        buildRequest({\n          method: config.method,\n          url: input.args[0],\n          params: (input.params ?? {}) as RequestParams,\n          baseUrl: ctx.config.baseUrl,\n          signal: ctx.signal,\n        }),\n      ),\n  });\n}\n","import type { ActionDefinition } from \"@venn-lang/sdk\";\nimport { onAction } from \"../server/on-action.js\";\nimport { serveAction } from \"../server/serve-action.js\";\nimport { httpAction } from \"./http-action.js\";\n\n/** The http namespace's verbs. Adding one is a single line here. */\nexport const httpActions: ActionDefinition[] = [\n  httpAction({ name: \"get\", method: \"GET\" }),\n  httpAction({ name: \"post\", method: \"POST\" }),\n  httpAction({ name: \"put\", method: \"PUT\" }),\n  httpAction({ name: \"patch\", method: \"PATCH\" }),\n  httpAction({ name: \"delete\", method: \"DELETE\" }),\n  httpAction({ name: \"head\", method: \"HEAD\" }),\n  httpAction({ name: \"options\", method: \"OPTIONS\" }),\n  // Serving, not requesting: a server stays, and the requests arrive later.\n  serveAction(),\n  onAction(),\n];\n","import { arg, defineMatcher, type MatcherDefinition, optionalArg } from \"@venn-lang/sdk\";\nimport { t } from \"@venn-lang/types\";\n\n/**\n * `expect res header \"content-type\"`: passes if the response carries the header.\n *\n * The lookup is case-insensitive, because header casing is whatever the far end\n * happened to send.\n */\nexport const header: MatcherDefinition = defineMatcher({\n  name: \"header\",\n  args: [\n    arg(\"name\", t.string, \"Which header to read.\"),\n    optionalArg(\n      \"value\",\n      t.string,\n      \"What it should say. Omit it to check the header is merely present.\",\n    ),\n  ],\n  appliesTo: \"Response\",\n  test: ({ subject, args }) => hasHeader(subject, String(args[0])),\n  message: ({ args }) => `expected the response to carry header \"${String(args[0])}\"`,\n});\n\nfunction hasHeader(subject: unknown, name: string): boolean {\n  const headers = (subject as { headers?: Record<string, string> }).headers ?? {};\n  const target = name.toLowerCase();\n  return Object.keys(headers).some((key) => key.toLowerCase() === target);\n}\n","import type { MatcherDefinition } from \"@venn-lang/sdk\";\nimport { header } from \"./header.js\";\n\nexport const httpMatchers: MatcherDefinition[] = [header];\n","import { type TypeSpec, t } from \"@venn-lang/types\";\n\n/**\n * The types the plugin publishes to flows: `http.Request`, `http.Reply`,\n * `http.Server` and `http.Response`.\n *\n * They are data, not TypeScript, because the compiler and the editor read them\n * without loading the plugin's implementation. Keep them in step by hand with\n * `server/http-server.types.ts` and `port/http-client.types.ts`.\n */\nexport const httpTypeDefs: Readonly<Record<string, TypeSpec>> = {\n  /** One request, as the handler receives it. */\n  Request: t.record({\n    method: t.string,\n    url: t.string,\n    headers: t.map(t.string),\n    body: t.string,\n  }),\n  /** What a handler may answer with. Anything else is taken as the body. */\n  Reply: t.record(\n    { status: t.number, headers: t.map(t.string), body: t.dynamic },\n    { optional: [\"status\", \"headers\", \"body\"], open: true },\n  ),\n  /**\n   * A bound socket: the port it got, and how to give it back.\n   *\n   * Attaching a handler is `http.on`, so the handle does not offer that itself.\n   * The type names only what a program may do with the value, which is why it is\n   * opaque with two visible members rather than fully opaque.\n   */\n  Server: t.opaque(\"http.Server\", { port: t.number, close: t.fn([], t.void) }),\n  /**\n   * One response, as the client verbs give it back.\n   *\n   * `body` is the raw text, always a string whatever came over the wire. `json`\n   * is that text parsed, and is the one field nothing can know the shape of: it\n   * is whatever the far end chose to send. Name a shape for it, as in\n   * `const price: Price = res.json`, and everything after reads as that shape.\n   */\n  Response: t.record(\n    {\n      status: t.number,\n      ok: t.bool,\n      headers: t.map(t.string),\n      body: t.string,\n      json: t.dynamic,\n      time: t.number,\n    },\n    { open: true },\n  ),\n};\n","import { definePlugin, type PluginDefinition } from \"@venn-lang/sdk\";\nimport { httpActions } from \"./actions/index.js\";\nimport { httpMatchers } from \"./matchers/index.js\";\nimport { httpTypeDefs } from \"./types.js\";\n\n/**\n * The `http` namespace: the request verbs, `http.serve`/`http.on`, the `header`\n * matcher and the types they trade in.\n *\n * Requires the `net` capability, so a host without it refuses the plugin at load\n * time rather than failing mid-flow. The compiler treats it exactly as it treats\n * a third-party plugin.\n */\nexport const httpPlugin: PluginDefinition = definePlugin({\n  name: \"venn/http\",\n  version: \"0.0.0\",\n  namespace: \"http\",\n  requires: [\"net\"],\n  actions: httpActions,\n  matchers: httpMatchers,\n  typeDefs: httpTypeDefs,\n});\n","import { VennError } from \"@venn-lang/contracts\";\n\n/** VN7020: the address the flow asked for is already taken by something else. */\nexport function portInUse(args: { port: number; host: string }): VennError {\n  return new VennError({\n    code: \"VN7020\",\n    message: `Port ${args.port} is already in use — stop whatever is listening on ${args.host}:${args.port}, or ask for \"port: 0\" to take any free one.`,\n    detail: { port: args.port, host: args.host, cause: \"EADDRINUSE\" },\n  });\n}\n\n/** VN7021: the socket refused to bind for any other reason. */\nexport function listenFailed(args: { port: number; host: string; cause: string }): VennError {\n  return new VennError({\n    code: \"VN7021\",\n    message: `Could not listen on ${args.host}:${args.port} — ${args.cause}.`,\n    detail: { port: args.port, host: args.host, cause: args.cause },\n  });\n}\n\n/**\n * Whatever the socket threw, as a Venn error: VN7020 for `EADDRINUSE`, VN7021\n * for anything else.\n *\n * The translation lives at the producer so no caller has to read a `node:net`\n * errno to know what went wrong.\n */\nexport function asListenError(args: { port: number; host: string; error: unknown }): VennError {\n  const error = args.error as { code?: string; message?: string } | undefined;\n  if (error?.code === \"EADDRINUSE\") return portInUse({ port: args.port, host: args.host });\n  return listenFailed({\n    port: args.port,\n    host: args.host,\n    cause: error?.message ?? String(args.error),\n  });\n}\n","import { portInUse } from \"./http-server.errors.js\";\nimport type {\n  HttpServer,\n  RequestHandler,\n  RunningServer,\n  ServerReply,\n  ServerRequest,\n} from \"./http-server.types.js\";\n\n/** Where the double starts handing out ports when a flow asks for any free one. */\nconst EPHEMERAL_START = 49152;\n\n/** A server that is listening in memory, plus the way to knock on its door. */\nexport interface MemoryServer extends RunningServer {\n  /** Deliver a request as though it had arrived over the network. */\n  deliver(request: Partial<ServerRequest>): Promise<ServerReply>;\n  readonly closed: boolean;\n}\n\n/** The double factory, which keeps every server it started so a test can find it. */\nexport interface MemoryHttpServer extends HttpServer {\n  /** Every server started through this, newest last. */\n  readonly started: readonly MemoryServer[];\n}\n\n/**\n * The double: no socket, no network, no waiting.\n *\n * A test starts the flow that serves, hands it a request and reads the reply,\n * running the same handler the real server would call. Ports are book-kept here\n * rather than by the operating system, so tests beside each other never collide.\n */\nexport function createMemoryServer(): MemoryHttpServer {\n  const started: MemoryServer[] = [];\n  const bound = new Set<number>();\n  let next = EPHEMERAL_START;\n  return {\n    started,\n    // Binding the same port twice must fail here exactly as it would against a\n    // real socket, so the double tracks what it has handed out.\n    listen: async ({ port, host, handle }) => {\n      const chosen = port === 0 ? next++ : port;\n      if (bound.has(chosen)) throw portInUse({ port: chosen, host: host ?? \"127.0.0.1\" });\n      bound.add(chosen);\n      const server = memoryServer({ port: chosen, handle, release: () => bound.delete(chosen) });\n      started.push(server);\n      return server;\n    },\n  };\n}\n\nfunction memoryServer(args: {\n  port: number;\n  handle: RequestHandler;\n  release: () => void;\n}): MemoryServer {\n  const state = { closed: false };\n  return {\n    port: args.port,\n    get closed() {\n      return state.closed;\n    },\n    close: async () => {\n      state.closed = true;\n      args.release();\n    },\n    deliver: async (request) => (await args.handle(fill(request))) ?? { status: 204 },\n  };\n}\n\nfunction fill(request: Partial<ServerRequest>): ServerRequest {\n  return {\n    method: request.method ?? \"GET\",\n    url: request.url ?? \"/\",\n    headers: request.headers ?? {},\n    body: request.body ?? \"\",\n  };\n}\n"],"mappings":"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"}