@thomasfosterau/effect-sveltekit 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Foster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,66 @@
+# @thomasfosterau/effect-sveltekit
+
+Effect v4-native integration for **SvelteKit**: write `load` functions, form
+actions, endpoints, hooks, and remote functions as Effects; move custom types
+across the server/client boundary with Effect Schema; and deploy on an Effect
+HTTP server.
+
+Part of the [`effect-svelte`](https://github.com/thomasfosterau/effect-svelte)
+monorepo. Depends on
+[`@thomasfosterau/effect-svelte`](https://www.npmjs.com/package/@thomasfosterau/effect-svelte)
+for the Svelte runes hooks.
+
+## Installation
+
+```bash
+npm install @thomasfosterau/effect-sveltekit effect@beta svelte @sveltejs/kit
+# the Effect deployment adapter additionally needs:
+npm install @effect/platform-node@beta
+```
+
+## Entry points
+
+| Import                             | What it provides                                                                                                                                         |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@thomasfosterau/effect-sveltekit` | universal helpers (`load`, the `Remote` call namespace, `transport`, `sveltekitConfig`, `reroute`)                                                       |
+| `…/server`                         | server wrappers (`serverLoad`, `action`, `actions`, `handle`, `endpoint`), app runtimes (`makeServerRuntime` / `makeUniversalRuntime`), `RemoteFunction` |
+| `…/client`                         | browser-only `Navigation` / `State` / `Remote` namespaces and `useRemoteQuery`                                                                           |
+| `…/vite`                           | the `effectKit()` Vite plugin (auto-wrap bare-Effect route exports)                                                                                      |
+| `…/adapter`                        | the Effect HTTP deployment adapter                                                                                                                       |
+
+## Example
+
+```ts
+// vite.config.ts — return Effects directly from route files
+import { sveltekit } from "@sveltejs/kit/vite";
+import { effectKit } from "@thomasfosterau/effect-sveltekit/vite";
+
+export default { plugins: [effectKit(), sveltekit()] };
+```
+
+```ts
+// +page.server.ts
+import { Effect } from "effect";
+export const load = (event) => Effect.succeed({ id: event.params.id });
+```
+
+## What's included
+
+- **Effects as route exports** — explicit wrappers, app-wide runtimes (services
+  built once per process), or the `effectKit()` plugin.
+- **Remote functions** — define with `RemoteFunction.*`, consume via the
+  `Remote` namespace (`Remote.callQuery`, `Remote.liveQueryStream`, …);
+  `useRemoteQuery` bridges a reactive remote resource to an `AsyncResult`.
+- **`transport` ⇄ Effect Schema** and **`$env` ⇄ Effect `Config`**.
+- **Client navigation/state** — the `Navigation` (`goto`/`invalidate`/… plus
+  `beforeNavigate`/`afterNavigate`/`onNavigate` streams) and `State` (`page`)
+  namespaces.
+- **Effect deployment adapter** — a production HTTP server on
+  `effect/unstable/http` + `@effect/platform-node`.
+
+See the [monorepo README](https://github.com/thomasfosterau/effect-svelte#readme)
+for the full API and a runnable SvelteKit example.
+
+## License
+
+MIT

package/dist/Hooks.d.ts

@@ -0,0 +1,33 @@
+import { transport, transporter } from "./transport.js";
+import { Effect } from "effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { Reroute } from "@sveltejs/kit";
+
+//#region src/Hooks.d.ts
+declare namespace Hooks_d_exports {
+  export { reroute, transport, transporter };
+}
+/**
+ * Wraps an Effect-based function as the SvelteKit universal
+ * [`reroute`](https://svelte.dev/docs/kit/hooks#Universal-hooks-reroute) hook,
+ * which rewrites the URL before routing. The effect runs on both the server and
+ * the client and gets an `HttpClient` backed by the event's `fetch`.
+ *
+ * @example
+ * ```ts
+ * // src/hooks.ts
+ * import { Hooks } from '@thomasfosterau/effect-sveltekit';
+ * import { Effect } from 'effect';
+ *
+ * export const reroute = Hooks.reroute((event) =>
+ *   Effect.succeed(event.url.pathname === '/old' ? '/new' : undefined),
+ * );
+ * ```
+ */
+declare function reroute(fn: (event: {
+  url: URL;
+  fetch: typeof globalThis.fetch;
+}) => Effect.Effect<string | void, unknown, HttpClient.HttpClient>): Reroute;
+//#endregion
+export { Hooks_d_exports };
+//# sourceMappingURL=Hooks.d.ts.map

package/dist/Hooks.js

@@ -0,0 +1,34 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { defaultUniversalRuntime } from "./internal/default-runtime.js";
+import { transport, transporter } from "./transport.js";
+import "effect";
+//#region src/Hooks.ts
+var Hooks_exports = /* @__PURE__ */ __exportAll({
+	reroute: () => reroute,
+	transport: () => transport,
+	transporter: () => transporter
+});
+/**
+* Wraps an Effect-based function as the SvelteKit universal
+* [`reroute`](https://svelte.dev/docs/kit/hooks#Universal-hooks-reroute) hook,
+* which rewrites the URL before routing. The effect runs on both the server and
+* the client and gets an `HttpClient` backed by the event's `fetch`.
+*
+* @example
+* ```ts
+* // src/hooks.ts
+* import { Hooks } from '@thomasfosterau/effect-sveltekit';
+* import { Effect } from 'effect';
+*
+* export const reroute = Hooks.reroute((event) =>
+*   Effect.succeed(event.url.pathname === '/old' ? '/new' : undefined),
+* );
+* ```
+*/
+function reroute(fn) {
+	return (event) => defaultUniversalRuntime().runPromise(event.fetch, fn(event));
+}
+//#endregion
+export { Hooks_exports };
+
+//# sourceMappingURL=Hooks.js.map

package/dist/Hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hooks.js","names":[],"sources":["../src/Hooks.ts"],"sourcesContent":["/**\n * Effect helpers for SvelteKit's universal hooks (`src/hooks.ts`), exposed as\n * the `Hooks` namespace of `@thomasfosterau/effect-sveltekit`.\n *\n * The `reroute` hook is expressed as an Effect (running on the universal\n * runtime, with an `HttpClient` backed by the event's `fetch`), and the\n * universal `transport` hook is built from Effect schemas via {@link transport}\n * / {@link transporter}.\n *\n * @example\n * ```ts\n * // src/hooks.ts\n * import { Hooks } from '@thomasfosterau/effect-sveltekit';\n * import { Effect, Schema } from 'effect';\n *\n * export const reroute = Hooks.reroute((event) =>\n *   Effect.succeed(event.url.pathname === '/old' ? '/new' : undefined),\n * );\n *\n * export const transport = Hooks.transport({\n *   Option: Schema.Option(Schema.Number),\n *   Date: Schema.Date,\n * });\n * ```\n */\n\nimport type { Reroute } from \"@sveltejs/kit\";\nimport { Effect } from \"effect\";\nimport type * as HttpClient from \"effect/unstable/http/HttpClient\";\nimport { defaultUniversalRuntime } from \"./internal/default-runtime.js\";\n\n/**\n * Wraps an Effect-based function as the SvelteKit universal\n * [`reroute`](https://svelte.dev/docs/kit/hooks#Universal-hooks-reroute) hook,\n * which rewrites the URL before routing. The effect runs on both the server and\n * the client and gets an `HttpClient` backed by the event's `fetch`.\n *\n * @example\n * ```ts\n * // src/hooks.ts\n * import { Hooks } from '@thomasfosterau/effect-sveltekit';\n * import { Effect } from 'effect';\n *\n * export const reroute = Hooks.reroute((event) =>\n *   Effect.succeed(event.url.pathname === '/old' ? '/new' : undefined),\n * );\n * ```\n */\nexport function reroute(\n  fn: (event: {\n    url: URL;\n    fetch: typeof globalThis.fetch;\n  }) => Effect.Effect<string | void, unknown, HttpClient.HttpClient>,\n): Reroute {\n  return (event) => defaultUniversalRuntime().runPromise(event.fetch, fn(event));\n}\n\n/**\n * The universal `transport` hook built from Effect schemas: `transport`\n * assembles a whole `transport` object from a record of schemas, and\n * `transporter` builds a single entry. See {@link transport} for details.\n */\nexport { transport, transporter } from \"./transport.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,QACd,IAIS;CACT,QAAQ,UAAU,wBAAwB,EAAE,WAAW,MAAM,OAAO,GAAG,KAAK,CAAC;AAC/E"}

package/dist/Navigation.d.ts

@@ -0,0 +1,110 @@
+import { Effect, Stream } from "effect";
+import { AfterNavigate, BeforeNavigate, OnNavigate } from "@sveltejs/kit";
+import { goto, invalidate, preloadData, refreshAll } from "$app/navigation";
+
+//#region src/Navigation.d.ts
+declare namespace Navigation_d_exports {
+  export { 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 };
+}
+/** Navigate to `url`. Wraps `$app/navigation`'s `goto`. */
+declare const goto$1: (...args: Parameters<typeof goto>) => Effect.Effect<void>;
+/** Re-run `load` functions that depend on `resource`. Wraps `invalidate`. */
+declare const invalidate$1: (...args: Parameters<typeof invalidate>) => Effect.Effect<void>;
+/** Re-run every `load` function for the active page. Wraps `invalidateAll`. */
+declare const invalidateAll$1: () => Effect.Effect<void>;
+/** Refresh active remote functions (and, by default, `load`s). Wraps `refreshAll`. */
+declare const refreshAll$1: (...args: Parameters<typeof refreshAll>) => Effect.Effect<void>;
+/** Preload the data for `href`. Wraps `preloadData`. */
+declare const preloadData$1: (href: string) => Effect.Effect<Awaited<ReturnType<typeof preloadData>>>;
+/** Preload the code for routes matching `pathname`. Wraps `preloadCode`. */
+declare const preloadCode$1: (pathname: string) => Effect.Effect<void>;
+/**
+ * Registers a `beforeNavigate` callback and exposes every navigation about to
+ * happen as an Effect `Stream`. Call during component initialization.
+ *
+ * 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>`,
+ * exactly where you'd call the bare `beforeNavigate`.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';
+ *   import { Stream, Effect } from 'effect';
+ *   import { getRuntime } from '@thomasfosterau/effect-svelte';
+ *
+ *   // Register at init so the callback is wired to the component lifecycle.
+ *   const navigations = Navigation.beforeNavigate();
+ *
+ *   getRuntime().runFork(
+ *     Stream.runForEach(navigations, (nav) =>
+ *       Effect.logInfo(`leaving: ${nav.from?.url.pathname}`),
+ *     ),
+ *   );
+ * </script>
+ * ```
+ */
+declare function beforeNavigate$1(): Stream.Stream<BeforeNavigate>;
+/**
+ * Registers an `afterNavigate` callback and exposes every completed navigation
+ * (including the initial one) as an Effect `Stream`. Call during component
+ * initialization.
+ *
+ * Like {@link beforeNavigate}, this is a **callback-registration** function:
+ * call it at the top level of `<script>`, exactly where you'd call the bare
+ * `afterNavigate`.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';
+ *   import { Stream, Effect } from 'effect';
+ *   import { getRuntime } from '@thomasfosterau/effect-svelte';
+ *
+ *   // Register at init so the callback is wired to the component lifecycle.
+ *   const navigations = Navigation.afterNavigate();
+ *
+ *   getRuntime().runFork(
+ *     Stream.runForEach(navigations, (nav) =>
+ *       Effect.logInfo(`navigated: ${nav.to?.url.pathname}`),
+ *     ),
+ *   );
+ * </script>
+ * ```
+ */
+declare function afterNavigate$1(): Stream.Stream<AfterNavigate>;
+/**
+ * Runs an `Effect` for each navigation, registered via `$app/navigation`'s
+ * `onNavigate`. Call during component initialization.
+ *
+ * SvelteKit's `onNavigate` callback may return a cleanup function (or a promise
+ * of one) that runs once the navigation completes and the DOM has updated; to
+ * support that, `fn`'s Effect may succeed with a `() => void` cleanup, which is
+ * forwarded to SvelteKit. The Effect is run with `runEffect` (default
+ * {@link Effect.runPromise}); pass a managed runtime's `runPromise` to supply
+ * services to `fn`.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';
+ *   import { Effect } from 'effect';
+ *
+ *   Navigation.onNavigate((nav) =>
+ *     Effect.gen(function* () {
+ *       yield* Effect.logInfo(`navigating to ${nav.to?.url.pathname}`);
+ *       // Optionally return a cleanup that runs after the navigation:
+ *       return () => console.log("navigation done");
+ *     }),
+ *   );
+ * </script>
+ * ```
+ */
+declare function onNavigate$1(fn: (navigation: OnNavigate) => Effect.Effect<(() => void) | void>, runEffect?: <X>(effect: Effect.Effect<X>) => Promise<X>): void;
+//#endregion
+export { Navigation_d_exports };
+//# sourceMappingURL=Navigation.d.ts.map

package/dist/Navigation.js

@@ -0,0 +1,155 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { onNavigateWith, registeredStream } from "./internal/navigation-events.js";
+import { Effect } from "effect";
+import { afterNavigate, beforeNavigate, goto, invalidate, invalidateAll, onNavigate, preloadCode, preloadData, refreshAll } from "$app/navigation";
+//#region src/Navigation.ts
+/**
+* Effect wrappers for SvelteKit's client-side
+* [`$app/navigation`](https://svelte.dev/docs/kit/$app-navigation) API.
+*
+* Each of SvelteKit's promise-returning navigation functions is wrapped as an
+* `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.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';
+*   import { Effect } from 'effect';
+*   import { getRuntime } from '@thomasfosterau/effect-svelte';
+*
+*   const runtime = getRuntime();
+*   const save = () =>
+*     runtime.runPromise(
+*       Effect.gen(function* () {
+*         yield* doSave();
+*         yield* Navigation.invalidateAll();
+*         yield* Navigation.goto('/done');
+*       }),
+*     );
+* <\/script>
+* ```
+*/
+var Navigation_exports = /* @__PURE__ */ __exportAll({
+	afterNavigate: () => afterNavigate$1,
+	beforeNavigate: () => beforeNavigate$1,
+	goto: () => goto$1,
+	invalidate: () => invalidate$1,
+	invalidateAll: () => invalidateAll$1,
+	onNavigate: () => onNavigate$1,
+	preloadCode: () => preloadCode$1,
+	preloadData: () => preloadData$1,
+	refreshAll: () => refreshAll$1
+});
+/** Navigate to `url`. Wraps `$app/navigation`'s `goto`. */
+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));
+/** Re-run every `load` function for the active page. Wraps `invalidateAll`. */
+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));
+/** Preload the code for routes matching `pathname`. Wraps `preloadCode`. */
+const preloadCode$1 = (pathname) => Effect.promise(() => preloadCode(pathname));
+/**
+* Registers a `beforeNavigate` callback and exposes every navigation about to
+* happen as an Effect `Stream`. Call during component initialization.
+*
+* 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>`,
+* exactly where you'd call the bare `beforeNavigate`.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';
+*   import { Stream, Effect } from 'effect';
+*   import { getRuntime } from '@thomasfosterau/effect-svelte';
+*
+*   // Register at init so the callback is wired to the component lifecycle.
+*   const navigations = Navigation.beforeNavigate();
+*
+*   getRuntime().runFork(
+*     Stream.runForEach(navigations, (nav) =>
+*       Effect.logInfo(`leaving: ${nav.from?.url.pathname}`),
+*     ),
+*   );
+* <\/script>
+* ```
+*/
+function beforeNavigate$1() {
+	return registeredStream(beforeNavigate);
+}
+/**
+* Registers an `afterNavigate` callback and exposes every completed navigation
+* (including the initial one) as an Effect `Stream`. Call during component
+* initialization.
+*
+* Like {@link beforeNavigate}, this is a **callback-registration** function:
+* call it at the top level of `<script>`, exactly where you'd call the bare
+* `afterNavigate`.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';
+*   import { Stream, Effect } from 'effect';
+*   import { getRuntime } from '@thomasfosterau/effect-svelte';
+*
+*   // Register at init so the callback is wired to the component lifecycle.
+*   const navigations = Navigation.afterNavigate();
+*
+*   getRuntime().runFork(
+*     Stream.runForEach(navigations, (nav) =>
+*       Effect.logInfo(`navigated: ${nav.to?.url.pathname}`),
+*     ),
+*   );
+* <\/script>
+* ```
+*/
+function afterNavigate$1() {
+	return registeredStream(afterNavigate);
+}
+/**
+* Runs an `Effect` for each navigation, registered via `$app/navigation`'s
+* `onNavigate`. Call during component initialization.
+*
+* SvelteKit's `onNavigate` callback may return a cleanup function (or a promise
+* of one) that runs once the navigation completes and the DOM has updated; to
+* support that, `fn`'s Effect may succeed with a `() => void` cleanup, which is
+* forwarded to SvelteKit. The Effect is run with `runEffect` (default
+* {@link Effect.runPromise}); pass a managed runtime's `runPromise` to supply
+* services to `fn`.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { Navigation } from '@thomasfosterau/effect-sveltekit/client';
+*   import { Effect } from 'effect';
+*
+*   Navigation.onNavigate((nav) =>
+*     Effect.gen(function* () {
+*       yield* Effect.logInfo(`navigating to ${nav.to?.url.pathname}`);
+*       // Optionally return a cleanup that runs after the navigation:
+*       return () => console.log("navigation done");
+*     }),
+*   );
+* <\/script>
+* ```
+*/
+function onNavigate$1(fn, runEffect = Effect.runPromise) {
+	onNavigateWith(onNavigate, fn, runEffect);
+}
+//#endregion
+export { Navigation_exports };
+
+//# sourceMappingURL=Navigation.js.map

