@thomasfosterau/effect-sveltekit 0.0.0

package/dist/State.js

@@ -0,0 +1,65 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { pageSnapshotStream } from "./internal/app-state.js";
+import { afterNavigate } from "$app/navigation";
+import { page } from "$app/state";
+//#region src/State.ts
+/**
+* A minimal Effect-side bridge for SvelteKit's
+* [`$app/state`](https://svelte.dev/docs/kit/$app-state) `page`.
+*
+* `$app/state` exposes rune-reactive `page` / `navigating` / `updated` for use
+* inside components. This bridges `page` to an Effect `Stream` so navigation can
+* drive Effect pipelines without touching Svelte runes: it emits the current
+* `page` immediately, then again after each navigation, by registering
+* `afterNavigate` (from `$app/navigation`) and reading `page` (from
+* `$app/state`) at callback time.
+*
+* Each emission is a *shallow snapshot* (`url`, `params`, `route`, `data`,
+* `status`, `error`, `form`, `state`) rather than the live `$app/state` proxy:
+* the proxy mutates in place on every navigation, so a captured reference is
+* unreliable for downstream consumers — the snapshot gives each emission a
+* stable value. Reading at `afterNavigate` time also avoids needing a `.svelte`
+* runes file.
+*
+* Like the navigation-event helpers, `page` registers its callback during
+* component initialization (where `$app/navigation` requires), so call it at the
+* top level of `<script>`. Client-only.
+*
+* NOTE: this is intentionally minimal. A richer reactive bridge (a `CurrentPage`
+* service readable from any Effect, `navigating` / `updated` streams) may later
+* compose with the official `@effect/atom-svelte` integration (see issue #23)
+* rather than re-implementing runes plumbing here.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { State } from '@thomasfosterau/effect-sveltekit/client';
+*   import { Stream, Effect } from 'effect';
+*   import { getRuntime } from '@thomasfosterau/effect-svelte';
+*
+*   const pages = State.page();
+*   getRuntime().runFork(
+*     Stream.runForEach(pages, (page) =>
+*       Effect.logInfo(`page: ${page.url.pathname}`),
+*     ),
+*   );
+* <\/script>
+* ```
+*/
+var State_exports = /* @__PURE__ */ __exportAll({ page: () => page$1 });
+/**
+* A `Stream` of the current SvelteKit `page`, emitting a shallow snapshot
+* immediately and again after every navigation. Call during component
+* initialization.
+*/
+function page$1() {
+	return pageSnapshotStream((callback) => {
+		afterNavigate(() => {
+			callback();
+		});
+	}, () => page);
+}
+//#endregion
+export { State_exports };
+
+//# sourceMappingURL=State.js.map

package/dist/State.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"State.js","names":["page","kitPage"],"sources":["../src/State.ts"],"sourcesContent":["/**\n * A minimal Effect-side bridge for SvelteKit's\n * [`$app/state`](https://svelte.dev/docs/kit/$app-state) `page`.\n *\n * `$app/state` exposes rune-reactive `page` / `navigating` / `updated` for use\n * inside components. This bridges `page` to an Effect `Stream` so navigation can\n * drive Effect pipelines without touching Svelte runes: it emits the current\n * `page` immediately, then again after each navigation, by registering\n * `afterNavigate` (from `$app/navigation`) and reading `page` (from\n * `$app/state`) at callback time.\n *\n * Each emission is a *shallow snapshot* (`url`, `params`, `route`, `data`,\n * `status`, `error`, `form`, `state`) rather than the live `$app/state` proxy:\n * the proxy mutates in place on every navigation, so a captured reference is\n * unreliable for downstream consumers — the snapshot gives each emission a\n * stable value. Reading at `afterNavigate` time also avoids needing a `.svelte`\n * runes file.\n *\n * Like the navigation-event helpers, `page` registers its callback during\n * component initialization (where `$app/navigation` requires), so call it at the\n * top level of `<script>`. Client-only.\n *\n * NOTE: this is intentionally minimal. A richer reactive bridge (a `CurrentPage`\n * service readable from any Effect, `navigating` / `updated` streams) may later\n * compose with the official `@effect/atom-svelte` integration (see issue #23)\n * rather than re-implementing runes plumbing here.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { State } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Stream, Effect } from 'effect';\n *   import { getRuntime } from '@thomasfosterau/effect-svelte';\n *\n *   const pages = State.page();\n *   getRuntime().runFork(\n *     Stream.runForEach(pages, (page) =>\n *       Effect.logInfo(`page: ${page.url.pathname}`),\n *     ),\n *   );\n * </script>\n * ```\n */\n\nimport { afterNavigate as kitAfterNavigate } from \"$app/navigation\";\nimport { page as kitPage } from \"$app/state\";\nimport type { Page } from \"@sveltejs/kit\";\nimport type { Stream } from \"effect\";\nimport { type PageSnapshot, pageSnapshotStream } from \"./internal/app-state.js\";\n\n/** A shallow snapshot of SvelteKit's `page` — see {@link page}. */\nexport type { PageSnapshot } from \"./internal/app-state.js\";\n\n/**\n * A `Stream` of the current SvelteKit `page`, emitting a shallow snapshot\n * immediately and again after every navigation. Call during component\n * initialization.\n */\nexport function page(): Stream.Stream<PageSnapshot<Page>> {\n  return pageSnapshotStream<Page>(\n    (callback) => {\n      kitAfterNavigate(() => {\n        callback();\n      });\n    },\n    () => kitPage,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,SAAgBA,SAA0C;CACxD,OAAO,oBACJ,aAAa;EACZ,oBAAuB;GACrB,SAAS;EACX,CAAC;CACH,SACMC,IACR;AACF"}

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/adapter/handler.d.ts

