@thomasfosterau/effect-sveltekit 0.4.1 → 0.6.0

package/dist/State.js

@@ -1,34 +1,48 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { pageSnapshotStream } from "./internal/app-state.js";
+import { UpdateCheckError, checkForUpdateWith, makeCurrentPage, pageSnapshotStream, snapshotNavigating, watchedStream } from "./internal/app-state.js";
+import { watch } from "./internal/watch.svelte.js";
+import { Context, Layer } from "effect";
 import { afterNavigate } from "$app/navigation";
-import { page } from "$app/state";
+import { navigating, page, updated } 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`.
+* An Effect-side bridge for SvelteKit's
+* [`$app/state`](https://svelte.dev/docs/kit/$app-state): `page`, `navigating`
+* and `updated`.
 *
-* `$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.
+* `$app/state` exposes rune-reactive objects for use inside components. This
+* module turns them into Effect values so navigation and version state can
+* drive Effect pipelines without touching Svelte runes:
 *
-* 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.
+* - {@link page} — a `Stream` of page snapshots, emitted now and after each
+*   navigation (via `afterNavigate`, so call it during component
+*   initialization).
+* - {@link navigating} — a `Stream` of the in-flight navigation as an
+*   `Option` (`None` when idle).
+* - {@link updated} / {@link checkForUpdate} — whether a new app version has
+*   been deployed, as a `Stream<boolean>` and as an on-demand check.
+* - {@link CurrentPage} — a `Context` service exposing the current page to any
+*   client Effect; provide {@link CurrentPage.layer} in your client runtime.
 *
-* 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.
+* Each page emission is a *shallow snapshot* (`url`, `params`, `route`, `data`,
+* `status`, `error`, `form`, `state`, `shallow`) 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. `navigating` emissions are snapshots for
+* the same reason.
 *
-* 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.
+* `navigating`, `updated` and `CurrentPage.changes` watch the rune state with a
+* root `$effect`, so they work anywhere on the client (not only during
+* component initialization). Each stream is cold: a run opens its own watcher,
+* emits the current value on the next Svelte flush and again whenever it
+* changes, and disposes the watcher when the stream ends or is interrupted.
+* All of this is client-only: during server rendering the watched streams
+* never emit, so consuming one there (for example with `Stream.runHead`)
+* hangs rather than failing.
+*
+* These are streams and a service rather than atoms; an atom-based variant
+* may follow once the official `@effect/atom-svelte` integration lands (see
+* issue #23).
 *
 * @example
 * ```svelte
@@ -46,11 +60,20 @@ import { page } from "$app/state";
 * <\/script>
 * ```
 */
-var State_exports = /* @__PURE__ */ __exportAll({ page: () => page$1 });
+var State_exports = /* @__PURE__ */ __exportAll({
+	CurrentPage: () => CurrentPage,
+	UpdateCheckError: () => UpdateCheckError,
+	checkForUpdate: () => checkForUpdate,
+	navigating: () => navigating$1,
+	page: () => page$1,
+	updated: () => updated$1
+});
 /**
 * A `Stream` of the current SvelteKit `page`, emitting a shallow snapshot
-* immediately and again after every navigation. Call during component
-* initialization.
+* immediately and again after every navigation; never fails. Call during
+* component initialization. It follows `afterNavigate`, so page changes
+* without a navigation (shallow routing, form results) don't emit — use
+* {@link CurrentPage}'s `changes` for those.
 */
 function page$1() {
 	return pageSnapshotStream((callback) => {
@@ -59,7 +82,73 @@ function page$1() {
 		});
 	}, () => page);
 }
+/**
+* A `Stream` of SvelteKit's in-flight navigation: `Option.some` with a
+* {@link NavigatingSnapshot} while a navigation is in progress, `Option.none()`
+* when idle. Emits the current state on the next Svelte flush, then on every
+* change; never fails. Client-only, but callable anywhere (not only during
+* component initialization).
+*
+* @example
+* ```ts
+* const spinner = Stream.runForEach(State.navigating(), (nav) =>
+*   Effect.sync(() => (busy = Option.isSome(nav))),
+* );
+* ```
+*/
+function navigating$1() {
+	return watchedStream(watch, () => snapshotNavigating(navigating));
+}
+/**
+* A `Stream` of SvelteKit's `updated.current`: whether a new version of the app
+* has been deployed since this one loaded. Emits the current value on the next
+* Svelte flush, then on every change (SvelteKit only ever flips it from `false`
+* to `true`); never fails. Client-only, but callable anywhere.
+*/
+function updated$1() {
+	return watchedStream(watch, () => updated.current);
+}
+/**
+* Asks SvelteKit to check for a new app version now (`updated.check()`),
+* succeeding with whether one is available; a positive result also flips
+* {@link updated}. Always succeeds with `false` in development. Fails with
+* {@link UpdateCheckError} if the check rejects. Client-only.
+*/
+function checkForUpdate() {
+	return checkForUpdateWith(() => updated.check());
+}
+/**
+* The current SvelteKit page as an Effect service, so any client Effect can read
+* it with `yield* State.CurrentPage` instead of taking it as an argument.
+* `get` snapshots the page when run; `changes` emits the current page on the
+* next Svelte flush, then a fresh snapshot whenever any field changes
+* (navigations, but also shallow routing and form results). Neither fails on
+* the client; on the server, Kit's `page` throws outside synchronous component
+* rendering (including after an async boundary in an Effect forked during
+* render), so `get` dies with a defect there.
+*
+* Provide {@link CurrentPage.layer} (backed by `$app/state`) in your client
+* runtime, or `Layer.succeed(State.CurrentPage, …)` in tests.
+*
+* @example
+* ```ts
+* const trackView = Effect.gen(function* () {
+*   const page = yield* (yield* State.CurrentPage).get;
+*   yield* analytics.view(page.url.pathname);
+* });
+*
+* runtime.runFork(trackView.pipe(Effect.provide(State.CurrentPage.layer)));
+* ```
+*/
+var CurrentPage = class CurrentPage extends Context.Service()("@thomasfosterau/effect-sveltekit/CurrentPage") {
+	/**
+	* A layer providing {@link CurrentPage} from `$app/state`'s `page`. Builds
+	* instantly and never fails; client-only (during server rendering `changes`
+	* never emits, so consuming it there hangs).
+	*/
+	static layer = Layer.succeed(CurrentPage, makeCurrentPage(() => page, watch));
+};
 //#endregion
-export { State_exports, page$1 as page };
+export { CurrentPage, State_exports, UpdateCheckError, checkForUpdate, navigating$1 as navigating, page$1 as page, updated$1 as updated };
 
 //# sourceMappingURL=State.js.map

package/dist/State.js.map

