@thomasfosterau/effect-sveltekit 0.5.0 → 0.7.0

package/dist/Navigation.js

@@ -1,6 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { onNavigateWith, registeredStream } from "./internal/navigation-events.js";
-import { Effect } from "effect";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
 import { afterNavigate, beforeNavigate, goto, invalidate, invalidateAll, onNavigate, preloadCode, preloadData, refreshAll } from "$app/navigation";
 //#region src/Navigation.ts
 /**
@@ -11,8 +12,12 @@ import { afterNavigate, beforeNavigate, goto, invalidate, invalidateAll, onNavig
 * `Effect`, so navigation composes inside Effect pipelines (sequencing,
 * retries, `Effect.race`, tracing spans, ...). Alongside them sit the
 * client-side lifecycle callbacks (`beforeNavigate`, `afterNavigate`,
-* `onNavigate`) bridged to Effect. These run on the client only — calling them
-* during SSR throws, exactly as the underlying `$app/navigation` functions do.
+* `onNavigate`) bridged to Effect. These run on the client only.
+*
+* When SvelteKit rejects (for example, `goto` to a URL outside the app) or
+* throws (for example, any of them run during server rendering), the wrapper
+* fails with a {@link NavigationError} that names the operation and carries
+* SvelteKit's original reason as its `cause`.
 *
 * @example
 * ```svelte
@@ -34,6 +39,7 @@ import { afterNavigate, beforeNavigate, goto, invalidate, invalidateAll, onNavig
 * ```
 */
 var Navigation_exports = /* @__PURE__ */ __exportAll({
+	NavigationError: () => NavigationError,
 	afterNavigate: () => afterNavigate$1,
 	beforeNavigate: () => beforeNavigate$1,
 	goto: () => goto$1,
@@ -45,29 +51,97 @@ var Navigation_exports = /* @__PURE__ */ __exportAll({
 	refreshAll: () => refreshAll$1
 });
 /**
-* Navigate to `url`. Wraps `$app/navigation`'s `goto`. SvelteKit rejects a URL
-* outside the app (external, or not matching a route); a rejection surfaces as
-* a defect.
+* A `$app/navigation` promise wrapper ({@link goto}, {@link invalidate},
+* {@link invalidateAll}, {@link refreshAll}, {@link preloadData},
+* {@link preloadCode}) rejected or threw. `operation` names the wrapper and
+* `cause` is SvelteKit's original reason, unchanged.
+*
+* SvelteKit 3 rejects `goto` with a URL outside the app (external, or matching
+* no route) and `preloadData` with a URL outside the app; `invalidate` throws on
+* a `resource` that cannot be parsed even relative to the current URL;
+* `preloadCode` rejects when a route's code fails to load; a navigation (including one that follows a `load` redirect during
+* `invalidate` / `refreshAll`) rejects when a `beforeNavigate` / `onNavigate`
+* callback throws; and every one of them throws when called during server
+* rendering. Recover with `Effect.catchTag("NavigationError", ...)`.
+*/
+var NavigationError = class extends Schema.TaggedError()("NavigationError", {
+	/** The wrapper whose SvelteKit call failed. */
+	operation: Schema.Literals([
+		"goto",
+		"invalidate",
+		"invalidateAll",
+		"refreshAll",
+		"preloadData",
+		"preloadCode"
+	]),
+	/** The rejection reason, or the value thrown, as SvelteKit produced it. */
+	cause: Schema.Defect()
+}) {};
+/**
+* Runs a `$app/navigation` call as an Effect, so a rejection, or a synchronous
+* throw, fails with a {@link NavigationError} instead of becoming a defect.
+*/
+const fromNavigation = (operation, thunk) => Effect.tryPromise({
+	try: () => thunk(),
+	catch: (cause) => new NavigationError({
+		operation,
+		cause
+	})
+});
+/**
+* Navigate to `url`. Wraps `$app/navigation`'s `goto`.
+*
+* Fails with a {@link NavigationError} if SvelteKit rejects: a URL outside the
+* app (external, or not matching a route) rejects, as does a navigation whose
+* `beforeNavigate` / `onNavigate` callback throws, or a call during server
+* rendering. For an external URL, set `window.location` instead.
 */
-const goto$1 = (...args) => Effect.promise(() => goto(...args));
-/** Re-run `load` functions that depend on `resource`. Wraps `invalidate`. */
-const invalidate$1 = (...args) => Effect.promise(() => invalidate(...args));
+const goto$1 = (...args) => fromNavigation("goto", () => goto(...args));
+/**
+* Re-run `load` functions that depend on `resource`. Wraps `invalidate`.
+*
+* Fails with a {@link NavigationError} if SvelteKit rejects or throws: a
+* `resource` string that cannot be parsed even relative to the current URL
+* throws, as does a call during server rendering, and the navigation that
+* follows a `load` redirect can reject.
+*/
+const invalidate$1 = (...args) => fromNavigation("invalidate", () => invalidate(...args));
 /**
 * Re-run every `load` function for the active page. Wraps `invalidateAll`.
 *
+* Fails with a {@link NavigationError} if SvelteKit rejects or throws: for
+* example, when the navigation that follows a `load` redirect fails, or when
+* called during server rendering.
+*
 * @deprecated SvelteKit 3 deprecates `invalidateAll`; use {@link refreshAll},
 * which also refreshes active remote functions and keeps `page.state`.
 */
-const invalidateAll$1 = () => Effect.promise(() => invalidateAll());
-/** Refresh active remote functions (and, by default, `load`s). Wraps `refreshAll`. */
-const refreshAll$1 = (...args) => Effect.promise(() => refreshAll(...args));
-/** Preload the data for `href`. Wraps `preloadData`. */
-const preloadData$1 = (href) => Effect.promise(() => preloadData(href));
+const invalidateAll$1 = () => fromNavigation("invalidateAll", () => invalidateAll());
+/**
+* Refresh active remote functions (and, by default, `load`s). Wraps `refreshAll`.
+*
+* Fails with a {@link NavigationError} if SvelteKit rejects or throws: for
+* example, when the navigation that follows a `load` redirect fails, or when
+* called during server rendering.
+*/
+const refreshAll$1 = (...args) => fromNavigation("refreshAll", () => refreshAll(...args));
+/**
+* Preload the data for `href`. Wraps `preloadData`, succeeding with SvelteKit's
+* result (`loaded`, `redirect`, or `error` when a `load` fails).
+*
+* Fails with a {@link NavigationError} if SvelteKit rejects: an `href` outside
+* the app rejects, as does a call during server rendering.
+*/
+const preloadData$1 = (href) => fromNavigation("preloadData", () => preloadData(href));
 /**
 * Preload the code for the route `id` (e.g. `/blog/[slug]`, without
 * `paths.base`). Wraps `preloadCode`.
+*
+* Fails with a {@link NavigationError} if SvelteKit rejects: a route module
+* that fails to load rejects, as does a call during server rendering (and, in
+* development, an `id` not starting with `/`).
 */
-const preloadCode$1 = (...args) => Effect.promise(() => preloadCode(...args));
+const preloadCode$1 = (...args) => fromNavigation("preloadCode", () => preloadCode(...args));
 /**
 * Registers a `beforeNavigate` callback and exposes every navigation about to
 * happen as an Effect `Stream`. Call during component initialization.
@@ -75,9 +149,9 @@ const preloadCode$1 = (...args) => Effect.promise(() => preloadCode(...args));
 * Unlike the promise-returning navigation functions above, this is a
 * **callback-registration** function: it must be called *synchronously during
 * component initialization* (SvelteKit wires it to the component's lifecycle).
-* It registers its callback eagerly and feeds an internal `Queue`, returning a
-* `Stream` backed by that queue — the same push-based bridge as `SignalEmitter`
-* in `@thomasfosterau/effect-svelte`. Call it at the top level of `<script>`,
+* It registers its callback eagerly and feeds an internal unbounded `Queue`,
+* returning a `Stream` backed by that queue: a push-based bridge that buffers
+* every event for its single consumer. Call it at the top level of `<script>`,
 * exactly where you'd call the bare `beforeNavigate`.
 *
 * @example
@@ -162,6 +236,6 @@ function onNavigate$1(fn, runEffect = Effect.runPromise) {
 	onNavigateWith(onNavigate, fn, runEffect);
 }
 //#endregion
-export { Navigation_exports, afterNavigate$1 as afterNavigate, beforeNavigate$1 as beforeNavigate, goto$1 as goto, invalidate$1 as invalidate, invalidateAll$1 as invalidateAll, onNavigate$1 as onNavigate, preloadCode$1 as preloadCode, preloadData$1 as preloadData, refreshAll$1 as refreshAll };
+export { NavigationError, Navigation_exports, afterNavigate$1 as afterNavigate, beforeNavigate$1 as beforeNavigate, goto$1 as goto, invalidate$1 as invalidate, invalidateAll$1 as invalidateAll, onNavigate$1 as onNavigate, preloadCode$1 as preloadCode, preloadData$1 as preloadData, refreshAll$1 as refreshAll };
 
 //# sourceMappingURL=Navigation.js.map

package/dist/Navigation.js.map

@@ -1 +1 @@
-{"version":3,"file":"Navigation.js","names":["goto","kitGoto","invalidate","kitInvalidate","invalidateAll","kitInvalidateAll","refreshAll","kitRefreshAll","preloadData","kitPreloadData","preloadCode","kitPreloadCode","beforeNavigate","kitBeforeNavigate","afterNavigate","kitAfterNavigate","onNavigate","kitOnNavigate"],"sources":["../src/Navigation.ts"],"sourcesContent":["/**\n * Effect wrappers for SvelteKit's client-side\n * [`$app/navigation`](https://svelte.dev/docs/kit/$app-navigation) API.\n *\n * Each of SvelteKit's promise-returning navigation functions is wrapped as an\n * `Effect`, so navigation composes inside Effect pipelines (sequencing,\n * retries, `Effect.race`, tracing spans, ...). Alongside them sit the\n * client-side lifecycle callbacks (`beforeNavigate`, `afterNavigate`,\n * `onNavigate`) bridged to Effect. These run on the client only — calling them\n * during SSR throws, exactly as the underlying `$app/navigation` functions do.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Effect } from 'effect';\n *   import { getRuntime } from '@thomasfosterau/effect-svelte';\n *\n *   const runtime = getRuntime();\n *   const save = () =>\n *     runtime.runPromise(\n *       Effect.gen(function* () {\n *         yield* doSave();\n *         yield* Navigation.refreshAll();\n *         yield* Navigation.goto('/done');\n *       }),\n *     );\n * </script>\n * ```\n */\n\nimport {\n  afterNavigate as kitAfterNavigate,\n  beforeNavigate as kitBeforeNavigate,\n  goto as kitGoto,\n  invalidate as kitInvalidate,\n  invalidateAll as kitInvalidateAll,\n  onNavigate as kitOnNavigate,\n  preloadCode as kitPreloadCode,\n  preloadData as kitPreloadData,\n  refreshAll as kitRefreshAll,\n} from \"$app/navigation\";\nimport type { AfterNavigate, BeforeNavigate, OnNavigate } from \"$app/navigation\";\nimport { Effect } from \"effect\";\nimport type { Stream } from \"effect\";\nimport { onNavigateWith, registeredStream } from \"./internal/navigation-events.js\";\n\n/**\n * Navigate to `url`. Wraps `$app/navigation`'s `goto`. SvelteKit rejects a URL\n * outside the app (external, or not matching a route); a rejection surfaces as\n * a defect.\n */\nexport const goto = (...args: Parameters<typeof kitGoto>): Effect.Effect<void> =>\n  Effect.promise(() => kitGoto(...args));\n\n/** Re-run `load` functions that depend on `resource`. Wraps `invalidate`. */\nexport const invalidate = (...args: Parameters<typeof kitInvalidate>): Effect.Effect<void> =>\n  Effect.promise(() => kitInvalidate(...args));\n\n/**\n * Re-run every `load` function for the active page. Wraps `invalidateAll`.\n *\n * @deprecated SvelteKit 3 deprecates `invalidateAll`; use {@link refreshAll},\n * which also refreshes active remote functions and keeps `page.state`.\n */\nexport const invalidateAll = (): Effect.Effect<void> => Effect.promise(() => kitInvalidateAll());\n\n/** Refresh active remote functions (and, by default, `load`s). Wraps `refreshAll`. */\nexport const refreshAll = (...args: Parameters<typeof kitRefreshAll>): Effect.Effect<void> =>\n  Effect.promise(() => kitRefreshAll(...args));\n\n/** Preload the data for `href`. Wraps `preloadData`. */\nexport const preloadData = (\n  href: string,\n): Effect.Effect<Awaited<ReturnType<typeof kitPreloadData>>> =>\n  Effect.promise(() => kitPreloadData(href));\n\n/**\n * Preload the code for the route `id` (e.g. `/blog/[slug]`, without\n * `paths.base`). Wraps `preloadCode`.\n */\nexport const preloadCode = (...args: Parameters<typeof kitPreloadCode>): Effect.Effect<void> =>\n  Effect.promise(() => kitPreloadCode(...args));\n\n/**\n * Registers a `beforeNavigate` callback and exposes every navigation about to\n * happen as an Effect `Stream`. Call during component initialization.\n *\n * Unlike the promise-returning navigation functions above, this is a\n * **callback-registration** function: it must be called *synchronously during\n * component initialization* (SvelteKit wires it to the component's lifecycle).\n * It registers its callback eagerly and feeds an internal `Queue`, returning a\n * `Stream` backed by that queue — the same push-based bridge as `SignalEmitter`\n * in `@thomasfosterau/effect-svelte`. Call it at the top level of `<script>`,\n * exactly where you'd call the bare `beforeNavigate`.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Stream, Effect } from 'effect';\n *   import { getRuntime } from '@thomasfosterau/effect-svelte';\n *\n *   // Register at init so the callback is wired to the component lifecycle.\n *   const navigations = Navigation.beforeNavigate();\n *\n *   getRuntime().runFork(\n *     Stream.runForEach(navigations, (nav) =>\n *       Effect.logInfo(`leaving: ${nav.from?.url.pathname}`),\n *     ),\n *   );\n * </script>\n * ```\n */\nexport function beforeNavigate(): Stream.Stream<BeforeNavigate> {\n  return registeredStream<BeforeNavigate>(kitBeforeNavigate);\n}\n\n/**\n * Registers an `afterNavigate` callback and exposes every completed navigation\n * (including the initial one) as an Effect `Stream`. Call during component\n * initialization.\n *\n * Like {@link beforeNavigate}, this is a **callback-registration** function:\n * call it at the top level of `<script>`, exactly where you'd call the bare\n * `afterNavigate`.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Stream, Effect } from 'effect';\n *   import { getRuntime } from '@thomasfosterau/effect-svelte';\n *\n *   // Register at init so the callback is wired to the component lifecycle.\n *   const navigations = Navigation.afterNavigate();\n *\n *   getRuntime().runFork(\n *     Stream.runForEach(navigations, (nav) =>\n *       Effect.logInfo(`navigated: ${nav.to?.url.pathname}`),\n *     ),\n *   );\n * </script>\n * ```\n */\nexport function afterNavigate(): Stream.Stream<AfterNavigate> {\n  return registeredStream<AfterNavigate>(kitAfterNavigate);\n}\n\n/**\n * Runs an `Effect` for each navigation, registered via `$app/navigation`'s\n * `onNavigate`. Call during component initialization.\n *\n * SvelteKit's `onNavigate` callback may return a cleanup function (or a promise\n * of one) that runs once the navigation completes and the DOM has updated; to\n * support that, `fn`'s Effect may succeed with a `() => void` cleanup, which is\n * forwarded to SvelteKit. The Effect is run with `runEffect` (default\n * {@link Effect.runPromise}); pass a managed runtime's `runPromise` to supply\n * services to `fn`.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Effect } from 'effect';\n *\n *   Navigation.onNavigate((nav) =>\n *     Effect.gen(function* () {\n *       yield* Effect.logInfo(`navigating to ${nav.to?.url.pathname}`);\n *       // Optionally return a cleanup that runs after the navigation:\n *       return () => console.log(\"navigation done\");\n *     }),\n *   );\n * </script>\n * ```\n */\nexport function onNavigate(\n  fn: (navigation: OnNavigate) => Effect.Effect<(() => void) | void>,\n  runEffect: <X>(effect: Effect.Effect<X>) => Promise<X> = Effect.runPromise,\n): void {\n  onNavigateWith<OnNavigate>(kitOnNavigate, fn, runEffect);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAaA,UAAQ,GAAG,SACtB,OAAO,cAAcC,KAAQ,GAAG,IAAI,CAAC;;AAGvC,MAAaC,gBAAc,GAAG,SAC5B,OAAO,cAAcC,WAAc,GAAG,IAAI,CAAC;;;;;;;AAQ7C,MAAaC,wBAA2C,OAAO,cAAcC,cAAiB,CAAC;;AAG/F,MAAaC,gBAAc,GAAG,SAC5B,OAAO,cAAcC,WAAc,GAAG,IAAI,CAAC;;AAG7C,MAAaC,iBACX,SAEA,OAAO,cAAcC,YAAe,IAAI,CAAC;;;;;AAM3C,MAAaC,iBAAe,GAAG,SAC7B,OAAO,cAAcC,YAAe,GAAG,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgC9C,SAAgBC,mBAAgD;CAC9D,OAAO,iBAAiCC,cAAiB;AAC3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgBC,kBAA8C;CAC5D,OAAO,iBAAgCC,aAAgB;AACzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgBC,aACd,IACA,YAAyD,OAAO,YAC1D;CACN,eAA2BC,YAAe,IAAI,SAAS;AACzD"}
+{"version":3,"file":"Navigation.js","names":["goto","kitGoto","invalidate","kitInvalidate","invalidateAll","kitInvalidateAll","refreshAll","kitRefreshAll","preloadData","kitPreloadData","preloadCode","kitPreloadCode","beforeNavigate","kitBeforeNavigate","afterNavigate","kitAfterNavigate","onNavigate","kitOnNavigate"],"sources":["../src/Navigation.ts"],"sourcesContent":["/**\n * Effect wrappers for SvelteKit's client-side\n * [`$app/navigation`](https://svelte.dev/docs/kit/$app-navigation) API.\n *\n * Each of SvelteKit's promise-returning navigation functions is wrapped as an\n * `Effect`, so navigation composes inside Effect pipelines (sequencing,\n * retries, `Effect.race`, tracing spans, ...). Alongside them sit the\n * client-side lifecycle callbacks (`beforeNavigate`, `afterNavigate`,\n * `onNavigate`) bridged to Effect. These run on the client only.\n *\n * When SvelteKit rejects (for example, `goto` to a URL outside the app) or\n * throws (for example, any of them run during server rendering), the wrapper\n * fails with a {@link NavigationError} that names the operation and carries\n * SvelteKit's original reason as its `cause`.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Effect } from 'effect';\n *   import { getRuntime } from '@thomasfosterau/effect-svelte';\n *\n *   const runtime = getRuntime();\n *   const save = () =>\n *     runtime.runPromise(\n *       Effect.gen(function* () {\n *         yield* doSave();\n *         yield* Navigation.refreshAll();\n *         yield* Navigation.goto('/done');\n *       }),\n *     );\n * </script>\n * ```\n */\n\nimport {\n  afterNavigate as kitAfterNavigate,\n  beforeNavigate as kitBeforeNavigate,\n  goto as kitGoto,\n  invalidate as kitInvalidate,\n  invalidateAll as kitInvalidateAll,\n  onNavigate as kitOnNavigate,\n  preloadCode as kitPreloadCode,\n  preloadData as kitPreloadData,\n  refreshAll as kitRefreshAll,\n} from \"$app/navigation\";\nimport type { AfterNavigate, BeforeNavigate, OnNavigate } from \"$app/navigation\";\nimport * as Schema from \"effect/Schema\";\nimport * as Effect from \"effect/Effect\";\nimport type * as Stream from \"effect/Stream\";\nimport { onNavigateWith, registeredStream } from \"./internal/navigation-events.js\";\n\n/**\n * A `$app/navigation` promise wrapper ({@link goto}, {@link invalidate},\n * {@link invalidateAll}, {@link refreshAll}, {@link preloadData},\n * {@link preloadCode}) rejected or threw. `operation` names the wrapper and\n * `cause` is SvelteKit's original reason, unchanged.\n *\n * SvelteKit 3 rejects `goto` with a URL outside the app (external, or matching\n * no route) and `preloadData` with a URL outside the app; `invalidate` throws on\n * a `resource` that cannot be parsed even relative to the current URL;\n * `preloadCode` rejects when a route's code fails to load; a navigation (including one that follows a `load` redirect during\n * `invalidate` / `refreshAll`) rejects when a `beforeNavigate` / `onNavigate`\n * callback throws; and every one of them throws when called during server\n * rendering. Recover with `Effect.catchTag(\"NavigationError\", ...)`.\n */\nexport class NavigationError extends Schema.TaggedError<NavigationError>()(\"NavigationError\", {\n  /** The wrapper whose SvelteKit call failed. */\n  operation: Schema.Literals([\n    \"goto\",\n    \"invalidate\",\n    \"invalidateAll\",\n    \"refreshAll\",\n    \"preloadData\",\n    \"preloadCode\",\n  ]),\n  /** The rejection reason, or the value thrown, as SvelteKit produced it. */\n  cause: Schema.Defect(),\n}) {}\n\n/**\n * Runs a `$app/navigation` call as an Effect, so a rejection, or a synchronous\n * throw, fails with a {@link NavigationError} instead of becoming a defect.\n */\nconst fromNavigation = <A>(\n  operation: NavigationError[\"operation\"],\n  thunk: () => Promise<A>,\n): Effect.Effect<A, NavigationError> =>\n  Effect.tryPromise({\n    try: () => thunk(),\n    catch: (cause) => new NavigationError({ operation, cause }),\n  });\n\n/**\n * Navigate to `url`. Wraps `$app/navigation`'s `goto`.\n *\n * Fails with a {@link NavigationError} if SvelteKit rejects: a URL outside the\n * app (external, or not matching a route) rejects, as does a navigation whose\n * `beforeNavigate` / `onNavigate` callback throws, or a call during server\n * rendering. For an external URL, set `window.location` instead.\n */\nexport const goto = (...args: Parameters<typeof kitGoto>): Effect.Effect<void, NavigationError> =>\n  fromNavigation(\"goto\", () => kitGoto(...args));\n\n/**\n * Re-run `load` functions that depend on `resource`. Wraps `invalidate`.\n *\n * Fails with a {@link NavigationError} if SvelteKit rejects or throws: a\n * `resource` string that cannot be parsed even relative to the current URL\n * throws, as does a call during server rendering, and the navigation that\n * follows a `load` redirect can reject.\n */\nexport const invalidate = (\n  ...args: Parameters<typeof kitInvalidate>\n): Effect.Effect<void, NavigationError> =>\n  fromNavigation(\"invalidate\", () => kitInvalidate(...args));\n\n/**\n * Re-run every `load` function for the active page. Wraps `invalidateAll`.\n *\n * Fails with a {@link NavigationError} if SvelteKit rejects or throws: for\n * example, when the navigation that follows a `load` redirect fails, or when\n * called during server rendering.\n *\n * @deprecated SvelteKit 3 deprecates `invalidateAll`; use {@link refreshAll},\n * which also refreshes active remote functions and keeps `page.state`.\n */\nexport const invalidateAll = (): Effect.Effect<void, NavigationError> =>\n  fromNavigation(\"invalidateAll\", () => kitInvalidateAll());\n\n/**\n * Refresh active remote functions (and, by default, `load`s). Wraps `refreshAll`.\n *\n * Fails with a {@link NavigationError} if SvelteKit rejects or throws: for\n * example, when the navigation that follows a `load` redirect fails, or when\n * called during server rendering.\n */\nexport const refreshAll = (\n  ...args: Parameters<typeof kitRefreshAll>\n): Effect.Effect<void, NavigationError> =>\n  fromNavigation(\"refreshAll\", () => kitRefreshAll(...args));\n\n/**\n * Preload the data for `href`. Wraps `preloadData`, succeeding with SvelteKit's\n * result (`loaded`, `redirect`, or `error` when a `load` fails).\n *\n * Fails with a {@link NavigationError} if SvelteKit rejects: an `href` outside\n * the app rejects, as does a call during server rendering.\n */\nexport const preloadData = (\n  href: string,\n): Effect.Effect<Awaited<ReturnType<typeof kitPreloadData>>, NavigationError> =>\n  fromNavigation(\"preloadData\", () => kitPreloadData(href));\n\n/**\n * Preload the code for the route `id` (e.g. `/blog/[slug]`, without\n * `paths.base`). Wraps `preloadCode`.\n *\n * Fails with a {@link NavigationError} if SvelteKit rejects: a route module\n * that fails to load rejects, as does a call during server rendering (and, in\n * development, an `id` not starting with `/`).\n */\nexport const preloadCode = (\n  ...args: Parameters<typeof kitPreloadCode>\n): Effect.Effect<void, NavigationError> =>\n  fromNavigation(\"preloadCode\", () => kitPreloadCode(...args));\n\n/**\n * Registers a `beforeNavigate` callback and exposes every navigation about to\n * happen as an Effect `Stream`. Call during component initialization.\n *\n * Unlike the promise-returning navigation functions above, this is a\n * **callback-registration** function: it must be called *synchronously during\n * component initialization* (SvelteKit wires it to the component's lifecycle).\n * It registers its callback eagerly and feeds an internal unbounded `Queue`,\n * returning a `Stream` backed by that queue: a push-based bridge that buffers\n * every event for its single consumer. Call it at the top level of `<script>`,\n * exactly where you'd call the bare `beforeNavigate`.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Stream, Effect } from 'effect';\n *   import { getRuntime } from '@thomasfosterau/effect-svelte';\n *\n *   // Register at init so the callback is wired to the component lifecycle.\n *   const navigations = Navigation.beforeNavigate();\n *\n *   getRuntime().runFork(\n *     Stream.runForEach(navigations, (nav) =>\n *       Effect.logInfo(`leaving: ${nav.from?.url.pathname}`),\n *     ),\n *   );\n * </script>\n * ```\n */\nexport function beforeNavigate(): Stream.Stream<BeforeNavigate> {\n  return registeredStream<BeforeNavigate>(kitBeforeNavigate);\n}\n\n/**\n * Registers an `afterNavigate` callback and exposes every completed navigation\n * (including the initial one) as an Effect `Stream`. Call during component\n * initialization.\n *\n * Like {@link beforeNavigate}, this is a **callback-registration** function:\n * call it at the top level of `<script>`, exactly where you'd call the bare\n * `afterNavigate`.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Stream, Effect } from 'effect';\n *   import { getRuntime } from '@thomasfosterau/effect-svelte';\n *\n *   // Register at init so the callback is wired to the component lifecycle.\n *   const navigations = Navigation.afterNavigate();\n *\n *   getRuntime().runFork(\n *     Stream.runForEach(navigations, (nav) =>\n *       Effect.logInfo(`navigated: ${nav.to?.url.pathname}`),\n *     ),\n *   );\n * </script>\n * ```\n */\nexport function afterNavigate(): Stream.Stream<AfterNavigate> {\n  return registeredStream<AfterNavigate>(kitAfterNavigate);\n}\n\n/**\n * Runs an `Effect` for each navigation, registered via `$app/navigation`'s\n * `onNavigate`. Call during component initialization.\n *\n * SvelteKit's `onNavigate` callback may return a cleanup function (or a promise\n * of one) that runs once the navigation completes and the DOM has updated; to\n * support that, `fn`'s Effect may succeed with a `() => void` cleanup, which is\n * forwarded to SvelteKit. The Effect is run with `runEffect` (default\n * {@link Effect.runPromise}); pass a managed runtime's `runPromise` to supply\n * services to `fn`.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';\n *   import { Effect } from 'effect';\n *\n *   Navigation.onNavigate((nav) =>\n *     Effect.gen(function* () {\n *       yield* Effect.logInfo(`navigating to ${nav.to?.url.pathname}`);\n *       // Optionally return a cleanup that runs after the navigation:\n *       return () => console.log(\"navigation done\");\n *     }),\n *   );\n * </script>\n * ```\n */\nexport function onNavigate(\n  fn: (navigation: OnNavigate) => Effect.Effect<(() => void) | void>,\n  runEffect: <X>(effect: Effect.Effect<X>) => Promise<X> = Effect.runPromise,\n): void {\n  onNavigateWith<OnNavigate>(kitOnNavigate, fn, runEffect);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,kBAAb,cAAqC,OAAO,YAA6B,CAAC,CAAC,mBAAmB;;CAE5F,WAAW,OAAO,SAAS;EACzB;EACA;EACA;EACA;EACA;EACA;CACF,CAAC;;CAED,OAAO,OAAO,OAAO;AACvB,CAAC,CAAC,CAAC,CAAC;;;;;AAMJ,MAAM,kBACJ,WACA,UAEA,OAAO,WAAW;CAChB,WAAW,MAAM;CACjB,QAAQ,UAAU,IAAI,gBAAgB;EAAE;EAAW;CAAM,CAAC;AAC5D,CAAC;;;;;;;;;AAUH,MAAaA,UAAQ,GAAG,SACtB,eAAe,cAAcC,KAAQ,GAAG,IAAI,CAAC;;;;;;;;;AAU/C,MAAaC,gBACX,GAAG,SAEH,eAAe,oBAAoBC,WAAc,GAAG,IAAI,CAAC;;;;;;;;;;;AAY3D,MAAaC,wBACX,eAAe,uBAAuBC,cAAiB,CAAC;;;;;;;;AAS1D,MAAaC,gBACX,GAAG,SAEH,eAAe,oBAAoBC,WAAc,GAAG,IAAI,CAAC;;;;;;;;AAS3D,MAAaC,iBACX,SAEA,eAAe,qBAAqBC,YAAe,IAAI,CAAC;;;;;;;;;AAU1D,MAAaC,iBACX,GAAG,SAEH,eAAe,qBAAqBC,YAAe,GAAG,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgC7D,SAAgBC,mBAAgD;CAC9D,OAAO,iBAAiCC,cAAiB;AAC3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgBC,kBAA8C;CAC5D,OAAO,iBAAgCC,aAAgB;AACzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgBC,aACd,IACA,YAAyD,OAAO,YAC1D;CACN,eAA2BC,YAAe,IAAI,SAAS;AACzD"}

package/dist/Remote.d.ts

@@ -1,4 +1,5 @@
-import { Effect, Stream } from "effect";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import { RemoteCommand, RemoteLiveQuery, RemotePrerenderFunction, RemoteQuery, RemoteQueryFunction, RemoteQueryOverride } from "$app/server";
 declare namespace Remote_d_exports {
   export { RemoteSubmit, callCommand, callCommandWithUpdates, callPrerender, callQuery, liveQueryStream, submitForm, submitFormWithUpdates };
@@ -6,34 +7,42 @@ declare namespace Remote_d_exports {
 /**
  * Calls a SvelteKit remote `query` as an Effect that succeeds with its output.
  *
- * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
- * defect, not on the error channel, despite the declared `unknown` error type.
+ * Fails with the remote call's rejection reason, typed `unknown` and passed
+ * through unchanged. On the client, a server-side `error()` arrives as
+ * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of
+ * failing.
  */
-declare function callQuery<Output>(query: RemoteQueryFunction<void, Output>): Effect.Effect<Output, unknown, never>;
+export declare function callQuery<Output>(query: RemoteQueryFunction<void, Output>): Effect.Effect<Output, unknown, never>;
 /**
  * Calls a SvelteKit remote `query` with `input` as an Effect that succeeds
  * with its output.
  *
- * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
- * defect, not on the error channel, despite the declared `unknown` error type.
+ * Fails with the remote call's rejection reason, typed `unknown` and passed
+ * through unchanged. On the client, a server-side `error()` arrives as
+ * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of
+ * failing.
  */
-declare function callQuery<Input, Output>(query: RemoteQueryFunction<Input, Output>, input: Input): Effect.Effect<Output, unknown, never>;
+export declare function callQuery<Input, Output>(query: RemoteQueryFunction<Input, Output>, input: Input): Effect.Effect<Output, unknown, never>;
 /**
  * Calls a SvelteKit remote `command` as an Effect that succeeds with its
  * output.
  *
- * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
- * defect, not on the error channel, despite the declared `unknown` error type.
+ * Fails with the remote call's rejection reason, typed `unknown` and passed
+ * through unchanged. On the client, a server-side `error()` arrives as
+ * SvelteKit's `HttpError`; commands may not `redirect()`, and SvelteKit
+ * rejects one with an `Error`.
  */
-declare function callCommand<Output>(command: RemoteCommand<void, Output>): Effect.Effect<Output, unknown, never>;
+export declare function callCommand<Output>(command: RemoteCommand<void, Output>): Effect.Effect<Output, unknown, never>;
 /**
  * Calls a SvelteKit remote `command` with `input` as an Effect that succeeds
  * with its output.
  *
- * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
- * defect, not on the error channel, despite the declared `unknown` error type.
+ * Fails with the remote call's rejection reason, typed `unknown` and passed
+ * through unchanged. On the client, a server-side `error()` arrives as
+ * SvelteKit's `HttpError`; commands may not `redirect()`, and SvelteKit
+ * rejects one with an `Error`.
  */
-declare function callCommand<Input, Output>(command: RemoteCommand<Input, Output>, input: Input): Effect.Effect<Output, unknown, never>;
+export declare function callCommand<Input, Output>(command: RemoteCommand<Input, Output>, input: Input): Effect.Effect<Output, unknown, never>;
 /**
  * Calls a remote command and refreshes the given queries in the same round
  * trip (SvelteKit's single-flight mutations).
@@ -42,49 +51,59 @@ declare function callCommand<Input, Output>(command: RemoteCommand<Input, Output
  * changes data those queries depend on must list them here (or call
  * `query.refresh()` afterwards) for their cached values to update.
  *
- * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
- * defect, not on the error channel, despite the declared `unknown` error type.
+ * Fails with the remote call's rejection reason, typed `unknown` and passed
+ * through unchanged. On the client, a server-side `error()` arrives as
+ * SvelteKit's `HttpError`; commands may not `redirect()`, and SvelteKit
+ * rejects one with an `Error`.
  */
-declare function callCommandWithUpdates<Input, Output>(command: RemoteCommand<Input, Output>, input: Input, ...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Effect.Effect<Output, unknown, never>;
+export declare function callCommandWithUpdates<Input, Output>(command: RemoteCommand<Input, Output>, input: Input, ...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Effect.Effect<Output, unknown, never>;
 /**
  * Calls a SvelteKit remote `prerender` function as an Effect that succeeds
  * with its output.
  *
- * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
- * defect, not on the error channel, despite the declared `unknown` error type.
+ * Fails with the remote call's rejection reason, typed `unknown` and passed
+ * through unchanged. On the client, a server-side `error()` arrives as
+ * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of
+ * failing.
  */
-declare function callPrerender<Output>(prerender: RemotePrerenderFunction<void, Output>): Effect.Effect<Output, unknown, never>;
+export declare function callPrerender<Output>(prerender: RemotePrerenderFunction<void, Output>): Effect.Effect<Output, unknown, never>;
 /**
  * Calls a SvelteKit remote `prerender` function with `input` as an Effect
  * that succeeds with its output.
  *
- * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
- * defect, not on the error channel, despite the declared `unknown` error type.
+ * Fails with the remote call's rejection reason, typed `unknown` and passed
+ * through unchanged. On the client, a server-side `error()` arrives as
+ * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of
+ * failing.
  */
-declare function callPrerender<Input, Output>(prerender: RemotePrerenderFunction<Input, Output>, input: Input): Effect.Effect<Output, unknown, never>;
+export declare function callPrerender<Input, Output>(prerender: RemotePrerenderFunction<Input, Output>, input: Input): Effect.Effect<Output, unknown, never>;
 /**
- * The shape of an enhanced remote form `submit` function. The promise result
- * is left open (SvelteKit returns `Promise<void>` in older versions and
- * `Promise<boolean>` in newer ones).
+ * The shape of an enhanced remote form `submit` function, as SvelteKit 3's
+ * `RemoteForm.submit`: it resolves with whether the submission was valid, and
+ * `updates` refreshes queries in the same round trip.
  */
-type RemoteSubmit = () => PromiseLike<unknown> & {
-  updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => PromiseLike<unknown>;
+export type RemoteSubmit = () => PromiseLike<boolean> & {
+  updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => PromiseLike<boolean>;
 };
 /**
  * Runs an enhanced remote form's `submit()` as an Effect.
  *
- * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
- * defect, not on the error channel, despite the declared `unknown` error type.
+ * Fails with the remote call's rejection reason, typed `unknown` and passed
+ * through unchanged. On the client, a server-side `error()` arrives as
+ * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of
+ * failing.
  */
-declare function submitForm(submit: () => PromiseLike<unknown>): Effect.Effect<void, unknown, never>;
+export declare function submitForm(submit: () => PromiseLike<boolean>): Effect.Effect<void, unknown, never>;
 /**
  * Runs an enhanced remote form's `submit()` and refreshes the given queries in
  * the same round trip (SvelteKit's single-flight mutations).
  *
- * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
- * defect, not on the error channel, despite the declared `unknown` error type.
+ * Fails with the remote call's rejection reason, typed `unknown` and passed
+ * through unchanged. On the client, a server-side `error()` arrives as
+ * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of
+ * failing.
  */
-declare function submitFormWithUpdates(submit: RemoteSubmit, ...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Effect.Effect<void, unknown, never>;
+export declare function submitFormWithUpdates(submit: RemoteSubmit, ...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Effect.Effect<void, unknown, never>;
 /**
  * Consumes a SvelteKit live query (`query.live(...)`) as an Effect `Stream`.
  *
@@ -101,7 +120,7 @@ declare function submitFormWithUpdates(submit: RemoteSubmit, ...queries: Array<R
  * const feed = useStream(Remote.liveQueryStream(messages()));
  * ```
  */
-declare function liveQueryStream<Output>(query: RemoteLiveQuery<Output>): Stream.Stream<Output, unknown>;
+export declare function liveQueryStream<Output>(query: RemoteLiveQuery<Output>): Stream.Stream<Output, unknown>;
 //#endregion
-export { RemoteSubmit, Remote_d_exports, callCommand, callCommandWithUpdates, callPrerender, callQuery, liveQueryStream, submitForm, submitFormWithUpdates };
+export { Remote_d_exports };
 //# sourceMappingURL=Remote.d.ts.map

package/dist/Remote.js

@@ -1,5 +1,6 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Effect, Stream } from "effect";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 //#region src/Remote.ts
 var Remote_exports = /* @__PURE__ */ __exportAll({
 	callCommand: () => callCommand,
@@ -10,15 +11,20 @@ var Remote_exports = /* @__PURE__ */ __exportAll({
 	submitForm: () => submitForm,
 	submitFormWithUpdates: () => submitFormWithUpdates
 });
+/**
+* Wraps a remote call so a rejection, or a synchronous throw from `thunk`,
+* fails the Effect with the original reason instead of becoming a defect.
+*/
 function fromRemotePromise(thunk) {
-	return Effect.promise(() => Promise.resolve(thunk()));
+	return Effect.tryPromise({
+		try: () => Promise.resolve(thunk()),
+		catch: (error) => error
+	});
 }
 function callQuery(query, input) {
-	if (arguments.length === 1) return fromRemotePromise(() => query(void 0));
 	return fromRemotePromise(() => query(input));
 }
 function callCommand(command, input) {
-	if (arguments.length === 1) return fromRemotePromise(() => command(void 0));
 	return fromRemotePromise(() => command(input));
 }
 /**
@@ -29,21 +35,24 @@ function callCommand(command, input) {
 * changes data those queries depend on must list them here (or call
 * `query.refresh()` afterwards) for their cached values to update.
 *
-* A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
-* defect, not on the error channel, despite the declared `unknown` error type.
+* Fails with the remote call's rejection reason, typed `unknown` and passed
+* through unchanged. On the client, a server-side `error()` arrives as
+* SvelteKit's `HttpError`; commands may not `redirect()`, and SvelteKit
+* rejects one with an `Error`.
 */
 function callCommandWithUpdates(command, input, ...queries) {
 	return fromRemotePromise(() => command(input).updates(...queries));
 }
 function callPrerender(prerender, input) {
-	if (arguments.length === 1) return fromRemotePromise(() => prerender(void 0));
 	return fromRemotePromise(() => prerender(input));
 }
 /**
 * Runs an enhanced remote form's `submit()` as an Effect.
 *
-* A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
-* defect, not on the error channel, despite the declared `unknown` error type.
+* Fails with the remote call's rejection reason, typed `unknown` and passed
+* through unchanged. On the client, a server-side `error()` arrives as
+* SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of
+* failing.
 */
 function submitForm(submit) {
 	return Effect.asVoid(fromRemotePromise(() => submit()));
@@ -52,8 +61,10 @@ function submitForm(submit) {
 * Runs an enhanced remote form's `submit()` and refreshes the given queries in
 * the same round trip (SvelteKit's single-flight mutations).
 *
-* A rejected call (including a thrown `error()` / `redirect()`) surfaces as a
-* defect, not on the error channel, despite the declared `unknown` error type.
+* Fails with the remote call's rejection reason, typed `unknown` and passed
+* through unchanged. On the client, a server-side `error()` arrives as
+* SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of
+* failing.
 */
 function submitFormWithUpdates(submit, ...queries) {
 	return Effect.asVoid(fromRemotePromise(() => submit().updates(...queries)));

package/dist/Remote.js.map

@@ -1 +1 @@
-{"version":3,"file":"Remote.js","names":[],"sources":["../src/Remote.ts"],"sourcesContent":["import type {\n  RemoteCommand,\n  RemoteLiveQuery,\n  RemotePrerenderFunction,\n  RemoteQuery,\n  RemoteQueryFunction,\n  RemoteQueryOverride,\n} from \"$app/server\";\nimport { Effect, Stream } from \"effect\";\n\nfunction fromRemotePromise<A>(thunk: () => PromiseLike<A>): Effect.Effect<A, unknown, never> {\n  return Effect.promise(() => Promise.resolve(thunk()));\n}\n\n/**\n * Calls a SvelteKit remote `query` as an Effect that succeeds with its output.\n *\n * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a\n * defect, not on the error channel, despite the declared `unknown` error type.\n */\nexport function callQuery<Output>(\n  query: RemoteQueryFunction<void, Output>,\n): Effect.Effect<Output, unknown, never>;\n/**\n * Calls a SvelteKit remote `query` with `input` as an Effect that succeeds\n * with its output.\n *\n * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a\n * defect, not on the error channel, despite the declared `unknown` error type.\n */\nexport function callQuery<Input, Output>(\n  query: RemoteQueryFunction<Input, Output>,\n  input: Input,\n): Effect.Effect<Output, unknown, never>;\nexport function callQuery<Input, Output>(\n  query: RemoteQueryFunction<Input, Output>,\n  input?: Input,\n): Effect.Effect<Output, unknown, never> {\n  if (arguments.length === 1) {\n    return fromRemotePromise(() =>\n      (query as unknown as RemoteQueryFunction<void, Output>)(undefined),\n    );\n  }\n\n  return fromRemotePromise(() => query(input as Input));\n}\n\n/**\n * Calls a SvelteKit remote `command` as an Effect that succeeds with its\n * output.\n *\n * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a\n * defect, not on the error channel, despite the declared `unknown` error type.\n */\nexport function callCommand<Output>(\n  command: RemoteCommand<void, Output>,\n): Effect.Effect<Output, unknown, never>;\n/**\n * Calls a SvelteKit remote `command` with `input` as an Effect that succeeds\n * with its output.\n *\n * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a\n * defect, not on the error channel, despite the declared `unknown` error type.\n */\nexport function callCommand<Input, Output>(\n  command: RemoteCommand<Input, Output>,\n  input: Input,\n): Effect.Effect<Output, unknown, never>;\nexport function callCommand<Input, Output>(\n  command: RemoteCommand<Input, Output>,\n  input?: Input,\n): Effect.Effect<Output, unknown, never> {\n  if (arguments.length === 1) {\n    return fromRemotePromise(() => (command as unknown as RemoteCommand<void, Output>)(undefined));\n  }\n\n  return fromRemotePromise(() => command(input as Input));\n}\n\n/**\n * Calls a remote command and refreshes the given queries in the same round\n * trip (SvelteKit's single-flight mutations).\n *\n * Newer SvelteKit versions cache remote query instances, so a command that\n * changes data those queries depend on must list them here (or call\n * `query.refresh()` afterwards) for their cached values to update.\n *\n * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a\n * defect, not on the error channel, despite the declared `unknown` error type.\n */\nexport function callCommandWithUpdates<Input, Output>(\n  command: RemoteCommand<Input, Output>,\n  input: Input,\n  ...queries: Array<RemoteQuery<any> | RemoteQueryOverride>\n): Effect.Effect<Output, unknown, never> {\n  return fromRemotePromise(() => command(input).updates(...queries));\n}\n\n/**\n * Calls a SvelteKit remote `prerender` function as an Effect that succeeds\n * with its output.\n *\n * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a\n * defect, not on the error channel, despite the declared `unknown` error type.\n */\nexport function callPrerender<Output>(\n  prerender: RemotePrerenderFunction<void, Output>,\n): Effect.Effect<Output, unknown, never>;\n/**\n * Calls a SvelteKit remote `prerender` function with `input` as an Effect\n * that succeeds with its output.\n *\n * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a\n * defect, not on the error channel, despite the declared `unknown` error type.\n */\nexport function callPrerender<Input, Output>(\n  prerender: RemotePrerenderFunction<Input, Output>,\n  input: Input,\n): Effect.Effect<Output, unknown, never>;\nexport function callPrerender<Input, Output>(\n  prerender: RemotePrerenderFunction<Input, Output>,\n  input?: Input,\n): Effect.Effect<Output, unknown, never> {\n  if (arguments.length === 1) {\n    return fromRemotePromise(() =>\n      (prerender as unknown as RemotePrerenderFunction<void, Output>)(undefined),\n    );\n  }\n\n  return fromRemotePromise(() => prerender(input as Input));\n}\n\n/**\n * The shape of an enhanced remote form `submit` function. The promise result\n * is left open (SvelteKit returns `Promise<void>` in older versions and\n * `Promise<boolean>` in newer ones).\n */\nexport type RemoteSubmit = () => PromiseLike<unknown> & {\n  updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => PromiseLike<unknown>;\n};\n\n/**\n * Runs an enhanced remote form's `submit()` as an Effect.\n *\n * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a\n * defect, not on the error channel, despite the declared `unknown` error type.\n */\nexport function submitForm(\n  submit: () => PromiseLike<unknown>,\n): Effect.Effect<void, unknown, never> {\n  return Effect.asVoid(fromRemotePromise(() => submit()));\n}\n\n/**\n * Runs an enhanced remote form's `submit()` and refreshes the given queries in\n * the same round trip (SvelteKit's single-flight mutations).\n *\n * A rejected call (including a thrown `error()` / `redirect()`) surfaces as a\n * defect, not on the error channel, despite the declared `unknown` error type.\n */\nexport function submitFormWithUpdates(\n  submit: RemoteSubmit,\n  ...queries: Array<RemoteQuery<any> | RemoteQueryOverride>\n): Effect.Effect<void, unknown, never> {\n  return Effect.asVoid(fromRemotePromise(() => submit().updates(...queries)));\n}\n\n/**\n * Consumes a SvelteKit live query (`query.live(...)`) as an Effect `Stream`.\n *\n * A `RemoteLiveQuery<T>` is an `AsyncIterable<T>` that yields every update\n * pushed from the server; this turns it into a `Stream` so live data can drive\n * Effect pipelines (and, via `useStream`, Svelte runes).\n *\n * @example\n * ```ts\n * import { Remote } from '@thomasfosterau/effect-sveltekit';\n * import { messages } from './chat.remote';\n * import { useStream } from '@thomasfosterau/effect-svelte';\n *\n * const feed = useStream(Remote.liveQueryStream(messages()));\n * ```\n */\nexport function liveQueryStream<Output>(\n  query: RemoteLiveQuery<Output>,\n): Stream.Stream<Output, unknown> {\n  return Stream.fromAsyncIterable(query, (error) => error);\n}\n"],"mappings":";;;;;;;;;;;;AAUA,SAAS,kBAAqB,OAA+D;CAC3F,OAAO,OAAO,cAAc,QAAQ,QAAQ,MAAM,CAAC,CAAC;AACtD;AAsBA,SAAgB,UACd,OACA,OACuC;CACvC,IAAI,UAAU,WAAW,GACvB,OAAO,wBACJ,MAAuD,KAAA,CAAS,CACnE;CAGF,OAAO,wBAAwB,MAAM,KAAc,CAAC;AACtD;AAuBA,SAAgB,YACd,SACA,OACuC;CACvC,IAAI,UAAU,WAAW,GACvB,OAAO,wBAAyB,QAAmD,KAAA,CAAS,CAAC;CAG/F,OAAO,wBAAwB,QAAQ,KAAc,CAAC;AACxD;;;;;;;;;;;;AAaA,SAAgB,uBACd,SACA,OACA,GAAG,SACoC;CACvC,OAAO,wBAAwB,QAAQ,KAAK,CAAC,CAAC,QAAQ,GAAG,OAAO,CAAC;AACnE;AAuBA,SAAgB,cACd,WACA,OACuC;CACvC,IAAI,UAAU,WAAW,GACvB,OAAO,wBACJ,UAA+D,KAAA,CAAS,CAC3E;CAGF,OAAO,wBAAwB,UAAU,KAAc,CAAC;AAC1D;;;;;;;AAiBA,SAAgB,WACd,QACqC;CACrC,OAAO,OAAO,OAAO,wBAAwB,OAAO,CAAC,CAAC;AACxD;;;;;;;;AASA,SAAgB,sBACd,QACA,GAAG,SACkC;CACrC,OAAO,OAAO,OAAO,wBAAwB,OAAO,CAAC,CAAC,QAAQ,GAAG,OAAO,CAAC,CAAC;AAC5E;;;;;;;;;;;;;;;;;AAkBA,SAAgB,gBACd,OACgC;CAChC,OAAO,OAAO,kBAAkB,QAAQ,UAAU,KAAK;AACzD"}
+{"version":3,"file":"Remote.js","names":[],"sources":["../src/Remote.ts"],"sourcesContent":["import type {\n  RemoteCommand,\n  RemoteLiveQuery,\n  RemotePrerenderFunction,\n  RemoteQuery,\n  RemoteQueryFunction,\n  RemoteQueryOverride,\n} from \"$app/server\";\nimport * as Effect from \"effect/Effect\";\nimport * as Stream from \"effect/Stream\";\n\n/**\n * Wraps a remote call so a rejection, or a synchronous throw from `thunk`,\n * fails the Effect with the original reason instead of becoming a defect.\n */\nfunction fromRemotePromise<A>(thunk: () => PromiseLike<A>): Effect.Effect<A, unknown, never> {\n  return Effect.tryPromise({\n    try: () => Promise.resolve(thunk()),\n    catch: (error) => error,\n  });\n}\n\n/**\n * Calls a SvelteKit remote `query` as an Effect that succeeds with its output.\n *\n * Fails with the remote call's rejection reason, typed `unknown` and passed\n * through unchanged. On the client, a server-side `error()` arrives as\n * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of\n * failing.\n */\nexport function callQuery<Output>(\n  query: RemoteQueryFunction<void, Output>,\n): Effect.Effect<Output, unknown, never>;\n/**\n * Calls a SvelteKit remote `query` with `input` as an Effect that succeeds\n * with its output.\n *\n * Fails with the remote call's rejection reason, typed `unknown` and passed\n * through unchanged. On the client, a server-side `error()` arrives as\n * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of\n * failing.\n */\nexport function callQuery<Input, Output>(\n  query: RemoteQueryFunction<Input, Output>,\n  input: Input,\n): Effect.Effect<Output, unknown, never>;\nexport function callQuery<Input, Output>(\n  query: RemoteQueryFunction<Input, Output>,\n  input?: Input,\n): Effect.Effect<Output, unknown, never> {\n  // SAFETY: `input` is only absent in the no-input overload, which fixes\n  // `Input` to `void`, so `query(undefined)` is the call that overload means.\n  return fromRemotePromise(() => query(input as Input));\n}\n\n/**\n * Calls a SvelteKit remote `command` as an Effect that succeeds with its\n * output.\n *\n * Fails with the remote call's rejection reason, typed `unknown` and passed\n * through unchanged. On the client, a server-side `error()` arrives as\n * SvelteKit's `HttpError`; commands may not `redirect()`, and SvelteKit\n * rejects one with an `Error`.\n */\nexport function callCommand<Output>(\n  command: RemoteCommand<void, Output>,\n): Effect.Effect<Output, unknown, never>;\n/**\n * Calls a SvelteKit remote `command` with `input` as an Effect that succeeds\n * with its output.\n *\n * Fails with the remote call's rejection reason, typed `unknown` and passed\n * through unchanged. On the client, a server-side `error()` arrives as\n * SvelteKit's `HttpError`; commands may not `redirect()`, and SvelteKit\n * rejects one with an `Error`.\n */\nexport function callCommand<Input, Output>(\n  command: RemoteCommand<Input, Output>,\n  input: Input,\n): Effect.Effect<Output, unknown, never>;\nexport function callCommand<Input, Output>(\n  command: RemoteCommand<Input, Output>,\n  input?: Input,\n): Effect.Effect<Output, unknown, never> {\n  // SAFETY: `input` is only absent in the no-input overload, which fixes\n  // `Input` to `void`, so `command(undefined)` is the call that overload means.\n  return fromRemotePromise(() => command(input as Input));\n}\n\n/**\n * Calls a remote command and refreshes the given queries in the same round\n * trip (SvelteKit's single-flight mutations).\n *\n * Newer SvelteKit versions cache remote query instances, so a command that\n * changes data those queries depend on must list them here (or call\n * `query.refresh()` afterwards) for their cached values to update.\n *\n * Fails with the remote call's rejection reason, typed `unknown` and passed\n * through unchanged. On the client, a server-side `error()` arrives as\n * SvelteKit's `HttpError`; commands may not `redirect()`, and SvelteKit\n * rejects one with an `Error`.\n */\nexport function callCommandWithUpdates<Input, Output>(\n  command: RemoteCommand<Input, Output>,\n  input: Input,\n  ...queries: Array<RemoteQuery<any> | RemoteQueryOverride>\n): Effect.Effect<Output, unknown, never> {\n  return fromRemotePromise(() => command(input).updates(...queries));\n}\n\n/**\n * Calls a SvelteKit remote `prerender` function as an Effect that succeeds\n * with its output.\n *\n * Fails with the remote call's rejection reason, typed `unknown` and passed\n * through unchanged. On the client, a server-side `error()` arrives as\n * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of\n * failing.\n */\nexport function callPrerender<Output>(\n  prerender: RemotePrerenderFunction<void, Output>,\n): Effect.Effect<Output, unknown, never>;\n/**\n * Calls a SvelteKit remote `prerender` function with `input` as an Effect\n * that succeeds with its output.\n *\n * Fails with the remote call's rejection reason, typed `unknown` and passed\n * through unchanged. On the client, a server-side `error()` arrives as\n * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of\n * failing.\n */\nexport function callPrerender<Input, Output>(\n  prerender: RemotePrerenderFunction<Input, Output>,\n  input: Input,\n): Effect.Effect<Output, unknown, never>;\nexport function callPrerender<Input, Output>(\n  prerender: RemotePrerenderFunction<Input, Output>,\n  input?: Input,\n): Effect.Effect<Output, unknown, never> {\n  // SAFETY: `input` is only absent in the no-input overload, which fixes\n  // `Input` to `void`, so `prerender(undefined)` is the call that overload means.\n  return fromRemotePromise(() => prerender(input as Input));\n}\n\n/**\n * The shape of an enhanced remote form `submit` function, as SvelteKit 3's\n * `RemoteForm.submit`: it resolves with whether the submission was valid, and\n * `updates` refreshes queries in the same round trip.\n */\nexport type RemoteSubmit = () => PromiseLike<boolean> & {\n  updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => PromiseLike<boolean>;\n};\n\n/**\n * Runs an enhanced remote form's `submit()` as an Effect.\n *\n * Fails with the remote call's rejection reason, typed `unknown` and passed\n * through unchanged. On the client, a server-side `error()` arrives as\n * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of\n * failing.\n */\nexport function submitForm(\n  submit: () => PromiseLike<boolean>,\n): Effect.Effect<void, unknown, never> {\n  return Effect.asVoid(fromRemotePromise(() => submit()));\n}\n\n/**\n * Runs an enhanced remote form's `submit()` and refreshes the given queries in\n * the same round trip (SvelteKit's single-flight mutations).\n *\n * Fails with the remote call's rejection reason, typed `unknown` and passed\n * through unchanged. On the client, a server-side `error()` arrives as\n * SvelteKit's `HttpError`; a server-side `redirect()` navigates instead of\n * failing.\n */\nexport function submitFormWithUpdates(\n  submit: RemoteSubmit,\n  ...queries: Array<RemoteQuery<any> | RemoteQueryOverride>\n): Effect.Effect<void, unknown, never> {\n  return Effect.asVoid(fromRemotePromise(() => submit().updates(...queries)));\n}\n\n/**\n * Consumes a SvelteKit live query (`query.live(...)`) as an Effect `Stream`.\n *\n * A `RemoteLiveQuery<T>` is an `AsyncIterable<T>` that yields every update\n * pushed from the server; this turns it into a `Stream` so live data can drive\n * Effect pipelines (and, via `useStream`, Svelte runes).\n *\n * @example\n * ```ts\n * import { Remote } from '@thomasfosterau/effect-sveltekit';\n * import { messages } from './chat.remote';\n * import { useStream } from '@thomasfosterau/effect-svelte';\n *\n * const feed = useStream(Remote.liveQueryStream(messages()));\n * ```\n */\nexport function liveQueryStream<Output>(\n  query: RemoteLiveQuery<Output>,\n): Stream.Stream<Output, unknown> {\n  return Stream.fromAsyncIterable(query, (error) => error);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAeA,SAAS,kBAAqB,OAA+D;CAC3F,OAAO,OAAO,WAAW;EACvB,WAAW,QAAQ,QAAQ,MAAM,CAAC;EAClC,QAAQ,UAAU;CACpB,CAAC;AACH;AA0BA,SAAgB,UACd,OACA,OACuC;CAGvC,OAAO,wBAAwB,MAAM,KAAc,CAAC;AACtD;AA2BA,SAAgB,YACd,SACA,OACuC;CAGvC,OAAO,wBAAwB,QAAQ,KAAc,CAAC;AACxD;;;;;;;;;;;;;;AAeA,SAAgB,uBACd,SACA,OACA,GAAG,SACoC;CACvC,OAAO,wBAAwB,QAAQ,KAAK,CAAC,CAAC,QAAQ,GAAG,OAAO,CAAC;AACnE;AA2BA,SAAgB,cACd,WACA,OACuC;CAGvC,OAAO,wBAAwB,UAAU,KAAc,CAAC;AAC1D;;;;;;;;;AAmBA,SAAgB,WACd,QACqC;CACrC,OAAO,OAAO,OAAO,wBAAwB,OAAO,CAAC,CAAC;AACxD;;;;;;;;;;AAWA,SAAgB,sBACd,QACA,GAAG,SACkC;CACrC,OAAO,OAAO,OAAO,wBAAwB,OAAO,CAAC,CAAC,QAAQ,GAAG,OAAO,CAAC,CAAC;AAC5E;;;;;;;;;;;;;;;;;AAkBA,SAAgB,gBACd,OACgC;CAChC,OAAO,OAAO,kBAAkB,QAAQ,UAAU,KAAK;AACzD"}

package/dist/State.d.ts

@@ -1,15 +1,88 @@
-import { PageSnapshot } from "./internal/app-state.js";
-import { Stream } from "effect";
+import { CurrentPageService, NavigatingSnapshot, PageSnapshot, UpdateCheckError } from "./internal/app-state.js";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
 import { Page } from "$app/state";
+import * as Option from "effect/Option";
 declare namespace State_d_exports {
-  export { PageSnapshot, page$1 as page };
+  export { CurrentPage, CurrentPageInterface, NavigatingSnapshot, PageSnapshot, UpdateCheckError, checkForUpdate, navigating$1 as navigating, page$1 as page, updated$1 as updated };
 }
 /**
  * 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.
  */
 declare function page$1(): Stream.Stream<PageSnapshot<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))),
+ * );
+ * ```
+ */
+declare function navigating$1(): Stream.Stream<Option.Option<NavigatingSnapshot>>;
+/**
+ * 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.
+ */
+declare function updated$1(): Stream.Stream<boolean>;
+/**
+ * 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.
+ */
+export declare function checkForUpdate(): Effect.Effect<boolean, UpdateCheckError>;
+/**
+ * The service shape of {@link CurrentPage}: `get` snapshots the current page
+ * and `changes` streams it. Neither fails on the client; see
+ * {@link CurrentPage} for the server.
+ */
+export interface CurrentPageInterface extends CurrentPageService<Page> {}
+declare const CurrentPage_base: Context.ServiceClass<CurrentPage, "@thomasfosterau/effect-sveltekit/CurrentPage", CurrentPageInterface>;
+/**
+ * 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)));
+ * ```
+ */
+export declare class CurrentPage extends CurrentPage_base {
+  /**
+   * 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 readonly layer: Layer.Layer<CurrentPage>;
+}
 //#endregion
-export { type PageSnapshot, State_d_exports, page$1 as page };
+export { type NavigatingSnapshot, type PageSnapshot, State_d_exports, UpdateCheckError, navigating$1 as navigating, page$1 as page, updated$1 as updated };
 //# sourceMappingURL=State.d.ts.map