@@ -0,0 +1,67 @@
+import { Effect } from "effect";
+import { SSRManifest, Server } from "@sveltejs/kit";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as HttpPlatform from "effect/unstable/http/HttpPlatform";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+
+//#region src/adapter/handler.d.ts
+/**
+ * The services required by the SvelteKit HTTP application. All of them are
+ * provided by `NodeHttpServer.layer` from `@effect/platform-node`.
+ */
+type SvelteKitHttpAppServices = FileSystem.FileSystem | Path.Path | HttpPlatform.HttpPlatform;
+/**
+ * The SvelteKit application as a composable Effect HTTP handler: an effect that
+ * produces an {@link HttpServerResponse.HttpServerResponse} for the current
+ * request. The `HttpServerRequest` is supplied per request by the server.
+ */
+type SvelteKitHttpApp = Effect.Effect<HttpServerResponse.HttpServerResponse, never, SvelteKitHttpAppServices | HttpServerRequest.HttpServerRequest>;
+interface SvelteKitHandlerOptions {
+  /** The SvelteKit `Server` class exported by the build output (`./server/index.js`). */
+  readonly Server: typeof Server;
+  /** The SSR manifest exported by the build output (`./manifest.js`). */
+  readonly manifest: SSRManifest;
+  /** The set of prerendered paths exported by the build output (`./manifest.js`). */
+  readonly prerendered: ReadonlySet<string>;
+  /** The configured `paths.base`, exported by the build output (`./manifest.js`). */
+  readonly base: string;
+  /** Absolute path of the build output directory (contains `client/`, `server/`, `prerendered/`). */
+  readonly dir: string;
+  /** Environment variables passed to the SvelteKit server (e.g. `process.env`). */
+  readonly env?: Record<string, string | undefined>;
+  /** Prefix for the runtime configuration environment variables (ORIGIN, ...). */
+  readonly envPrefix?: string;
+}
+/**
+ * Creates the SvelteKit HTTP handler.
+ *
+ * The returned effect initialises the SvelteKit server (running your app's
+ * server `init` hook) and yields an HTTP handler that:
+ *
+ * 1. serves static client assets from `<dir>/client` (with immutable cache
+ *    headers for hashed build assets),
+ * 2. serves prerendered pages from `<dir>/prerendered`,
+ * 3. falls back to server-side rendering via the SvelteKit server.
+ *
+ * @example
+ * ```ts
+ * // Mounting SvelteKit inside an existing effect/unstable/http server:
+ * import { handler } from "./build/handler.js";
+ * import * as HttpServer from "effect/unstable/http/HttpServer";
+ * import { NodeHttpServer, NodeRuntime } from "@effect/platform-node";
+ * import { Effect, Layer } from "effect";
+ * import { createServer } from "node:http";
+ *
+ * const serverLayer = Layer.unwrap(
+ *   Effect.map(handler, (app) => HttpServer.serve(app))
+ * ).pipe(Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 })));
+ *
+ * NodeRuntime.runMain(Layer.launch(serverLayer));
+ * ```
+ */
+declare const makeHandler: (options: SvelteKitHandlerOptions) => Effect.Effect<SvelteKitHttpApp, never, SvelteKitHttpAppServices>;
+//#endregion
+export { SvelteKitHandlerOptions, SvelteKitHttpApp, SvelteKitHttpAppServices, makeHandler };
+//# sourceMappingURL=handler.d.ts.map

package/dist/adapter/handler.js

