@thomasfosterau/effect-sveltekit 0.5.0 → 0.7.0

package/dist/State.js

@@ -1,34 +1,49 @@
 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 * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
 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 +61,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 +83,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 \"$app/state\";\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 * as Context from \"effect/Context\";\nimport * as Layer from \"effect/Layer\";\nimport type * as Effect from \"effect/Effect\";\nimport type * as Option from \"effect/Option\";\nimport type * as Stream from \"effect/Stream\";\nimport {\n  type CurrentPageService,\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 CurrentPageService<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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGA,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/assets.d.ts

@@ -1,7 +1,9 @@
-import { Effect, Option } from "effect";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import * as HttpPlatform from "effect/http/HttpPlatform";
+import * as Option from "effect/Option";
 import * as HttpServerResponse from "effect/http/HttpServerResponse";
 //#region src/adapter/assets.d.ts
 /**
@@ -11,25 +13,40 @@ import * as HttpServerResponse from "effect/http/HttpServerResponse";
  * needs (e.g. `FileSystem | Path | HttpPlatform` for {@link fileSystem}, or
  * `never` for {@link cloudflareAssets}).
  */
-interface AssetSource<R = never> {
+export interface AssetSource<R = never> {
   readonly serveAsset: (request: Request, pathname: string) => Effect.Effect<Option.Option<HttpServerResponse.HttpServerResponse>, never, R>;
 }
 /** The services a file-system {@link AssetSource} requires. */
-type FileSystemAssetServices = FileSystem.FileSystem | Path.Path | HttpPlatform.HttpPlatform;
+export type FileSystemAssetServices = FileSystem.FileSystem | Path.Path | HttpPlatform.HttpPlatform;
+declare const AssetFetchError_base: Schema.Class<AssetFetchError, Schema.TaggedStruct<"AssetFetchError", {
+  /** The request path the binding was asked for. */
+  readonly url: Schema.String;
+  /** What the binding's `fetch` rejected with, or threw. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A {@link cloudflareAssets} binding's `fetch` rejected. The asset source's
+ * error channel is `never`, so this reaches the handler as a DEFECT (a 500),
+ * carrying what `fetch` rejected with as `cause`.
+ */
+export declare class AssetFetchError extends AssetFetchError_base {}
 /** The {@link AssetSource} constructors, grouped for the adapter API. */
-declare const AssetSource: {
+export declare const AssetSource: {
   fileSystem: (config: {
     /** Absolute path of the build output directory (contains `client/`, `prerendered/`). */
     readonly dir: string;
     /** The configured `manifest.appPath` — its `immutable/` subtree gets immutable caching. */
     readonly appPath: string;
-    /** The set of prerendered paths exported by the build output. */
-    readonly prerendered: ReadonlySet<string>;
+    /**
+     * The prerendered paths exported by the build output (the build's
+     * `prerendered` `Set`, or any iterable of paths).
+     */
+    readonly prerendered: Iterable<string>;
   }) => AssetSource<FileSystemAssetServices>;
   cloudflareAssets: (assets: {
     fetch: (request: Request) => Promise<Response> | Response;
   }) => AssetSource;
 };
 //#endregion
-export { AssetSource, FileSystemAssetServices };
+export {};
 //# sourceMappingURL=assets.d.ts.map

package/dist/adapter/assets.js

@@ -1,8 +1,12 @@
-import { Effect, Option } from "effect";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 import "effect/http/HttpPlatform";
+import * as Option from "effect/Option";
 import * as HttpServerResponse from "effect/http/HttpServerResponse";
+import * as HashSet from "effect/HashSet";
 //#region src/adapter/assets.ts
 /**
 * Pluggable asset serving for the Effect SvelteKit adapter.
@@ -26,41 +30,52 @@ const IMMUTABLE_HEADERS = { "cache-control": "public, max-age=31536000, immutabl
 * Serve static client assets and prerendered pages from a build directory on
 * disk (the Node default). `dir` contains `client/` and `prerendered/`.
 */
-const fileSystem = (config) => ({ serveAsset: (request, pathname) => Effect.gen(function* () {
-	if (request.method !== "GET" && request.method !== "HEAD") return Option.none();
-	const path = yield* Path.Path;
-	const fs = yield* FileSystem.FileSystem;
-	const clientDir = path.join(config.dir, "client");
-	const prerenderedDir = path.join(config.dir, "prerendered");
-	const immutablePrefix = `/${config.appPath}/immutable/`;
-	/**
-	* Serve a file from `root` if `pathname` resolves to an existing file
-	* inside it (rejecting path traversal). `Option.none()` otherwise.
-	*/
-	const serveFile = (root, candidate, headers) => Effect.gen(function* () {
-		const filePath = path.join(root, candidate);
-		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);
-	});
-	const asset = yield* serveFile(clientDir, pathname, pathname.startsWith(immutablePrefix) ? IMMUTABLE_HEADERS : void 0);
-	if (Option.isSome(asset)) return asset;
-	if (config.prerendered.has(pathname) || config.prerendered.has(pathname + "/")) {
-		const candidates = pathname === "/" ? ["/index.html"] : pathname.endsWith("/") ? [`${pathname}index.html`, `${pathname.slice(0, -1)}.html`] : [
-			pathname,
-			`${pathname}.html`,
-			`${pathname}/index.html`
-		];
-		for (const candidate of candidates) {
-			const page = yield* serveFile(prerenderedDir, candidate);
-			if (Option.isSome(page)) return page;
+const fileSystem = (config) => {
+	const prerendered = HashSet.fromIterable(config.prerendered);
+	return { serveAsset: (request, pathname) => Effect.gen(function* () {
+		if (request.method !== "GET" && request.method !== "HEAD") return Option.none();
+		const path = yield* Path.Path;
+		const fs = yield* FileSystem.FileSystem;
+		const clientDir = path.join(config.dir, "client");
+		const prerenderedDir = path.join(config.dir, "prerendered");
+		const immutablePrefix = `/${config.appPath}/immutable/`;
+		/**
+		* Serve a file from `root` if `pathname` resolves to an existing file
+		* inside it (rejecting path traversal). `Option.none()` otherwise.
+		*/
+		const serveFile = (root, candidate, headers) => Effect.gen(function* () {
+			const filePath = path.join(root, candidate);
+			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);
+		});
+		const asset = yield* serveFile(clientDir, pathname, pathname.startsWith(immutablePrefix) ? IMMUTABLE_HEADERS : void 0);
+		if (Option.isSome(asset)) return asset;
+		if (HashSet.has(prerendered, pathname) || HashSet.has(prerendered, pathname + "/")) {
+			const candidates = pathname === "/" ? ["/index.html"] : pathname.endsWith("/") ? [`${pathname}index.html`, `${pathname.slice(0, -1)}.html`] : [
+				pathname,
+				`${pathname}.html`,
+				`${pathname}/index.html`
+			];
+			return yield* Effect.findFirstFilter(candidates, (candidate) => serveFile(prerenderedDir, candidate).pipe(Effect.map(Result.fromOption(() => candidate))));
 		}
-	}
-	return Option.none();
-}) });
+		return Option.none();
+	}) };
+};
+/**
+* A {@link cloudflareAssets} binding's `fetch` rejected. The asset source's
+* error channel is `never`, so this reaches the handler as a DEFECT (a 500),
+* carrying what `fetch` rejected with as `cause`.
+*/
+var AssetFetchError = class extends Schema.TaggedError()("AssetFetchError", {
+	/** The request path the binding was asked for. */
+	url: Schema.String,
+	/** What the binding's `fetch` rejected with, or threw. */
+	cause: Schema.Defect()
+}) {};
 /**
 * Serve static assets from a Cloudflare Workers static-assets binding (commonly
 * `env.ASSETS`). The binding's `fetch` resolves client assets and prerendered
@@ -72,7 +87,13 @@ const fileSystem = (config) => ({ serveAsset: (request, pathname) => Effect.gen(
 */
 const cloudflareAssets = (assets) => ({ serveAsset: (request) => Effect.gen(function* () {
 	if (request.method !== "GET" && request.method !== "HEAD") return Option.none();
-	const response = yield* Effect.promise(async () => assets.fetch(request));
+	const response = yield* Effect.tryPromise({
+		try: async () => assets.fetch(request),
+		catch: (cause) => new AssetFetchError({
+			url: request.url,
+			cause
+		})
+	}).pipe(Effect.orDie);
 	if (response.status === 404) return Option.none();
 	return Option.some(HttpServerResponse.fromWeb(response));
 }) });
@@ -82,6 +103,6 @@ const AssetSource = {
 	cloudflareAssets
 };
 //#endregion
-export { AssetSource, cloudflareAssets, fileSystem };
+export { AssetFetchError, AssetSource, cloudflareAssets, fileSystem };
 
 //# sourceMappingURL=assets.js.map

package/dist/adapter/assets.js.map

@@ -1 +1 @@
-{"version":3,"file":"assets.js","names":[],"sources":["../../src/adapter/assets.ts"],"sourcesContent":["/**\n * Pluggable asset serving for the Effect SvelteKit adapter.\n *\n * The SSR core ({@link makeHandler}) is platform-neutral: it falls through to an\n * injected {@link AssetSource} for static client assets and prerendered pages,\n * rather than reading the file system directly. This lets the same SvelteKit\n * `HttpApp` run on a Node server (assets from disk) or on Cloudflare Workers\n * (assets from the `env.ASSETS` binding, or any custom source — R2, KV, a CDN\n * passthrough).\n *\n * Ship several sources as equals and let the adapter (or the caller) pick:\n *\n * - {@link fileSystem} — serve `client/` + `prerendered/` from disk (Node\n *   default). Requires `FileSystem` / `Path` / `HttpPlatform`.\n * - {@link cloudflareAssets} — serve from a Workers static-assets binding\n *   (`env.ASSETS`). Requires nothing.\n */\n\nimport { Effect, Option } from \"effect\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as Path from \"effect/Path\";\nimport * as HttpPlatform from \"effect/http/HttpPlatform\";\nimport * as HttpServerResponse from \"effect/http/HttpServerResponse\";\n\n/**\n * A source of static assets. `serveAsset` returns the response for an asset\n * request, or `Option.none()` when the request is not an asset (so the SSR core\n * continues to server-side rendering). `R` is the set of services the source\n * needs (e.g. `FileSystem | Path | HttpPlatform` for {@link fileSystem}, or\n * `never` for {@link cloudflareAssets}).\n */\nexport interface AssetSource<R = never> {\n  readonly serveAsset: (\n    request: Request,\n    pathname: string,\n  ) => Effect.Effect<Option.Option<HttpServerResponse.HttpServerResponse>, never, R>;\n}\n\n/** The services a file-system {@link AssetSource} requires. */\nexport type FileSystemAssetServices = FileSystem.FileSystem | Path.Path | HttpPlatform.HttpPlatform;\n\nconst IMMUTABLE_HEADERS = { \"cache-control\": \"public, max-age=31536000, immutable\" };\n\n/**\n * Serve static client assets and prerendered pages from a build directory on\n * disk (the Node default). `dir` contains `client/` and `prerendered/`.\n */\nexport const fileSystem = (config: {\n  /** Absolute path of the build output directory (contains `client/`, `prerendered/`). */\n  readonly dir: string;\n  /** The configured `manifest.appPath` — its `immutable/` subtree gets immutable caching. */\n  readonly appPath: string;\n  /** The set of prerendered paths exported by the build output. */\n  readonly prerendered: ReadonlySet<string>;\n}): AssetSource<FileSystemAssetServices> => ({\n  serveAsset: (request, pathname) =>\n    Effect.gen(function* () {\n      // Only GET/HEAD reach static assets.\n      if (request.method !== \"GET\" && request.method !== \"HEAD\") return Option.none();\n\n      const path = yield* Path.Path;\n      const fs = yield* FileSystem.FileSystem;\n\n      const clientDir = path.join(config.dir, \"client\");\n      const prerenderedDir = path.join(config.dir, \"prerendered\");\n      const immutablePrefix = `/${config.appPath}/immutable/`;\n\n      /**\n       * Serve a file from `root` if `pathname` resolves to an existing file\n       * inside it (rejecting path traversal). `Option.none()` otherwise.\n       */\n      const serveFile = (\n        root: string,\n        candidate: string,\n        headers?: Record<string, string>,\n      ): Effect.Effect<\n        Option.Option<HttpServerResponse.HttpServerResponse>,\n        never,\n        FileSystemAssetServices\n      > =>\n        Effect.gen(function* () {\n          const filePath = path.join(root, candidate);\n          const relative = path.relative(root, filePath);\n          if (relative.startsWith(\"..\") || path.isAbsolute(relative)) return Option.none();\n\n          const stat = yield* fs.stat(filePath).pipe(Effect.option);\n          if (Option.isNone(stat) || stat.value.type !== \"File\") return Option.none();\n\n          const response = yield* HttpServerResponse.file(filePath, { headers }).pipe(Effect.orDie);\n          return Option.some(response);\n        });\n\n      // 1. Static client assets (hashed build assets get immutable caching).\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;\n\n      // 2. Prerendered pages.\n      if (config.prerendered.has(pathname) || config.prerendered.has(pathname + \"/\")) {\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        for (const candidate of candidates) {\n          const page = yield* serveFile(prerenderedDir, candidate);\n          if (Option.isSome(page)) return page;\n        }\n      }\n\n      return Option.none();\n    }),\n});\n\n/**\n * Serve static assets from a Cloudflare Workers static-assets binding (commonly\n * `env.ASSETS`). The binding's `fetch` resolves client assets and prerendered\n * pages uploaded by the deployment; a 404 from it means \"not an asset\", so the\n * SSR core continues to server-side rendering.\n *\n * This is one provided convenience, not the assumption: pass any object with a\n * `fetch` (R2, KV, a CDN passthrough) or a custom {@link AssetSource}.\n */\nexport const cloudflareAssets = (assets: {\n  fetch: (request: Request) => Promise<Response> | Response;\n}): AssetSource => ({\n  serveAsset: (request) =>\n    Effect.gen(function* () {\n      if (request.method !== \"GET\" && request.method !== \"HEAD\") return Option.none();\n      const response = yield* Effect.promise(async () => assets.fetch(request));\n      if (response.status === 404) return Option.none();\n      return Option.some(HttpServerResponse.fromWeb(response));\n    }),\n});\n\n/** The {@link AssetSource} constructors, grouped for the adapter API. */\nexport const AssetSource = {\n  fileSystem,\n  cloudflareAssets,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAM,oBAAoB,EAAE,iBAAiB,sCAAsC;;;;;AAMnF,MAAa,cAAc,YAOkB,EAC3C,aAAa,SAAS,aACpB,OAAO,IAAI,aAAa;CAEtB,IAAI,QAAQ,WAAW,SAAS,QAAQ,WAAW,QAAQ,OAAO,OAAO,KAAK;CAE9E,MAAM,OAAO,OAAO,KAAK;CACzB,MAAM,KAAK,OAAO,WAAW;CAE7B,MAAM,YAAY,KAAK,KAAK,OAAO,KAAK,QAAQ;CAChD,MAAM,iBAAiB,KAAK,KAAK,OAAO,KAAK,aAAa;CAC1D,MAAM,kBAAkB,IAAI,OAAO,QAAQ;;;;;CAM3C,MAAM,aACJ,MACA,WACA,YAMA,OAAO,IAAI,aAAa;EACtB,MAAM,WAAW,KAAK,KAAK,MAAM,SAAS;EAC1C,MAAM,WAAW,KAAK,SAAS,MAAM,QAAQ;EAC7C,IAAI,SAAS,WAAW,IAAI,KAAK,KAAK,WAAW,QAAQ,GAAG,OAAO,OAAO,KAAK;EAE/E,MAAM,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,KAAK,OAAO,MAAM;EACxD,IAAI,OAAO,OAAO,IAAI,KAAK,KAAK,MAAM,SAAS,QAAQ,OAAO,OAAO,KAAK;EAE1E,MAAM,WAAW,OAAO,mBAAmB,KAAK,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK;EACxF,OAAO,OAAO,KAAK,QAAQ;CAC7B,CAAC;CAIH,MAAM,QAAQ,OAAO,UACnB,WACA,UAHkB,SAAS,WAAW,eAI5B,IAAI,oBAAoB,KAAA,CACpC;CACA,IAAI,OAAO,OAAO,KAAK,GAAG,OAAO;CAGjC,IAAI,OAAO,YAAY,IAAI,QAAQ,KAAK,OAAO,YAAY,IAAI,WAAW,GAAG,GAAG;EAC9E,MAAM,aACJ,aAAa,MACT,CAAC,aAAa,IACd,SAAS,SAAS,GAAG,IACnB,CAAC,GAAG,SAAS,aAAa,GAAG,SAAS,MAAM,GAAG,EAAE,EAAE,MAAM,IACzD;GAAC;GAAU,GAAG,SAAS;GAAQ,GAAG,SAAS;EAAY;EAC/D,KAAK,MAAM,aAAa,YAAY;GAClC,MAAM,OAAO,OAAO,UAAU,gBAAgB,SAAS;GACvD,IAAI,OAAO,OAAO,IAAI,GAAG,OAAO;EAClC;CACF;CAEA,OAAO,OAAO,KAAK;AACrB,CAAC,EACL;;;;;;;;;;AAWA,MAAa,oBAAoB,YAEb,EAClB,aAAa,YACX,OAAO,IAAI,aAAa;CACtB,IAAI,QAAQ,WAAW,SAAS,QAAQ,WAAW,QAAQ,OAAO,OAAO,KAAK;CAC9E,MAAM,WAAW,OAAO,OAAO,QAAQ,YAAY,OAAO,MAAM,OAAO,CAAC;CACxE,IAAI,SAAS,WAAW,KAAK,OAAO,OAAO,KAAK;CAChD,OAAO,OAAO,KAAK,mBAAmB,QAAQ,QAAQ,CAAC;AACzD,CAAC,EACL;;AAGA,MAAa,cAAc;CACzB;CACA;AACF"}
+{"version":3,"file":"assets.js","names":[],"sources":["../../src/adapter/assets.ts"],"sourcesContent":["/**\n * Pluggable asset serving for the Effect SvelteKit adapter.\n *\n * The SSR core ({@link makeHandler}) is platform-neutral: it falls through to an\n * injected {@link AssetSource} for static client assets and prerendered pages,\n * rather than reading the file system directly. This lets the same SvelteKit\n * `HttpApp` run on a Node server (assets from disk) or on Cloudflare Workers\n * (assets from the `env.ASSETS` binding, or any custom source — R2, KV, a CDN\n * passthrough).\n *\n * Ship several sources as equals and let the adapter (or the caller) pick:\n *\n * - {@link fileSystem} — serve `client/` + `prerendered/` from disk (Node\n *   default). Requires `FileSystem` / `Path` / `HttpPlatform`.\n * - {@link cloudflareAssets} — serve from a Workers static-assets binding\n *   (`env.ASSETS`). Requires nothing.\n */\n\nimport * as Effect from \"effect/Effect\";\nimport * as HashSet from \"effect/HashSet\";\nimport * as Option from \"effect/Option\";\nimport * as Result from \"effect/Result\";\nimport * as Schema from \"effect/Schema\";\nimport * as FileSystem from \"effect/FileSystem\";\nimport * as Path from \"effect/Path\";\nimport * as HttpPlatform from \"effect/http/HttpPlatform\";\nimport * as HttpServerResponse from \"effect/http/HttpServerResponse\";\n\n/**\n * A source of static assets. `serveAsset` returns the response for an asset\n * request, or `Option.none()` when the request is not an asset (so the SSR core\n * continues to server-side rendering). `R` is the set of services the source\n * needs (e.g. `FileSystem | Path | HttpPlatform` for {@link fileSystem}, or\n * `never` for {@link cloudflareAssets}).\n */\nexport interface AssetSource<R = never> {\n  readonly serveAsset: (\n    request: Request,\n    pathname: string,\n  ) => Effect.Effect<Option.Option<HttpServerResponse.HttpServerResponse>, never, R>;\n}\n\n/** The services a file-system {@link AssetSource} requires. */\nexport type FileSystemAssetServices = FileSystem.FileSystem | Path.Path | HttpPlatform.HttpPlatform;\n\nconst IMMUTABLE_HEADERS = { \"cache-control\": \"public, max-age=31536000, immutable\" };\n\n/**\n * Serve static client assets and prerendered pages from a build directory on\n * disk (the Node default). `dir` contains `client/` and `prerendered/`.\n */\nexport const fileSystem = (config: {\n  /** Absolute path of the build output directory (contains `client/`, `prerendered/`). */\n  readonly dir: string;\n  /** The configured `manifest.appPath` — its `immutable/` subtree gets immutable caching. */\n  readonly appPath: string;\n  /**\n   * The prerendered paths exported by the build output (the build's\n   * `prerendered` `Set`, or any iterable of paths).\n   */\n  readonly prerendered: Iterable<string>;\n}): AssetSource<FileSystemAssetServices> => {\n  const prerendered = HashSet.fromIterable(config.prerendered);\n  return {\n    serveAsset: (request, pathname) =>\n      Effect.gen(function* () {\n        // Only GET/HEAD reach static assets.\n        if (request.method !== \"GET\" && request.method !== \"HEAD\") return Option.none();\n\n        const path = yield* Path.Path;\n        const fs = yield* FileSystem.FileSystem;\n\n        const clientDir = path.join(config.dir, \"client\");\n        const prerenderedDir = path.join(config.dir, \"prerendered\");\n        const immutablePrefix = `/${config.appPath}/immutable/`;\n\n        /**\n         * Serve a file from `root` if `pathname` resolves to an existing file\n         * inside it (rejecting path traversal). `Option.none()` otherwise.\n         */\n        const serveFile = (\n          root: string,\n          candidate: string,\n          headers?: Record<string, string>,\n        ): Effect.Effect<\n          Option.Option<HttpServerResponse.HttpServerResponse>,\n          never,\n          FileSystemAssetServices\n        > =>\n          Effect.gen(function* () {\n            const filePath = path.join(root, candidate);\n            const relative = path.relative(root, filePath);\n            if (relative.startsWith(\"..\") || path.isAbsolute(relative)) return Option.none();\n\n            const stat = yield* fs.stat(filePath).pipe(Effect.option);\n            if (Option.isNone(stat) || stat.value.type !== \"File\") return Option.none();\n\n            const response = yield* HttpServerResponse.file(filePath, { headers }).pipe(\n              Effect.orDie,\n            );\n            return Option.some(response);\n          });\n\n        // 1. Static client assets (hashed build assets get immutable caching).\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;\n\n        // 2. Prerendered pages.\n        if (HashSet.has(prerendered, pathname) || HashSet.has(prerendered, pathname + \"/\")) {\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          // The first candidate that exists, tried in order.\n          return yield* Effect.findFirstFilter(candidates, (candidate) =>\n            serveFile(prerenderedDir, candidate).pipe(\n              Effect.map(Result.fromOption(() => candidate)),\n            ),\n          );\n        }\n\n        return Option.none();\n      }),\n  };\n};\n\n/**\n * A {@link cloudflareAssets} binding's `fetch` rejected. The asset source's\n * error channel is `never`, so this reaches the handler as a DEFECT (a 500),\n * carrying what `fetch` rejected with as `cause`.\n */\nexport class AssetFetchError extends Schema.TaggedError<AssetFetchError>()(\"AssetFetchError\", {\n  /** The request path the binding was asked for. */\n  url: Schema.String,\n  /** What the binding's `fetch` rejected with, or threw. */\n  cause: Schema.Defect(),\n}) {}\n\n/**\n * Serve static assets from a Cloudflare Workers static-assets binding (commonly\n * `env.ASSETS`). The binding's `fetch` resolves client assets and prerendered\n * pages uploaded by the deployment; a 404 from it means \"not an asset\", so the\n * SSR core continues to server-side rendering.\n *\n * This is one provided convenience, not the assumption: pass any object with a\n * `fetch` (R2, KV, a CDN passthrough) or a custom {@link AssetSource}.\n */\nexport const cloudflareAssets = (assets: {\n  fetch: (request: Request) => Promise<Response> | Response;\n}): AssetSource => ({\n  serveAsset: (request) =>\n    Effect.gen(function* () {\n      if (request.method !== \"GET\" && request.method !== \"HEAD\") return Option.none();\n      const response = yield* Effect.tryPromise({\n        try: async () => assets.fetch(request),\n        catch: (cause) => new AssetFetchError({ url: request.url, cause }),\n      }).pipe(Effect.orDie);\n      if (response.status === 404) return Option.none();\n      return Option.some(HttpServerResponse.fromWeb(response));\n    }),\n});\n\n/** The {@link AssetSource} constructors, grouped for the adapter API. */\nexport const AssetSource = {\n  fileSystem,\n  cloudflareAssets,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,MAAM,oBAAoB,EAAE,iBAAiB,sCAAsC;;;;;AAMnF,MAAa,cAAc,WAUiB;CAC1C,MAAM,cAAc,QAAQ,aAAa,OAAO,WAAW;CAC3D,OAAO,EACL,aAAa,SAAS,aACpB,OAAO,IAAI,aAAa;EAEtB,IAAI,QAAQ,WAAW,SAAS,QAAQ,WAAW,QAAQ,OAAO,OAAO,KAAK;EAE9E,MAAM,OAAO,OAAO,KAAK;EACzB,MAAM,KAAK,OAAO,WAAW;EAE7B,MAAM,YAAY,KAAK,KAAK,OAAO,KAAK,QAAQ;EAChD,MAAM,iBAAiB,KAAK,KAAK,OAAO,KAAK,aAAa;EAC1D,MAAM,kBAAkB,IAAI,OAAO,QAAQ;;;;;EAM3C,MAAM,aACJ,MACA,WACA,YAMA,OAAO,IAAI,aAAa;GACtB,MAAM,WAAW,KAAK,KAAK,MAAM,SAAS;GAC1C,MAAM,WAAW,KAAK,SAAS,MAAM,QAAQ;GAC7C,IAAI,SAAS,WAAW,IAAI,KAAK,KAAK,WAAW,QAAQ,GAAG,OAAO,OAAO,KAAK;GAE/E,MAAM,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,KAAK,OAAO,MAAM;GACxD,IAAI,OAAO,OAAO,IAAI,KAAK,KAAK,MAAM,SAAS,QAAQ,OAAO,OAAO,KAAK;GAE1E,MAAM,WAAW,OAAO,mBAAmB,KAAK,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,KACrE,OAAO,KACT;GACA,OAAO,OAAO,KAAK,QAAQ;EAC7B,CAAC;EAIH,MAAM,QAAQ,OAAO,UACnB,WACA,UAHkB,SAAS,WAAW,eAI5B,IAAI,oBAAoB,KAAA,CACpC;EACA,IAAI,OAAO,OAAO,KAAK,GAAG,OAAO;EAGjC,IAAI,QAAQ,IAAI,aAAa,QAAQ,KAAK,QAAQ,IAAI,aAAa,WAAW,GAAG,GAAG;GAClF,MAAM,aACJ,aAAa,MACT,CAAC,aAAa,IACd,SAAS,SAAS,GAAG,IACnB,CAAC,GAAG,SAAS,aAAa,GAAG,SAAS,MAAM,GAAG,EAAE,EAAE,MAAM,IACzD;IAAC;IAAU,GAAG,SAAS;IAAQ,GAAG,SAAS;GAAY;GAE/D,OAAO,OAAO,OAAO,gBAAgB,aAAa,cAChD,UAAU,gBAAgB,SAAS,CAAC,CAAC,KACnC,OAAO,IAAI,OAAO,iBAAiB,SAAS,CAAC,CAC/C,CACF;EACF;EAEA,OAAO,OAAO,KAAK;CACrB,CAAC,EACL;AACF;;;;;;AAOA,IAAa,kBAAb,cAAqC,OAAO,YAA6B,CAAC,CAAC,mBAAmB;;CAE5F,KAAK,OAAO;;CAEZ,OAAO,OAAO,OAAO;AACvB,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;AAWJ,MAAa,oBAAoB,YAEb,EAClB,aAAa,YACX,OAAO,IAAI,aAAa;CACtB,IAAI,QAAQ,WAAW,SAAS,QAAQ,WAAW,QAAQ,OAAO,OAAO,KAAK;CAC9E,MAAM,WAAW,OAAO,OAAO,WAAW;EACxC,KAAK,YAAY,OAAO,MAAM,OAAO;EACrC,QAAQ,UAAU,IAAI,gBAAgB;GAAE,KAAK,QAAQ;GAAK;EAAM,CAAC;CACnE,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK;CACpB,IAAI,SAAS,WAAW,KAAK,OAAO,OAAO,KAAK;CAChD,OAAO,OAAO,KAAK,mBAAmB,QAAQ,QAAQ,CAAC;AACzD,CAAC,EACL;;AAGA,MAAa,cAAc;CACzB;CACA;AACF"}

package/dist/adapter/handler.d.ts

@@ -1,6 +1,8 @@
-import { AssetSource, FileSystemAssetServices } from "./assets.js";
-import { Effect, Layer } from "effect";
+import { AssetFetchError, AssetSource, FileSystemAssetServices } from "./assets.js";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import { Server } from "@sveltejs/kit";
+import * as Schema from "effect/Schema";
 import * as HttpServerRequest from "effect/http/HttpServerRequest";
 import * as HttpServerResponse from "effect/http/HttpServerResponse";
 //#region src/adapter/handler.d.ts
@@ -9,16 +11,16 @@ import * as HttpServerResponse from "effect/http/HttpServerResponse";
  * from the file system (the Node default). All of them are provided by
  * `NodeHttpServer.layer` from `@effect/platform-node`.
  */
-type SvelteKitHttpAppServices = FileSystemAssetServices;
+export type SvelteKitHttpAppServices = FileSystemAssetServices;
 /**
  * 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. `R`
  * is the asset source's services (defaults to the file-system services).
  */
-type SvelteKitHttpApp<R = SvelteKitHttpAppServices> = Effect.Effect<HttpServerResponse.HttpServerResponse, never, R | HttpServerRequest.HttpServerRequest>;
+export type SvelteKitHttpApp<R = SvelteKitHttpAppServices> = Effect.Effect<HttpServerResponse.HttpServerResponse, never, R | HttpServerRequest.HttpServerRequest>;
 /** The SvelteKit build output {@link makeHandler} serves. */
-interface SvelteKitHandlerOptions {
+export interface SvelteKitHandlerOptions {
   /** The SvelteKit `server` instance exported by the build output (`./server.js`). */
   readonly server: Server;
   /**
@@ -28,8 +30,8 @@ interface SvelteKitHandlerOptions {
    * headers.
    */
   readonly appPath: string;
-  /** The set of prerendered paths exported by the build output (`./manifest.js`). */
-  readonly prerendered: ReadonlySet<string>;
+  /** The prerendered paths exported by the build output (`./manifest.js`'s `Set`, or any iterable). */
+  readonly prerendered: Iterable<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/`). */
@@ -40,7 +42,7 @@ interface SvelteKitHandlerOptions {
   readonly envPrefix?: string;
 }
 /** Options for the platform-neutral SSR core, {@link makeHandlerWith}. */
-interface SvelteKitNeutralHandlerOptions<RAssets> {
+export interface SvelteKitNeutralHandlerOptions<RAssets> {
   /** The SvelteKit `server` instance exported by the build output (`./server.js`). */
   readonly server: Server;
   /** Environment variables passed to the SvelteKit server. */
@@ -83,7 +85,20 @@ interface SvelteKitNeutralHandlerOptions<RAssets> {
  * NodeRuntime.runMain(Layer.launch(serverLayer));
  * ```
  */
-declare const makeHandler: (options: SvelteKitHandlerOptions) => Effect.Effect<SvelteKitHttpApp, never, SvelteKitHttpAppServices>;
+export declare const makeHandler: (options: SvelteKitHandlerOptions) => Effect.Effect<SvelteKitHttpApp, never, SvelteKitHttpAppServices>;
+declare const SvelteKitServerError_base: Schema.Class<SvelteKitServerError, Schema.TaggedStruct<"SvelteKitServerError", {
+  /** Which `Server` method rejected. */
+  readonly operation: Schema.Literals<readonly ["init", "respond"]>;
+  /** What the method rejected with, or threw. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The SvelteKit server's `init` or `respond` rejected. SvelteKit turns a
+ * route's own errors into responses, so a rejection is a bug in the server
+ * build; the handler's error channel is `never`, so this reaches the platform
+ * as a DEFECT (a 500), carrying what SvelteKit rejected with as `cause`.
+ */
+export declare class SvelteKitServerError extends SvelteKitServerError_base {}
 /**
  * The platform-neutral SSR core. Like {@link makeHandler}, but the asset source
  * and the server-asset `read` capability are injected, so the same SvelteKit
@@ -114,7 +129,7 @@ declare const makeHandler: (options: SvelteKitHandlerOptions) => Effect.Effect<S
  * };
  * ```
  */
-declare const makeHandlerWith: <RAssets = never>(options: SvelteKitNeutralHandlerOptions<RAssets>) => Effect.Effect<SvelteKitHttpApp<RAssets>, never, never>;
+export declare const makeHandlerWith: <RAssets = never>(options: SvelteKitNeutralHandlerOptions<RAssets>) => Effect.Effect<SvelteKitHttpApp<RAssets>, never, never>;
 /**
  * Convert a SvelteKit `HttpApp` to a Web `fetch` handler, providing the asset
  * source's services with `layer`. Use this for a Workers `fetch` export or any
@@ -128,7 +143,7 @@ declare const makeHandlerWith: <RAssets = never>(options: SvelteKitNeutralHandle
  * );
  * ```
  */
-declare const toWebHandler: <RAssets, E>(app: Effect.Effect<SvelteKitHttpApp<RAssets>, never, never>, layer: Layer.Layer<RAssets, E>) => ((request: Request) => Promise<Response>);
+export declare const toWebHandler: <RAssets, E>(app: Effect.Effect<SvelteKitHttpApp<RAssets>, never, never>, layer: Layer.Layer<RAssets, E>) => ((request: Request) => Promise<Response>);
 //#endregion
-export { AssetSource, type FileSystemAssetServices, SvelteKitHandlerOptions, SvelteKitHttpApp, SvelteKitHttpAppServices, SvelteKitNeutralHandlerOptions, makeHandler, makeHandlerWith, toWebHandler };
+export { AssetFetchError, AssetSource, type FileSystemAssetServices };
 //# sourceMappingURL=handler.d.ts.map