@@ -1 +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"}
+{"version":3,"file":"State.js","names":["page","kitPage","navigating","kitNavigating","updated","kitUpdated"],"sources":["../src/State.ts"],"sourcesContent":["/**\n * An Effect-side bridge for SvelteKit's\n * [`$app/state`](https://svelte.dev/docs/kit/$app-state): `page`, `navigating`\n * and `updated`.\n *\n * `$app/state` exposes rune-reactive objects for use inside components. This\n * module turns them into Effect values so navigation and version state can\n * drive Effect pipelines without touching Svelte runes:\n *\n * - {@link page} — a `Stream` of page snapshots, emitted now and after each\n *   navigation (via `afterNavigate`, so call it during component\n *   initialization).\n * - {@link navigating} — a `Stream` of the in-flight navigation as an\n *   `Option` (`None` when idle).\n * - {@link updated} / {@link checkForUpdate} — whether a new app version has\n *   been deployed, as a `Stream<boolean>` and as an on-demand check.\n * - {@link CurrentPage} — a `Context` service exposing the current page to any\n *   client Effect; provide {@link CurrentPage.layer} in your client runtime.\n *\n * Each page emission is a *shallow snapshot* (`url`, `params`, `route`, `data`,\n * `status`, `error`, `form`, `state`, `shallow`) rather than the live\n * `$app/state` proxy: the proxy mutates in place on every navigation, so a\n * captured reference is unreliable for downstream consumers — the snapshot\n * gives each emission a stable value. `navigating` emissions are snapshots for\n * the same reason.\n *\n * `navigating`, `updated` and `CurrentPage.changes` watch the rune state with a\n * root `$effect`, so they work anywhere on the client (not only during\n * component initialization). Each stream is cold: a run opens its own watcher,\n * emits the current value on the next Svelte flush and again whenever it\n * changes, and disposes the watcher when the stream ends or is interrupted.\n * All of this is client-only: during server rendering the watched streams\n * never emit, so consuming one there (for example with `Stream.runHead`)\n * hangs rather than failing.\n *\n * These are streams and a service rather than atoms; an atom-based variant\n * may follow once the official `@effect/atom-svelte` integration lands (see\n * issue #23).\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 { navigating as kitNavigating, page as kitPage, updated as kitUpdated } from \"$app/state\";\nimport type { Page } from \"$app/state\";\nimport { Context, Layer } from \"effect\";\nimport type { Effect, Option, Stream } from \"effect\";\nimport {\n  type CurrentPageShape,\n  type NavigatingSnapshot,\n  type PageSnapshot,\n  type UpdateCheckError,\n  checkForUpdateWith,\n  makeCurrentPage,\n  pageSnapshotStream,\n  snapshotNavigating,\n  watchedStream,\n} from \"./internal/app-state.js\";\nimport { watch } from \"./internal/watch.svelte.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 snapshot of an in-flight SvelteKit navigation (`type`, `from`, `to`,\n * `willUnload`, `delta`, `complete`) — see {@link navigating}.\n */\nexport type { NavigatingSnapshot } from \"./internal/app-state.js\";\n\n/**\n * The error {@link checkForUpdate} fails with when SvelteKit's\n * `updated.check()` rejects (misuse such as calling it during server\n * rendering; a failed version request resolves `false` instead). The original\n * error is on `cause`.\n */\nexport { UpdateCheckError } 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; never fails. Call during\n * component initialization. It follows `afterNavigate`, so page changes\n * without a navigation (shallow routing, form results) don't emit — use\n * {@link CurrentPage}'s `changes` for those.\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\n/**\n * A `Stream` of SvelteKit's in-flight navigation: `Option.some` with a\n * {@link NavigatingSnapshot} while a navigation is in progress, `Option.none()`\n * when idle. Emits the current state on the next Svelte flush, then on every\n * change; never fails. Client-only, but callable anywhere (not only during\n * component initialization).\n *\n * @example\n * ```ts\n * const spinner = Stream.runForEach(State.navigating(), (nav) =>\n *   Effect.sync(() => (busy = Option.isSome(nav))),\n * );\n * ```\n */\nexport function navigating(): Stream.Stream<Option.Option<NavigatingSnapshot>> {\n  return watchedStream(watch, () => snapshotNavigating(kitNavigating));\n}\n\n/**\n * A `Stream` of SvelteKit's `updated.current`: whether a new version of the app\n * has been deployed since this one loaded. Emits the current value on the next\n * Svelte flush, then on every change (SvelteKit only ever flips it from `false`\n * to `true`); never fails. Client-only, but callable anywhere.\n */\nexport function updated(): Stream.Stream<boolean> {\n  return watchedStream(watch, () => kitUpdated.current);\n}\n\n/**\n * Asks SvelteKit to check for a new app version now (`updated.check()`),\n * succeeding with whether one is available; a positive result also flips\n * {@link updated}. Always succeeds with `false` in development. Fails with\n * {@link UpdateCheckError} if the check rejects. Client-only.\n */\nexport function checkForUpdate(): Effect.Effect<boolean, UpdateCheckError> {\n  return checkForUpdateWith(() => kitUpdated.check());\n}\n\n/**\n * The service shape of {@link CurrentPage}: `get` snapshots the current page\n * and `changes` streams it. Neither fails on the client; see\n * {@link CurrentPage} for the server.\n */\nexport interface CurrentPageInterface extends CurrentPageShape<Page> {}\n\n/**\n * The current SvelteKit page as an Effect service, so any client Effect can read\n * it with `yield* State.CurrentPage` instead of taking it as an argument.\n * `get` snapshots the page when run; `changes` emits the current page on the\n * next Svelte flush, then a fresh snapshot whenever any field changes\n * (navigations, but also shallow routing and form results). Neither fails on\n * the client; on the server, Kit's `page` throws outside synchronous component\n * rendering (including after an async boundary in an Effect forked during\n * render), so `get` dies with a defect there.\n *\n * Provide {@link CurrentPage.layer} (backed by `$app/state`) in your client\n * runtime, or `Layer.succeed(State.CurrentPage, …)` in tests.\n *\n * @example\n * ```ts\n * const trackView = Effect.gen(function* () {\n *   const page = yield* (yield* State.CurrentPage).get;\n *   yield* analytics.view(page.url.pathname);\n * });\n *\n * runtime.runFork(trackView.pipe(Effect.provide(State.CurrentPage.layer)));\n * ```\n */\nexport class CurrentPage extends Context.Service<CurrentPage, CurrentPageInterface>()(\n  \"@thomasfosterau/effect-sveltekit/CurrentPage\",\n) {\n  /**\n   * A layer providing {@link CurrentPage} from `$app/state`'s `page`. Builds\n   * instantly and never fails; client-only (during server rendering `changes`\n   * never emits, so consuming it there hangs).\n   */\n  static readonly layer: Layer.Layer<CurrentPage> = Layer.succeed(\n    CurrentPage,\n    makeCurrentPage(() => kitPage, watch),\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkGA,SAAgBA,SAA0C;CACxD,OAAO,oBACJ,aAAa;EACZ,oBAAuB;GACrB,SAAS;EACX,CAAC;CACH,SACMC,IACR;AACF;;;;;;;;;;;;;;;AAgBA,SAAgBC,eAA+D;CAC7E,OAAO,cAAc,aAAa,mBAAmBC,UAAa,CAAC;AACrE;;;;;;;AAQA,SAAgBC,YAAkC;CAChD,OAAO,cAAc,aAAaC,QAAW,OAAO;AACtD;;;;;;;AAQA,SAAgB,iBAA2D;CACzE,OAAO,yBAAyBA,QAAW,MAAM,CAAC;AACpD;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAa,cAAb,MAAa,oBAAoB,QAAQ,QAA2C,CAAC,CACnF,8CACF,CAAC,CAAC;;;;;;CAMA,OAAgB,QAAkC,MAAM,QACtD,aACA,sBAAsBJ,MAAS,KAAK,CACtC;AACF"}

package/dist/adapter/handler.d.ts

@@ -1,6 +1,6 @@
 import { AssetSource, FileSystemAssetServices } from "./assets.js";
 import { Effect, Layer } from "effect";
-import { SSRManifest, Server } from "@sveltejs/kit";
+import { Server } from "@sveltejs/kit";
 import * as HttpServerRequest from "effect/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/http/HttpServerResponse";
 //#region src/adapter/handler.d.ts
@@ -19,10 +19,15 @@ type SvelteKitHttpAppServices = FileSystemAssetServices;
 type SvelteKitHttpApp<R = SvelteKitHttpAppServices> = Effect.Effect<HttpServerResponse.HttpServerResponse, never, R | HttpServerRequest.HttpServerRequest>;
 /** The SvelteKit build output {@link makeHandler} serves. */
 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 SvelteKit `server` instance exported by the build output (`./server.js`). */
+  readonly server: Server;
+  /**
+   * The application path, including any `paths.base` without its leading
+   * slash (`"_app"`, or `"my-app/_app"` under a base), exported by the build
+   * output (`./manifest.js`). Its `immutable/` subtree gets immutable cache
+   * headers.
+   */
+  readonly appPath: string;
   /** 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`). */
@@ -36,10 +41,8 @@ interface SvelteKitHandlerOptions {
 }
 /** Options for the platform-neutral SSR core, {@link makeHandlerWith}. */
 interface SvelteKitNeutralHandlerOptions<RAssets> {
-  /** The SvelteKit `Server` class exported by the build output. */
-  readonly Server: typeof Server;
-  /** The SSR manifest exported by the build output. */
-  readonly manifest: SSRManifest;
+  /** The SvelteKit `server` instance exported by the build output (`./server.js`). */
+  readonly server: Server;
   /** Environment variables passed to the SvelteKit server. */
   readonly env?: Record<string, string | undefined> | undefined;
   /** Prefix for the runtime configuration environment variables (ORIGIN, ...). */
@@ -97,14 +100,13 @@ declare const makeHandler: (options: SvelteKitHandlerOptions) => Effect.Effect<S
  * ```ts
  * // Workers: a fetch handler with assets from env.ASSETS
  * import { makeHandlerWith, AssetSource, toWebHandler } from "...adapter/handler";
- * import { Server } from "./server/index.js";
- * import { manifest } from "./manifest.js";
+ * import { server } from "./server.js";
  *
  * export default {
  *   fetch: (request, env, ctx) =>
  *     toWebHandler(
  *       makeHandlerWith({
- *         Server, manifest, env,
+ *         server, env,
  *         assets: AssetSource.cloudflareAssets(env.ASSETS),
  *         read: () => { throw new Error("read() not supported on this deployment"); },
  *       }),

package/dist/adapter/handler.js

@@ -89,14 +89,13 @@ const makeHandler = (options) => Effect.gen(function* () {
 	const context = yield* Effect.context();
 	const serverDir = path.join(options.dir, "server");
 	return yield* makeHandlerWith({
-		Server: options.Server,
-		manifest: options.manifest,
+		server: options.server,
 		env: options.env,
 		envPrefix: options.envPrefix,
 		read: (file) => Stream.toReadableStreamWith(fs.stream(path.join(serverDir, file)), context),
 		assets: AssetSource.fileSystem({
 			dir: options.dir,
-			appPath: options.manifest.appPath,
+			appPath: options.appPath,
 			prerendered: options.prerendered
 		})
 	});
@@ -117,14 +116,13 @@ const makeHandler = (options) => Effect.gen(function* () {
 * ```ts
 * // Workers: a fetch handler with assets from env.ASSETS
 * import { makeHandlerWith, AssetSource, toWebHandler } from "...adapter/handler";
-* import { Server } from "./server/index.js";
-* import { manifest } from "./manifest.js";
+* import { server } from "./server.js";
 *
 * export default {
 *   fetch: (request, env, ctx) =>
 *     toWebHandler(
 *       makeHandlerWith({
-*         Server, manifest, env,
+*         server, env,
 *         assets: AssetSource.cloudflareAssets(env.ASSETS),
 *         read: () => { throw new Error("read() not supported on this deployment"); },
 *       }),
@@ -134,7 +132,7 @@ const makeHandler = (options) => Effect.gen(function* () {
 */
 const makeHandlerWith = (options) => Effect.gen(function* () {
 	const config = yield* handlerConfig(options.envPrefix ?? "").pipe(Effect.orDie);
-	const server = new options.Server(options.manifest);
+	const server = options.server;
 	yield* Effect.promise(() => server.init({
 		env: options.env ?? {},
 		read: options.read

package/dist/adapter/handler.js.map

@@ -1 +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 from\n * disk — the Node default.\n *\n * {@link makeHandlerWith} is the platform-neutral core: it takes an injected\n * {@link AssetSource} (where assets come from) and a `read` capability (how to\n * read server assets), so the same SvelteKit `HttpApp` can run on a Node server\n * or on Cloudflare Workers (assets from `env.ASSETS`).\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`), mounted inside any\n * existing `effect/http` HTTP server, or converted to a `fetch` handler\n * (see {@link toWebHandler}).\n */\n\nimport type { SSRManifest, Server as SvelteKitServer } from \"@sveltejs/kit\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as HttpMethod from \"effect/http/HttpMethod\";\nimport * as HttpEffect from \"effect/http/HttpEffect\";\nimport * as HttpServerRequest from \"effect/http/HttpServerRequest\";\nimport * as HttpServerResponse from \"effect/http/HttpServerResponse\";\nimport * as Path from \"effect/Path\";\nimport { Config, Context, Effect, Layer, Option, Stream } from \"effect\";\nimport { AssetSource, type FileSystemAssetServices } from \"./assets.js\";\n\nexport { AssetSource, type FileSystemAssetServices } from \"./assets.js\";\n\n/**\n * The services required by the SvelteKit HTTP application when serving assets\n * from the file system (the Node default). All of them are provided by\n * `NodeHttpServer.layer` from `@effect/platform-node`.\n */\nexport type SvelteKitHttpAppServices = FileSystemAssetServices;\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. `R`\n * is the asset source's services (defaults to the file-system services).\n */\nexport type SvelteKitHttpApp<R = SvelteKitHttpAppServices> = Effect.Effect<\n  HttpServerResponse.HttpServerResponse,\n  never,\n  R | HttpServerRequest.HttpServerRequest\n>;\n\n/** The SvelteKit build output {@link makeHandler} serves. */\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/** Options for the platform-neutral SSR core, {@link makeHandlerWith}. */\nexport interface SvelteKitNeutralHandlerOptions<RAssets> {\n  /** The SvelteKit `Server` class exported by the build output. */\n  readonly Server: typeof SvelteKitServer;\n  /** The SSR manifest exported by the build output. */\n  readonly manifest: SSRManifest;\n  /** Environment variables passed to the SvelteKit server. */\n  readonly env?: Record<string, string | undefined> | undefined;\n  /** Prefix for the runtime configuration environment variables (ORIGIN, ...). */\n  readonly envPrefix?: string | undefined;\n  /** Where static client assets and prerendered pages come from. */\n  readonly assets: AssetSource<RAssets>;\n  /**\n   * How to read a server asset (backs `read()` from `$app/server`). On Node\n   * this streams from `<dir>/server`; on Workers, back it with the platform's\n   * own mechanism.\n   */\n  readonly read: (file: string) => ReadableStream<Uint8Array>;\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\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/http server:\n * import { handler } from \"./build/handler.js\";\n * import * as HttpServer from \"effect/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 fs = yield* FileSystem.FileSystem;\n    const path = yield* Path.Path;\n    const context = yield* Effect.context<never>();\n\n    const serverDir = path.join(options.dir, \"server\");\n\n    return yield* makeHandlerWith<SvelteKitHttpAppServices>({\n      Server: options.Server,\n      manifest: options.manifest,\n      env: options.env,\n      envPrefix: options.envPrefix,\n      // `read` backs the `read()` helper from `$app/server`, streaming server\n      // assets from the build output.\n      read: (file) => Stream.toReadableStreamWith(fs.stream(path.join(serverDir, file)), context),\n      assets: AssetSource.fileSystem({\n        dir: options.dir,\n        appPath: options.manifest.appPath,\n        prerendered: options.prerendered,\n      }),\n    });\n  });\n\n/**\n * The platform-neutral SSR core. Like {@link makeHandler}, but the asset source\n * and the server-asset `read` capability are injected, so the same SvelteKit\n * `HttpApp` can run on Node (file-system assets) or on Cloudflare Workers\n * (`AssetSource.cloudflareAssets(env.ASSETS)`).\n *\n * The returned app:\n *\n * 1. falls through to the injected {@link AssetSource} for static client assets\n *    and prerendered pages (GET/HEAD), then\n * 2. server-side renders via the SvelteKit server.\n *\n * @example\n * ```ts\n * // Workers: a fetch handler with assets from env.ASSETS\n * import { makeHandlerWith, AssetSource, toWebHandler } from \"...adapter/handler\";\n * import { Server } from \"./server/index.js\";\n * import { manifest } from \"./manifest.js\";\n *\n * export default {\n *   fetch: (request, env, ctx) =>\n *     toWebHandler(\n *       makeHandlerWith({\n *         Server, manifest, env,\n *         assets: AssetSource.cloudflareAssets(env.ASSETS),\n *         read: () => { throw new Error(\"read() not supported on this deployment\"); },\n *       }),\n *     )(request),\n * };\n * ```\n */\nexport const makeHandlerWith = <RAssets = never>(\n  options: SvelteKitNeutralHandlerOptions<RAssets>,\n): Effect.Effect<SvelteKitHttpApp<RAssets>, never, never> =>\n  Effect.gen(function* () {\n    const config = yield* handlerConfig(options.envPrefix ?? \"\").pipe(Effect.orDie);\n\n    // Initialise the SvelteKit server. `read` backs `read()` from `$app/server`.\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: options.read,\n      }),\n    );\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 / prerendered pages, via the injected source.\n      //    Only GET/HEAD reach assets; build a body-less request for the source.\n      if (request.method === \"GET\" || request.method === \"HEAD\") {\n        const assetRequest = new Request(url, {\n          method: request.method,\n          headers: { ...request.headers },\n        });\n        const asset = yield* options.assets.serveAsset(assetRequest, pathname);\n        if (Option.isSome(asset)) return asset.value;\n      }\n\n      // 2. 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\n/**\n * Convert a SvelteKit `HttpApp` to a Web `fetch` handler, providing the asset\n * source's services with `layer`. Use this for a Workers `fetch` export or any\n * runtime that speaks the Web platform.\n *\n * @example\n * ```ts\n * const fetchHandler = toWebHandler(\n *   makeHandlerWith({ ..., assets: AssetSource.cloudflareAssets(env.ASSETS) }),\n *   Layer.empty,\n * );\n * ```\n */\nexport const toWebHandler = <RAssets, E>(\n  app: Effect.Effect<SvelteKitHttpApp<RAssets>, never, never>,\n  layer: Layer.Layer<RAssets, E>,\n): ((request: Request) => Promise<Response>) => {\n  // Build the app (server.init) and the per-request web handler once, lazily on\n  // the first request, then dispatch each request through it.\n  let built: Promise<(request: Request) => Promise<Response>> | undefined;\n  const build = (): Promise<(request: Request) => Promise<Response>> =>\n    (built ??= Effect.runPromise(app).then(\n      (inner) =>\n        HttpEffect.toWebHandlerLayer(inner, layer).handler as (\n          request: Request,\n        ) => Promise<Response>,\n    ));\n  return async (request) => (await build())(request);\n};\n"],"mappings":"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"}
+{"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` instance the adapter\n * generates with `builder.generateServerInstance`) into an Effect HTTP application that serves\n * static client assets, prerendered pages, and server-side rendered routes from\n * disk — the Node default.\n *\n * {@link makeHandlerWith} is the platform-neutral core: it takes an injected\n * {@link AssetSource} (where assets come from) and a `read` capability (how to\n * read server assets), so the same SvelteKit `HttpApp` can run on a Node server\n * or on Cloudflare Workers (assets from `env.ASSETS`).\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`), mounted inside any\n * existing `effect/http` HTTP server, or converted to a `fetch` handler\n * (see {@link toWebHandler}).\n */\n\nimport type { Server as SvelteKitServer } from \"@sveltejs/kit\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as HttpMethod from \"effect/http/HttpMethod\";\nimport * as HttpEffect from \"effect/http/HttpEffect\";\nimport * as HttpServerRequest from \"effect/http/HttpServerRequest\";\nimport * as HttpServerResponse from \"effect/http/HttpServerResponse\";\nimport * as Path from \"effect/Path\";\nimport { Config, Context, Effect, Layer, Option, Stream } from \"effect\";\nimport { AssetSource, type FileSystemAssetServices } from \"./assets.js\";\n\nexport { AssetSource, type FileSystemAssetServices } from \"./assets.js\";\n\n/**\n * The services required by the SvelteKit HTTP application when serving assets\n * from the file system (the Node default). All of them are provided by\n * `NodeHttpServer.layer` from `@effect/platform-node`.\n */\nexport type SvelteKitHttpAppServices = FileSystemAssetServices;\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. `R`\n * is the asset source's services (defaults to the file-system services).\n */\nexport type SvelteKitHttpApp<R = SvelteKitHttpAppServices> = Effect.Effect<\n  HttpServerResponse.HttpServerResponse,\n  never,\n  R | HttpServerRequest.HttpServerRequest\n>;\n\n/** The SvelteKit build output {@link makeHandler} serves. */\nexport interface SvelteKitHandlerOptions {\n  /** The SvelteKit `server` instance exported by the build output (`./server.js`). */\n  readonly server: SvelteKitServer;\n  /**\n   * The application path, including any `paths.base` without its leading\n   * slash (`\"_app\"`, or `\"my-app/_app\"` under a base), exported by the build\n   * output (`./manifest.js`). Its `immutable/` subtree gets immutable cache\n   * headers.\n   */\n  readonly appPath: string;\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/** Options for the platform-neutral SSR core, {@link makeHandlerWith}. */\nexport interface SvelteKitNeutralHandlerOptions<RAssets> {\n  /** The SvelteKit `server` instance exported by the build output (`./server.js`). */\n  readonly server: SvelteKitServer;\n  /** Environment variables passed to the SvelteKit server. */\n  readonly env?: Record<string, string | undefined> | undefined;\n  /** Prefix for the runtime configuration environment variables (ORIGIN, ...). */\n  readonly envPrefix?: string | undefined;\n  /** Where static client assets and prerendered pages come from. */\n  readonly assets: AssetSource<RAssets>;\n  /**\n   * How to read a server asset (backs `read()` from `$app/server`). On Node\n   * this streams from `<dir>/server`; on Workers, back it with the platform's\n   * own mechanism.\n   */\n  readonly read: (file: string) => ReadableStream<Uint8Array>;\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\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/http server:\n * import { handler } from \"./build/handler.js\";\n * import * as HttpServer from \"effect/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 fs = yield* FileSystem.FileSystem;\n    const path = yield* Path.Path;\n    const context = yield* Effect.context<never>();\n\n    const serverDir = path.join(options.dir, \"server\");\n\n    return yield* makeHandlerWith<SvelteKitHttpAppServices>({\n      server: options.server,\n      env: options.env,\n      envPrefix: options.envPrefix,\n      // `read` backs the `read()` helper from `$app/server`, streaming server\n      // assets from the build output.\n      read: (file) => Stream.toReadableStreamWith(fs.stream(path.join(serverDir, file)), context),\n      assets: AssetSource.fileSystem({\n        dir: options.dir,\n        appPath: options.appPath,\n        prerendered: options.prerendered,\n      }),\n    });\n  });\n\n/**\n * The platform-neutral SSR core. Like {@link makeHandler}, but the asset source\n * and the server-asset `read` capability are injected, so the same SvelteKit\n * `HttpApp` can run on Node (file-system assets) or on Cloudflare Workers\n * (`AssetSource.cloudflareAssets(env.ASSETS)`).\n *\n * The returned app:\n *\n * 1. falls through to the injected {@link AssetSource} for static client assets\n *    and prerendered pages (GET/HEAD), then\n * 2. server-side renders via the SvelteKit server.\n *\n * @example\n * ```ts\n * // Workers: a fetch handler with assets from env.ASSETS\n * import { makeHandlerWith, AssetSource, toWebHandler } from \"...adapter/handler\";\n * import { server } from \"./server.js\";\n *\n * export default {\n *   fetch: (request, env, ctx) =>\n *     toWebHandler(\n *       makeHandlerWith({\n *         server, env,\n *         assets: AssetSource.cloudflareAssets(env.ASSETS),\n *         read: () => { throw new Error(\"read() not supported on this deployment\"); },\n *       }),\n *     )(request),\n * };\n * ```\n */\nexport const makeHandlerWith = <RAssets = never>(\n  options: SvelteKitNeutralHandlerOptions<RAssets>,\n): Effect.Effect<SvelteKitHttpApp<RAssets>, never, never> =>\n  Effect.gen(function* () {\n    const config = yield* handlerConfig(options.envPrefix ?? \"\").pipe(Effect.orDie);\n\n    // Initialise the SvelteKit server. `read` backs `read()` from `$app/server`.\n    const server = options.server;\n    yield* Effect.promise(() =>\n      server.init({\n        env: options.env ?? {},\n        read: options.read,\n      }),\n    );\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 / prerendered pages, via the injected source.\n      //    Only GET/HEAD reach assets; build a body-less request for the source.\n      if (request.method === \"GET\" || request.method === \"HEAD\") {\n        const assetRequest = new Request(url, {\n          method: request.method,\n          headers: { ...request.headers },\n        });\n        const asset = yield* options.assets.serveAsset(assetRequest, pathname);\n        if (Option.isSome(asset)) return asset.value;\n      }\n\n      // 2. 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\n/**\n * Convert a SvelteKit `HttpApp` to a Web `fetch` handler, providing the asset\n * source's services with `layer`. Use this for a Workers `fetch` export or any\n * runtime that speaks the Web platform.\n *\n * @example\n * ```ts\n * const fetchHandler = toWebHandler(\n *   makeHandlerWith({ ..., assets: AssetSource.cloudflareAssets(env.ASSETS) }),\n *   Layer.empty,\n * );\n * ```\n */\nexport const toWebHandler = <RAssets, E>(\n  app: Effect.Effect<SvelteKitHttpApp<RAssets>, never, never>,\n  layer: Layer.Layer<RAssets, E>,\n): ((request: Request) => Promise<Response>) => {\n  // Build the app (server.init) and the per-request web handler once, lazily on\n  // the first request, then dispatch each request through it.\n  let built: Promise<(request: Request) => Promise<Response>> | undefined;\n  const build = (): Promise<(request: Request) => Promise<Response>> =>\n    (built ??= Effect.runPromise(app).then(\n      (inner) =>\n        HttpEffect.toWebHandlerLayer(inner, layer).handler as (\n          request: Request,\n        ) => Promise<Response>,\n    ));\n  return async (request) => (await build())(request);\n};\n"],"mappings":"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"}

package/dist/adapter/index.js

@@ -1,4 +1,4 @@
-import { writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 //#region src/adapter/index.ts
 /**
 * Effect deployment adapter for SvelteKit.
@@ -10,14 +10,14 @@ import { writeFileSync } from "node:fs";
 * shutdown that runs all finalizers).
 *
 * ```js
-* // svelte.config.js
+* // vite.config.ts
+* import { sveltekit } from "@sveltejs/kit/vite";
 * import adapter from "@thomasfosterau/effect-sveltekit/adapter";
+* import { defineConfig } from "vite";
 *
-* const config = {
-*   kit: { adapter: adapter() },
-* };
-*
-* export default config;
+* export default defineConfig({
+*   plugins: [sveltekit({ adapter: adapter() })],
+* });
 * ```
 *
 * The build output (`build/` by default) contains:
@@ -25,7 +25,9 @@ import { writeFileSync } from "node:fs";
 * - `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/http` server
-* - `client/`, `server/`, `prerendered/`, `manifest.js` — the built app
+* - `client/`, `server/`, `prerendered/`, `server.js` (the SvelteKit
+*   `server` instance), `manifest.js` (prerendered paths, base and app path) —
+*   the built app
 *
 * Unlike `adapter-node`, the server output is not bundled: the deployment
 * needs `node_modules` with the app's production dependencies installed
@@ -39,8 +41,8 @@ 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";
+import { server } from "./server.js";
+import { prerendered, base, appPath } from "./manifest.js";
 
 const dir = dirname(fileURLToPath(import.meta.url));
 
@@ -51,8 +53,8 @@ const dir = dirname(fileURLToPath(import.meta.url));
  * \`effect/http\` HTTP server.
  */
 export const handler = makeHandler({
-  Server,
-  manifest,
+  server,
+  appPath,
   prerendered,
   base,
   dir,
@@ -77,8 +79,7 @@ serve(handler, { envPrefix: ${JSON.stringify(envPrefix)} });
 const fetchEntryTemplate = (envPrefix) => `\
 import { Layer } from "effect";
 import { makeHandlerWith, AssetSource, toWebHandler } from "${PACKAGE}/adapter/handler";
-import { Server } from "./server/index.js";
-import { manifest } from "./manifest.js";
+import { server } from "./server.js";
 
 let fetchHandler;
 
@@ -87,8 +88,7 @@ export default {
   fetch(request, env, ctx) {
     fetchHandler ??= toWebHandler(
       makeHandlerWith({
-        Server,
-        manifest,
+        server,
         env,
         envPrefix: ${JSON.stringify(envPrefix)},
         // Static assets come from the Workers ASSETS binding (configure it to
@@ -113,9 +113,12 @@ function effectAdapter(options = {}) {
 	return {
 		name: `${PACKAGE}/adapter`,
 		async adapt(builder) {
-			const base = builder.config.kit.paths.base;
-			builder.rimraf(out);
-			builder.mkdirp(out);
+			const base = builder.config.paths.base;
+			rmSync(out, {
+				recursive: true,
+				force: true
+			});
+			mkdirSync(out, { recursive: true });
 			builder.log.minor("Copying assets");
 			builder.writeClient(`${out}/client${base}`);
 			builder.writePrerendered(`${out}/prerendered${base}`);
@@ -125,10 +128,11 @@ function effectAdapter(options = {}) {
 			}
 			builder.log.minor("Building server");
 			builder.writeServer(`${out}/server`);
+			builder.generateServerInstance(`${out}/server.js`, { serverDirectory: `${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)};`
+				`export const base = ${JSON.stringify(base)};`,
+				`export const appPath = ${JSON.stringify(builder.getAppPath())};`
 			].join("\n\n"));
 			builder.log.minor("Writing server entry");
 			writeFileSync(`${out}/handler.js`, handlerTemplate(envPrefix));

package/dist/adapter/index.js.map

@@ -1 +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/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/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\n/** Options for {@link effectAdapter}. */\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   * The deployment target for the generated entry:\n   *\n   * - `\"node\"` (default) — a production Node HTTP server (`node build`) on\n   *   `@effect/platform-node`, serving assets from disk.\n   * - `\"fetch\"` — a Web `fetch` handler suitable for Cloudflare Workers\n   *   (`build/index.js` exports `default { fetch }`), serving assets from the\n   *   `env.ASSETS` binding via `AssetSource.cloudflareAssets`.\n   *\n   * Both targets also write `build/handler.js` (the SvelteKit `HttpApp`), so you\n   * can compose your own entry for any `effect/http` runtime.\n   *\n   * @default \"node\"\n   */\n  readonly target?: \"node\" | \"fetch\";\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/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 Node `<out>/index.js`. */\nconst nodeEntryTemplate = (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 * Template for the generated Cloudflare Workers `<out>/index.js`.\n *\n * Exports a module worker (`default { fetch }`). Static client assets and\n * prerendered pages are served from the `ASSETS` binding; everything else is\n * server-side rendered by the SvelteKit `HttpApp`.\n */\nconst fetchEntryTemplate = (envPrefix: string): string => `\\\nimport { Layer } from \"effect\";\nimport { makeHandlerWith, AssetSource, toWebHandler } from \"${PACKAGE}/adapter/handler\";\nimport { Server } from \"./server/index.js\";\nimport { manifest } from \"./manifest.js\";\n\nlet fetchHandler;\n\nexport default {\n  /** @param {Request} request @param {Record<string, any>} env @param {any} ctx */\n  fetch(request, env, ctx) {\n    fetchHandler ??= toWebHandler(\n      makeHandlerWith({\n        Server,\n        manifest,\n        env,\n        envPrefix: ${JSON.stringify(envPrefix)},\n        // Static assets come from the Workers ASSETS binding (configure it to\n        // serve the uploaded \\`client/\\` + \\`prerendered/\\` output).\n        assets: AssetSource.cloudflareAssets(env.ASSETS),\n        // \\`read()\\` from \\`$app/server\\` is not backed by a file system on workerd.\n        read: (file) => {\n          throw new Error(\\`read() is not supported on this deployment (\\${file})\\`);\n        },\n      }),\n      Layer.empty,\n    );\n    return fetchHandler(request);\n  },\n};\n`;\n\n/**\n * Creates the Effect SvelteKit adapter.\n */\nexport function effectAdapter(options: EffectAdapterOptions = {}): Adapter {\n  const { out = \"build\", precompress = true, envPrefix = \"\", target = \"node\" } = 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(\n        `${out}/index.js`,\n        target === \"fetch\" ? fetchEntryTemplate(envPrefix) : nodeEntryTemplate(envPrefix),\n      );\n    },\n\n    supports: {\n      // On Node, `read()` from `$app/server` is backed by the platform\n      // FileSystem. On the `fetch` (Workers) target it has no file system, so\n      // routes using `read()` are unsupported there.\n      read: () => target !== \"fetch\",\n    },\n  };\n}\n\nexport default effectAdapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,MAAM,UAAU;;AAGhB,MAAM,mBAAmB,cAA8B;;;;+BAIxB,QAAQ;;;;;;;;;;;;;;;;;;;eAmBxB,KAAK,UAAU,SAAS,EAAE;;;;AAKzC,MAAM,qBAAqB,cAA8B;yBAChC,QAAQ;;;8BAGH,KAAK,UAAU,SAAS,EAAE;;;;;;;;;AAUxD,MAAM,sBAAsB,cAA8B;;8DAEI,QAAQ;;;;;;;;;;;;;;qBAcjD,KAAK,UAAU,SAAS,EAAE;;;;;;;;;;;;;;;;;;AAmB/C,SAAgB,cAAc,UAAgC,CAAC,GAAY;CACzE,MAAM,EAAE,MAAM,SAAS,cAAc,MAAM,YAAY,IAAI,SAAS,WAAW;CAE/E,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,CAAC,CAAC,KAAK,MAAM,CACf;GAEA,QAAQ,IAAI,MAAM,sBAAsB;GACxC,cAAc,GAAG,IAAI,cAAc,gBAAgB,SAAS,CAAC;GAC7D,cACE,GAAG,IAAI,YACP,WAAW,UAAU,mBAAmB,SAAS,IAAI,kBAAkB,SAAS,CAClF;EACF;EAEA,UAAU,EAIR,YAAY,WAAW,QACzB;CACF;AACF"}
+{"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/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 * // vite.config.ts\n * import { sveltekit } from \"@sveltejs/kit/vite\";\n * import adapter from \"@thomasfosterau/effect-sveltekit/adapter\";\n * import { defineConfig } from \"vite\";\n *\n * export default defineConfig({\n *   plugins: [sveltekit({ adapter: adapter() })],\n * });\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/http` server\n * - `client/`, `server/`, `prerendered/`, `server.js` (the SvelteKit\n *   `server` instance), `manifest.js` (prerendered paths, base and app path) —\n *   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 { mkdirSync, rmSync, writeFileSync } from \"node:fs\";\nimport type { Adapter } from \"@sveltejs/kit\";\n\n/** Options for {@link effectAdapter}. */\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   * The deployment target for the generated entry:\n   *\n   * - `\"node\"` (default) — a production Node HTTP server (`node build`) on\n   *   `@effect/platform-node`, serving assets from disk.\n   * - `\"fetch\"` — a Web `fetch` handler suitable for Cloudflare Workers\n   *   (`build/index.js` exports `default { fetch }`), serving assets from the\n   *   `env.ASSETS` binding via `AssetSource.cloudflareAssets`.\n   *\n   * Both targets also write `build/handler.js` (the SvelteKit `HttpApp`), so you\n   * can compose your own entry for any `effect/http` runtime.\n   *\n   * @default \"node\"\n   */\n  readonly target?: \"node\" | \"fetch\";\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.js\";\nimport { prerendered, base, appPath } 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/http\\` HTTP server.\n */\nexport const handler = makeHandler({\n  server,\n  appPath,\n  prerendered,\n  base,\n  dir,\n  env: process.env,\n  envPrefix: ${JSON.stringify(envPrefix)},\n});\n`;\n\n/** Template for the generated Node `<out>/index.js`. */\nconst nodeEntryTemplate = (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 * Template for the generated Cloudflare Workers `<out>/index.js`.\n *\n * Exports a module worker (`default { fetch }`). Static client assets and\n * prerendered pages are served from the `ASSETS` binding; everything else is\n * server-side rendered by the SvelteKit `HttpApp`.\n */\nconst fetchEntryTemplate = (envPrefix: string): string => `\\\nimport { Layer } from \"effect\";\nimport { makeHandlerWith, AssetSource, toWebHandler } from \"${PACKAGE}/adapter/handler\";\nimport { server } from \"./server.js\";\n\nlet fetchHandler;\n\nexport default {\n  /** @param {Request} request @param {Record<string, any>} env @param {any} ctx */\n  fetch(request, env, ctx) {\n    fetchHandler ??= toWebHandler(\n      makeHandlerWith({\n        server,\n        env,\n        envPrefix: ${JSON.stringify(envPrefix)},\n        // Static assets come from the Workers ASSETS binding (configure it to\n        // serve the uploaded \\`client/\\` + \\`prerendered/\\` output).\n        assets: AssetSource.cloudflareAssets(env.ASSETS),\n        // \\`read()\\` from \\`$app/server\\` is not backed by a file system on workerd.\n        read: (file) => {\n          throw new Error(\\`read() is not supported on this deployment (\\${file})\\`);\n        },\n      }),\n      Layer.empty,\n    );\n    return fetchHandler(request);\n  },\n};\n`;\n\n/**\n * Creates the Effect SvelteKit adapter.\n */\nexport function effectAdapter(options: EffectAdapterOptions = {}): Adapter {\n  const { out = \"build\", precompress = true, envPrefix = \"\", target = \"node\" } = options;\n\n  return {\n    name: `${PACKAGE}/adapter`,\n\n    async adapt(builder) {\n      const base = builder.config.paths.base;\n\n      rmSync(out, { recursive: true, force: true });\n      mkdirSync(out, { recursive: true });\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      // `<out>/server.js` exports the SvelteKit `server` instance, with the\n      // manifest of the (non-prerendered) routes baked in.\n      builder.generateServerInstance(`${out}/server.js`, { serverDirectory: `${out}/server` });\n\n      writeFileSync(\n        `${out}/manifest.js`,\n        [\n          `export const prerendered = new Set(${JSON.stringify(builder.prerendered.paths)});`,\n          `export const base = ${JSON.stringify(base)};`,\n          `export const appPath = ${JSON.stringify(builder.getAppPath())};`,\n        ].join(\"\\n\\n\"),\n      );\n\n      builder.log.minor(\"Writing server entry\");\n      writeFileSync(`${out}/handler.js`, handlerTemplate(envPrefix));\n      writeFileSync(\n        `${out}/index.js`,\n        target === \"fetch\" ? fetchEntryTemplate(envPrefix) : nodeEntryTemplate(envPrefix),\n      );\n    },\n\n    supports: {\n      // On Node, `read()` from `$app/server` is backed by the platform\n      // FileSystem. On the `fetch` (Workers) target it has no file system, so\n      // routes using `read()` are unsupported there.\n      read: () => target !== \"fetch\",\n    },\n  };\n}\n\nexport default effectAdapter;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,MAAM,UAAU;;AAGhB,MAAM,mBAAmB,cAA8B;;;;+BAIxB,QAAQ;;;;;;;;;;;;;;;;;;;eAmBxB,KAAK,UAAU,SAAS,EAAE;;;;AAKzC,MAAM,qBAAqB,cAA8B;yBAChC,QAAQ;;;8BAGH,KAAK,UAAU,SAAS,EAAE;;;;;;;;;AAUxD,MAAM,sBAAsB,cAA8B;;8DAEI,QAAQ;;;;;;;;;;;;qBAYjD,KAAK,UAAU,SAAS,EAAE;;;;;;;;;;;;;;;;;;AAmB/C,SAAgB,cAAc,UAAgC,CAAC,GAAY;CACzE,MAAM,EAAE,MAAM,SAAS,cAAc,MAAM,YAAY,IAAI,SAAS,WAAW;CAE/E,OAAO;EACL,MAAM,GAAG,QAAQ;EAEjB,MAAM,MAAM,SAAS;GACnB,MAAM,OAAO,QAAQ,OAAO,MAAM;GAElC,OAAO,KAAK;IAAE,WAAW;IAAM,OAAO;GAAK,CAAC;GAC5C,UAAU,KAAK,EAAE,WAAW,KAAK,CAAC;GAElC,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;GAGnC,QAAQ,uBAAuB,GAAG,IAAI,aAAa,EAAE,iBAAiB,GAAG,IAAI,SAAS,CAAC;GAEvF,cACE,GAAG,IAAI,eACP;IACE,sCAAsC,KAAK,UAAU,QAAQ,YAAY,KAAK,EAAE;IAChF,uBAAuB,KAAK,UAAU,IAAI,EAAE;IAC5C,0BAA0B,KAAK,UAAU,QAAQ,WAAW,CAAC,EAAE;GACjE,CAAC,CAAC,KAAK,MAAM,CACf;GAEA,QAAQ,IAAI,MAAM,sBAAsB;GACxC,cAAc,GAAG,IAAI,cAAc,gBAAgB,SAAS,CAAC;GAC7D,cACE,GAAG,IAAI,YACP,WAAW,UAAU,mBAAmB,SAAS,IAAI,kBAAkB,SAAS,CAClF;EACF;EAEA,UAAU,EAIR,YAAY,WAAW,QACzB;CACF;AACF"}

package/dist/api-client.js

@@ -17,7 +17,7 @@ import * as HttpApiClient from "effect/http-api/HttpApiClient";
 * // src/routes/+page.ts — a universal load
 * import { apiClient } from "@thomasfosterau/effect-sveltekit";
 * import { Effect } from "effect";
-* import { api } from "$lib/api"; // the shared HttpApi definition
+* import { api } from "#lib/api.ts"; // the shared HttpApi definition
 *
 * export const load = (event) =>
 *   Effect.gen(function* () {

package/dist/api-client.js.map

@@ -1 +1 @@
-{"version":3,"file":"api-client.js","names":[],"sources":["../src/api-client.ts"],"sourcesContent":["/**\n * A typed client for an Effect [`HttpApi`](https://effect.website) served by\n * {@link Endpoint.fromApi}, closing the serve↔consume loop.\n *\n * {@link apiClient} wraps Effect's own `HttpApiClient.make` and provides the\n * `HttpClient` for you (via `FetchHttpClient`), so a browser or a universal\n * `load` can call the same-origin API with full end-to-end types derived from\n * the shared `HttpApi` definition. In a `load`, pass `event.fetch` so the call\n * participates in SvelteKit's SSR fetch (relative URLs, credentials, dedupe).\n *\n * @example\n * ```ts\n * // src/routes/+page.ts — a universal load\n * import { apiClient } from \"@thomasfosterau/effect-sveltekit\";\n * import { Effect } from \"effect\";\n * import { api } from \"$lib/api\"; // the shared HttpApi definition\n *\n * export const load = (event) =>\n *   Effect.gen(function* () {\n *     const client = yield* apiClient(api, { baseUrl: \"/api\", fetch: event.fetch });\n *     return { user: yield* client.users.get({ path: { id: event.params.id } }) };\n *   });\n * ```\n */\n\nimport { Effect, Layer } from \"effect\";\nimport * as FetchHttpClient from \"effect/http/FetchHttpClient\";\nimport type * as HttpClient from \"effect/http/HttpClient\";\nimport type * as HttpApi from \"effect/http-api/HttpApi\";\nimport * as HttpApiClient from \"effect/http-api/HttpApiClient\";\nimport type * as HttpApiGroup from \"effect/http-api/HttpApiGroup\";\n\n/** Options for {@link apiClient}. */\nexport interface ApiClientOptions {\n  /**\n   * The base URL the API is mounted at. For an `Endpoint.fromApi` mounted at\n   * `src/routes/api/[...path]` with `prefix: \"/api\"`, pass `\"/api\"`. Defaults to\n   * the endpoint paths relative to the current origin.\n   */\n  readonly baseUrl?: URL | string;\n  /**\n   * The `fetch` implementation to use. In a `load`, pass `event.fetch` so the\n   * request joins SvelteKit's SSR fetch. Defaults to the platform `fetch`.\n   */\n  readonly fetch?: typeof globalThis.fetch;\n  /** Transform the underlying `HttpClient` (e.g. add headers, retries). */\n  readonly transformClient?: (client: HttpClient.HttpClient) => HttpClient.HttpClient;\n}\n\n/**\n * Build a typed {@link HttpApiClient} for `api`, with the `HttpClient` provided\n * via `FetchHttpClient`. Yields the client from an `Effect`; the only remaining\n * requirement is any client middleware the API declares.\n */\nexport const apiClient = <ApiId extends string, Groups extends HttpApiGroup.Constraint>(\n  api: HttpApi.HttpApi<ApiId, Groups>,\n  options?: ApiClientOptions,\n): Effect.Effect<HttpApiClient.Client<Groups>, never, HttpApiGroup.MiddlewareClient<Groups>> => {\n  const fetchLayer =\n    options?.fetch === undefined\n      ? FetchHttpClient.layer\n      : FetchHttpClient.layer.pipe(\n          Layer.provide(Layer.succeed(FetchHttpClient.Fetch, options.fetch)),\n        );\n\n  return HttpApiClient.make(api, {\n    baseUrl: options?.baseUrl,\n    transformClient: options?.transformClient,\n  }).pipe(Effect.provide(fetchLayer));\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,MAAa,aACX,KACA,YAC8F;CAC9F,MAAM,aACJ,SAAS,UAAU,KAAA,IACf,gBAAgB,QAChB,gBAAgB,MAAM,KACpB,MAAM,QAAQ,MAAM,QAAQ,gBAAgB,OAAO,QAAQ,KAAK,CAAC,CACnE;CAEN,OAAO,cAAc,KAAK,KAAK;EAC7B,SAAS,SAAS;EAClB,iBAAiB,SAAS;CAC5B,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,UAAU,CAAC;AACpC"}
+{"version":3,"file":"api-client.js","names":[],"sources":["../src/api-client.ts"],"sourcesContent":["/**\n * A typed client for an Effect [`HttpApi`](https://effect.website) served by\n * {@link Endpoint.fromApi}, closing the serve↔consume loop.\n *\n * {@link apiClient} wraps Effect's own `HttpApiClient.make` and provides the\n * `HttpClient` for you (via `FetchHttpClient`), so a browser or a universal\n * `load` can call the same-origin API with full end-to-end types derived from\n * the shared `HttpApi` definition. In a `load`, pass `event.fetch` so the call\n * participates in SvelteKit's SSR fetch (relative URLs, credentials, dedupe).\n *\n * @example\n * ```ts\n * // src/routes/+page.ts — a universal load\n * import { apiClient } from \"@thomasfosterau/effect-sveltekit\";\n * import { Effect } from \"effect\";\n * import { api } from \"#lib/api.ts\"; // the shared HttpApi definition\n *\n * export const load = (event) =>\n *   Effect.gen(function* () {\n *     const client = yield* apiClient(api, { baseUrl: \"/api\", fetch: event.fetch });\n *     return { user: yield* client.users.get({ path: { id: event.params.id } }) };\n *   });\n * ```\n */\n\nimport { Effect, Layer } from \"effect\";\nimport * as FetchHttpClient from \"effect/http/FetchHttpClient\";\nimport type * as HttpClient from \"effect/http/HttpClient\";\nimport type * as HttpApi from \"effect/http-api/HttpApi\";\nimport * as HttpApiClient from \"effect/http-api/HttpApiClient\";\nimport type * as HttpApiGroup from \"effect/http-api/HttpApiGroup\";\n\n/** Options for {@link apiClient}. */\nexport interface ApiClientOptions {\n  /**\n   * The base URL the API is mounted at. For an `Endpoint.fromApi` mounted at\n   * `src/routes/api/[...path]` with `prefix: \"/api\"`, pass `\"/api\"`. Defaults to\n   * the endpoint paths relative to the current origin.\n   */\n  readonly baseUrl?: URL | string;\n  /**\n   * The `fetch` implementation to use. In a `load`, pass `event.fetch` so the\n   * request joins SvelteKit's SSR fetch. Defaults to the platform `fetch`.\n   */\n  readonly fetch?: typeof globalThis.fetch;\n  /** Transform the underlying `HttpClient` (e.g. add headers, retries). */\n  readonly transformClient?: (client: HttpClient.HttpClient) => HttpClient.HttpClient;\n}\n\n/**\n * Build a typed {@link HttpApiClient} for `api`, with the `HttpClient` provided\n * via `FetchHttpClient`. Yields the client from an `Effect`; the only remaining\n * requirement is any client middleware the API declares.\n */\nexport const apiClient = <ApiId extends string, Groups extends HttpApiGroup.Constraint>(\n  api: HttpApi.HttpApi<ApiId, Groups>,\n  options?: ApiClientOptions,\n): Effect.Effect<HttpApiClient.Client<Groups>, never, HttpApiGroup.MiddlewareClient<Groups>> => {\n  const fetchLayer =\n    options?.fetch === undefined\n      ? FetchHttpClient.layer\n      : FetchHttpClient.layer.pipe(\n          Layer.provide(Layer.succeed(FetchHttpClient.Fetch, options.fetch)),\n        );\n\n  return HttpApiClient.make(api, {\n    baseUrl: options?.baseUrl,\n    transformClient: options?.transformClient,\n  }).pipe(Effect.provide(fetchLayer));\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,MAAa,aACX,KACA,YAC8F;CAC9F,MAAM,aACJ,SAAS,UAAU,KAAA,IACf,gBAAgB,QAChB,gBAAgB,MAAM,KACpB,MAAM,QAAQ,MAAM,QAAQ,gBAAgB,OAAO,QAAQ,KAAK,CAAC,CACnE;CAEN,OAAO,cAAc,KAAK,KAAK;EAC7B,SAAS,SAAS;EAClB,iBAAiB,SAAS;CAC5B,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,UAAU,CAAC;AACpC"}

package/dist/app-runtime.d.ts

@@ -4,7 +4,8 @@ import { ErrorTranslator } from "./request-runtime.js";
 import { SvelteKitCookies, SvelteKitLocals, SvelteKitResponseHeaders } from "./request-services.js";
 import { Effect, Exit, Fiber, Layer, ManagedRuntime } from "effect";
 import * as HttpClient from "effect/http/HttpClient";
-import { Action, Actions, Handle, HandleFetch, HandleServerError, Load, RequestEvent, ServerInit, ServerLoad } from "@sveltejs/kit";
+import { Action, Actions, Load, RequestEvent, ServerLoad } from "@sveltejs/kit";
+import { Handle, HandleFetch, HandleServerError, ServerInit } from "@sveltejs/kit/hooks";
 //#region src/app-runtime.d.ts
 /**
  * The services provided to every wrapped effect on the server, in addition to
@@ -152,9 +153,9 @@ interface ServerRuntime<R = never, E = never> {
  *
  * ```ts
  * // src/routes/items/+page.server.ts
- * import { runtime } from '$lib/server/runtime';
+ * import { runtime } from '#lib/server/runtime.ts';
  * import { Effect } from 'effect';
- * import { Database } from '$lib/server/database';
+ * import { Database } from '#lib/server/database.ts';
  *
  * export const load = runtime.serverLoad((event) =>
  *   Effect.gen(function* () {
@@ -204,16 +205,16 @@ interface UniversalRuntime<R = never, E = never> {
  * ```ts
  * // src/lib/runtime.ts
  * import { makeUniversalRuntime } from '@thomasfosterau/effect-sveltekit';
- * import { ApiClient } from '$lib/api';
+ * import { ApiClient } from '#lib/api.ts';
  *
  * export const runtime = makeUniversalRuntime(ApiClient.layer);
  * ```
  *
  * ```ts
  * // src/routes/+page.ts
- * import { runtime } from '$lib/runtime';
+ * import { runtime } from '#lib/runtime.ts';
  * import { Effect } from 'effect';
- * import { ApiClient } from '$lib/api';
+ * import { ApiClient } from '#lib/api.ts';
  *
  * export const load = runtime.load((event) =>
  *   Effect.gen(function* () {