@thomasfosterau/effect-svelte 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,58 @@
+# @thomasfosterau/effect-svelte
+
+Effect v4-native integration for **Svelte 5 runes**. Run Effects from
+components and bridge Effect's reactive primitives to runes — results are
+exposed as Effect's native
+[`AsyncResult`](https://effect.website) (`effect/unstable/reactivity/AsyncResult`)
+with stale-while-revalidate `waiting` semantics.
+
+Part of the [`effect-svelte`](https://github.com/thomasfosterau/effect-svelte)
+monorepo. For the SvelteKit integration, see
+[`@thomasfosterau/effect-sveltekit`](https://www.npmjs.com/package/@thomasfosterau/effect-sveltekit).
+
+## Installation
+
+```bash
+npm install @thomasfosterau/effect-svelte effect@beta svelte
+```
+
+## Usage
+
+```svelte
+<script lang="ts">
+  import { provideRuntime, useDerived, AsyncResult } from "@thomasfosterau/effect-svelte";
+  import { Effect } from "effect";
+
+  provideRuntime();
+
+  let userId = $state(1);
+  const user = useDerived(() => fetchUser(userId));
+</script>
+
+<button onclick={() => userId++}>Next</button>
+
+{#if AsyncResult.isSuccess(user.current)}
+  <!-- `waiting` stays true while re-fetching, so the previous value is kept -->
+  <p class:stale={user.current.waiting}>{user.current.value.name}</p>
+{/if}
+```
+
+## What's included
+
+- **Runtime context** — `provideRuntime` / `getRuntime`, `SvelteRuntime`, and
+  component-lifecycle scopes (`useScope` / `useScopeCallback`).
+- **Reactive hooks** (all expose a `.current` `AsyncResult`): `useEffect`,
+  `useQuery`, `useDerived`, `useStream`, `useSubscriptionRef`, `usePubSub`, and
+  the keyed-reactivity hooks `reactiveQuery` / `reactiveStream` /
+  `reactiveMutation` / `useInvalidateKeys`.
+- **Store interop** — the `Store` namespace (`Store.toStream` for
+  Svelte → Effect; `Store.fromStream` / `fromSubscriptionRef` / `fromPubSub` /
+  `fromQueue` / `fromRef` for Effect → Svelte stores), plus `SignalEmitter`.
+- The native `AsyncResult` namespace is re-exported from the package root.
+
+See the [monorepo README](https://github.com/thomasfosterau/effect-svelte#readme)
+for the full API and runnable examples.
+
+## License
+
+MIT

package/dist/Store.d.ts

@@ -0,0 +1,154 @@
+import { RuntimeLike } from "./internal/run.js";
+import { PubSub, Queue, Ref, Stream, SubscriptionRef } from "effect";
+import { Readable } from "svelte/store";
+
+//#region src/Store.d.ts
+declare namespace Store_d_exports {
+  export { fromPubSub, fromQueue, fromRef, fromStream, fromSubscriptionRef, toStream };
+}
+/**
+ * Converts a Svelte [store](https://svelte.dev/docs/svelte/stores) (anything
+ * implementing the readable store contract) into an Effect `Stream` that emits
+ * the store's current value and every subsequent update.
+ *
+ * This is the Svelte→Effect counterpart to the `from*` helpers in this module
+ * (which go Effect→Svelte): it lets store-based state — including third-party
+ * libraries that expose Svelte stores — feed Effect pipelines. The subscription
+ * is opened when the stream is run and closed when its scope closes.
+ *
+ * @example
+ * ```ts
+ * import { Store } from '@thomasfosterau/effect-svelte';
+ * import { Stream } from 'effect';
+ *
+ * // `query` is a Svelte store from some library
+ * const debounced = Store.toStream(query).pipe(
+ *   Stream.debounce('300 millis'),
+ * );
+ * ```
+ */
+declare function toStream<A>(store: Readable<A>): Stream.Stream<A>;
+/**
+ * Converts an Effect `Stream` into a Svelte
+ * [readable store](https://svelte.dev/docs/svelte/stores), tracking the latest
+ * emitted value. The given `initial` value is used until the stream emits.
+ *
+ * This is the base Effect→Svelte helper that the other `from*` functions build
+ * on. Unlike the `useX` hooks, it takes an explicit `runtime` rather than
+ * reading the Svelte context, so it can be called outside component
+ * initialization (e.g. in module scope or a load function) and is
+ * straightforward to test.
+ *
+ * The Effect fiber driving the store is forked lazily on the first subscription
+ * and interrupted when the last subscriber unsubscribes, mirroring Svelte's
+ * start/stop notifier semantics.
+ *
+ * @example
+ * ```ts
+ * import { Store } from '@thomasfosterau/effect-svelte';
+ * import { Stream } from 'effect';
+ *
+ * const ticks = Store.fromStream(
+ *   Stream.tick('1 second').pipe(Stream.scan(0, (n) => n + 1)),
+ *   0,
+ *   runtime,
+ * );
+ * ```
+ */
+declare function fromStream<A, E>(stream: Stream.Stream<A, E, never>, initial: A, runtime: RuntimeLike<never>): Readable<A>;
+/**
+ * Converts an Effect `SubscriptionRef` into a Svelte
+ * [readable store](https://svelte.dev/docs/svelte/stores), so Effect-managed
+ * reactive state can be consumed anywhere a store is expected (including the
+ * `$store` auto-subscription syntax in components, and store-based libraries).
+ *
+ * This is the Effect→Svelte counterpart to {@link toStream}. Like
+ * {@link fromStream}, it takes an explicit `runtime` rather than reading the
+ * Svelte context, so it can be called outside component initialization.
+ *
+ * The fiber driving the store is forked lazily on the first subscription and
+ * interrupted when the last subscriber unsubscribes. Because
+ * `SubscriptionRef.changes` re-emits the current value on subscribe,
+ * subscribers receive the up-to-date value immediately; the ref's current value
+ * is also used as the store's initial value for reads that occur before the
+ * fiber has emitted.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { Store, getRuntime } from '@thomasfosterau/effect-svelte';
+ *
+ *   // Assume counterRef is a SubscriptionRef<number>
+ *   const count = Store.fromSubscriptionRef(counterRef, getRuntime());
+ * </script>
+ *
+ * <p>Count: {$count}</p>
+ * ```
+ */
+declare function fromSubscriptionRef<A>(ref: SubscriptionRef.SubscriptionRef<A>, runtime: RuntimeLike<never>): Readable<A>;
+/**
+ * Converts an Effect `PubSub` into a Svelte
+ * [readable store](https://svelte.dev/docs/svelte/stores) that tracks the most
+ * recently published message. The given `initial` value is used until the
+ * first message is published.
+ *
+ * A `PubSub` has no notion of a "current" value, so an explicit `initial` is
+ * required; only messages published while the store has at least one subscriber
+ * are observed. Built on {@link fromStream} via `Stream.fromPubSub`.
+ *
+ * @example
+ * ```ts
+ * import { Store } from '@thomasfosterau/effect-svelte';
+ *
+ * // Assume eventsPubSub is a PubSub<Event>
+ * const latestEvent = Store.fromPubSub(eventsPubSub, null, runtime);
+ * ```
+ */
+declare function fromPubSub<A>(pubsub: PubSub.PubSub<A>, initial: A, runtime: RuntimeLike<never>): Readable<A>;
+/**
+ * Converts an Effect `Queue` (its consumer/`Dequeue` side) into a Svelte
+ * [readable store](https://svelte.dev/docs/svelte/stores) that tracks the most
+ * recently taken value. The given `initial` value is used until the first value
+ * is taken.
+ *
+ * A queue has no notion of a "current" value, so an explicit `initial` is
+ * required. Built on {@link fromStream} via `Stream.fromQueue`, which takes from
+ * the queue while the store has at least one subscriber and ends the stream
+ * when the queue completes (`Cause.Done` is treated as end-of-stream and is
+ * therefore excluded from the store's error channel).
+ *
+ * @example
+ * ```ts
+ * import { Store } from '@thomasfosterau/effect-svelte';
+ *
+ * // Assume workQueue is a Queue<Job>
+ * const currentJob = Store.fromQueue(workQueue, null, runtime);
+ * ```
+ */
+declare function fromQueue<A, E>(queue: Queue.Dequeue<A, E>, initial: A, runtime: RuntimeLike<never>): Readable<A>;
+/**
+ * Reads the current value of an Effect `Ref` and exposes it as a Svelte
+ * [readable store](https://svelte.dev/docs/svelte/stores).
+ *
+ * **Caveat — this is a static snapshot.** A plain `Ref` has no change
+ * notifications, so the returned store reads the ref's value synchronously when
+ * a subscriber first subscribes and never updates afterwards: later mutations
+ * to the ref are *not* tracked. Two subscribers that subscribe at different
+ * times may therefore observe different snapshots, and a single subscriber will
+ * never see a value change.
+ *
+ * For a ref whose changes should be reflected reactively, use a
+ * `SubscriptionRef` with {@link fromSubscriptionRef} instead.
+ *
+ * @example
+ * ```ts
+ * import { Store } from '@thomasfosterau/effect-svelte';
+ *
+ * // Assume configRef is a Ref<Config> — snapshot only, not reactive.
+ * const config = Store.fromRef(configRef, runtime);
+ * ```
+ */
+declare function fromRef<A>(ref: Ref.Ref<A>, runtime: RuntimeLike<never>): Readable<A>;
+//#endregion
+export { Store_d_exports };
+//# sourceMappingURL=Store.d.ts.map

package/dist/Store.js

@@ -0,0 +1,183 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { interruptFiber, runFork } from "./internal/run.js";
+import { Effect, Queue, Ref, Stream, SubscriptionRef } from "effect";
+import { readable } from "svelte/store";
+//#region src/Store.ts
+var Store_exports = /* @__PURE__ */ __exportAll({
+	fromPubSub: () => fromPubSub,
+	fromQueue: () => fromQueue,
+	fromRef: () => fromRef,
+	fromStream: () => fromStream,
+	fromSubscriptionRef: () => fromSubscriptionRef,
+	toStream: () => toStream
+});
+/**
+* Converts a Svelte [store](https://svelte.dev/docs/svelte/stores) (anything
+* implementing the readable store contract) into an Effect `Stream` that emits
+* the store's current value and every subsequent update.
+*
+* This is the Svelte→Effect counterpart to the `from*` helpers in this module
+* (which go Effect→Svelte): it lets store-based state — including third-party
+* libraries that expose Svelte stores — feed Effect pipelines. The subscription
+* is opened when the stream is run and closed when its scope closes.
+*
+* @example
+* ```ts
+* import { Store } from '@thomasfosterau/effect-svelte';
+* import { Stream } from 'effect';
+*
+* // `query` is a Svelte store from some library
+* const debounced = Store.toStream(query).pipe(
+*   Stream.debounce('300 millis'),
+* );
+* ```
+*/
+function toStream(store) {
+	return Stream.callback((queue) => {
+		const unsubscribe = store.subscribe((value) => {
+			Queue.offerUnsafe(queue, value);
+		});
+		return Effect.sync(() => unsubscribe());
+	});
+}
+/**
+* Converts an Effect `Stream` into a Svelte
+* [readable store](https://svelte.dev/docs/svelte/stores), tracking the latest
+* emitted value. The given `initial` value is used until the stream emits.
+*
+* This is the base Effect→Svelte helper that the other `from*` functions build
+* on. Unlike the `useX` hooks, it takes an explicit `runtime` rather than
+* reading the Svelte context, so it can be called outside component
+* initialization (e.g. in module scope or a load function) and is
+* straightforward to test.
+*
+* The Effect fiber driving the store is forked lazily on the first subscription
+* and interrupted when the last subscriber unsubscribes, mirroring Svelte's
+* start/stop notifier semantics.
+*
+* @example
+* ```ts
+* import { Store } from '@thomasfosterau/effect-svelte';
+* import { Stream } from 'effect';
+*
+* const ticks = Store.fromStream(
+*   Stream.tick('1 second').pipe(Stream.scan(0, (n) => n + 1)),
+*   0,
+*   runtime,
+* );
+* ```
+*/
+function fromStream(stream, initial, runtime) {
+	return readable(initial, (set) => {
+		const fiber = runFork(runtime)(Stream.runForEach(stream, (value) => Effect.sync(() => set(value))));
+		return () => interruptFiber(fiber);
+	});
+}
+/**
+* Converts an Effect `SubscriptionRef` into a Svelte
+* [readable store](https://svelte.dev/docs/svelte/stores), so Effect-managed
+* reactive state can be consumed anywhere a store is expected (including the
+* `$store` auto-subscription syntax in components, and store-based libraries).
+*
+* This is the Effect→Svelte counterpart to {@link toStream}. Like
+* {@link fromStream}, it takes an explicit `runtime` rather than reading the
+* Svelte context, so it can be called outside component initialization.
+*
+* The fiber driving the store is forked lazily on the first subscription and
+* interrupted when the last subscriber unsubscribes. Because
+* `SubscriptionRef.changes` re-emits the current value on subscribe,
+* subscribers receive the up-to-date value immediately; the ref's current value
+* is also used as the store's initial value for reads that occur before the
+* fiber has emitted.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { Store, getRuntime } from '@thomasfosterau/effect-svelte';
+*
+*   // Assume counterRef is a SubscriptionRef<number>
+*   const count = Store.fromSubscriptionRef(counterRef, getRuntime());
+* <\/script>
+*
+* <p>Count: {$count}</p>
+* ```
+*/
+function fromSubscriptionRef(ref, runtime) {
+	const initial = SubscriptionRef.getUnsafe(ref);
+	return fromStream(SubscriptionRef.changes(ref), initial, runtime);
+}
+/**
+* Converts an Effect `PubSub` into a Svelte
+* [readable store](https://svelte.dev/docs/svelte/stores) that tracks the most
+* recently published message. The given `initial` value is used until the
+* first message is published.
+*
+* A `PubSub` has no notion of a "current" value, so an explicit `initial` is
+* required; only messages published while the store has at least one subscriber
+* are observed. Built on {@link fromStream} via `Stream.fromPubSub`.
+*
+* @example
+* ```ts
+* import { Store } from '@thomasfosterau/effect-svelte';
+*
+* // Assume eventsPubSub is a PubSub<Event>
+* const latestEvent = Store.fromPubSub(eventsPubSub, null, runtime);
+* ```
+*/
+function fromPubSub(pubsub, initial, runtime) {
+	return fromStream(Stream.fromPubSub(pubsub), initial, runtime);
+}
+/**
+* Converts an Effect `Queue` (its consumer/`Dequeue` side) into a Svelte
+* [readable store](https://svelte.dev/docs/svelte/stores) that tracks the most
+* recently taken value. The given `initial` value is used until the first value
+* is taken.
+*
+* A queue has no notion of a "current" value, so an explicit `initial` is
+* required. Built on {@link fromStream} via `Stream.fromQueue`, which takes from
+* the queue while the store has at least one subscriber and ends the stream
+* when the queue completes (`Cause.Done` is treated as end-of-stream and is
+* therefore excluded from the store's error channel).
+*
+* @example
+* ```ts
+* import { Store } from '@thomasfosterau/effect-svelte';
+*
+* // Assume workQueue is a Queue<Job>
+* const currentJob = Store.fromQueue(workQueue, null, runtime);
+* ```
+*/
+function fromQueue(queue, initial, runtime) {
+	return fromStream(Stream.fromQueue(queue), initial, runtime);
+}
+/**
+* Reads the current value of an Effect `Ref` and exposes it as a Svelte
+* [readable store](https://svelte.dev/docs/svelte/stores).
+*
+* **Caveat — this is a static snapshot.** A plain `Ref` has no change
+* notifications, so the returned store reads the ref's value synchronously when
+* a subscriber first subscribes and never updates afterwards: later mutations
+* to the ref are *not* tracked. Two subscribers that subscribe at different
+* times may therefore observe different snapshots, and a single subscriber will
+* never see a value change.
+*
+* For a ref whose changes should be reflected reactively, use a
+* `SubscriptionRef` with {@link fromSubscriptionRef} instead.
+*
+* @example
+* ```ts
+* import { Store } from '@thomasfosterau/effect-svelte';
+*
+* // Assume configRef is a Ref<Config> — snapshot only, not reactive.
+* const config = Store.fromRef(configRef, runtime);
+* ```
+*/
+function fromRef(ref, runtime) {
+	return readable(Ref.getUnsafe(ref), (set) => {
+		set(Ref.getUnsafe(ref));
+	});
+}
+//#endregion
+export { Store_exports };
+
+//# sourceMappingURL=Store.js.map

package/dist/Store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Store.js","names":[],"sources":["../src/Store.ts"],"sourcesContent":["import { Effect, type PubSub, Queue, Ref, Stream, SubscriptionRef } from \"effect\";\nimport { type Readable, readable } from \"svelte/store\";\nimport { interruptFiber, runFork, type RuntimeLike } from \"./internal/run.js\";\n\n/**\n * Converts a Svelte [store](https://svelte.dev/docs/svelte/stores) (anything\n * implementing the readable store contract) into an Effect `Stream` that emits\n * the store's current value and every subsequent update.\n *\n * This is the Svelte→Effect counterpart to the `from*` helpers in this module\n * (which go Effect→Svelte): it lets store-based state — including third-party\n * libraries that expose Svelte stores — feed Effect pipelines. The subscription\n * is opened when the stream is run and closed when its scope closes.\n *\n * @example\n * ```ts\n * import { Store } from '@thomasfosterau/effect-svelte';\n * import { Stream } from 'effect';\n *\n * // `query` is a Svelte store from some library\n * const debounced = Store.toStream(query).pipe(\n *   Stream.debounce('300 millis'),\n * );\n * ```\n */\nexport function toStream<A>(store: Readable<A>): Stream.Stream<A> {\n  return Stream.callback<A>((queue) => {\n    const unsubscribe = store.subscribe((value) => {\n      Queue.offerUnsafe(queue, value);\n    });\n    return Effect.sync(() => unsubscribe());\n  });\n}\n\n/**\n * Converts an Effect `Stream` into a Svelte\n * [readable store](https://svelte.dev/docs/svelte/stores), tracking the latest\n * emitted value. The given `initial` value is used until the stream emits.\n *\n * This is the base Effect→Svelte helper that the other `from*` functions build\n * on. Unlike the `useX` hooks, it takes an explicit `runtime` rather than\n * reading the Svelte context, so it can be called outside component\n * initialization (e.g. in module scope or a load function) and is\n * straightforward to test.\n *\n * The Effect fiber driving the store is forked lazily on the first subscription\n * and interrupted when the last subscriber unsubscribes, mirroring Svelte's\n * start/stop notifier semantics.\n *\n * @example\n * ```ts\n * import { Store } from '@thomasfosterau/effect-svelte';\n * import { Stream } from 'effect';\n *\n * const ticks = Store.fromStream(\n *   Stream.tick('1 second').pipe(Stream.scan(0, (n) => n + 1)),\n *   0,\n *   runtime,\n * );\n * ```\n */\nexport function fromStream<A, E>(\n  stream: Stream.Stream<A, E, never>,\n  initial: A,\n  runtime: RuntimeLike<never>,\n): Readable<A> {\n  return readable<A>(initial, (set) => {\n    const fiber = runFork(runtime)(\n      Stream.runForEach(stream, (value) => Effect.sync(() => set(value))),\n    );\n    return () => interruptFiber(fiber);\n  });\n}\n\n/**\n * Converts an Effect `SubscriptionRef` into a Svelte\n * [readable store](https://svelte.dev/docs/svelte/stores), so Effect-managed\n * reactive state can be consumed anywhere a store is expected (including the\n * `$store` auto-subscription syntax in components, and store-based libraries).\n *\n * This is the Effect→Svelte counterpart to {@link toStream}. Like\n * {@link fromStream}, it takes an explicit `runtime` rather than reading the\n * Svelte context, so it can be called outside component initialization.\n *\n * The fiber driving the store is forked lazily on the first subscription and\n * interrupted when the last subscriber unsubscribes. Because\n * `SubscriptionRef.changes` re-emits the current value on subscribe,\n * subscribers receive the up-to-date value immediately; the ref's current value\n * is also used as the store's initial value for reads that occur before the\n * fiber has emitted.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { Store, getRuntime } from '@thomasfosterau/effect-svelte';\n *\n *   // Assume counterRef is a SubscriptionRef<number>\n *   const count = Store.fromSubscriptionRef(counterRef, getRuntime());\n * </script>\n *\n * <p>Count: {$count}</p>\n * ```\n */\nexport function fromSubscriptionRef<A>(\n  ref: SubscriptionRef.SubscriptionRef<A>,\n  runtime: RuntimeLike<never>,\n): Readable<A> {\n  // Read the current value synchronously so the store has a sensible initial\n  // value before the fiber starts. `SubscriptionRef.changes` re-emits the\n  // current value on subscribe, so no update is missed.\n  const initial = SubscriptionRef.getUnsafe(ref);\n  return fromStream(SubscriptionRef.changes(ref), initial, runtime);\n}\n\n/**\n * Converts an Effect `PubSub` into a Svelte\n * [readable store](https://svelte.dev/docs/svelte/stores) that tracks the most\n * recently published message. The given `initial` value is used until the\n * first message is published.\n *\n * A `PubSub` has no notion of a \"current\" value, so an explicit `initial` is\n * required; only messages published while the store has at least one subscriber\n * are observed. Built on {@link fromStream} via `Stream.fromPubSub`.\n *\n * @example\n * ```ts\n * import { Store } from '@thomasfosterau/effect-svelte';\n *\n * // Assume eventsPubSub is a PubSub<Event>\n * const latestEvent = Store.fromPubSub(eventsPubSub, null, runtime);\n * ```\n */\nexport function fromPubSub<A>(\n  pubsub: PubSub.PubSub<A>,\n  initial: A,\n  runtime: RuntimeLike<never>,\n): Readable<A> {\n  return fromStream(Stream.fromPubSub(pubsub), initial, runtime);\n}\n\n/**\n * Converts an Effect `Queue` (its consumer/`Dequeue` side) into a Svelte\n * [readable store](https://svelte.dev/docs/svelte/stores) that tracks the most\n * recently taken value. The given `initial` value is used until the first value\n * is taken.\n *\n * A queue has no notion of a \"current\" value, so an explicit `initial` is\n * required. Built on {@link fromStream} via `Stream.fromQueue`, which takes from\n * the queue while the store has at least one subscriber and ends the stream\n * when the queue completes (`Cause.Done` is treated as end-of-stream and is\n * therefore excluded from the store's error channel).\n *\n * @example\n * ```ts\n * import { Store } from '@thomasfosterau/effect-svelte';\n *\n * // Assume workQueue is a Queue<Job>\n * const currentJob = Store.fromQueue(workQueue, null, runtime);\n * ```\n */\nexport function fromQueue<A, E>(\n  queue: Queue.Dequeue<A, E>,\n  initial: A,\n  runtime: RuntimeLike<never>,\n): Readable<A> {\n  return fromStream(Stream.fromQueue(queue), initial, runtime);\n}\n\n/**\n * Reads the current value of an Effect `Ref` and exposes it as a Svelte\n * [readable store](https://svelte.dev/docs/svelte/stores).\n *\n * **Caveat — this is a static snapshot.** A plain `Ref` has no change\n * notifications, so the returned store reads the ref's value synchronously when\n * a subscriber first subscribes and never updates afterwards: later mutations\n * to the ref are *not* tracked. Two subscribers that subscribe at different\n * times may therefore observe different snapshots, and a single subscriber will\n * never see a value change.\n *\n * For a ref whose changes should be reflected reactively, use a\n * `SubscriptionRef` with {@link fromSubscriptionRef} instead.\n *\n * @example\n * ```ts\n * import { Store } from '@thomasfosterau/effect-svelte';\n *\n * // Assume configRef is a Ref<Config> — snapshot only, not reactive.\n * const config = Store.fromRef(configRef, runtime);\n * ```\n */\nexport function fromRef<A>(ref: Ref.Ref<A>, runtime: RuntimeLike<never>): Readable<A> {\n  // A plain Ref offers no change feed, so we snapshot the value and never emit\n  // again. `Ref.getUnsafe` reads synchronously without a fiber, so both the\n  // `readable` initial value and the value re-read on subscribe come straight\n  // from the ref; the `runtime` is accepted only for API symmetry with the\n  // other `from*` helpers.\n  void runtime;\n  return readable<A>(Ref.getUnsafe(ref), (set) => {\n    set(Ref.getUnsafe(ref));\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,SAAY,OAAsC;CAChE,OAAO,OAAO,UAAa,UAAU;EACnC,MAAM,cAAc,MAAM,WAAW,UAAU;GAC7C,MAAM,YAAY,OAAO,KAAK;EAChC,CAAC;EACD,OAAO,OAAO,WAAW,YAAY,CAAC;CACxC,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,WACd,QACA,SACA,SACa;CACb,OAAO,SAAY,UAAU,QAAQ;EACnC,MAAM,QAAQ,QAAQ,OAAO,EAC3B,OAAO,WAAW,SAAS,UAAU,OAAO,WAAW,IAAI,KAAK,CAAC,CAAC,CACpE;EACA,aAAa,eAAe,KAAK;CACnC,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,oBACd,KACA,SACa;CAIb,MAAM,UAAU,gBAAgB,UAAU,GAAG;CAC7C,OAAO,WAAW,gBAAgB,QAAQ,GAAG,GAAG,SAAS,OAAO;AAClE;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,WACd,QACA,SACA,SACa;CACb,OAAO,WAAW,OAAO,WAAW,MAAM,GAAG,SAAS,OAAO;AAC/D;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,UACd,OACA,SACA,SACa;CACb,OAAO,WAAW,OAAO,UAAU,KAAK,GAAG,SAAS,OAAO;AAC7D;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,QAAW,KAAiB,SAA0C;CAOpF,OAAO,SAAY,IAAI,UAAU,GAAG,IAAI,QAAQ;EAC9C,IAAI,IAAI,UAAU,GAAG,CAAC;CACxB,CAAC;AACH"}

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/context.svelte.d.ts

@@ -0,0 +1,37 @@
+import { RuntimeLike } from "./internal/run.js";
+
+//#region src/context.svelte.d.ts
+/**
+ * Retrieves the Effect runtime from Svelte context.
+ *
+ * @returns The runtime provided via provideRuntime
+ * @throws Will throw if called outside of a component with a provided runtime
+ */
+declare function getRuntimeContext(): RuntimeLike<never>;
+/**
+ * Provides an Effect runtime to the Svelte context tree.
+ * This should be called at the root of your component tree, typically in your root layout.
+ *
+ * The default runtime (SvelteRuntime.defaultRuntime) is recommended for most applications.
+ * For applications requiring custom services, extend the runtime using SvelteRuntime.extend().
+ *
+ * @param runtime - The Effect runtime to provide. Defaults to SvelteRuntime.defaultRuntime
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { provideRuntime, SvelteRuntime } from '@thomasfosterau/effect-svelte';
+ *
+ *   // Use default runtime
+ *   provideRuntime();
+ *
+ *   // Or provide a custom runtime
+ *   const customRuntime = SvelteRuntime.extend(myCustomLayer);
+ *   provideRuntime(customRuntime);
+ * </script>
+ * ```
+ */
+declare function provideRuntime<R = never>(runtime?: RuntimeLike<R>): void;
+//#endregion
+export { getRuntimeContext, provideRuntime };
+//# sourceMappingURL=context.svelte.d.ts.map

package/dist/context.svelte.js

@@ -0,0 +1,53 @@
+import { defaultSvelteRuntime } from "./runtime.js";
+import { createContext } from "svelte";
+//#region src/context.svelte.ts
+/**
+* Type-safe context for Effect runtime management.
+* Uses Svelte 5's createContext API for better type safety and developer experience.
+*
+* The context accepts either a plain services `Context.Context` (e.g. `Context.empty()`)
+* or a `ManagedRuntime` (e.g. `SvelteRuntime.defaultRuntime` / `SvelteRuntime.extend(...)`).
+* Users must ensure their runtime provides all required services for the effects they run.
+*/
+const [getRuntime, provideRuntimeInternal] = createContext();
+/**
+* Retrieves the Effect runtime from Svelte context.
+*
+* @returns The runtime provided via provideRuntime
+* @throws Will throw if called outside of a component with a provided runtime
+*/
+function getRuntimeContext() {
+	const runtime = getRuntime();
+	if (runtime === void 0) throw new Error("effect-svelte: No Effect runtime found in context. Make sure you have called provideRuntime() in a parent component.");
+	return runtime;
+}
+/**
+* Provides an Effect runtime to the Svelte context tree.
+* This should be called at the root of your component tree, typically in your root layout.
+*
+* The default runtime (SvelteRuntime.defaultRuntime) is recommended for most applications.
+* For applications requiring custom services, extend the runtime using SvelteRuntime.extend().
+*
+* @param runtime - The Effect runtime to provide. Defaults to SvelteRuntime.defaultRuntime
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { provideRuntime, SvelteRuntime } from '@thomasfosterau/effect-svelte';
+*
+*   // Use default runtime
+*   provideRuntime();
+*
+*   // Or provide a custom runtime
+*   const customRuntime = SvelteRuntime.extend(myCustomLayer);
+*   provideRuntime(customRuntime);
+* <\/script>
+* ```
+*/
+function provideRuntime(runtime = defaultSvelteRuntime) {
+	provideRuntimeInternal(runtime);
+}
+//#endregion
+export { getRuntimeContext, provideRuntime };
+
+//# sourceMappingURL=context.svelte.js.map

package/dist/context.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.svelte.js","names":[],"sources":["../src/context.svelte.ts"],"sourcesContent":["import { createContext } from \"svelte\";\nimport { defaultSvelteRuntime } from \"./runtime.js\";\nimport type { RuntimeLike } from \"./internal/run.js\";\n\n/**\n * Type-safe context for Effect runtime management.\n * Uses Svelte 5's createContext API for better type safety and developer experience.\n *\n * The context accepts either a plain services `Context.Context` (e.g. `Context.empty()`)\n * or a `ManagedRuntime` (e.g. `SvelteRuntime.defaultRuntime` / `SvelteRuntime.extend(...)`).\n * Users must ensure their runtime provides all required services for the effects they run.\n */\nconst [getRuntime, provideRuntimeInternal] = createContext<RuntimeLike<never>>();\n\n/**\n * Retrieves the Effect runtime from Svelte context.\n *\n * @returns The runtime provided via provideRuntime\n * @throws Will throw if called outside of a component with a provided runtime\n */\nfunction getRuntimeContext(): RuntimeLike<never> {\n  const runtime = getRuntime();\n  if (runtime === undefined) {\n    throw new Error(\n      \"effect-svelte: No Effect runtime found in context. \" +\n        \"Make sure you have called provideRuntime() in a parent component.\",\n    );\n  }\n  return runtime;\n}\n\n/**\n * Provides an Effect runtime to the Svelte context tree.\n * This should be called at the root of your component tree, typically in your root layout.\n *\n * The default runtime (SvelteRuntime.defaultRuntime) is recommended for most applications.\n * For applications requiring custom services, extend the runtime using SvelteRuntime.extend().\n *\n * @param runtime - The Effect runtime to provide. Defaults to SvelteRuntime.defaultRuntime\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { provideRuntime, SvelteRuntime } from '@thomasfosterau/effect-svelte';\n *\n *   // Use default runtime\n *   provideRuntime();\n *\n *   // Or provide a custom runtime\n *   const customRuntime = SvelteRuntime.extend(myCustomLayer);\n *   provideRuntime(customRuntime);\n * </script>\n * ```\n */\nfunction provideRuntime<R = never>(\n  runtime: RuntimeLike<R> = defaultSvelteRuntime as RuntimeLike<R>,\n): void {\n  provideRuntimeInternal(runtime as RuntimeLike<never>);\n}\n\nexport { getRuntimeContext as getRuntime, provideRuntime };\nexport type { RuntimeLike };\n"],"mappings":";;;;;;;;;;;AAYA,MAAM,CAAC,YAAY,0BAA0B,cAAkC;;;;;;;AAQ/E,SAAS,oBAAwC;CAC/C,MAAM,UAAU,WAAW;CAC3B,IAAI,YAAY,KAAA,GACd,MAAM,IAAI,MACR,sHAEF;CAEF,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAS,eACP,UAA0B,sBACpB;CACN,uBAAuB,OAA6B;AACtD"}

package/dist/derived.svelte.d.ts

@@ -0,0 +1,43 @@
+import { Effect } from "effect";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+
+//#region src/derived.svelte.d.ts
+interface DerivedReturn<A, E> {
+  /**
+   * The current result. While re-running after a dependency change, the
+   * previous value is kept as a waiting `Success` (stale-while-revalidate).
+   */
+  readonly current: AsyncResult.AsyncResult<A, E>;
+}
+/**
+ * Re-run an effect whenever reactive dependencies change.
+ * The function parameter is called inside $effect, so it automatically tracks dependencies.
+ * When dependencies change, the previous fiber is interrupted and a new one starts.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useDerived, AsyncResult } from '@thomasfosterau/effect-svelte';
+ *   import { Effect } from 'effect';
+ *
+ *   let userId = $state(1);
+ *
+ *   const user = useDerived(() =>
+ *     Effect.gen(function* () {
+ *       const response = yield* fetchUser(userId);
+ *       return response;
+ *     })
+ *   );
+ * </script>
+ *
+ * <button onclick={() => userId++}>Next User</button>
+ *
+ * {#if AsyncResult.isSuccess(user.current)}
+ *   <p>User: {user.current.value.name}</p>
+ * {/if}
+ * ```
+ */
+declare function useDerived<A, E, R>(fn: () => Effect.Effect<A, E, R>): DerivedReturn<A, E>;
+//#endregion
+export { DerivedReturn, useDerived };
+//# sourceMappingURL=derived.svelte.d.ts.map

package/dist/derived.svelte.js

@@ -0,0 +1,65 @@
+import { getRuntimeContext } from "./context.svelte.js";
+import { interruptFiber, runFork } from "./internal/run.js";
+import { makeResult } from "./internal/result.svelte.js";
+import { Effect, Fiber } from "effect";
+//#region src/derived.svelte.ts
+/**
+* Re-run an effect whenever reactive dependencies change.
+* The function parameter is called inside $effect, so it automatically tracks dependencies.
+* When dependencies change, the previous fiber is interrupted and a new one starts.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { useDerived, AsyncResult } from '@thomasfosterau/effect-svelte';
+*   import { Effect } from 'effect';
+*
+*   let userId = $state(1);
+*
+*   const user = useDerived(() =>
+*     Effect.gen(function* () {
+*       const response = yield* fetchUser(userId);
+*       return response;
+*     })
+*   );
+* <\/script>
+*
+* <button onclick={() => userId++}>Next User</button>
+*
+* {#if AsyncResult.isSuccess(user.current)}
+*   <p>User: {user.current.value.name}</p>
+* {/if}
+* ```
+*/
+function useDerived(fn) {
+	const runtime = getRuntimeContext();
+	const state = makeResult();
+	let currentFiber = null;
+	$effect(() => {
+		if (currentFiber !== null) interruptFiber(currentFiber);
+		const effect = fn();
+		state.startWaiting();
+		const runningFiber = runFork(runtime)(effect);
+		currentFiber = runningFiber;
+		runFork(runtime)(Effect.gen(function* () {
+			const exit = yield* Fiber.await(runningFiber);
+			if (currentFiber === runningFiber) {
+				state.settle(exit);
+				currentFiber = null;
+			}
+		}));
+		return () => {
+			if (currentFiber !== null) {
+				interruptFiber(currentFiber);
+				currentFiber = null;
+			}
+		};
+	});
+	return { get current() {
+		return state.current;
+	} };
+}
+//#endregion
+export { useDerived };
+
+//# sourceMappingURL=derived.svelte.js.map

package/dist/derived.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derived.svelte.js","names":["getRuntime"],"sources":["../src/derived.svelte.ts"],"sourcesContent":["import { Effect, Fiber } from \"effect\";\nimport type * as AsyncResult from \"effect/unstable/reactivity/AsyncResult\";\nimport { getRuntime } from \"./context.svelte.js\";\nimport { interruptFiber, runFork, type RuntimeLike } from \"./internal/run.js\";\nimport { makeResult } from \"./internal/result.svelte.js\";\n\nexport interface DerivedReturn<A, E> {\n  /**\n   * The current result. While re-running after a dependency change, the\n   * previous value is kept as a waiting `Success` (stale-while-revalidate).\n   */\n  readonly current: AsyncResult.AsyncResult<A, E>;\n}\n\n/**\n * Re-run an effect whenever reactive dependencies change.\n * The function parameter is called inside $effect, so it automatically tracks dependencies.\n * When dependencies change, the previous fiber is interrupted and a new one starts.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useDerived, AsyncResult } from '@thomasfosterau/effect-svelte';\n *   import { Effect } from 'effect';\n *\n *   let userId = $state(1);\n *\n *   const user = useDerived(() =>\n *     Effect.gen(function* () {\n *       const response = yield* fetchUser(userId);\n *       return response;\n *     })\n *   );\n * </script>\n *\n * <button onclick={() => userId++}>Next User</button>\n *\n * {#if AsyncResult.isSuccess(user.current)}\n *   <p>User: {user.current.value.name}</p>\n * {/if}\n * ```\n */\nexport function useDerived<A, E, R>(fn: () => Effect.Effect<A, E, R>): DerivedReturn<A, E> {\n  const runtime = getRuntime() as RuntimeLike<R>;\n\n  const state = makeResult<A, E>();\n  let currentFiber: Fiber.Fiber<A, E> | null = null;\n\n  $effect(() => {\n    // Interrupt previous fiber if it exists\n    if (currentFiber !== null) {\n      interruptFiber(currentFiber);\n    }\n\n    // Get the effect (this tracks reactive dependencies)\n    const effect = fn();\n\n    // Mark as waiting, preserving the previous value if there is one.\n    state.startWaiting();\n\n    // Run the effect and capture the fiber reference\n    const runningFiber = runFork(runtime)(effect);\n    currentFiber = runningFiber;\n\n    // Settle the result when the fiber completes, unless deps changed first.\n    runFork(runtime)(\n      Effect.gen(function* () {\n        const exit = yield* Fiber.await(runningFiber);\n        if (currentFiber === runningFiber) {\n          state.settle(exit);\n          currentFiber = null;\n        }\n      }),\n    );\n\n    // Cleanup: interrupt the fiber when dependencies change or component unmounts\n    return () => {\n      if (currentFiber !== null) {\n        interruptFiber(currentFiber);\n        currentFiber = null;\n      }\n    };\n  });\n\n  return {\n    get current() {\n      return state.current;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,WAAoB,IAAuD;CACzF,MAAM,UAAUA,kBAAW;CAE3B,MAAM,QAAQ,WAAiB;CAC/B,IAAI,eAAyC;CAE7C,cAAc;EAEZ,IAAI,iBAAiB,MACnB,eAAe,YAAY;EAI7B,MAAM,SAAS,GAAG;EAGlB,MAAM,aAAa;EAGnB,MAAM,eAAe,QAAQ,OAAO,EAAE,MAAM;EAC5C,eAAe;EAGf,QAAQ,OAAO,EACb,OAAO,IAAI,aAAa;GACtB,MAAM,OAAO,OAAO,MAAM,MAAM,YAAY;GAC5C,IAAI,iBAAiB,cAAc;IACjC,MAAM,OAAO,IAAI;IACjB,eAAe;GACjB;EACF,CAAC,CACH;EAGA,aAAa;GACX,IAAI,iBAAiB,MAAM;IACzB,eAAe,YAAY;IAC3B,eAAe;GACjB;EACF;CACF,CAAC;CAED,OAAO,EACL,IAAI,UAAU;EACZ,OAAO,MAAM;CACf,EACF;AACF"}