@@ -0,0 +1,158 @@
+import { Config, Effect, Option, Stream } from "effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import "effect/unstable/http/HttpPlatform";
+import * as HttpMethod from "effect/unstable/http/HttpMethod";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+//#region src/adapter/handler.ts
+/** Runtime configuration, read from the environment (compatible with adapter-node). */
+const handlerConfig = (prefix) => Config.all({
+	origin: Config.option(Config.string(`${prefix}ORIGIN`)),
+	protocolHeader: Config.option(Config.string(`${prefix}PROTOCOL_HEADER`)),
+	hostHeader: Config.option(Config.string(`${prefix}HOST_HEADER`)),
+	portHeader: Config.option(Config.string(`${prefix}PORT_HEADER`)),
+	addressHeader: Config.option(Config.string(`${prefix}ADDRESS_HEADER`)),
+	xffDepth: Config.int(`${prefix}XFF_DEPTH`).pipe(Config.withDefault(1))
+});
+/** Compute the request origin from configuration and headers (adapter-node semantics). */
+const originOf = (request, config) => {
+	if (Option.isSome(config.origin)) return config.origin.value;
+	const headers = request.headers;
+	const protocolHeader = Option.getOrUndefined(config.protocolHeader)?.toLowerCase();
+	const hostHeader = Option.getOrUndefined(config.hostHeader)?.toLowerCase() ?? "host";
+	const portHeader = Option.getOrUndefined(config.portHeader)?.toLowerCase();
+	const protocol = protocolHeader && headers[protocolHeader] || "http";
+	const host = headers[hostHeader] ?? "localhost";
+	const port = portHeader ? headers[portHeader] : void 0;
+	return port ? `${protocol}://${host.split(":")[0]}:${port}` : `${protocol}://${host}`;
+};
+/** Resolve the client address, honouring ADDRESS_HEADER / XFF_DEPTH if configured. */
+const clientAddressOf = (request, config) => {
+	const addressHeader = Option.getOrUndefined(config.addressHeader)?.toLowerCase();
+	if (addressHeader) {
+		const value = request.headers[addressHeader];
+		if (value) {
+			if (addressHeader === "x-forwarded-for") {
+				const addresses = value.split(",").map((address) => address.trim());
+				if (config.xffDepth < 1 || config.xffDepth > addresses.length) return addresses[0] ?? "";
+				return addresses[addresses.length - config.xffDepth];
+			}
+			return value;
+		}
+	}
+	return Option.getOrElse(request.remoteAddress, () => "");
+};
+/** Build a web `Request` for SvelteKit from an `HttpServerRequest`. */
+const toWebRequest = (request, url, context) => {
+	const init = {
+		method: request.method,
+		headers: { ...request.headers }
+	};
+	if (HttpMethod.hasBody(request.method)) {
+		init.body = Stream.toReadableStreamWith(request.stream, context);
+		init.duplex = "half";
+	}
+	return new Request(url, init);
+};
+const IMMUTABLE_HEADERS = { "cache-control": "public, max-age=31536000, immutable" };
+/**
+* Creates the SvelteKit HTTP handler.
+*
+* The returned effect initialises the SvelteKit server (running your app's
+* server `init` hook) and yields an HTTP handler that:
+*
+* 1. serves static client assets from `<dir>/client` (with immutable cache
+*    headers for hashed build assets),
+* 2. serves prerendered pages from `<dir>/prerendered`,
+* 3. falls back to server-side rendering via the SvelteKit server.
+*
+* @example
+* ```ts
+* // Mounting SvelteKit inside an existing effect/unstable/http server:
+* import { handler } from "./build/handler.js";
+* import * as HttpServer from "effect/unstable/http/HttpServer";
+* import { NodeHttpServer, NodeRuntime } from "@effect/platform-node";
+* import { Effect, Layer } from "effect";
+* import { createServer } from "node:http";
+*
+* const serverLayer = Layer.unwrap(
+*   Effect.map(handler, (app) => HttpServer.serve(app))
+* ).pipe(Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 })));
+*
+* NodeRuntime.runMain(Layer.launch(serverLayer));
+* ```
+*/
+const makeHandler = (options) => Effect.gen(function* () {
+	const config = yield* handlerConfig(options.envPrefix ?? "").pipe(Effect.orDie);
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const context = yield* Effect.context();
+	const clientDir = path.join(options.dir, "client");
+	const prerenderedDir = path.join(options.dir, "prerendered");
+	const serverDir = path.join(options.dir, "server");
+	const server = new options.Server(options.manifest);
+	yield* Effect.promise(() => server.init({
+		env: options.env ?? {},
+		read: (file) => Stream.toReadableStreamWith(fs.stream(path.join(serverDir, file)), context)
+	}));
+	/**
+	* Serve a file from `root` if `pathname` resolves to an existing file
+	* inside it. Returns `Option.none()` when the file does not exist or the
+	* path escapes `root`.
+	*/
+	const serveFile = (root, pathname, headers) => Effect.gen(function* () {
+		const filePath = path.join(root, pathname);
+		const relative = path.relative(root, filePath);
+		if (relative.startsWith("..") || path.isAbsolute(relative)) return Option.none();
+		const stat = yield* fs.stat(filePath).pipe(Effect.option);
+		if (Option.isNone(stat) || stat.value.type !== "File") return Option.none();
+		const response = yield* HttpServerResponse.file(filePath, { headers }).pipe(Effect.orDie);
+		return Option.some(response);
+	});
+	/** Serve a prerendered page, trying the file layouts SvelteKit emits. */
+	const servePrerendered = (pathname) => {
+		const candidates = pathname === "/" ? ["/index.html"] : pathname.endsWith("/") ? [`${pathname}index.html`, `${pathname.slice(0, -1)}.html`] : [
+			pathname,
+			`${pathname}.html`,
+			`${pathname}/index.html`
+		];
+		return Effect.gen(function* () {
+			let found = Option.none();
+			for (const candidate of candidates) {
+				if (Option.isSome(found)) break;
+				found = yield* serveFile(prerenderedDir, candidate);
+			}
+			return found;
+		});
+	};
+	const immutablePrefix = `/${options.manifest.appPath}/immutable/`;
+	return Effect.gen(function* () {
+		const request = yield* HttpServerRequest.HttpServerRequest;
+		const requestContext = yield* Effect.context();
+		const origin = originOf(request, config);
+		const url = new URL(request.url, origin);
+		let pathname;
+		try {
+			pathname = decodeURIComponent(url.pathname);
+		} catch {
+			return HttpServerResponse.empty({ status: 400 });
+		}
+		if (request.method === "GET" || request.method === "HEAD") {
+			const isImmutable = pathname.startsWith(immutablePrefix);
+			const asset = yield* serveFile(clientDir, pathname, isImmutable ? IMMUTABLE_HEADERS : void 0);
+			if (Option.isSome(asset)) return asset.value;
+			if (options.prerendered.has(pathname) || options.prerendered.has(pathname + "/")) {
+				const page = yield* servePrerendered(pathname);
+				if (Option.isSome(page)) return page.value;
+			}
+		}
+		const webRequest = toWebRequest(request, url, requestContext);
+		const response = yield* Effect.promise(() => server.respond(webRequest, { getClientAddress: () => clientAddressOf(request, config) }));
+		return HttpServerResponse.fromWeb(response);
+	});
+});
+//#endregion
+export { makeHandler };
+
+//# sourceMappingURL=handler.js.map

