@thomasfosterau/effect-sveltekit 0.5.0 → 0.6.0

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 { Data, Effect } from \"effect\";\nimport type { Stream } from \"effect\";\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 Data.TaggedError(\"NavigationError\")<{\n  /** The wrapper whose SvelteKit call failed. */\n  readonly operation:\n    | \"goto\"\n    | \"invalidate\"\n    | \"invalidateAll\"\n    | \"refreshAll\"\n    | \"preloadData\"\n    | \"preloadCode\";\n  /** The rejection reason, or the value thrown, as SvelteKit produced it. */\n  readonly cause: unknown;\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,IAAa,kBAAb,cAAqC,KAAK,YAAY,iBAAiB,CAAC,CAWrE,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

@@ -6,32 +6,40 @@ 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>;
 /**
  * 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>;
 /**
  * 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>;
 /**
  * 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>;
 /**
@@ -42,24 +50,30 @@ 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>;
 /**
  * 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>;
 /**
  * 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>;
 /**
@@ -73,16 +87,20 @@ type RemoteSubmit = () => PromiseLike<unknown> & {
 /**
  * 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>;
 /**
  * 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>;
 /**

package/dist/Remote.js

@@ -10,8 +10,15 @@ 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));
@@ -29,8 +36,10 @@ 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));
@@ -42,8 +51,10 @@ function callPrerender(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 +63,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 { Effect, Stream } from \"effect\";\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  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 * 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  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 * 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  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 * 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<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 * 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":";;;;;;;;;;;;;;;;AAcA,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;CACvC,IAAI,UAAU,WAAW,GACvB,OAAO,wBACJ,MAAuD,KAAA,CAAS,CACnE;CAGF,OAAO,wBAAwB,MAAM,KAAc,CAAC;AACtD;AA2BA,SAAgB,YACd,SACA,OACuC;CACvC,IAAI,UAAU,WAAW,GACvB,OAAO,wBAAyB,QAAmD,KAAA,CAAS,CAAC;CAG/F,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;CACvC,IAAI,UAAU,WAAW,GACvB,OAAO,wBACJ,UAA+D,KAAA,CAAS,CAC3E;CAGF,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,84 @@
-import { PageSnapshot } from "./internal/app-state.js";
-import { Stream } from "effect";
+import { CurrentPageShape, NavigatingSnapshot, PageSnapshot, UpdateCheckError } from "./internal/app-state.js";
+import { Context, Effect, Layer, Option, Stream } from "effect";
 import { Page } from "$app/state";
 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.
+ */
+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.
+ */
+interface CurrentPageInterface extends CurrentPageShape<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)));
+ * ```
+ */
+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 { CurrentPage, CurrentPageInterface, type NavigatingSnapshot, type PageSnapshot, State_d_exports, UpdateCheckError, checkForUpdate, navigating$1 as navigating, page$1 as page, updated$1 as updated };
 //# sourceMappingURL=State.d.ts.map

package/dist/State.js

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

package/dist/State.js.map

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