@thomasfosterau/effect-sveltekit 0.5.0 → 0.7.0

package/dist/forms.js

@@ -1,6 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { makeSubmitFunction } from "./internal/enhance.js";
-import { Effect } from "effect";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
 import { applyAction, deserialize } from "$app/forms";
 //#region src/forms.ts
 /**
@@ -34,6 +35,7 @@ import { applyAction, deserialize } from "$app/forms";
 * ```
 */
 var forms_exports = /* @__PURE__ */ __exportAll({
+	ApplyActionError: () => ApplyActionError,
 	applyAction: () => applyAction$1,
 	deserialize: () => deserialize$1,
 	enhance: () => enhance
@@ -43,15 +45,77 @@ var forms_exports = /* @__PURE__ */ __exportAll({
 *
 * `onSubmit` runs before the request (call `input.cancel()` to abort);
 * `onResult` runs on the response with SvelteKit's `update()`. Omit `onResult`
-* to keep SvelteKit's default behaviour. Pass `{ runtime }` when the handlers
-* require application services.
+* to keep SvelteKit's default behaviour. When the handlers (or `onError`)
+* require application services, pass `{ runtime }` (a `Context` or
+* `ManagedRuntime` providing them): it is then required, and a call without it
+* does not type-check. Each handler may require different services; the runtime
+* must provide all of them. A missing runtime is reported on the call, and one
+* that lacks a service on the runtime, never on a handler; the message may at
+* first name only the services of the handlers TypeScript types first (such as
+* an `onError` passed by name), and the rest once the runtime provides those.
+* Handlers that require no services run on the default runtime, and the options
+* may be omitted; an effect typed as requiring `any` or `unknown` is treated as
+* requiring no services, so no runtime is demanded. A function that wraps
+* `enhance` for handlers requiring any `R` forwards its options as
+* `...options: EnhanceOptionsArgs<R>` (or takes a required
+* `{ runtime: EnhanceRuntime<R> }`): an `EnhanceOptions<R>`, whose runtime is
+* optional, does not type-check there.
+*
+* Either handler may fail. Add an `onError` handler to handle the error
+* (typed as the union of the handlers' error types when written after them;
+* `unknown` when written before a handler with unannotated parameters): a
+* failed `onSubmit` also cancels the submission, and a failed `onResult` does
+* not fall back to SvelteKit's default behaviour. Without `onError`, or for a
+* defect or interruption, the promise SvelteKit awaits rejects (with the error
+* itself for a failure), which SvelteKit leaves unhandled.
+*
+* @example
+* ```ts
+* const submit = Forms.enhance({
+*   onResult: ({ result }) => Forms.applyAction(result),
+*   // error: ApplyActionError
+*   onError: (error) => Effect.logWarning("applyAction failed", error.cause),
+* });
+* ```
 */
 const enhance = makeSubmitFunction;
 /**
+* {@link applyAction} rejected or threw. `cause` is SvelteKit's original
+* reason, unchanged.
+*
+* SvelteKit 3 throws when `applyAction` is called during server rendering, and
+* follows a `redirect` result with a client-side navigation that rejects if it
+* fails: for example, a `location` that cannot be parsed even relative to the
+* page's base URL, or a `beforeNavigate` / `onNavigate` callback that throws. Recover with
+* `Effect.catchTag("ApplyActionError", ...)`.
+*/
+var ApplyActionError = class extends Schema.TaggedError()("ApplyActionError", { 
+/** The rejection reason, or the value thrown, as SvelteKit produced it. */
+cause: Schema.Defect() }) {};
+/**
 * Apply an `ActionResult` to the page (updating `page.form` / `page.status`,
 * resetting the form, etc.) as an Effect. Wraps `$app/forms`' `applyAction`.
+*
+* Fails with an {@link ApplyActionError} if SvelteKit rejects or throws: for
+* example, when the navigation that follows a `redirect` result fails, or when
+* called during server rendering.
+*
+* {@link enhance}'s `onResult` can return it directly; its `onError` handler
+* then receives the `ApplyActionError`. Without `onError`, the error rejects
+* the promise SvelteKit awaits.
+*
+* @example
+* ```ts
+* const submit = Forms.enhance({
+*   onResult: ({ result }) => Forms.applyAction(result),
+*   onError: (error) => Effect.logWarning("applyAction failed", error.cause),
+* });
+* ```
 */
-const applyAction$1 = (result) => Effect.promise(() => applyAction(result));
+const applyAction$1 = (result) => Effect.tryPromise({
+	try: () => applyAction(result),
+	catch: (cause) => new ApplyActionError({ cause })
+});
 /**
 * Deserialize a raw form-action response body into an `ActionResult`, as an
 * Effect. Wraps `$app/forms`' `deserialize`; a malformed body fails the effect.
@@ -61,6 +125,6 @@ const deserialize$1 = (result) => Effect.try({
 	catch: (error) => error
 });
 //#endregion
-export { applyAction$1 as applyAction, deserialize$1 as deserialize, enhance, forms_exports };
+export { ApplyActionError, applyAction$1 as applyAction, deserialize$1 as deserialize, enhance, forms_exports };
 
 //# sourceMappingURL=forms.js.map

package/dist/forms.js.map

@@ -1 +1 @@
-{"version":3,"file":"forms.js","names":["applyAction","kitApplyAction","deserialize","kitDeserialize"],"sources":["../src/forms.ts"],"sourcesContent":["/**\n * Effect bridge for SvelteKit's native form actions\n * ([`$app/forms`](https://svelte.dev/docs/kit/$app-forms)) — the `Forms`\n * namespace of `@thomasfosterau/effect-sveltekit/client`.\n *\n * This complements `Remote.submitForm` (which covers *remote* forms): here the\n * progressive-enhancement `use:enhance` flow for page `actions` is expressed\n * with Effects, and `applyAction` / `deserialize` are wrapped so a hand-rolled\n * `fetch` submission can be finished off inside an Effect pipeline.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { enhance } from '$app/forms';\n *   import { Forms } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Effect } from 'effect';\n *\n *   const submit = Forms.enhance({\n *     onSubmit: () => Effect.sync(() => { saving = true; }),\n *     onResult: ({ result, update }) =>\n *       Effect.gen(function* () {\n *         yield* Effect.promise(() => update());\n *         saving = false;\n *       }),\n *   });\n * </script>\n *\n * <form method=\"POST\" use:enhance={submit}>...</form>\n * ```\n */\n\nimport { applyAction as kitApplyAction, deserialize as kitDeserialize } from \"$app/forms\";\nimport type { ActionResult } from \"$app/forms\";\nimport { Effect } from \"effect\";\nimport { makeSubmitFunction } from \"./internal/enhance.js\";\n\nexport type {\n  EnhanceHandlers,\n  EnhanceOptions,\n  EnhanceRuntime,\n  SubmitInput,\n  ResultOptions,\n} from \"./internal/enhance.js\";\n\n/**\n * Build a `SubmitFunction` for `use:enhance` from Effect-based handlers.\n *\n * `onSubmit` runs before the request (call `input.cancel()` to abort);\n * `onResult` runs on the response with SvelteKit's `update()`. Omit `onResult`\n * to keep SvelteKit's default behaviour. Pass `{ runtime }` when the handlers\n * require application services.\n */\nexport const enhance = makeSubmitFunction;\n\n/**\n * Apply an `ActionResult` to the page (updating `page.form` / `page.status`,\n * resetting the form, etc.) as an Effect. Wraps `$app/forms`' `applyAction`.\n */\nexport const applyAction = <\n  Success extends Record<string, unknown> | undefined = Record<string, unknown>,\n  Failure extends Record<string, unknown> | undefined = Record<string, unknown>,\n>(\n  result: ActionResult<Success, Failure>,\n): Effect.Effect<void> => Effect.promise(() => kitApplyAction(result));\n\n/**\n * Deserialize a raw form-action response body into an `ActionResult`, as an\n * Effect. Wraps `$app/forms`' `deserialize`; a malformed body fails the effect.\n */\nexport const deserialize = <\n  Success extends Record<string, unknown> | undefined = Record<string, unknown>,\n  Failure extends Record<string, unknown> | undefined = Record<string, unknown>,\n>(\n  result: string,\n): Effect.Effect<ActionResult<Success, Failure>, unknown> =>\n  Effect.try({\n    try: () => kitDeserialize<Success, Failure>(result),\n    catch: (error) => error,\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAa,UAAU;;;;;AAMvB,MAAaA,iBAIX,WACwB,OAAO,cAAcC,YAAe,MAAM,CAAC;;;;;AAMrE,MAAaC,iBAIX,WAEA,OAAO,IAAI;CACT,WAAWC,YAAiC,MAAM;CAClD,QAAQ,UAAU;AACpB,CAAC"}
+{"version":3,"file":"forms.js","names":["applyAction","kitApplyAction","deserialize","kitDeserialize"],"sources":["../src/forms.ts"],"sourcesContent":["/**\n * Effect bridge for SvelteKit's native form actions\n * ([`$app/forms`](https://svelte.dev/docs/kit/$app-forms)) — the `Forms`\n * namespace of `@thomasfosterau/effect-sveltekit/client`.\n *\n * This complements `Remote.submitForm` (which covers *remote* forms): here the\n * progressive-enhancement `use:enhance` flow for page `actions` is expressed\n * with Effects, and `applyAction` / `deserialize` are wrapped so a hand-rolled\n * `fetch` submission can be finished off inside an Effect pipeline.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { enhance } from '$app/forms';\n *   import { Forms } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Effect } from 'effect';\n *\n *   const submit = Forms.enhance({\n *     onSubmit: () => Effect.sync(() => { saving = true; }),\n *     onResult: ({ result, update }) =>\n *       Effect.gen(function* () {\n *         yield* Effect.promise(() => update());\n *         saving = false;\n *       }),\n *   });\n * </script>\n *\n * <form method=\"POST\" use:enhance={submit}>...</form>\n * ```\n */\n\nimport { applyAction as kitApplyAction, deserialize as kitDeserialize } from \"$app/forms\";\nimport type { ActionResult } from \"$app/forms\";\nimport * as Schema from \"effect/Schema\";\nimport * as Effect from \"effect/Effect\";\nimport { makeSubmitFunction } from \"./internal/enhance.js\";\n\nexport type {\n  EnhanceHandlers,\n  EnhanceOptions,\n  EnhanceOptionsArgs,\n  EnhanceRuntime,\n  SubmitInput,\n  ResultOptions,\n} from \"./internal/enhance.js\";\n\n/**\n * Build a `SubmitFunction` for `use:enhance` from Effect-based handlers.\n *\n * `onSubmit` runs before the request (call `input.cancel()` to abort);\n * `onResult` runs on the response with SvelteKit's `update()`. Omit `onResult`\n * to keep SvelteKit's default behaviour. When the handlers (or `onError`)\n * require application services, pass `{ runtime }` (a `Context` or\n * `ManagedRuntime` providing them): it is then required, and a call without it\n * does not type-check. Each handler may require different services; the runtime\n * must provide all of them. A missing runtime is reported on the call, and one\n * that lacks a service on the runtime, never on a handler; the message may at\n * first name only the services of the handlers TypeScript types first (such as\n * an `onError` passed by name), and the rest once the runtime provides those.\n * Handlers that require no services run on the default runtime, and the options\n * may be omitted; an effect typed as requiring `any` or `unknown` is treated as\n * requiring no services, so no runtime is demanded. A function that wraps\n * `enhance` for handlers requiring any `R` forwards its options as\n * `...options: EnhanceOptionsArgs<R>` (or takes a required\n * `{ runtime: EnhanceRuntime<R> }`): an `EnhanceOptions<R>`, whose runtime is\n * optional, does not type-check there.\n *\n * Either handler may fail. Add an `onError` handler to handle the error\n * (typed as the union of the handlers' error types when written after them;\n * `unknown` when written before a handler with unannotated parameters): a\n * failed `onSubmit` also cancels the submission, and a failed `onResult` does\n * not fall back to SvelteKit's default behaviour. Without `onError`, or for a\n * defect or interruption, the promise SvelteKit awaits rejects (with the error\n * itself for a failure), which SvelteKit leaves unhandled.\n *\n * @example\n * ```ts\n * const submit = Forms.enhance({\n *   onResult: ({ result }) => Forms.applyAction(result),\n *   // error: ApplyActionError\n *   onError: (error) => Effect.logWarning(\"applyAction failed\", error.cause),\n * });\n * ```\n */\nexport const enhance = makeSubmitFunction;\n\n/**\n * {@link applyAction} rejected or threw. `cause` is SvelteKit's original\n * reason, unchanged.\n *\n * SvelteKit 3 throws when `applyAction` is called during server rendering, and\n * follows a `redirect` result with a client-side navigation that rejects if it\n * fails: for example, a `location` that cannot be parsed even relative to the\n * page's base URL, or a `beforeNavigate` / `onNavigate` callback that throws. Recover with\n * `Effect.catchTag(\"ApplyActionError\", ...)`.\n */\nexport class ApplyActionError extends Schema.TaggedError<ApplyActionError>()(\"ApplyActionError\", {\n  /** The rejection reason, or the value thrown, as SvelteKit produced it. */\n  cause: Schema.Defect(),\n}) {}\n\n/**\n * Apply an `ActionResult` to the page (updating `page.form` / `page.status`,\n * resetting the form, etc.) as an Effect. Wraps `$app/forms`' `applyAction`.\n *\n * Fails with an {@link ApplyActionError} if SvelteKit rejects or throws: for\n * example, when the navigation that follows a `redirect` result fails, or when\n * called during server rendering.\n *\n * {@link enhance}'s `onResult` can return it directly; its `onError` handler\n * then receives the `ApplyActionError`. Without `onError`, the error rejects\n * the promise SvelteKit awaits.\n *\n * @example\n * ```ts\n * const submit = Forms.enhance({\n *   onResult: ({ result }) => Forms.applyAction(result),\n *   onError: (error) => Effect.logWarning(\"applyAction failed\", error.cause),\n * });\n * ```\n */\nexport const applyAction = <\n  Success extends Record<string, unknown> | undefined = Record<string, unknown>,\n  Failure extends Record<string, unknown> | undefined = Record<string, unknown>,\n>(\n  result: ActionResult<Success, Failure>,\n): Effect.Effect<void, ApplyActionError> =>\n  Effect.tryPromise({\n    try: () => kitApplyAction(result),\n    catch: (cause) => new ApplyActionError({ cause }),\n  });\n\n/**\n * Deserialize a raw form-action response body into an `ActionResult`, as an\n * Effect. Wraps `$app/forms`' `deserialize`; a malformed body fails the effect.\n */\nexport const deserialize = <\n  Success extends Record<string, unknown> | undefined = Record<string, unknown>,\n  Failure extends Record<string, unknown> | undefined = Record<string, unknown>,\n>(\n  result: string,\n): Effect.Effect<ActionResult<Success, Failure>, unknown> =>\n  Effect.try({\n    try: () => kitDeserialize<Success, Failure>(result),\n    catch: (error) => error,\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFA,MAAa,UAAU;;;;;;;;;;;AAYvB,IAAa,mBAAb,cAAsC,OAAO,YAA8B,CAAC,CAAC,oBAAoB;;AAE/F,OAAO,OAAO,OAAO,EACvB,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;AAsBJ,MAAaA,iBAIX,WAEA,OAAO,WAAW;CAChB,WAAWC,YAAe,MAAM;CAChC,QAAQ,UAAU,IAAI,iBAAiB,EAAE,MAAM,CAAC;AAClD,CAAC;;;;;AAMH,MAAaC,iBAIX,WAEA,OAAO,IAAI;CACT,WAAWC,YAAiC,MAAM;CAClD,QAAQ,UAAU;AACpB,CAAC"}

package/dist/internal/app-state.d.ts

@@ -1,11 +1,15 @@
-import { Stream } from "effect";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import { NavigationTarget, NavigationType } from "$app/navigation";
+import "effect/Option";
 //#region src/internal/app-state.d.ts
 /**
  * The fields of SvelteKit's `page` we snapshot. Mirrors the shape of
  * `@sveltejs/kit`'s `Page`, but as a plain readonly record rather than the live
  * mutating proxy.
  */
-interface PageSnapshot<P extends ReadonlyPage = ReadonlyPage> {
+export interface PageSnapshot<P extends ReadonlyPage = ReadonlyPage> {
   readonly url: P["url"];
   readonly params: P["params"];
   readonly route: P["route"];
@@ -14,6 +18,7 @@ interface PageSnapshot<P extends ReadonlyPage = ReadonlyPage> {
   readonly data: P["data"];
   readonly state: P["state"];
   readonly form: P["form"];
+  readonly shallow: P["shallow"];
 }
 /**
  * The subset of `Page` fields the snapshot reads. Deliberately loose (the value
@@ -21,7 +26,7 @@ interface PageSnapshot<P extends ReadonlyPage = ReadonlyPage> {
  * / `error` / `state` are app-specific — satisfies the constraint, while
  * `PageSnapshot<P>` recovers the precise field types from `P`.
  */
-interface ReadonlyPage {
+export interface ReadonlyPage {
   readonly url: Readonly<Omit<URL, "searchParams">>;
   readonly params: Record<string, string | undefined>;
   readonly route: {
@@ -29,10 +34,42 @@ interface ReadonlyPage {
   };
   readonly status: number;
   readonly error: unknown;
-  readonly data: Record<string, unknown>;
+  readonly data: App.PageData;
   readonly state: unknown;
   readonly form: unknown;
+  readonly shallow: unknown;
+}
+/**
+ * A snapshot of an in-flight SvelteKit navigation, as `$app/state`'s
+ * `navigating` exposes it. `delta` is the history step count for a `popstate`
+ * navigation and `null` otherwise; `complete` resolves when the navigation
+ * finishes and rejects if it fails or is aborted.
+ */
+export interface NavigatingSnapshot {
+  readonly type: Exclude<NavigationType, "enter">;
+  readonly from: NavigationTarget | null;
+  readonly to: NavigationTarget | null;
+  readonly willUnload: boolean;
+  readonly delta: number | null;
+  readonly complete: Promise<void>;
+}
+declare const UpdateCheckError_base: Schema.Class<UpdateCheckError, Schema.TaggedStruct<"UpdateCheckError", {
+  /** What `updated.check()` rejected with, or threw. */
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * `updated.check()` rejected. SvelteKit resolves `false` when the version
+ * request fails, so this signals misuse (e.g. calling it during server
+ * rendering, where there is no `window`) rather than a network error.
+ */
+export declare class UpdateCheckError extends UpdateCheckError_base {}
+/** The service behind `State.CurrentPage`: a snapshot and a stream of page changes. */
+export interface CurrentPageService<P extends ReadonlyPage = ReadonlyPage> {
+  /** Snapshots the current page when run. */
+  readonly get: Effect.Effect<PageSnapshot<P>>;
+  /** The current page, then a fresh snapshot whenever any of its fields changes. */
+  readonly changes: Stream.Stream<PageSnapshot<P>>;
 }
 //#endregion
-export { PageSnapshot, ReadonlyPage };
+export {};
 //# sourceMappingURL=app-state.d.ts.map

package/dist/internal/app-state.js

@@ -1,18 +1,10 @@
-import { Effect, Queue, Stream } from "effect";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Schema from "effect/Schema";
+import * as Queue from "effect/Queue";
+import * as Option from "effect/Option";
 //#region src/internal/app-state.ts
 /**
-* Pure, `$app/*`-free core for the `$app/state` bridge in `../State.ts`.
-*
-* The public `page` can't be unit-tested directly because importing it
-* pulls in `$app/navigation` and `$app/state` (SvelteKit virtual modules that
-* only exist inside a build). The snapshotting and the "emit now, then after
-* each navigation" plumbing live here instead, parameterised over the
-* navigation registrar and a `readPage` thunk, so they can be driven with
-* stand-ins in tests while the public wrapper stays a thin pass-through.
-*
-* @internal
-*/
-/**
 * Builds a shallow snapshot of the `page` fields that matter. We copy the
 * fields rather than forwarding the live `$app/state` proxy so downstream Effect
 * consumers see a stable value (the proxy mutates in place on every
@@ -29,7 +21,8 @@ function snapshotPage(page) {
 		error: page.error,
 		data: page.data,
 		state: page.state,
-		form: page.form
+		form: page.form,
+		shallow: page.shallow
 	};
 }
 /**
@@ -46,7 +39,63 @@ function pageSnapshotStream(registerAfterNavigate, readPage) {
 	});
 	return Stream.fromQueue(queue);
 }
+/**
+* A `Stream` of `read()`: the current value, then a new one each time `watch`
+* reports a change. Cold and lazy — each run opens its own watcher and disposes
+* it when the stream ends or is interrupted. Never fails; a throwing `watch`
+* surfaces as a defect (the stream dies with what it threw, with no watcher
+* left to dispose).
+*/
+function watchedStream(watch, read) {
+	return Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => watch(read, (value) => {
+		Queue.offerUnsafe(queue, value);
+	})), (dispose) => Effect.sync(dispose)));
+}
+/**
+* Copies `navigating` into a plain {@link NavigatingSnapshot}, or `None` when
+* no navigation is in flight (`type` is `null`). Reads every field, so a
+* watcher tracks the whole object.
+*/
+function snapshotNavigating(navigating) {
+	const { type, from, to, willUnload, delta, complete } = navigating;
+	if (type === null || willUnload === null || complete === null) return Option.none();
+	return Option.some({
+		type,
+		from,
+		to,
+		willUnload,
+		delta: delta ?? null,
+		complete
+	});
+}
+/**
+* `updated.check()` rejected. SvelteKit resolves `false` when the version
+* request fails, so this signals misuse (e.g. calling it during server
+* rendering, where there is no `window`) rather than a network error.
+*/
+var UpdateCheckError = class extends Schema.TaggedError()("UpdateCheckError", { 
+/** What `updated.check()` rejected with, or threw. */
+cause: Schema.Defect() }) {};
+/**
+* Runs `check` (SvelteKit's `updated.check`) as an Effect that succeeds with
+* whether a new version is available and fails with {@link UpdateCheckError}
+* if the promise rejects (or `check` throws).
+*/
+function checkForUpdateWith(check) {
+	return Effect.tryPromise({
+		try: () => check(),
+		catch: (cause) => new UpdateCheckError({ cause })
+	});
+}
+/** Builds a {@link CurrentPageService} reading `readPage()` and watching it with `watch`. */
+function makeCurrentPage(readPage, watch) {
+	const read = () => snapshotPage(readPage());
+	return {
+		get: Effect.sync(read),
+		changes: watchedStream(watch, read)
+	};
+}
 //#endregion
-export { pageSnapshotStream, snapshotPage };
+export { UpdateCheckError, checkForUpdateWith, makeCurrentPage, pageSnapshotStream, snapshotNavigating, snapshotPage, watchedStream };
 
 //# sourceMappingURL=app-state.js.map

package/dist/internal/app-state.js.map

@@ -1 +1 @@
-{"version":3,"file":"app-state.js","names":[],"sources":["../../src/internal/app-state.ts"],"sourcesContent":["/**\n * Pure, `$app/*`-free core for the `$app/state` bridge in `../State.ts`.\n *\n * The public `page` can't be unit-tested directly because importing it\n * pulls in `$app/navigation` and `$app/state` (SvelteKit virtual modules that\n * only exist inside a build). The snapshotting and the \"emit now, then after\n * each navigation\" plumbing live here instead, parameterised over the\n * navigation registrar and a `readPage` thunk, so they can be driven with\n * stand-ins in tests while the public wrapper stays a thin pass-through.\n *\n * @internal\n */\n\nimport { Effect, Queue, Stream } from \"effect\";\n\n/**\n * The fields of SvelteKit's `page` we snapshot. Mirrors the shape of\n * `@sveltejs/kit`'s `Page`, but as a plain readonly record rather than the live\n * mutating proxy.\n */\nexport interface PageSnapshot<P extends ReadonlyPage = ReadonlyPage> {\n  readonly url: P[\"url\"];\n  readonly params: P[\"params\"];\n  readonly route: P[\"route\"];\n  readonly status: P[\"status\"];\n  readonly error: P[\"error\"];\n  readonly data: P[\"data\"];\n  readonly state: P[\"state\"];\n  readonly form: P[\"form\"];\n}\n\n/**\n * The subset of `Page` fields the snapshot reads. Deliberately loose (the value\n * types are `unknown` / broad) so SvelteKit's `Page` — whose `params` / `data`\n * / `error` / `state` are app-specific — satisfies the constraint, while\n * `PageSnapshot<P>` recovers the precise field types from `P`.\n */\nexport interface ReadonlyPage {\n  // SvelteKit 3 types `page.url` as an immutable `ReadonlyURL` (from\n  // `$app/state`); everything but `searchParams` is enough here.\n  readonly url: Readonly<Omit<URL, \"searchParams\">>;\n  readonly params: Record<string, string | undefined>;\n  readonly route: { readonly id: string | null };\n  readonly status: number;\n  readonly error: unknown;\n  readonly data: Record<string, unknown>;\n  readonly state: unknown;\n  readonly form: unknown;\n}\n\n/**\n * Builds a shallow snapshot of the `page` fields that matter. We copy the\n * fields rather than forwarding the live `$app/state` proxy so downstream Effect\n * consumers see a stable value (the proxy mutates in place on every\n * navigation, which would make a captured reference unreliable). Nested values\n * (`url`, `data`, ...) are *not* deep-cloned: they're replaced wholesale on each\n * navigation, so a shallow copy is enough to distinguish snapshots.\n */\nexport function snapshotPage<P extends ReadonlyPage>(page: P): PageSnapshot<P> {\n  return {\n    url: page.url,\n    params: page.params,\n    route: page.route,\n    status: page.status,\n    error: page.error,\n    data: page.data,\n    state: page.state,\n    form: page.form,\n  };\n}\n\n/**\n * Emits a snapshot of `readPage()` immediately, then again every time\n * `registerAfterNavigate`'s callback fires (i.e. after each navigation). Backed\n * by an unbounded queue, exposed as a `Stream` — the same push bridge as the\n * navigation-event helpers.\n */\nexport function pageSnapshotStream<P extends ReadonlyPage>(\n  registerAfterNavigate: (callback: () => void) => void,\n  readPage: () => P,\n): Stream.Stream<PageSnapshot<P>> {\n  const queue = Effect.runSync(Queue.unbounded<PageSnapshot<P>>());\n  // Initial value: the current page, so consumers start from a known state.\n  Queue.offerUnsafe(queue, snapshotPage(readPage()));\n  // afterNavigate fires once on mount too, but emitting up front means a\n  // late-subscribing consumer still sees the current page without waiting for a\n  // navigation.\n  registerAfterNavigate(() => {\n    Queue.offerUnsafe(queue, snapshotPage(readPage()));\n  });\n  return Stream.fromQueue(queue);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA0DA,SAAgB,aAAqC,MAA0B;CAC7E,OAAO;EACL,KAAK,KAAK;EACV,QAAQ,KAAK;EACb,OAAO,KAAK;EACZ,QAAQ,KAAK;EACb,OAAO,KAAK;EACZ,MAAM,KAAK;EACX,OAAO,KAAK;EACZ,MAAM,KAAK;CACb;AACF;;;;;;;AAQA,SAAgB,mBACd,uBACA,UACgC;CAChC,MAAM,QAAQ,OAAO,QAAQ,MAAM,UAA2B,CAAC;CAE/D,MAAM,YAAY,OAAO,aAAa,SAAS,CAAC,CAAC;CAIjD,4BAA4B;EAC1B,MAAM,YAAY,OAAO,aAAa,SAAS,CAAC,CAAC;CACnD,CAAC;CACD,OAAO,OAAO,UAAU,KAAK;AAC/B"}
+{"version":3,"file":"app-state.js","names":[],"sources":["../../src/internal/app-state.ts"],"sourcesContent":["/**\n * Pure, `$app/*`-free core for the `$app/state` bridge in `../State.ts`.\n *\n * The public helpers can't be unit-tested in plain Node because importing them\n * pulls in `$app/navigation` and `$app/state` (SvelteKit virtual modules that\n * only exist inside a build). The snapshotting, the \"emit now, then after each\n * navigation\" plumbing and the watch-to-`Stream` bridge live here instead,\n * parameterised over the navigation registrar, a {@link Watch} function and\n * read thunks, so they can be driven with stand-ins in tests while the public\n * wrappers stay thin pass-throughs. The only runes code is `watch.svelte.ts`.\n *\n * @internal\n */\n\nimport type { NavigationTarget, NavigationType } from \"$app/navigation\";\nimport * as Schema from \"effect/Schema\";\nimport * as Effect from \"effect/Effect\";\nimport * as Option from \"effect/Option\";\nimport * as Queue from \"effect/Queue\";\nimport * as Stream from \"effect/Stream\";\n\n/**\n * The fields of SvelteKit's `page` we snapshot. Mirrors the shape of\n * `@sveltejs/kit`'s `Page`, but as a plain readonly record rather than the live\n * mutating proxy.\n */\nexport interface PageSnapshot<P extends ReadonlyPage = ReadonlyPage> {\n  readonly url: P[\"url\"];\n  readonly params: P[\"params\"];\n  readonly route: P[\"route\"];\n  readonly status: P[\"status\"];\n  readonly error: P[\"error\"];\n  readonly data: P[\"data\"];\n  readonly state: P[\"state\"];\n  readonly form: P[\"form\"];\n  readonly shallow: P[\"shallow\"];\n}\n\n/**\n * The subset of `Page` fields the snapshot reads. Deliberately loose (the value\n * types are `unknown` / broad) so SvelteKit's `Page` — whose `params` / `data`\n * / `error` / `state` are app-specific — satisfies the constraint, while\n * `PageSnapshot<P>` recovers the precise field types from `P`.\n */\nexport interface ReadonlyPage {\n  // SvelteKit 3 types `page.url` as an immutable `ReadonlyURL` (from\n  // `$app/state`); everything but `searchParams` is enough here.\n  readonly url: Readonly<Omit<URL, \"searchParams\">>;\n  readonly params: Record<string, string | undefined>;\n  readonly route: { readonly id: string | null };\n  readonly status: number;\n  readonly error: unknown;\n  readonly data: App.PageData;\n  readonly state: unknown;\n  readonly form: unknown;\n  // SvelteKit 3: the target of the current shallow navigation, or `null`.\n  readonly shallow: unknown;\n}\n\n/**\n * Builds a shallow snapshot of the `page` fields that matter. We copy the\n * fields rather than forwarding the live `$app/state` proxy so downstream Effect\n * consumers see a stable value (the proxy mutates in place on every\n * navigation, which would make a captured reference unreliable). Nested values\n * (`url`, `data`, ...) are *not* deep-cloned: they're replaced wholesale on each\n * navigation, so a shallow copy is enough to distinguish snapshots.\n */\nexport function snapshotPage<P extends ReadonlyPage>(page: P): PageSnapshot<P> {\n  return {\n    url: page.url,\n    params: page.params,\n    route: page.route,\n    status: page.status,\n    error: page.error,\n    data: page.data,\n    state: page.state,\n    form: page.form,\n    shallow: page.shallow,\n  };\n}\n\n/**\n * Emits a snapshot of `readPage()` immediately, then again every time\n * `registerAfterNavigate`'s callback fires (i.e. after each navigation). Backed\n * by an unbounded queue, exposed as a `Stream` — the same push bridge as the\n * navigation-event helpers.\n */\nexport function pageSnapshotStream<P extends ReadonlyPage>(\n  registerAfterNavigate: (callback: () => void) => void,\n  readPage: () => P,\n): Stream.Stream<PageSnapshot<P>> {\n  const queue = Effect.runSync(Queue.unbounded<PageSnapshot<P>>());\n  // Initial value: the current page, so consumers start from a known state.\n  Queue.offerUnsafe(queue, snapshotPage(readPage()));\n  // afterNavigate fires once on mount too, but emitting up front means a\n  // late-subscribing consumer still sees the current page without waiting for a\n  // navigation.\n  registerAfterNavigate(() => {\n    Queue.offerUnsafe(queue, snapshotPage(readPage()));\n  });\n  return Stream.fromQueue(queue);\n}\n\n// ─── Watching rune state ─────────────────────────────────────────────────────\n\n/**\n * Observes a reactive read: calls `onValue` with `read()` once, then again\n * whenever something `read` touched changes, until the returned disposer runs.\n * The real implementation is `watch` in `./watch.svelte.ts`.\n */\nexport type Watch = <A>(read: () => A, onValue: (value: A) => void) => () => void;\n\n/**\n * A `Stream` of `read()`: the current value, then a new one each time `watch`\n * reports a change. Cold and lazy — each run opens its own watcher and disposes\n * it when the stream ends or is interrupted. Never fails; a throwing `watch`\n * surfaces as a defect (the stream dies with what it threw, with no watcher\n * left to dispose).\n */\nexport function watchedStream<A>(watch: Watch, read: () => A): Stream.Stream<A> {\n  return Stream.callback<A>((queue) =>\n    Effect.acquireRelease(\n      Effect.sync(() =>\n        watch(read, (value) => {\n          Queue.offerUnsafe(queue, value);\n        }),\n      ),\n      (dispose) => Effect.sync(dispose),\n    ),\n  );\n}\n\n// ─── navigating ──────────────────────────────────────────────────────────────\n\n/**\n * A snapshot of an in-flight SvelteKit navigation, as `$app/state`'s\n * `navigating` exposes it. `delta` is the history step count for a `popstate`\n * navigation and `null` otherwise; `complete` resolves when the navigation\n * finishes and rejects if it fails or is aborted.\n */\nexport interface NavigatingSnapshot {\n  readonly type: Exclude<NavigationType, \"enter\">;\n  readonly from: NavigationTarget | null;\n  readonly to: NavigationTarget | null;\n  readonly willUnload: boolean;\n  readonly delta: number | null;\n  readonly complete: Promise<void>;\n}\n\n/**\n * The shape of `$app/state`'s `navigating`: every field is `null` while no\n * navigation is in flight.\n */\nexport interface ReadonlyNavigating {\n  readonly type: NavigatingSnapshot[\"type\"] | null;\n  readonly from: NavigationTarget | null;\n  readonly to: NavigationTarget | null;\n  readonly willUnload: boolean | null;\n  readonly delta?: number | null | undefined;\n  readonly complete: Promise<void> | null;\n}\n\n/**\n * Copies `navigating` into a plain {@link NavigatingSnapshot}, or `None` when\n * no navigation is in flight (`type` is `null`). Reads every field, so a\n * watcher tracks the whole object.\n */\nexport function snapshotNavigating(\n  navigating: ReadonlyNavigating,\n): Option.Option<NavigatingSnapshot> {\n  const { type, from, to, willUnload, delta, complete } = navigating;\n  if (type === null || willUnload === null || complete === null) return Option.none();\n  return Option.some({ type, from, to, willUnload, delta: delta ?? null, complete });\n}\n\n// ─── updated ─────────────────────────────────────────────────────────────────\n\n/**\n * `updated.check()` rejected. SvelteKit resolves `false` when the version\n * request fails, so this signals misuse (e.g. calling it during server\n * rendering, where there is no `window`) rather than a network error.\n */\nexport class UpdateCheckError extends Schema.TaggedError<UpdateCheckError>()(\"UpdateCheckError\", {\n  /** What `updated.check()` rejected with, or threw. */\n  cause: Schema.Defect(),\n}) {}\n\n/**\n * Runs `check` (SvelteKit's `updated.check`) as an Effect that succeeds with\n * whether a new version is available and fails with {@link UpdateCheckError}\n * if the promise rejects (or `check` throws).\n */\nexport function checkForUpdateWith(\n  check: () => Promise<boolean>,\n): Effect.Effect<boolean, UpdateCheckError> {\n  return Effect.tryPromise({\n    try: () => check(),\n    catch: (cause) => new UpdateCheckError({ cause }),\n  });\n}\n\n// ─── CurrentPage ─────────────────────────────────────────────────────────────\n\n/** The service behind `State.CurrentPage`: a snapshot and a stream of page changes. */\nexport interface CurrentPageService<P extends ReadonlyPage = ReadonlyPage> {\n  /** Snapshots the current page when run. */\n  readonly get: Effect.Effect<PageSnapshot<P>>;\n  /** The current page, then a fresh snapshot whenever any of its fields changes. */\n  readonly changes: Stream.Stream<PageSnapshot<P>>;\n}\n\n/** Builds a {@link CurrentPageService} reading `readPage()` and watching it with `watch`. */\nexport function makeCurrentPage<P extends ReadonlyPage>(\n  readPage: () => P,\n  watch: Watch,\n): CurrentPageService<P> {\n  const read = (): PageSnapshot<P> => snapshotPage(readPage());\n  return { get: Effect.sync(read), changes: watchedStream(watch, read) };\n}\n"],"mappings":";;;;;;;;;;;;;;AAmEA,SAAgB,aAAqC,MAA0B;CAC7E,OAAO;EACL,KAAK,KAAK;EACV,QAAQ,KAAK;EACb,OAAO,KAAK;EACZ,QAAQ,KAAK;EACb,OAAO,KAAK;EACZ,MAAM,KAAK;EACX,OAAO,KAAK;EACZ,MAAM,KAAK;EACX,SAAS,KAAK;CAChB;AACF;;;;;;;AAQA,SAAgB,mBACd,uBACA,UACgC;CAChC,MAAM,QAAQ,OAAO,QAAQ,MAAM,UAA2B,CAAC;CAE/D,MAAM,YAAY,OAAO,aAAa,SAAS,CAAC,CAAC;CAIjD,4BAA4B;EAC1B,MAAM,YAAY,OAAO,aAAa,SAAS,CAAC,CAAC;CACnD,CAAC;CACD,OAAO,OAAO,UAAU,KAAK;AAC/B;;;;;;;;AAkBA,SAAgB,cAAiB,OAAc,MAAiC;CAC9E,OAAO,OAAO,UAAa,UACzB,OAAO,eACL,OAAO,WACL,MAAM,OAAO,UAAU;EACrB,MAAM,YAAY,OAAO,KAAK;CAChC,CAAC,CACH,IACC,YAAY,OAAO,KAAK,OAAO,CAClC,CACF;AACF;;;;;;AAqCA,SAAgB,mBACd,YACmC;CACnC,MAAM,EAAE,MAAM,MAAM,IAAI,YAAY,OAAO,aAAa;CACxD,IAAI,SAAS,QAAQ,eAAe,QAAQ,aAAa,MAAM,OAAO,OAAO,KAAK;CAClF,OAAO,OAAO,KAAK;EAAE;EAAM;EAAM;EAAI;EAAY,OAAO,SAAS;EAAM;CAAS,CAAC;AACnF;;;;;;AASA,IAAa,mBAAb,cAAsC,OAAO,YAA8B,CAAC,CAAC,oBAAoB;;AAE/F,OAAO,OAAO,OAAO,EACvB,CAAC,CAAC,CAAC,CAAC;;;;;;AAOJ,SAAgB,mBACd,OAC0C;CAC1C,OAAO,OAAO,WAAW;EACvB,WAAW,MAAM;EACjB,QAAQ,UAAU,IAAI,iBAAiB,EAAE,MAAM,CAAC;CAClD,CAAC;AACH;;AAaA,SAAgB,gBACd,UACA,OACuB;CACvB,MAAM,aAA8B,aAAa,SAAS,CAAC;CAC3D,OAAO;EAAE,KAAK,OAAO,KAAK,IAAI;EAAG,SAAS,cAAc,OAAO,IAAI;CAAE;AACvE"}

package/dist/internal/auto.d.ts

@@ -1,70 +1,79 @@
 import { ServerRuntime, UniversalRuntime } from "../app-runtime.js";
-import { Effect } from "effect";
+import * as Effect from "effect/Effect";
 import { Action, Actions, Load, RequestEvent, ServerLoad } from "@sveltejs/kit";
 import { Handle, HandleClientError, HandleFetch, HandleServerError, Reroute } from "@sveltejs/kit/hooks";
 //#region src/internal/auto.d.ts
 type AnyEffect = Effect.Effect<unknown, unknown, never>;
+/**
+ * The function form of a user export: called with the hook / load argument, it
+ * returns an Effect to run or a plain SvelteKit value to pass through. Its
+ * result is only known at runtime (`Effect.isEffect` tells the two apart).
+ */
+type UserFn<Arg> = (arg: Arg) => unknown;
+/** The argument-less function form of a user `init` export (see {@link UserFn}). */
+type UserThunk = () => unknown;
 type AnyRuntime = ServerRuntime<any, any> | UniversalRuntime<any, any>;
 /**
  * Module shape accepted for the plugin's `serverRuntime` / `clientRuntime`
  * options: the runtime can be the default export or a named `runtime` export.
  */
-interface RuntimeModule {
+export interface RuntimeModule {
   readonly runtime?: AnyRuntime;
   readonly default?: AnyRuntime;
 }
-type LoadLikeInput = undefined | AnyEffect | ((event: any) => unknown);
+type LoadLikeInput = undefined | AnyEffect | UserFn<any>;
 /**
  * Wraps a value intended to be a SvelteKit universal `load` export.
  * Used by the Vite plugin for `+page.ts` / `+layout.ts`.
  */
-declare function wrapLoad<T extends LoadLikeInput>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Load;
+export declare function wrapLoad<T extends LoadLikeInput>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Load;
 /**
  * Wraps a value intended to be a SvelteKit server `load` export.
  * Used by the Vite plugin for `+page.server.ts` / `+layout.server.ts`.
  */
-declare function wrapServerLoad<T extends LoadLikeInput>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : ServerLoad;
+export declare function wrapServerLoad<T extends LoadLikeInput>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : ServerLoad;
 /**
  * Wraps a single SvelteKit action handler.
  */
-declare function wrapAction<T extends LoadLikeInput>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Action;
+export declare function wrapAction<T extends LoadLikeInput>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Action;
 /**
  * Wraps a SvelteKit `actions` object, individually wrapping each entry.
  */
-declare function wrapActions<T extends Record<string, LoadLikeInput> | undefined>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Actions;
+export declare function wrapActions<T extends Record<string, LoadLikeInput> | undefined>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Actions;
 /**
  * Wraps a SvelteKit `handle` hook export.
  */
-declare function wrapHandle<T extends undefined | AnyEffect | ((args: Parameters<Handle>[0]) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Handle;
+export declare function wrapHandle<T extends undefined | AnyEffect | UserFn<Parameters<Handle>[0]>>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Handle;
 /**
  * Wraps a SvelteKit `handleFetch` hook export.
  */
-declare function wrapHandleFetch<T extends undefined | AnyEffect | ((args: Parameters<HandleFetch>[0]) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : HandleFetch;
+export declare function wrapHandleFetch<T extends undefined | AnyEffect | UserFn<Parameters<HandleFetch>[0]>>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : HandleFetch;
 type AnyHandleError = HandleServerError | HandleClientError;
+type HandleErrorInput = Parameters<AnyHandleError>[0];
 /**
  * Wraps a SvelteKit `handleError` hook export.
  */
-declare function wrapHandleError<T extends undefined | AnyEffect | ((args: Parameters<AnyHandleError>[0]) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : AnyHandleError;
+export declare function wrapHandleError<T extends undefined | AnyEffect | UserFn<HandleErrorInput>>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : AnyHandleError;
 /**
  * Wraps a SvelteKit HTTP endpoint export (`GET`, `POST`, etc.).
  * Errors thrown by the underlying Effect propagate to SvelteKit's normal
  * error-handling pipeline (i.e. they are not silently swallowed). Use the
  * explicit `endpoint()` helper if you need the `exposeErrors` toggle.
  */
-declare function wrapEndpoint<T extends undefined | AnyEffect | ((event: RequestEvent) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : (event: RequestEvent) => Response | Promise<Response>;
+export declare function wrapEndpoint<T extends undefined | AnyEffect | UserFn<RequestEvent>>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : (event: RequestEvent) => Response | Promise<Response>;
 type RerouteEvent = Parameters<Reroute>[0];
 /**
  * Wraps a SvelteKit universal `reroute` hook export. The effect runs on the
  * universal runtime with an `HttpClient` backed by the event's `fetch`, on both
  * the server and the client.
  */
-declare function wrapReroute<T extends undefined | AnyEffect | ((event: RerouteEvent) => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Reroute;
+export declare function wrapReroute<T extends undefined | AnyEffect | UserFn<RerouteEvent>>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : Reroute;
 /**
  * Wraps a SvelteKit `init` hook export (server or client).
  * `init` runs once at startup; there is no request event available, but the
  * application runtime's services (if configured) are.
  */
-declare function wrapInit<T extends undefined | AnyEffect | (() => unknown)>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : () => Promise<void>;
+export declare function wrapInit<T extends undefined | AnyEffect | UserThunk>(value: T, runtimeMod?: RuntimeModule): T extends undefined ? undefined : () => Promise<void>;
 //#endregion
-export { RuntimeModule, wrapAction, wrapActions, wrapEndpoint, wrapHandle, wrapHandleError, wrapHandleFetch, wrapInit, wrapLoad, wrapReroute, wrapServerLoad };
+export {};
 //# sourceMappingURL=auto.d.ts.map

package/dist/internal/auto.js

@@ -1,6 +1,10 @@
 import { causeToThrowable } from "./error.js";
 import { makeServerRuntime, makeUniversalRuntime } from "../app-runtime.js";
-import { Effect, Exit } from "effect";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Predicate from "effect/Predicate";
+import * as Rec from "effect/Record";
+import * as Result from "effect/Result";
 //#region src/internal/auto.ts
 let defaultServerRuntime;
 let defaultUniversalRuntime;
@@ -30,27 +34,33 @@ async function runBare(effect, runtime) {
 		onSuccess: (value) => value
 	});
 }
-function isEffectValue(value) {
-	return Effect.isEffect(value);
-}
+/**
+* Detect an Effect returned by (or exported as) a user hook. Its requirements
+* are typed `never`: the user's export may only need what the runtime provides,
+* and anything else surfaces as a missing-service defect when it runs.
+*/
+const isUserEffect = (value) => Effect.isEffect(value);
+/** A user export's Effect form as is, or the result of calling its function form with `arg`. */
+const resolveExport = (value, arg) => Effect.isEffect(value) ? value : value(arg);
 /**
 * Wraps a value intended to be a SvelteKit universal `load` export.
 * Used by the Vite plugin for `+page.ts` / `+layout.ts`.
 */
 function wrapLoad(value, runtimeMod) {
-	if (value === void 0) return void 0;
-	return (async (event) => {
-		const result = isEffectValue(value) ? value : value(event);
-		if (!isEffectValue(result)) return result;
+	if (value === void 0) return;
+	const load = async (event) => {
+		const result = resolveExport(value, event);
+		if (!Effect.isEffect(result)) return result;
 		return universalRuntimeOf(runtimeMod).load(() => result)(event);
-	});
+	};
+	return load;
 }
 /** Shared implementation for server-side, event-based wrappers. */
 function wrapServerEvent(value, runtimeMod) {
 	if (value === void 0) return void 0;
 	return async (event) => {
-		const result = isEffectValue(value) ? value : value(event);
-		if (!isEffectValue(result)) return result;
+		const result = resolveExport(value, event);
+		if (!Effect.isEffect(result)) return result;
 		return serverRuntimeOf(runtimeMod).runPromise(event, result);
 	};
 }
@@ -71,23 +81,20 @@ function wrapAction(value, runtimeMod) {
 * Wraps a SvelteKit `actions` object, individually wrapping each entry.
 */
 function wrapActions(value, runtimeMod) {
-	if (value === void 0) return void 0;
-	if (typeof value !== "object" || value === null) return value;
-	const wrapped = {};
-	for (const [key, fn] of Object.entries(value)) {
-		const wrappedAction = wrapAction(fn, runtimeMod);
-		if (wrappedAction !== void 0) wrapped[key] = wrappedAction;
-	}
-	return wrapped;
+	if (value === void 0 || !Predicate.isObjectOrArray(value)) return value;
+	return Rec.filterMap(value, (fn) => {
+		const wrappedAction = wrapServerEvent(fn, runtimeMod);
+		return wrappedAction === void 0 ? Result.fail(void 0) : Result.succeed(wrappedAction);
+	});
 }
 /**
 * Wraps a SvelteKit `handle` hook export.
 */
 function wrapHandle(value, runtimeMod) {
-	if (value === void 0) return void 0;
+	if (value === void 0) return;
 	const handle = (input) => {
-		const result = isEffectValue(value) ? value : value(input);
-		if (!isEffectValue(result)) return result;
+		const result = resolveExport(value, input);
+		if (!Effect.isEffect(result)) return result;
 		return serverRuntimeOf(runtimeMod).handle(() => result)(input);
 	};
 	return handle;
@@ -96,10 +103,10 @@ function wrapHandle(value, runtimeMod) {
 * Wraps a SvelteKit `handleFetch` hook export.
 */
 function wrapHandleFetch(value, runtimeMod) {
-	if (value === void 0) return void 0;
+	if (value === void 0) return;
 	const handleFetch = async (args) => {
-		const result = isEffectValue(value) ? value : value(args);
-		if (!isEffectValue(result)) return result;
+		const result = resolveExport(value, args);
+		if (!Effect.isEffect(result)) return result;
 		return serverRuntimeOf(runtimeMod).runPromise(args.event, result);
 	};
 	return handleFetch;
@@ -108,14 +115,15 @@ function wrapHandleFetch(value, runtimeMod) {
 * Wraps a SvelteKit `handleError` hook export.
 */
 function wrapHandleError(value, runtimeMod) {
-	if (value === void 0) return void 0;
-	return (async (args) => {
-		const result = isEffectValue(value) ? value : value(args);
-		if (!isEffectValue(result)) return result;
+	if (value === void 0) return;
+	const handleError = async (args) => {
+		const result = resolveExport(value, args);
+		if (!isUserEffect(result)) return result;
 		const event = args.event;
 		if (event !== void 0 && "request" in event) return serverRuntimeOf(runtimeMod).runPromise(event, result);
 		return runBare(result, runtimeOfModule(runtimeMod));
-	});
+	};
+	return handleError;
 }
 /**
 * Wraps a SvelteKit HTTP endpoint export (`GET`, `POST`, etc.).
@@ -132,12 +140,13 @@ function wrapEndpoint(value, runtimeMod) {
 * the server and the client.
 */
 function wrapReroute(value, runtimeMod) {
-	if (value === void 0) return void 0;
-	return ((event) => {
-		const result = isEffectValue(value) ? value : value(event);
-		if (!isEffectValue(result)) return result;
+	if (value === void 0) return;
+	const reroute = (event) => {
+		const result = resolveExport(value, event);
+		if (!Effect.isEffect(result)) return result;
 		return universalRuntimeOf(runtimeMod).runPromise(event.fetch, result);
-	});
+	};
+	return reroute;
 }
 /**
 * Wraps a SvelteKit `init` hook export (server or client).
@@ -145,15 +154,16 @@ function wrapReroute(value, runtimeMod) {
 * application runtime's services (if configured) are.
 */
 function wrapInit(value, runtimeMod) {
-	if (value === void 0) return void 0;
-	return (async () => {
-		const result = isEffectValue(value) ? value : value();
-		if (!isEffectValue(result)) {
+	if (value === void 0) return;
+	const init = async () => {
+		const result = Effect.isEffect(value) ? value : value();
+		if (!isUserEffect(result)) {
 			await result;
 			return;
 		}
 		await runBare(result, runtimeOfModule(runtimeMod));
-	});
+	};
+	return init;
 }
 //#endregion
 export { wrapAction, wrapActions, wrapEndpoint, wrapHandle, wrapHandleError, wrapHandleFetch, wrapInit, wrapLoad, wrapReroute, wrapServerLoad };