package/dist/adapter/handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.js","names":[],"sources":["../../src/adapter/handler.ts"],"sourcesContent":["/**\n * Runtime handler for the Effect SvelteKit adapter.\n *\n * `makeHandler` turns a built SvelteKit app (the `Server` class and manifest\n * emitted by `vite build`) into an Effect HTTP application that serves\n * static client assets, prerendered pages, and server-side rendered routes.\n *\n * The returned app is an ordinary Effect value: it can be served with the\n * generated `build/index.js` entry (see `./serve.js`), or mounted inside any\n * existing `effect/unstable/http` HTTP server alongside other routes.\n */\n\nimport type { SSRManifest, Server as SvelteKitServer } from \"@sveltejs/kit\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as HttpMethod from \"effect/unstable/http/HttpMethod\";\nimport * as HttpPlatform from \"effect/unstable/http/HttpPlatform\";\nimport * as HttpServerRequest from \"effect/unstable/http/HttpServerRequest\";\nimport * as HttpServerResponse from \"effect/unstable/http/HttpServerResponse\";\nimport * as Path from \"effect/Path\";\nimport { Config, Context, Effect, Option, Stream } from \"effect\";\n\n/**\n * The services required by the SvelteKit HTTP application. All of them are\n * provided by `NodeHttpServer.layer` from `@effect/platform-node`.\n */\nexport type SvelteKitHttpAppServices =\n  | FileSystem.FileSystem\n  | Path.Path\n  | HttpPlatform.HttpPlatform;\n\n/**\n * The SvelteKit application as a composable Effect HTTP handler: an effect that\n * produces an {@link HttpServerResponse.HttpServerResponse} for the current\n * request. The `HttpServerRequest` is supplied per request by the server.\n */\nexport type SvelteKitHttpApp = Effect.Effect<\n  HttpServerResponse.HttpServerResponse,\n  never,\n  SvelteKitHttpAppServices | HttpServerRequest.HttpServerRequest\n>;\n\nexport interface SvelteKitHandlerOptions {\n  /** The SvelteKit `Server` class exported by the build output (`./server/index.js`). */\n  readonly Server: typeof SvelteKitServer;\n  /** The SSR manifest exported by the build output (`./manifest.js`). */\n  readonly manifest: SSRManifest;\n  /** The set of prerendered paths exported by the build output (`./manifest.js`). */\n  readonly prerendered: ReadonlySet<string>;\n  /** The configured `paths.base`, exported by the build output (`./manifest.js`). */\n  readonly base: string;\n  /** Absolute path of the build output directory (contains `client/`, `server/`, `prerendered/`). */\n  readonly dir: string;\n  /** Environment variables passed to the SvelteKit server (e.g. `process.env`). */\n  readonly env?: Record<string, string | undefined>;\n  /** Prefix for the runtime configuration environment variables (ORIGIN, ...). */\n  readonly envPrefix?: string;\n}\n\n/** Runtime configuration, read from the environment (compatible with adapter-node). */\nconst handlerConfig = (prefix: string) =>\n  Config.all({\n    origin: Config.option(Config.string(`${prefix}ORIGIN`)),\n    protocolHeader: Config.option(Config.string(`${prefix}PROTOCOL_HEADER`)),\n    hostHeader: Config.option(Config.string(`${prefix}HOST_HEADER`)),\n    portHeader: Config.option(Config.string(`${prefix}PORT_HEADER`)),\n    addressHeader: Config.option(Config.string(`${prefix}ADDRESS_HEADER`)),\n    xffDepth: Config.int(`${prefix}XFF_DEPTH`).pipe(Config.withDefault(1)),\n  });\n\ntype HandlerConfig = Effect.Success<ReturnType<typeof handlerConfig>>;\n\n/** Compute the request origin from configuration and headers (adapter-node semantics). */\nconst originOf = (request: HttpServerRequest.HttpServerRequest, config: HandlerConfig): string => {\n  if (Option.isSome(config.origin)) return config.origin.value;\n\n  const headers = request.headers;\n  const protocolHeader = Option.getOrUndefined(config.protocolHeader)?.toLowerCase();\n  const hostHeader = Option.getOrUndefined(config.hostHeader)?.toLowerCase() ?? \"host\";\n  const portHeader = Option.getOrUndefined(config.portHeader)?.toLowerCase();\n\n  const protocol = (protocolHeader && headers[protocolHeader]) || \"http\";\n  const host = headers[hostHeader] ?? \"localhost\";\n  const port = portHeader ? headers[portHeader] : undefined;\n\n  return port ? `${protocol}://${host.split(\":\")[0]}:${port}` : `${protocol}://${host}`;\n};\n\n/** Resolve the client address, honouring ADDRESS_HEADER / XFF_DEPTH if configured. */\nconst clientAddressOf = (\n  request: HttpServerRequest.HttpServerRequest,\n  config: HandlerConfig,\n): string => {\n  const addressHeader = Option.getOrUndefined(config.addressHeader)?.toLowerCase();\n  if (addressHeader) {\n    const value = request.headers[addressHeader];\n    if (value) {\n      if (addressHeader === \"x-forwarded-for\") {\n        const addresses = value.split(\",\").map((address) => address.trim());\n        if (config.xffDepth < 1 || config.xffDepth > addresses.length) {\n          return addresses[0] ?? \"\";\n        }\n        return addresses[addresses.length - config.xffDepth]!;\n      }\n      return value;\n    }\n  }\n  return Option.getOrElse(request.remoteAddress, () => \"\");\n};\n\n/** Build a web `Request` for SvelteKit from an `HttpServerRequest`. */\nconst toWebRequest = (\n  request: HttpServerRequest.HttpServerRequest,\n  url: URL,\n  context: Context.Context<never>,\n): Request => {\n  // `Headers` is a redactable record-like value; copy the enumerable string\n  // entries into a plain record for the web `Request` constructor.\n  const init: RequestInit & { duplex?: \"half\" } = {\n    method: request.method,\n    headers: { ...request.headers },\n  };\n  if (HttpMethod.hasBody(request.method)) {\n    init.body = Stream.toReadableStreamWith(request.stream, context);\n    init.duplex = \"half\";\n  }\n  return new Request(url, init);\n};\n\nconst IMMUTABLE_HEADERS = { \"cache-control\": \"public, max-age=31536000, immutable\" };\n\n/**\n * Creates the SvelteKit HTTP handler.\n *\n * The returned effect initialises the SvelteKit server (running your app's\n * server `init` hook) and yields an HTTP handler that:\n *\n * 1. serves static client assets from `<dir>/client` (with immutable cache\n *    headers for hashed build assets),\n * 2. serves prerendered pages from `<dir>/prerendered`,\n * 3. falls back to server-side rendering via the SvelteKit server.\n *\n * @example\n * ```ts\n * // Mounting SvelteKit inside an existing effect/unstable/http server:\n * import { handler } from \"./build/handler.js\";\n * import * as HttpServer from \"effect/unstable/http/HttpServer\";\n * import { NodeHttpServer, NodeRuntime } from \"@effect/platform-node\";\n * import { Effect, Layer } from \"effect\";\n * import { createServer } from \"node:http\";\n *\n * const serverLayer = Layer.unwrap(\n *   Effect.map(handler, (app) => HttpServer.serve(app))\n * ).pipe(Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 })));\n *\n * NodeRuntime.runMain(Layer.launch(serverLayer));\n * ```\n */\nexport const makeHandler = (\n  options: SvelteKitHandlerOptions,\n): Effect.Effect<SvelteKitHttpApp, never, SvelteKitHttpAppServices> =>\n  Effect.gen(function* () {\n    const config = yield* handlerConfig(options.envPrefix ?? \"\").pipe(Effect.orDie);\n    const fs = yield* FileSystem.FileSystem;\n    const path = yield* Path.Path;\n    const context = yield* Effect.context<never>();\n\n    const clientDir = path.join(options.dir, \"client\");\n    const prerenderedDir = path.join(options.dir, \"prerendered\");\n    const serverDir = path.join(options.dir, \"server\");\n\n    // Initialise the SvelteKit server. `read` backs the `read()` helper from\n    // `$app/server`, streaming server assets from the build output.\n    const server = new options.Server(options.manifest);\n    yield* Effect.promise(() =>\n      server.init({\n        env: (options.env ?? {}) as Record<string, string>,\n        read: (file) => Stream.toReadableStreamWith(fs.stream(path.join(serverDir, file)), context),\n      }),\n    );\n\n    /**\n     * Serve a file from `root` if `pathname` resolves to an existing file\n     * inside it. Returns `Option.none()` when the file does not exist or the\n     * path escapes `root`.\n     */\n    const serveFile = (\n      root: string,\n      pathname: string,\n      headers?: Record<string, string>,\n    ): Effect.Effect<\n      Option.Option<HttpServerResponse.HttpServerResponse>,\n      never,\n      SvelteKitHttpAppServices\n    > =>\n      Effect.gen(function* () {\n        const filePath = path.join(root, pathname);\n\n        // Prevent path traversal outside of the served directory.\n        const relative = path.relative(root, filePath);\n        if (relative.startsWith(\"..\") || path.isAbsolute(relative)) {\n          return Option.none();\n        }\n\n        const stat = yield* fs.stat(filePath).pipe(Effect.option);\n        if (Option.isNone(stat) || stat.value.type !== \"File\") {\n          return Option.none();\n        }\n\n        const response = yield* HttpServerResponse.file(filePath, { headers }).pipe(Effect.orDie);\n        return Option.some(response);\n      });\n\n    /** Serve a prerendered page, trying the file layouts SvelteKit emits. */\n    const servePrerendered = (\n      pathname: string,\n    ): Effect.Effect<\n      Option.Option<HttpServerResponse.HttpServerResponse>,\n      never,\n      SvelteKitHttpAppServices\n    > => {\n      const candidates =\n        pathname === \"/\"\n          ? [\"/index.html\"]\n          : pathname.endsWith(\"/\")\n            ? [`${pathname}index.html`, `${pathname.slice(0, -1)}.html`]\n            : [pathname, `${pathname}.html`, `${pathname}/index.html`];\n\n      return Effect.gen(function* () {\n        let found = Option.none<HttpServerResponse.HttpServerResponse>();\n        for (const candidate of candidates) {\n          if (Option.isSome(found)) break;\n          found = yield* serveFile(prerenderedDir, candidate);\n        }\n        return found;\n      });\n    };\n\n    const immutablePrefix = `/${options.manifest.appPath}/immutable/`;\n\n    // The HTTP handler itself, evaluated once per request.\n    return Effect.gen(function* () {\n      const request = yield* HttpServerRequest.HttpServerRequest;\n      const requestContext = yield* Effect.context<never>();\n\n      const origin = originOf(request, config);\n      const url = new URL(request.url, origin);\n\n      let pathname: string;\n      try {\n        pathname = decodeURIComponent(url.pathname);\n      } catch {\n        return HttpServerResponse.empty({ status: 400 });\n      }\n\n      // 1. Static client assets (hashed build assets get immutable caching).\n      if (request.method === \"GET\" || request.method === \"HEAD\") {\n        const isImmutable = pathname.startsWith(immutablePrefix);\n        const asset = yield* serveFile(\n          clientDir,\n          pathname,\n          isImmutable ? IMMUTABLE_HEADERS : undefined,\n        );\n        if (Option.isSome(asset)) return asset.value;\n\n        // 2. Prerendered pages.\n        if (options.prerendered.has(pathname) || options.prerendered.has(pathname + \"/\")) {\n          const page = yield* servePrerendered(pathname);\n          if (Option.isSome(page)) return page.value;\n        }\n      }\n\n      // 3. Server-side rendering.\n      const webRequest = toWebRequest(request, url, requestContext);\n      const response = yield* Effect.promise(() =>\n        server.respond(webRequest, {\n          getClientAddress: () => clientAddressOf(request, config),\n        }),\n      );\n      return HttpServerResponse.fromWeb(response);\n    });\n  });\n"],"mappings":"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"}