package/dist/Navigation.js.map

@@ -0,0 +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.invalidateAll();\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 \"@sveltejs/kit\";\nimport { Effect } from \"effect\";\nimport type { Stream } from \"effect\";\nimport { onNavigateWith, registeredStream } from \"./internal/navigation-events.js\";\n\n/** Navigate to `url`. Wraps `$app/navigation`'s `goto`. */\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/** Re-run every `load` function for the active page. Wraps `invalidateAll`. */\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/** Preload the code for routes matching `pathname`. Wraps `preloadCode`. */\nexport const preloadCode = (pathname: string): Effect.Effect<void> =>\n  Effect.promise(() => kitPreloadCode(pathname));\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,MAAaA,UAAQ,GAAG,SACtB,OAAO,cAAcC,KAAQ,GAAG,IAAI,CAAC;;AAGvC,MAAaC,gBAAc,GAAG,SAC5B,OAAO,cAAcC,WAAc,GAAG,IAAI,CAAC;;AAG7C,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;;AAG3C,MAAaC,iBAAe,aAC1B,OAAO,cAAcC,YAAe,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgC/C,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

@@ -0,0 +1,52 @@
+import { Effect, Stream } from "effect";
+import { RemoteCommand, RemoteLiveQuery, RemotePrerenderFunction, RemoteQuery, RemoteQueryFunction, RemoteQueryOverride } from "@sveltejs/kit";
+
+//#region src/Remote.d.ts
+declare namespace Remote_d_exports {
+  export { RemoteSubmit, callCommand, callCommandWithUpdates, callPrerender, callQuery, liveQueryStream, submitForm, submitFormWithUpdates };
+}
+declare function callQuery<Output>(query: RemoteQueryFunction<void, Output>): Effect.Effect<Output, unknown, never>;
+declare function callQuery<Input, Output>(query: RemoteQueryFunction<Input, Output>, input: Input): Effect.Effect<Output, unknown, never>;
+declare function callCommand<Output>(command: RemoteCommand<void, Output>): Effect.Effect<Output, unknown, never>;
+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).
+ *
+ * Newer SvelteKit versions cache remote query instances, so a command that
+ * changes data those queries depend on must list them here (or call
+ * `query.refresh()` afterwards) for their cached values to update.
+ */
+declare function callCommandWithUpdates<Input, Output>(command: RemoteCommand<Input, Output>, input: Input, ...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Effect.Effect<Output, unknown, never>;
+declare function callPrerender<Output>(prerender: RemotePrerenderFunction<void, Output>): Effect.Effect<Output, unknown, never>;
+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).
+ */
+type RemoteSubmit = () => PromiseLike<unknown> & {
+  updates: (...queries: Array<RemoteQuery<any> | RemoteQueryOverride>) => PromiseLike<unknown>;
+};
+declare function submitForm(submit: () => PromiseLike<unknown>): Effect.Effect<void, unknown, never>;
+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`.
+ *
+ * A `RemoteLiveQuery<T>` is an `AsyncIterable<T>` that yields every update
+ * pushed from the server; this turns it into a `Stream` so live data can drive
+ * Effect pipelines (and, via `useStream`, Svelte runes).
+ *
+ * @example
+ * ```ts
+ * import { Remote } from '@thomasfosterau/effect-sveltekit';
+ * import { messages } from './chat.remote';
+ * import { useStream } from '@thomasfosterau/effect-svelte';
+ *
+ * const feed = useStream(Remote.liveQueryStream(messages()));
+ * ```
+ */
+declare function liveQueryStream<Output>(query: RemoteLiveQuery<Output>): Stream.Stream<Output, unknown>;
+//#endregion
+export { Remote_d_exports };
+//# sourceMappingURL=Remote.d.ts.map

package/dist/Remote.js

@@ -0,0 +1,67 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Effect, Stream } from "effect";
+//#region src/Remote.ts
+var Remote_exports = /* @__PURE__ */ __exportAll({
+	callCommand: () => callCommand,
+	callCommandWithUpdates: () => callCommandWithUpdates,
+	callPrerender: () => callPrerender,
+	callQuery: () => callQuery,
+	liveQueryStream: () => liveQueryStream,
+	submitForm: () => submitForm,
+	submitFormWithUpdates: () => submitFormWithUpdates
+});
+function fromRemotePromise(thunk) {
+	return Effect.promise(() => Promise.resolve(thunk()));
+}
+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));
+}
+/**
+* Calls a remote command and refreshes the given queries in the same round
+* trip (SvelteKit's single-flight mutations).
+*
+* Newer SvelteKit versions cache remote query instances, so a command that
+* changes data those queries depend on must list them here (or call
+* `query.refresh()` afterwards) for their cached values to update.
+*/
+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));
+}
+function submitForm(submit) {
+	return Effect.asVoid(fromRemotePromise(() => submit()));
+}
+function submitFormWithUpdates(submit, ...queries) {
+	return Effect.asVoid(fromRemotePromise(() => submit().updates(...queries)));
+}
+/**
+* Consumes a SvelteKit live query (`query.live(...)`) as an Effect `Stream`.
+*
+* A `RemoteLiveQuery<T>` is an `AsyncIterable<T>` that yields every update
+* pushed from the server; this turns it into a `Stream` so live data can drive
+* Effect pipelines (and, via `useStream`, Svelte runes).
+*
+* @example
+* ```ts
+* import { Remote } from '@thomasfosterau/effect-sveltekit';
+* import { messages } from './chat.remote';
+* import { useStream } from '@thomasfosterau/effect-svelte';
+*
+* const feed = useStream(Remote.liveQueryStream(messages()));
+* ```
+*/
+function liveQueryStream(query) {
+	return Stream.fromAsyncIterable(query, (error) => error);
+}
+//#endregion
+export { Remote_exports };
+
+//# sourceMappingURL=Remote.js.map

package/dist/Remote.js.map

@@ -0,0 +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 \"@sveltejs/kit\";\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\nexport function callQuery<Output>(\n  query: RemoteQueryFunction<void, Output>,\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>;\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\nexport function callCommand<Output>(\n  command: RemoteCommand<void, Output>,\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>;\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 */\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\nexport function callPrerender<Output>(\n  prerender: RemotePrerenderFunction<void, Output>,\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>;\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\nexport function submitForm(\n  submit: () => PromiseLike<unknown>,\n): Effect.Effect<void, unknown, never> {\n  return Effect.asVoid(fromRemotePromise(() => submit()));\n}\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;AASA,SAAgB,UACd,OACA,OACuC;CACvC,IAAI,UAAU,WAAW,GACvB,OAAO,wBACJ,MAAuD,KAAA,CAAS,CACnE;CAGF,OAAO,wBAAwB,MAAM,KAAc,CAAC;AACtD;AASA,SAAgB,YACd,SACA,OACuC;CACvC,IAAI,UAAU,WAAW,GACvB,OAAO,wBAAyB,QAAmD,KAAA,CAAS,CAAC;CAG/F,OAAO,wBAAwB,QAAQ,KAAc,CAAC;AACxD;;;;;;;;;AAUA,SAAgB,uBACd,SACA,OACA,GAAG,SACoC;CACvC,OAAO,wBAAwB,QAAQ,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;AACnE;AASA,SAAgB,cACd,WACA,OACuC;CACvC,IAAI,UAAU,WAAW,GACvB,OAAO,wBACJ,UAA+D,KAAA,CAAS,CAC3E;CAGF,OAAO,wBAAwB,UAAU,KAAc,CAAC;AAC1D;AAWA,SAAgB,WACd,QACqC;CACrC,OAAO,OAAO,OAAO,wBAAwB,OAAO,CAAC,CAAC;AACxD;AAEA,SAAgB,sBACd,QACA,GAAG,SACkC;CACrC,OAAO,OAAO,OAAO,wBAAwB,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC;AAC5E;;;;;;;;;;;;;;;;;AAkBA,SAAgB,gBACd,OACgC;CAChC,OAAO,OAAO,kBAAkB,QAAQ,UAAU,KAAK;AACzD"}

package/dist/State.d.ts

@@ -0,0 +1,17 @@
+import { PageSnapshot } from "./internal/app-state.js";
+import { Stream } from "effect";
+import { Page } from "@sveltejs/kit";
+
+//#region src/State.d.ts
+declare namespace State_d_exports {
+  export { PageSnapshot, page };
+}
+/**
+ * A `Stream` of the current SvelteKit `page`, emitting a shallow snapshot
+ * immediately and again after every navigation. Call during component
+ * initialization.
+ */
+declare function page(): Stream.Stream<PageSnapshot<Page>>;
+//#endregion
+export { State_d_exports };
+//# sourceMappingURL=State.d.ts.map