package/dist/adapter/index.d.ts

@@ -0,0 +1,29 @@
+import { Adapter } from "@sveltejs/kit";
+
+//#region src/adapter/index.d.ts
+interface EffectAdapterOptions {
+  /**
+   * The directory to write the production build to.
+   * @default "build"
+   */
+  readonly out?: string;
+  /**
+   * Precompress static assets and prerendered pages with gzip and brotli.
+   * @default true
+   */
+  readonly precompress?: boolean;
+  /**
+   * Prefix for the environment variables the production server reads
+   * (`PORT`, `HOST`, `ORIGIN`, `PROTOCOL_HEADER`, `HOST_HEADER`,
+   * `PORT_HEADER`, `ADDRESS_HEADER`, `XFF_DEPTH`).
+   * @default ""
+   */
+  readonly envPrefix?: string;
+}
+/**
+ * Creates the Effect SvelteKit adapter.
+ */
+declare function effectAdapter(options?: EffectAdapterOptions): Adapter;
+//#endregion
+export { EffectAdapterOptions, effectAdapter as default, effectAdapter };
+//# sourceMappingURL=index.d.ts.map

package/dist/adapter/index.js

@@ -0,0 +1,105 @@
+import { writeFileSync } from "node:fs";
+//#region src/adapter/index.ts
+/**
+* Effect deployment adapter for SvelteKit.
+*
+* Like `@sveltejs/adapter-node`, but the production server is an
+* `effect/unstable/http` HTTP server: requests are handled by an Effect HTTP
+* handler, configuration is read through `Config`, and startup/shutdown is
+* managed by Effect layers and scopes (SIGINT/SIGTERM trigger a graceful
+* shutdown that runs all finalizers).
+*
+* ```js
+* // svelte.config.js
+* import adapter from "@thomasfosterau/effect-sveltekit/adapter";
+*
+* const config = {
+*   kit: { adapter: adapter() },
+* };
+*
+* export default config;
+* ```
+*
+* The build output (`build/` by default) contains:
+*
+* - `index.js` — runs the production server: `node build`
+* - `handler.js` — exports the SvelteKit app as a composable Effect HTTP
+*   handler, for mounting inside an existing `effect/unstable/http` server
+* - `client/`, `server/`, `prerendered/`, `manifest.js` — the built app
+*
+* Unlike `adapter-node`, the server output is not bundled: the deployment
+* needs `node_modules` with the app's production dependencies installed
+* (including `@thomasfosterau/effect-sveltekit`, `effect`, and
+* `@effect/platform-node`).
+*/
+const PACKAGE = "@thomasfosterau/effect-sveltekit";
+/** Template for the generated `<out>/handler.js`. */
+const handlerTemplate = (envPrefix) => `\
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+import { makeHandler } from "${PACKAGE}/adapter/handler";
+import { Server } from "./server/index.js";
+import { manifest, prerendered, base } from "./manifest.js";
+
+const dir = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * The SvelteKit application as a composable Effect HTTP handler.
+ *
+ * Serve it with the generated index.js, or mount it inside any
+ * \`effect/unstable/http\` HTTP server.
+ */
+export const handler = makeHandler({
+  Server,
+  manifest,
+  prerendered,
+  base,
+  dir,
+  env: process.env,
+  envPrefix: ${JSON.stringify(envPrefix)},
+});
+`;
+/** Template for the generated `<out>/index.js`. */
+const entryTemplate = (envPrefix) => `\
+import { serve } from "${PACKAGE}/adapter/serve";
+import { handler } from "./handler.js";
+
+serve(handler, { envPrefix: ${JSON.stringify(envPrefix)} });
+`;
+/**
+* Creates the Effect SvelteKit adapter.
+*/
+function effectAdapter(options = {}) {
+	const { out = "build", precompress = true, envPrefix = "" } = options;
+	return {
+		name: `${PACKAGE}/adapter`,
+		async adapt(builder) {
+			const base = builder.config.kit.paths.base;
+			builder.rimraf(out);
+			builder.mkdirp(out);
+			builder.log.minor("Copying assets");
+			builder.writeClient(`${out}/client${base}`);
+			builder.writePrerendered(`${out}/prerendered${base}`);
+			if (precompress) {
+				builder.log.minor("Compressing assets");
+				await Promise.all([builder.compress(`${out}/client`), builder.compress(`${out}/prerendered`)]);
+			}
+			builder.log.minor("Building server");
+			builder.writeServer(`${out}/server`);
+			writeFileSync(`${out}/manifest.js`, [
+				`export const manifest = ${builder.generateManifest({ relativePath: "./server" })};`,
+				`export const prerendered = new Set(${JSON.stringify(builder.prerendered.paths)});`,
+				`export const base = ${JSON.stringify(base)};`
+			].join("\n\n"));
+			builder.log.minor("Writing server entry");
+			writeFileSync(`${out}/handler.js`, handlerTemplate(envPrefix));
+			writeFileSync(`${out}/index.js`, entryTemplate(envPrefix));
+		},
+		supports: { read: () => true }
+	};
+}
+//#endregion
+export { effectAdapter as default, effectAdapter };
+
+//# sourceMappingURL=index.js.map

package/dist/adapter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/adapter/index.ts"],"sourcesContent":["/**\n * Effect deployment adapter for SvelteKit.\n *\n * Like `@sveltejs/adapter-node`, but the production server is an\n * `effect/unstable/http` HTTP server: requests are handled by an Effect HTTP\n * handler, configuration is read through `Config`, and startup/shutdown is\n * managed by Effect layers and scopes (SIGINT/SIGTERM trigger a graceful\n * shutdown that runs all finalizers).\n *\n * ```js\n * // svelte.config.js\n * import adapter from \"@thomasfosterau/effect-sveltekit/adapter\";\n *\n * const config = {\n *   kit: { adapter: adapter() },\n * };\n *\n * export default config;\n * ```\n *\n * The build output (`build/` by default) contains:\n *\n * - `index.js` — runs the production server: `node build`\n * - `handler.js` — exports the SvelteKit app as a composable Effect HTTP\n *   handler, for mounting inside an existing `effect/unstable/http` server\n * - `client/`, `server/`, `prerendered/`, `manifest.js` — the built app\n *\n * Unlike `adapter-node`, the server output is not bundled: the deployment\n * needs `node_modules` with the app's production dependencies installed\n * (including `@thomasfosterau/effect-sveltekit`, `effect`, and\n * `@effect/platform-node`).\n */\n\nimport { writeFileSync } from \"node:fs\";\nimport type { Adapter } from \"@sveltejs/kit\";\n\nexport interface EffectAdapterOptions {\n  /**\n   * The directory to write the production build to.\n   * @default \"build\"\n   */\n  readonly out?: string;\n  /**\n   * Precompress static assets and prerendered pages with gzip and brotli.\n   * @default true\n   */\n  readonly precompress?: boolean;\n  /**\n   * Prefix for the environment variables the production server reads\n   * (`PORT`, `HOST`, `ORIGIN`, `PROTOCOL_HEADER`, `HOST_HEADER`,\n   * `PORT_HEADER`, `ADDRESS_HEADER`, `XFF_DEPTH`).\n   * @default \"\"\n   */\n  readonly envPrefix?: string;\n}\n\nconst PACKAGE = \"@thomasfosterau/effect-sveltekit\";\n\n/** Template for the generated `<out>/handler.js`. */\nconst handlerTemplate = (envPrefix: string): string => `\\\nimport { dirname } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport process from \"node:process\";\nimport { makeHandler } from \"${PACKAGE}/adapter/handler\";\nimport { Server } from \"./server/index.js\";\nimport { manifest, prerendered, base } from \"./manifest.js\";\n\nconst dir = dirname(fileURLToPath(import.meta.url));\n\n/**\n * The SvelteKit application as a composable Effect HTTP handler.\n *\n * Serve it with the generated index.js, or mount it inside any\n * \\`effect/unstable/http\\` HTTP server.\n */\nexport const handler = makeHandler({\n  Server,\n  manifest,\n  prerendered,\n  base,\n  dir,\n  env: process.env,\n  envPrefix: ${JSON.stringify(envPrefix)},\n});\n`;\n\n/** Template for the generated `<out>/index.js`. */\nconst entryTemplate = (envPrefix: string): string => `\\\nimport { serve } from \"${PACKAGE}/adapter/serve\";\nimport { handler } from \"./handler.js\";\n\nserve(handler, { envPrefix: ${JSON.stringify(envPrefix)} });\n`;\n\n/**\n * Creates the Effect SvelteKit adapter.\n */\nexport function effectAdapter(options: EffectAdapterOptions = {}): Adapter {\n  const { out = \"build\", precompress = true, envPrefix = \"\" } = options;\n\n  return {\n    name: `${PACKAGE}/adapter`,\n\n    async adapt(builder) {\n      const base = builder.config.kit.paths.base;\n\n      builder.rimraf(out);\n      builder.mkdirp(out);\n\n      builder.log.minor(\"Copying assets\");\n      builder.writeClient(`${out}/client${base}`);\n      builder.writePrerendered(`${out}/prerendered${base}`);\n\n      if (precompress) {\n        builder.log.minor(\"Compressing assets\");\n        await Promise.all([\n          builder.compress(`${out}/client`),\n          builder.compress(`${out}/prerendered`),\n        ]);\n      }\n\n      builder.log.minor(\"Building server\");\n      builder.writeServer(`${out}/server`);\n\n      writeFileSync(\n        `${out}/manifest.js`,\n        [\n          `export const manifest = ${builder.generateManifest({ relativePath: \"./server\" })};`,\n          `export const prerendered = new Set(${JSON.stringify(builder.prerendered.paths)});`,\n          `export const base = ${JSON.stringify(base)};`,\n        ].join(\"\\n\\n\"),\n      );\n\n      builder.log.minor(\"Writing server entry\");\n      writeFileSync(`${out}/handler.js`, handlerTemplate(envPrefix));\n      writeFileSync(`${out}/index.js`, entryTemplate(envPrefix));\n    },\n\n    supports: {\n      // `read()` from `$app/server` is backed by the platform FileSystem.\n      read: () => true,\n    },\n  };\n}\n\nexport default effectAdapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,MAAM,UAAU;;AAGhB,MAAM,mBAAmB,cAA8B;;;;+BAIxB,QAAQ;;;;;;;;;;;;;;;;;;;eAmBxB,KAAK,UAAU,SAAS,EAAE;;;;AAKzC,MAAM,iBAAiB,cAA8B;yBAC5B,QAAQ;;;8BAGH,KAAK,UAAU,SAAS,EAAE;;;;;AAMxD,SAAgB,cAAc,UAAgC,CAAC,GAAY;CACzE,MAAM,EAAE,MAAM,SAAS,cAAc,MAAM,YAAY,OAAO;CAE9D,OAAO;EACL,MAAM,GAAG,QAAQ;EAEjB,MAAM,MAAM,SAAS;GACnB,MAAM,OAAO,QAAQ,OAAO,IAAI,MAAM;GAEtC,QAAQ,OAAO,GAAG;GAClB,QAAQ,OAAO,GAAG;GAElB,QAAQ,IAAI,MAAM,gBAAgB;GAClC,QAAQ,YAAY,GAAG,IAAI,SAAS,MAAM;GAC1C,QAAQ,iBAAiB,GAAG,IAAI,cAAc,MAAM;GAEpD,IAAI,aAAa;IACf,QAAQ,IAAI,MAAM,oBAAoB;IACtC,MAAM,QAAQ,IAAI,CAChB,QAAQ,SAAS,GAAG,IAAI,QAAQ,GAChC,QAAQ,SAAS,GAAG,IAAI,aAAa,CACvC,CAAC;GACH;GAEA,QAAQ,IAAI,MAAM,iBAAiB;GACnC,QAAQ,YAAY,GAAG,IAAI,QAAQ;GAEnC,cACE,GAAG,IAAI,eACP;IACE,2BAA2B,QAAQ,iBAAiB,EAAE,cAAc,WAAW,CAAC,EAAE;IAClF,sCAAsC,KAAK,UAAU,QAAQ,YAAY,KAAK,EAAE;IAChF,uBAAuB,KAAK,UAAU,IAAI,EAAE;GAC9C,EAAE,KAAK,MAAM,CACf;GAEA,QAAQ,IAAI,MAAM,sBAAsB;GACxC,cAAc,GAAG,IAAI,cAAc,gBAAgB,SAAS,CAAC;GAC7D,cAAc,GAAG,IAAI,YAAY,cAAc,SAAS,CAAC;EAC3D;EAEA,UAAU,EAER,YAAY,KACd;CACF;AACF"}

package/dist/adapter/serve.d.ts

@@ -0,0 +1,46 @@
+import { SvelteKitHttpApp } from "./handler.js";
+import { Effect, Layer } from "effect";
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
+
+//#region src/adapter/serve.d.ts
+interface ServeOptions {
+  /** Prefix for the configuration environment variables (PORT, HOST, ...). */
+  readonly envPrefix?: string;
+  /**
+   * Additional layer merged into the server context, e.g. tracing or logging
+   * layers.
+   */
+  readonly layer?: Layer.Layer<never, never>;
+  /**
+   * Disable the default request logger middleware.
+   */
+  readonly disableLogger?: boolean;
+}
+/**
+ * Builds the full server layer for a SvelteKit HttpApp: HTTP listener
+ * (`PORT` / `HOST` environment variables), request logging, and the
+ * platform services the handler needs.
+ *
+ * Launch it with `Layer.launch`, or merge it into a larger application.
+ */
+declare const layer: (handler: Effect.Effect<SvelteKitHttpApp, never, NodeHttpServerServices>, options?: ServeOptions) => Layer.Layer<never, unknown>;
+/** The services provided to the handler effect by `NodeHttpServer.layerConfig`. */
+type NodeHttpServerServices = Layer.Success<ReturnType<typeof NodeHttpServer.layerConfig>>;
+/**
+ * Starts the production server and runs it until the process receives
+ * SIGINT/SIGTERM, at which point the server (and every Effect resource) is
+ * shut down gracefully.
+ *
+ * @example
+ * ```ts
+ * // build/index.js (generated by the adapter)
+ * import { handler } from "./handler.js";
+ * import { serve } from "@thomasfosterau/effect-sveltekit/adapter/serve";
+ *
+ * serve(handler);
+ * ```
+ */
+declare const serve: (handler: Effect.Effect<SvelteKitHttpApp, never, NodeHttpServerServices>, options?: ServeOptions) => void;
+//#endregion
+export { ServeOptions, layer, serve };
+//# sourceMappingURL=serve.d.ts.map

package/dist/adapter/serve.js

@@ -0,0 +1,57 @@
+import { Config, Effect, Layer } from "effect";
+import { createServer } from "node:http";
+import * as HttpMiddleware from "effect/unstable/http/HttpMiddleware";
+import * as HttpServer from "effect/unstable/http/HttpServer";
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+//#region src/adapter/serve.ts
+/**
+* Production server entry for the Effect SvelteKit adapter.
+*
+* The adapter's generated `build/index.js` calls {@link serve} with the
+* handler from `build/handler.js`. The server runs on
+* `@effect/platform-node`'s `NodeHttpServer`, with configuration read from
+* the environment and graceful shutdown handled by Effect scopes.
+*
+* For full control (custom layers, tracing, additional routes), skip the
+* generated entry and compose {@link layer} — or the handler itself — into
+* your own Effect application.
+*/
+/**
+* Builds the full server layer for a SvelteKit HttpApp: HTTP listener
+* (`PORT` / `HOST` environment variables), request logging, and the
+* platform services the handler needs.
+*
+* Launch it with `Layer.launch`, or merge it into a larger application.
+*/
+const layer = (handler, options = {}) => {
+	const prefix = options.envPrefix ?? "";
+	const serveLayer = Layer.unwrap(Effect.map(handler, (app) => options.disableLogger ? HttpServer.serve(app) : HttpServer.serve(app, HttpMiddleware.logger)));
+	const listenLayer = NodeHttpServer.layerConfig(createServer, {
+		port: Config.int(`${prefix}PORT`).pipe(Config.withDefault(3e3)),
+		host: Config.string(`${prefix}HOST`).pipe(Config.withDefault("0.0.0.0"))
+	});
+	const withListener = serveLayer.pipe(HttpServer.withLogAddress, Layer.provide(listenLayer));
+	return options.layer ? Layer.merge(withListener, options.layer) : withListener;
+};
+/**
+* Starts the production server and runs it until the process receives
+* SIGINT/SIGTERM, at which point the server (and every Effect resource) is
+* shut down gracefully.
+*
+* @example
+* ```ts
+* // build/index.js (generated by the adapter)
+* import { handler } from "./handler.js";
+* import { serve } from "@thomasfosterau/effect-sveltekit/adapter/serve";
+*
+* serve(handler);
+* ```
+*/
+const serve = (handler, options = {}) => {
+	NodeRuntime.runMain(Layer.launch(layer(handler, options)));
+};
+//#endregion
+export { layer, serve };
+
+//# sourceMappingURL=serve.js.map

package/dist/adapter/serve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.js","names":[],"sources":["../../src/adapter/serve.ts"],"sourcesContent":["/**\n * Production server entry for the Effect SvelteKit adapter.\n *\n * The adapter's generated `build/index.js` calls {@link serve} with the\n * handler from `build/handler.js`. The server runs on\n * `@effect/platform-node`'s `NodeHttpServer`, with configuration read from\n * the environment and graceful shutdown handled by Effect scopes.\n *\n * For full control (custom layers, tracing, additional routes), skip the\n * generated entry and compose {@link layer} — or the handler itself — into\n * your own Effect application.\n */\n\nimport { createServer } from \"node:http\";\nimport * as HttpMiddleware from \"effect/unstable/http/HttpMiddleware\";\nimport * as HttpServer from \"effect/unstable/http/HttpServer\";\nimport * as NodeHttpServer from \"@effect/platform-node/NodeHttpServer\";\nimport * as NodeRuntime from \"@effect/platform-node/NodeRuntime\";\nimport { Config, Effect, Layer } from \"effect\";\nimport type { SvelteKitHttpApp } from \"./handler.js\";\n\nexport interface ServeOptions {\n  /** Prefix for the configuration environment variables (PORT, HOST, ...). */\n  readonly envPrefix?: string;\n  /**\n   * Additional layer merged into the server context, e.g. tracing or logging\n   * layers.\n   */\n  readonly layer?: Layer.Layer<never, never>;\n  /**\n   * Disable the default request logger middleware.\n   */\n  readonly disableLogger?: boolean;\n}\n\n/**\n * Builds the full server layer for a SvelteKit HttpApp: HTTP listener\n * (`PORT` / `HOST` environment variables), request logging, and the\n * platform services the handler needs.\n *\n * Launch it with `Layer.launch`, or merge it into a larger application.\n */\nexport const layer = (\n  handler: Effect.Effect<SvelteKitHttpApp, never, NodeHttpServerServices>,\n  options: ServeOptions = {},\n): Layer.Layer<never, unknown> => {\n  const prefix = options.envPrefix ?? \"\";\n\n  const serveLayer = Layer.unwrap(\n    Effect.map(handler, (app) =>\n      options.disableLogger ? HttpServer.serve(app) : HttpServer.serve(app, HttpMiddleware.logger),\n    ),\n  );\n\n  const listenLayer = NodeHttpServer.layerConfig(createServer, {\n    port: Config.int(`${prefix}PORT`).pipe(Config.withDefault(3000)),\n    host: Config.string(`${prefix}HOST`).pipe(Config.withDefault(\"0.0.0.0\")),\n  });\n\n  const withListener = serveLayer.pipe(HttpServer.withLogAddress, Layer.provide(listenLayer));\n\n  return options.layer ? Layer.merge(withListener, options.layer) : withListener;\n};\n\n/** The services provided to the handler effect by `NodeHttpServer.layerConfig`. */\ntype NodeHttpServerServices = Layer.Success<ReturnType<typeof NodeHttpServer.layerConfig>>;\n\n/**\n * Starts the production server and runs it until the process receives\n * SIGINT/SIGTERM, at which point the server (and every Effect resource) is\n * shut down gracefully.\n *\n * @example\n * ```ts\n * // build/index.js (generated by the adapter)\n * import { handler } from \"./handler.js\";\n * import { serve } from \"@thomasfosterau/effect-sveltekit/adapter/serve\";\n *\n * serve(handler);\n * ```\n */\nexport const serve = (\n  handler: Effect.Effect<SvelteKitHttpApp, never, NodeHttpServerServices>,\n  options: ServeOptions = {},\n): void => {\n  NodeRuntime.runMain(Layer.launch(layer(handler, options)));\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,MAAa,SACX,SACA,UAAwB,CAAC,MACO;CAChC,MAAM,SAAS,QAAQ,aAAa;CAEpC,MAAM,aAAa,MAAM,OACvB,OAAO,IAAI,UAAU,QACnB,QAAQ,gBAAgB,WAAW,MAAM,GAAG,IAAI,WAAW,MAAM,KAAK,eAAe,MAAM,CAC7F,CACF;CAEA,MAAM,cAAc,eAAe,YAAY,cAAc;EAC3D,MAAM,OAAO,IAAI,GAAG,OAAO,KAAK,EAAE,KAAK,OAAO,YAAY,GAAI,CAAC;EAC/D,MAAM,OAAO,OAAO,GAAG,OAAO,KAAK,EAAE,KAAK,OAAO,YAAY,SAAS,CAAC;CACzE,CAAC;CAED,MAAM,eAAe,WAAW,KAAK,WAAW,gBAAgB,MAAM,QAAQ,WAAW,CAAC;CAE1F,OAAO,QAAQ,QAAQ,MAAM,MAAM,cAAc,QAAQ,KAAK,IAAI;AACpE;;;;;;;;;;;;;;;AAmBA,MAAa,SACX,SACA,UAAwB,CAAC,MAChB;CACT,YAAY,QAAQ,MAAM,OAAO,MAAM,SAAS,OAAO,CAAC,CAAC;AAC3D"}