@thomasfosterau/effect-svelte 0.0.0

package/dist/reactivity.svelte.d.ts

@@ -0,0 +1,123 @@
+import { Effect } from "effect";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+
+//#region src/reactivity.svelte.d.ts
+interface ReactiveQueryReturn<A, E> {
+  /** The current result, re-derived whenever the keys are invalidated. */
+  readonly current: AsyncResult.AsyncResult<A, E>;
+}
+/**
+ * Creates a reactive query that automatically re-runs when the specified keys are invalidated.
+ *
+ * Note: Make sure your runtime includes `Reactivity.layer` from `effect/unstable/reactivity`.
+ *
+ * @param keys - Reactivity keys that this query depends on
+ * @param effectFn - The Effect to run when keys are invalidated
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { reactiveQuery, AsyncResult } from '@thomasfosterau/effect-svelte';
+ *   import { Effect } from 'effect';
+ *
+ *   // Query that depends on a user ID key
+ *   let userId = $state(1);
+ *
+ *   const user = reactiveQuery(
+ *     () => ['user', userId],
+ *     () => Effect.gen(function* () {
+ *       const data = yield* fetchUser(userId);
+ *       return data;
+ *     })
+ *   );
+ * </script>
+ *
+ * {#if AsyncResult.isSuccess(user.current)}
+ *   <p>User: {user.current.value.name}</p>
+ * {/if}
+ * ```
+ */
+declare function reactiveQuery<A, E, R>(keys: () => ReadonlyArray<unknown>, effectFn: () => Effect.Effect<A, E, R>): ReactiveQueryReturn<A, E>;
+interface ReactiveStreamReturn<A, E> {
+  readonly current: AsyncResult.AsyncResult<ReadonlyArray<A>, E>;
+  readonly values: ReadonlyArray<A>;
+  readonly latest: A | undefined;
+}
+/**
+ * Creates a reactive stream that emits values whenever the specified keys are invalidated.
+ * The effect re-runs automatically when keys change.
+ *
+ * @param keys - Reactivity keys that this stream depends on
+ * @param effect - The Effect to run when keys are invalidated
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { reactiveStream } from '@thomasfosterau/effect-svelte';
+ *   import { Effect } from 'effect';
+ *
+ *   const messages = reactiveStream(
+ *     ['messages'],
+ *     Effect.gen(function* () {
+ *       const data = yield* fetchMessages();
+ *       return data;
+ *     })
+ *   );
+ * </script>
+ *
+ * <ul>
+ *   {#each messages.values as msg}
+ *     <li>{msg}</li>
+ *   {/each}
+ * </ul>
+ * ```
+ */
+declare function reactiveStream<A, E, R>(keys: ReadonlyArray<unknown> | (() => ReadonlyArray<unknown>), effect: Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>)): ReactiveStreamReturn<A, E>;
+interface ReactiveMutationReturn<A, E> {
+  readonly current: AsyncResult.AsyncResult<A, E>;
+  run: () => void;
+}
+/**
+ * Runs a mutation effect and invalidates the specified keys.
+ * This will cause any reactive queries depending on these keys to re-run.
+ *
+ * @param keys - Reactivity keys to invalidate after the mutation
+ * @param effect - The mutation effect to run
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { reactiveMutation } from '@thomasfosterau/effect-svelte';
+ *   import { Effect } from 'effect';
+ *
+ *   const updateUser = reactiveMutation(
+ *     ['user', userId],
+ *     Effect.gen(function* () {
+ *       yield* updateUserInDB(userId, data);
+ *     })
+ *   );
+ * </script>
+ *
+ * <button onclick={() => updateUser.run()}>Update</button>
+ * ```
+ */
+declare function reactiveMutation<A, E, R>(keys: ReadonlyArray<unknown> | (() => ReadonlyArray<unknown>), effect: Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>)): ReactiveMutationReturn<A, E>;
+/**
+ * Returns a function that manually invalidates reactivity keys, causing any
+ * reactive queries depending on those keys to re-run.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useInvalidateKeys } from '@thomasfosterau/effect-svelte';
+ *
+ *   const invalidate = useInvalidateKeys();
+ * </script>
+ *
+ * <button onclick={() => invalidate(['users'])}>Refresh Users</button>
+ * ```
+ */
+declare function useInvalidateKeys(): (keys: ReadonlyArray<unknown>) => void;
+//#endregion
+export { ReactiveMutationReturn, ReactiveQueryReturn, ReactiveStreamReturn, reactiveMutation, reactiveQuery, reactiveStream, useInvalidateKeys };
+//# sourceMappingURL=reactivity.svelte.d.ts.map

package/dist/reactivity.svelte.js

@@ -0,0 +1,186 @@
+import { getRuntimeContext } from "./context.svelte.js";
+import { interruptFiber, runFork, runSync } from "./internal/run.js";
+import { makeResult } from "./internal/result.svelte.js";
+import { streamState } from "./internal/subscribe.js";
+import { Effect, Fiber, Stream } from "effect";
+import { Reactivity } from "effect/unstable/reactivity";
+//#region src/reactivity.svelte.ts
+/**
+* Creates a reactive query that automatically re-runs when the specified keys are invalidated.
+*
+* Note: Make sure your runtime includes `Reactivity.layer` from `effect/unstable/reactivity`.
+*
+* @param keys - Reactivity keys that this query depends on
+* @param effectFn - The Effect to run when keys are invalidated
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { reactiveQuery, AsyncResult } from '@thomasfosterau/effect-svelte';
+*   import { Effect } from 'effect';
+*
+*   // Query that depends on a user ID key
+*   let userId = $state(1);
+*
+*   const user = reactiveQuery(
+*     () => ['user', userId],
+*     () => Effect.gen(function* () {
+*       const data = yield* fetchUser(userId);
+*       return data;
+*     })
+*   );
+* <\/script>
+*
+* {#if AsyncResult.isSuccess(user.current)}
+*   <p>User: {user.current.value.name}</p>
+* {/if}
+* ```
+*/
+function reactiveQuery(keys, effectFn) {
+	const runtime = getRuntimeContext();
+	const state = makeResult();
+	let fiber = null;
+	$effect(() => {
+		const currentKeys = keys();
+		const effect = effectFn();
+		state.startWaiting();
+		const queryEffect = Effect.scoped(Effect.gen(function* () {
+			const queue = yield* Reactivity.query(effect, currentKeys);
+			yield* Stream.runForEach(Stream.fromQueue(queue), (value) => Effect.sync(() => {
+				state.succeed(value);
+			}));
+		})).pipe(Effect.catchCause((cause) => Effect.sync(() => {
+			state.failCause(cause);
+		})));
+		fiber = runFork(runtime)(queryEffect);
+		return () => {
+			if (fiber !== null) {
+				interruptFiber(fiber);
+				fiber = null;
+			}
+		};
+	});
+	return { get current() {
+		return state.current;
+	} };
+}
+/**
+* Creates a reactive stream that emits values whenever the specified keys are invalidated.
+* The effect re-runs automatically when keys change.
+*
+* @param keys - Reactivity keys that this stream depends on
+* @param effect - The Effect to run when keys are invalidated
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { reactiveStream } from '@thomasfosterau/effect-svelte';
+*   import { Effect } from 'effect';
+*
+*   const messages = reactiveStream(
+*     ['messages'],
+*     Effect.gen(function* () {
+*       const data = yield* fetchMessages();
+*       return data;
+*     })
+*   );
+* <\/script>
+*
+* <ul>
+*   {#each messages.values as msg}
+*     <li>{msg}</li>
+*   {/each}
+* </ul>
+* ```
+*/
+function reactiveStream(keys, effect) {
+	return streamState(getRuntimeContext(), () => {
+		const currentKeys = typeof keys === "function" ? keys() : keys;
+		const currentEffect = typeof effect === "function" ? effect() : effect;
+		return Reactivity.stream(currentEffect, currentKeys);
+	});
+}
+/**
+* Runs a mutation effect and invalidates the specified keys.
+* This will cause any reactive queries depending on these keys to re-run.
+*
+* @param keys - Reactivity keys to invalidate after the mutation
+* @param effect - The mutation effect to run
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { reactiveMutation } from '@thomasfosterau/effect-svelte';
+*   import { Effect } from 'effect';
+*
+*   const updateUser = reactiveMutation(
+*     ['user', userId],
+*     Effect.gen(function* () {
+*       yield* updateUserInDB(userId, data);
+*     })
+*   );
+* <\/script>
+*
+* <button onclick={() => updateUser.run()}>Update</button>
+* ```
+*/
+function reactiveMutation(keys, effect) {
+	const runtime = getRuntimeContext();
+	const state = makeResult();
+	let currentFiber = null;
+	const run = () => {
+		if (currentFiber !== null) interruptFiber(currentFiber);
+		const currentKeys = typeof keys === "function" ? keys() : keys;
+		const currentEffect = typeof effect === "function" ? effect() : effect;
+		state.startWaiting();
+		const mutationEffect = Reactivity.mutation(currentEffect, currentKeys);
+		const runningFiber = runFork(runtime)(mutationEffect);
+		currentFiber = runningFiber;
+		runFork(runtime)(Effect.gen(function* () {
+			const exit = yield* Fiber.await(runningFiber);
+			if (currentFiber === runningFiber) {
+				state.settle(exit);
+				currentFiber = null;
+			}
+		}));
+	};
+	$effect(() => {
+		return () => {
+			if (currentFiber !== null) {
+				interruptFiber(currentFiber);
+				currentFiber = null;
+			}
+		};
+	});
+	return {
+		get current() {
+			return state.current;
+		},
+		run
+	};
+}
+/**
+* Returns a function that manually invalidates reactivity keys, causing any
+* reactive queries depending on those keys to re-run.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { useInvalidateKeys } from '@thomasfosterau/effect-svelte';
+*
+*   const invalidate = useInvalidateKeys();
+* <\/script>
+*
+* <button onclick={() => invalidate(['users'])}>Refresh Users</button>
+* ```
+*/
+function useInvalidateKeys() {
+	const runtime = getRuntimeContext();
+	return (keys) => {
+		runSync(runtime)(Reactivity.invalidate(keys));
+	};
+}
+//#endregion
+export { reactiveMutation, reactiveQuery, reactiveStream, useInvalidateKeys };
+
+//# sourceMappingURL=reactivity.svelte.js.map

package/dist/reactivity.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactivity.svelte.js","names":["getRuntime"],"sources":["../src/reactivity.svelte.ts"],"sourcesContent":["import { Effect, Fiber, Stream } from \"effect\";\nimport type * as AsyncResult from \"effect/unstable/reactivity/AsyncResult\";\nimport { Reactivity } from \"effect/unstable/reactivity\";\nimport { getRuntime } from \"./context.svelte.js\";\nimport { interruptFiber, runFork, runSync, type RuntimeLike } from \"./internal/run.js\";\nimport { makeResult } from \"./internal/result.svelte.js\";\nimport { streamState } from \"./internal/subscribe.js\";\n\nexport interface ReactiveQueryReturn<A, E> {\n  /** The current result, re-derived whenever the keys are invalidated. */\n  readonly current: AsyncResult.AsyncResult<A, E>;\n}\n\n/**\n * Creates a reactive query that automatically re-runs when the specified keys are invalidated.\n *\n * Note: Make sure your runtime includes `Reactivity.layer` from `effect/unstable/reactivity`.\n *\n * @param keys - Reactivity keys that this query depends on\n * @param effectFn - The Effect to run when keys are invalidated\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { reactiveQuery, AsyncResult } from '@thomasfosterau/effect-svelte';\n *   import { Effect } from 'effect';\n *\n *   // Query that depends on a user ID key\n *   let userId = $state(1);\n *\n *   const user = reactiveQuery(\n *     () => ['user', userId],\n *     () => Effect.gen(function* () {\n *       const data = yield* fetchUser(userId);\n *       return data;\n *     })\n *   );\n * </script>\n *\n * {#if AsyncResult.isSuccess(user.current)}\n *   <p>User: {user.current.value.name}</p>\n * {/if}\n * ```\n */\nexport function reactiveQuery<A, E, R>(\n  keys: () => ReadonlyArray<unknown>,\n  effectFn: () => Effect.Effect<A, E, R>,\n): ReactiveQueryReturn<A, E> {\n  const runtime = getRuntime() as RuntimeLike<R | Reactivity.Reactivity>;\n\n  const state = makeResult<A, E>();\n  let fiber: Fiber.Fiber<void, never> | null = null;\n\n  $effect(() => {\n    // Get the current keys (tracks Svelte dependencies)\n    const currentKeys = keys();\n    const effect = effectFn();\n\n    // Mark as waiting, preserving any previous value.\n    state.startWaiting();\n\n    // Run the reactive query inside a scope so that the registered\n    // invalidation handlers are cleaned up when the fiber is interrupted.\n    const queryEffect = Effect.scoped(\n      Effect.gen(function* () {\n        const queue = yield* Reactivity.query(effect, currentKeys);\n        yield* Stream.runForEach(Stream.fromQueue(queue), (value) =>\n          Effect.sync(() => {\n            state.succeed(value);\n          }),\n        );\n      }),\n    ).pipe(\n      Effect.catchCause((cause) =>\n        Effect.sync(() => {\n          state.failCause(cause);\n        }),\n      ),\n    );\n\n    const runningFiber = runFork(runtime)(queryEffect);\n    fiber = runningFiber;\n\n    // Cleanup: interrupt the fiber when dependencies change or component unmounts\n    return () => {\n      if (fiber !== null) {\n        interruptFiber(fiber);\n        fiber = null;\n      }\n    };\n  });\n\n  return {\n    get current() {\n      return state.current;\n    },\n  };\n}\n\nexport interface ReactiveStreamReturn<A, E> {\n  readonly current: AsyncResult.AsyncResult<ReadonlyArray<A>, E>;\n  readonly values: ReadonlyArray<A>;\n  readonly latest: A | undefined;\n}\n\n/**\n * Creates a reactive stream that emits values whenever the specified keys are invalidated.\n * The effect re-runs automatically when keys change.\n *\n * @param keys - Reactivity keys that this stream depends on\n * @param effect - The Effect to run when keys are invalidated\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { reactiveStream } from '@thomasfosterau/effect-svelte';\n *   import { Effect } from 'effect';\n *\n *   const messages = reactiveStream(\n *     ['messages'],\n *     Effect.gen(function* () {\n *       const data = yield* fetchMessages();\n *       return data;\n *     })\n *   );\n * </script>\n *\n * <ul>\n *   {#each messages.values as msg}\n *     <li>{msg}</li>\n *   {/each}\n * </ul>\n * ```\n */\nexport function reactiveStream<A, E, R>(\n  keys: ReadonlyArray<unknown> | (() => ReadonlyArray<unknown>),\n  effect: Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>),\n): ReactiveStreamReturn<A, E> {\n  const runtime = getRuntime() as RuntimeLike<R | Reactivity.Reactivity>;\n  return streamState(runtime, () => {\n    const currentKeys = typeof keys === \"function\" ? keys() : keys;\n    const currentEffect = typeof effect === \"function\" ? effect() : effect;\n    return Reactivity.stream(currentEffect, currentKeys);\n  });\n}\n\nexport interface ReactiveMutationReturn<A, E> {\n  readonly current: AsyncResult.AsyncResult<A, E>;\n  run: () => void;\n}\n\n/**\n * Runs a mutation effect and invalidates the specified keys.\n * This will cause any reactive queries depending on these keys to re-run.\n *\n * @param keys - Reactivity keys to invalidate after the mutation\n * @param effect - The mutation effect to run\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { reactiveMutation } from '@thomasfosterau/effect-svelte';\n *   import { Effect } from 'effect';\n *\n *   const updateUser = reactiveMutation(\n *     ['user', userId],\n *     Effect.gen(function* () {\n *       yield* updateUserInDB(userId, data);\n *     })\n *   );\n * </script>\n *\n * <button onclick={() => updateUser.run()}>Update</button>\n * ```\n */\nexport function reactiveMutation<A, E, R>(\n  keys: ReadonlyArray<unknown> | (() => ReadonlyArray<unknown>),\n  effect: Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>),\n): ReactiveMutationReturn<A, E> {\n  const runtime = getRuntime() as RuntimeLike<R | Reactivity.Reactivity>;\n\n  const state = makeResult<A, E>();\n  let currentFiber: Fiber.Fiber<A, E> | null = null;\n\n  const run = () => {\n    if (currentFiber !== null) {\n      interruptFiber(currentFiber);\n    }\n\n    const currentKeys = typeof keys === \"function\" ? keys() : keys;\n    const currentEffect = typeof effect === \"function\" ? effect() : effect;\n\n    state.startWaiting();\n\n    const mutationEffect = Reactivity.mutation(currentEffect, currentKeys);\n    const runningFiber = runFork(runtime)(mutationEffect);\n    currentFiber = runningFiber;\n\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\n  $effect(() => {\n    // Cleanup: interrupt any running fiber on unmount\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    run,\n  };\n}\n\n/**\n * Returns a function that manually invalidates reactivity keys, causing any\n * reactive queries depending on those keys to re-run.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useInvalidateKeys } from '@thomasfosterau/effect-svelte';\n *\n *   const invalidate = useInvalidateKeys();\n * </script>\n *\n * <button onclick={() => invalidate(['users'])}>Refresh Users</button>\n * ```\n */\nexport function useInvalidateKeys(): (keys: ReadonlyArray<unknown>) => void {\n  const runtime = getRuntime() as RuntimeLike<Reactivity.Reactivity>;\n  return (keys) => {\n    runSync(runtime)(Reactivity.invalidate(keys));\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,cACd,MACA,UAC2B;CAC3B,MAAM,UAAUA,kBAAW;CAE3B,MAAM,QAAQ,WAAiB;CAC/B,IAAI,QAAyC;CAE7C,cAAc;EAEZ,MAAM,cAAc,KAAK;EACzB,MAAM,SAAS,SAAS;EAGxB,MAAM,aAAa;EAInB,MAAM,cAAc,OAAO,OACzB,OAAO,IAAI,aAAa;GACtB,MAAM,QAAQ,OAAO,WAAW,MAAM,QAAQ,WAAW;GACzD,OAAO,OAAO,WAAW,OAAO,UAAU,KAAK,IAAI,UACjD,OAAO,WAAW;IAChB,MAAM,QAAQ,KAAK;GACrB,CAAC,CACH;EACF,CAAC,CACH,EAAE,KACA,OAAO,YAAY,UACjB,OAAO,WAAW;GAChB,MAAM,UAAU,KAAK;EACvB,CAAC,CACH,CACF;EAGA,QADqB,QAAQ,OAAO,EAAE,WACnB;EAGnB,aAAa;GACX,IAAI,UAAU,MAAM;IAClB,eAAe,KAAK;IACpB,QAAQ;GACV;EACF;CACF,CAAC;CAED,OAAO,EACL,IAAI,UAAU;EACZ,OAAO,MAAM;CACf,EACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,eACd,MACA,QAC4B;CAE5B,OAAO,YADSA,kBACS,SAAS;EAChC,MAAM,cAAc,OAAO,SAAS,aAAa,KAAK,IAAI;EAC1D,MAAM,gBAAgB,OAAO,WAAW,aAAa,OAAO,IAAI;EAChE,OAAO,WAAW,OAAO,eAAe,WAAW;CACrD,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,iBACd,MACA,QAC8B;CAC9B,MAAM,UAAUA,kBAAW;CAE3B,MAAM,QAAQ,WAAiB;CAC/B,IAAI,eAAyC;CAE7C,MAAM,YAAY;EAChB,IAAI,iBAAiB,MACnB,eAAe,YAAY;EAG7B,MAAM,cAAc,OAAO,SAAS,aAAa,KAAK,IAAI;EAC1D,MAAM,gBAAgB,OAAO,WAAW,aAAa,OAAO,IAAI;EAEhE,MAAM,aAAa;EAEnB,MAAM,iBAAiB,WAAW,SAAS,eAAe,WAAW;EACrE,MAAM,eAAe,QAAQ,OAAO,EAAE,cAAc;EACpD,eAAe;EAEf,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;CACF;CAEA,cAAc;EAEZ,aAAa;GACX,IAAI,iBAAiB,MAAM;IACzB,eAAe,YAAY;IAC3B,eAAe;GACjB;EACF;CACF,CAAC;CAED,OAAO;EACL,IAAI,UAAU;GACZ,OAAO,MAAM;EACf;EACA;CACF;AACF;;;;;;;;;;;;;;;;AAiBA,SAAgB,oBAA4D;CAC1E,MAAM,UAAUA,kBAAW;CAC3B,QAAQ,SAAS;EACf,QAAQ,OAAO,EAAE,WAAW,WAAW,IAAI,CAAC;CAC9C;AACF"}

package/dist/runtime.d.ts

@@ -0,0 +1,81 @@
+import { Layer, ManagedRuntime } from "effect";
+
+//#region src/runtime.d.ts
+/**
+ * Custom runtime for Svelte helpers.
+ *
+ * This runtime is designed specifically for Svelte components and provides:
+ * - Type-safe environment tracking
+ * - Optimized for client-side execution
+ * - Support for reactive primitives
+ *
+ * Users can extend this runtime with additional services as needed.
+ *
+ * @example
+ * ```ts
+ * import { SvelteRuntime } from '@thomasfosterau/effect-svelte';
+ * import { provideRuntime } from '@thomasfosterau/effect-svelte';
+ * import { Layer } from 'effect';
+ * import { MyService } from './services';
+ *
+ * // Extend the base runtime with custom services
+ * const customRuntime = SvelteRuntime.extend(Layer.succeed(MyService, myServiceImpl));
+ *
+ * // Provide to Svelte context
+ * provideRuntime(customRuntime);
+ * ```
+ */
+declare class SvelteRuntime {
+  /**
+   * The base Svelte runtime with minimal services.
+   * This is suitable for most client-side Svelte applications.
+   */
+  private static readonly baseLayer;
+  /**
+   * The default managed runtime instance.
+   * This provides the core runtime without additional services.
+   */
+  static readonly defaultRuntime: ManagedRuntime.ManagedRuntime<never, never>;
+  /**
+   * Creates a custom runtime by extending the base Svelte runtime with additional layers.
+   *
+   * @param layer - The layer containing additional services to provide
+   * @returns A new managed runtime with the extended services
+   *
+   * @example
+   * ```ts
+   * import { SvelteRuntime } from '@thomasfosterau/effect-svelte';
+   * import { Layer, Context } from 'effect';
+   *
+   * // Define a custom service
+   * class Analytics extends Context.Service<Analytics, {
+   *   track: (event: string) => Effect.Effect<void>
+   * }>()("Analytics") {}
+   *
+   * // Create an implementation
+   * const analyticsLayer = Layer.succeed(Analytics, {
+   *   track: (event) => Effect.sync(() => console.log(event))
+   * });
+   *
+   * // Extend the runtime
+   * const runtime = SvelteRuntime.extend(analyticsLayer);
+   * ```
+   */
+  static extend<R>(layer: Layer.Layer<R>): ManagedRuntime.ManagedRuntime<R, never>;
+  /**
+   * Creates a custom runtime from a layer, replacing the base layer entirely.
+   * Use this when you want full control over the runtime environment.
+   *
+   * @param layer - The complete layer to use for the runtime
+   * @returns A new managed runtime with only the provided services
+   */
+  static make<R>(layer: Layer.Layer<R>): ManagedRuntime.ManagedRuntime<R, never>;
+}
+/**
+ * Default runtime instance for convenience.
+ * This is the recommended runtime for most Svelte applications.
+ */
+declare const defaultSvelteRuntime: ManagedRuntime.ManagedRuntime<never, never>;
+//#endregion
+export { SvelteRuntime, defaultSvelteRuntime };
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.js

@@ -0,0 +1,85 @@
+import { Layer, ManagedRuntime } from "effect";
+//#region src/runtime.ts
+/**
+* Custom runtime for Svelte helpers.
+*
+* This runtime is designed specifically for Svelte components and provides:
+* - Type-safe environment tracking
+* - Optimized for client-side execution
+* - Support for reactive primitives
+*
+* Users can extend this runtime with additional services as needed.
+*
+* @example
+* ```ts
+* import { SvelteRuntime } from '@thomasfosterau/effect-svelte';
+* import { provideRuntime } from '@thomasfosterau/effect-svelte';
+* import { Layer } from 'effect';
+* import { MyService } from './services';
+*
+* // Extend the base runtime with custom services
+* const customRuntime = SvelteRuntime.extend(Layer.succeed(MyService, myServiceImpl));
+*
+* // Provide to Svelte context
+* provideRuntime(customRuntime);
+* ```
+*/
+var SvelteRuntime = class {
+	/**
+	* The base Svelte runtime with minimal services.
+	* This is suitable for most client-side Svelte applications.
+	*/
+	static baseLayer = Layer.empty;
+	/**
+	* The default managed runtime instance.
+	* This provides the core runtime without additional services.
+	*/
+	static defaultRuntime = ManagedRuntime.make(this.baseLayer);
+	/**
+	* Creates a custom runtime by extending the base Svelte runtime with additional layers.
+	*
+	* @param layer - The layer containing additional services to provide
+	* @returns A new managed runtime with the extended services
+	*
+	* @example
+	* ```ts
+	* import { SvelteRuntime } from '@thomasfosterau/effect-svelte';
+	* import { Layer, Context } from 'effect';
+	*
+	* // Define a custom service
+	* class Analytics extends Context.Service<Analytics, {
+	*   track: (event: string) => Effect.Effect<void>
+	* }>()("Analytics") {}
+	*
+	* // Create an implementation
+	* const analyticsLayer = Layer.succeed(Analytics, {
+	*   track: (event) => Effect.sync(() => console.log(event))
+	* });
+	*
+	* // Extend the runtime
+	* const runtime = SvelteRuntime.extend(analyticsLayer);
+	* ```
+	*/
+	static extend(layer) {
+		return ManagedRuntime.make(Layer.merge(this.baseLayer, layer));
+	}
+	/**
+	* Creates a custom runtime from a layer, replacing the base layer entirely.
+	* Use this when you want full control over the runtime environment.
+	*
+	* @param layer - The complete layer to use for the runtime
+	* @returns A new managed runtime with only the provided services
+	*/
+	static make(layer) {
+		return ManagedRuntime.make(layer);
+	}
+};
+/**
+* Default runtime instance for convenience.
+* This is the recommended runtime for most Svelte applications.
+*/
+const defaultSvelteRuntime = SvelteRuntime.defaultRuntime;
+//#endregion
+export { SvelteRuntime, defaultSvelteRuntime };
+
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","names":[],"sources":["../src/runtime.ts"],"sourcesContent":["import { Layer, ManagedRuntime } from \"effect\";\n\n/**\n * Custom runtime for Svelte helpers.\n *\n * This runtime is designed specifically for Svelte components and provides:\n * - Type-safe environment tracking\n * - Optimized for client-side execution\n * - Support for reactive primitives\n *\n * Users can extend this runtime with additional services as needed.\n *\n * @example\n * ```ts\n * import { SvelteRuntime } from '@thomasfosterau/effect-svelte';\n * import { provideRuntime } from '@thomasfosterau/effect-svelte';\n * import { Layer } from 'effect';\n * import { MyService } from './services';\n *\n * // Extend the base runtime with custom services\n * const customRuntime = SvelteRuntime.extend(Layer.succeed(MyService, myServiceImpl));\n *\n * // Provide to Svelte context\n * provideRuntime(customRuntime);\n * ```\n */\nexport class SvelteRuntime {\n  /**\n   * The base Svelte runtime with minimal services.\n   * This is suitable for most client-side Svelte applications.\n   */\n  private static readonly baseLayer = Layer.empty;\n\n  /**\n   * The default managed runtime instance.\n   * This provides the core runtime without additional services.\n   */\n  static readonly defaultRuntime = ManagedRuntime.make(this.baseLayer);\n\n  /**\n   * Creates a custom runtime by extending the base Svelte runtime with additional layers.\n   *\n   * @param layer - The layer containing additional services to provide\n   * @returns A new managed runtime with the extended services\n   *\n   * @example\n   * ```ts\n   * import { SvelteRuntime } from '@thomasfosterau/effect-svelte';\n   * import { Layer, Context } from 'effect';\n   *\n   * // Define a custom service\n   * class Analytics extends Context.Service<Analytics, {\n   *   track: (event: string) => Effect.Effect<void>\n   * }>()(\"Analytics\") {}\n   *\n   * // Create an implementation\n   * const analyticsLayer = Layer.succeed(Analytics, {\n   *   track: (event) => Effect.sync(() => console.log(event))\n   * });\n   *\n   * // Extend the runtime\n   * const runtime = SvelteRuntime.extend(analyticsLayer);\n   * ```\n   */\n  static extend<R>(layer: Layer.Layer<R>): ManagedRuntime.ManagedRuntime<R, never> {\n    return ManagedRuntime.make(Layer.merge(this.baseLayer, layer));\n  }\n\n  /**\n   * Creates a custom runtime from a layer, replacing the base layer entirely.\n   * Use this when you want full control over the runtime environment.\n   *\n   * @param layer - The complete layer to use for the runtime\n   * @returns A new managed runtime with only the provided services\n   */\n  static make<R>(layer: Layer.Layer<R>): ManagedRuntime.ManagedRuntime<R, never> {\n    return ManagedRuntime.make(layer);\n  }\n}\n\n/**\n * Default runtime instance for convenience.\n * This is the recommended runtime for most Svelte applications.\n */\nexport const defaultSvelteRuntime = SvelteRuntime.defaultRuntime;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAa,gBAAb,MAA2B;;;;;CAKzB,OAAwB,YAAY,MAAM;;;;;CAM1C,OAAgB,iBAAiB,eAAe,KAAK,KAAK,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BnE,OAAO,OAAU,OAAgE;EAC/E,OAAO,eAAe,KAAK,MAAM,MAAM,KAAK,WAAW,KAAK,CAAC;CAC/D;;;;;;;;CASA,OAAO,KAAQ,OAAgE;EAC7E,OAAO,eAAe,KAAK,KAAK;CAClC;AACF;;;;;AAMA,MAAa,uBAAuB,cAAc"}

package/dist/scope.svelte.d.ts

@@ -0,0 +1,49 @@
+import { Scope } from "effect";
+
+//#region src/scope.svelte.d.ts
+/**
+ * Creates an Effect Scope that is tied to the component lifecycle.
+ * The scope is created when the component mounts and closed when it unmounts.
+ *
+ * Note: Due to Svelte's initialization order ($effect runs after mount),
+ * the scope will be null initially. Use the callback-based approach for
+ * guaranteed availability.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useScope } from 'effect-svelte';
+ *
+ *   const scope = useScope();
+ *
+ *   $effect(() => {
+ *     if (scope.current) {
+ *       // Use scope.current here
+ *     }
+ *   });
+ * </script>
+ * ```
+ */
+declare function useScope(): {
+  get current(): Scope.Closeable | null;
+};
+/**
+ * Callback-based variant of useScope that guarantees scope availability.
+ * The callback is executed once the scope is created and receives the scope as parameter.
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useScopeCallback } from 'effect-svelte';
+ *
+ *   useScopeCallback((scope) => {
+ *     // Scope is guaranteed to be available here
+ *     // Set up any scope-dependent resources
+ *   });
+ * </script>
+ * ```
+ */
+declare function useScopeCallback(callback: (scope: Scope.Closeable) => void | (() => void)): void;
+//#endregion
+export { useScope, useScopeCallback };
+//# sourceMappingURL=scope.svelte.d.ts.map

package/dist/scope.svelte.js

@@ -0,0 +1,68 @@
+import { untrack } from "svelte";
+import { Effect, Exit, Scope } from "effect";
+//#region src/scope.svelte.ts
+/**
+* Creates an Effect Scope that is tied to the component lifecycle.
+* The scope is created when the component mounts and closed when it unmounts.
+*
+* Note: Due to Svelte's initialization order ($effect runs after mount),
+* the scope will be null initially. Use the callback-based approach for
+* guaranteed availability.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { useScope } from 'effect-svelte';
+*
+*   const scope = useScope();
+*
+*   $effect(() => {
+*     if (scope.current) {
+*       // Use scope.current here
+*     }
+*   });
+* <\/script>
+* ```
+*/
+function useScope() {
+	let scope = $state(null);
+	$effect(() => {
+		scope = Effect.runSync(Scope.make());
+		return () => {
+			if (scope) Effect.runSync(Scope.close(scope, Exit.void));
+		};
+	});
+	return { get current() {
+		return scope;
+	} };
+}
+/**
+* Callback-based variant of useScope that guarantees scope availability.
+* The callback is executed once the scope is created and receives the scope as parameter.
+*
+* @example
+* ```svelte
+* <script lang="ts">
+*   import { useScopeCallback } from 'effect-svelte';
+*
+*   useScopeCallback((scope) => {
+*     // Scope is guaranteed to be available here
+*     // Set up any scope-dependent resources
+*   });
+* <\/script>
+* ```
+*/
+function useScopeCallback(callback) {
+	$effect(() => {
+		const scope = Effect.runSync(Scope.make());
+		const cleanup = untrack(() => callback(scope));
+		return () => {
+			if (typeof cleanup === "function") cleanup();
+			Effect.runSync(Scope.close(scope, Exit.void));
+		};
+	});
+}
+//#endregion
+export { useScope, useScopeCallback };
+
+//# sourceMappingURL=scope.svelte.js.map

package/dist/scope.svelte.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.svelte.js","names":[],"sources":["../src/scope.svelte.ts"],"sourcesContent":["import { Scope, Exit, Effect } from \"effect\";\nimport { untrack } from \"svelte\";\n\n/**\n * Creates an Effect Scope that is tied to the component lifecycle.\n * The scope is created when the component mounts and closed when it unmounts.\n *\n * Note: Due to Svelte's initialization order ($effect runs after mount),\n * the scope will be null initially. Use the callback-based approach for\n * guaranteed availability.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useScope } from 'effect-svelte';\n *\n *   const scope = useScope();\n *\n *   $effect(() => {\n *     if (scope.current) {\n *       // Use scope.current here\n *     }\n *   });\n * </script>\n * ```\n */\nexport function useScope(): { get current(): Scope.Closeable | null } {\n  let scope = $state<Scope.Closeable | null>(null);\n\n  $effect(() => {\n    // Create the scope when component mounts\n    scope = Effect.runSync(Scope.make());\n\n    // Clean up: close the scope when component unmounts\n    return () => {\n      if (scope) {\n        Effect.runSync(Scope.close(scope, Exit.void));\n      }\n    };\n  });\n\n  return {\n    get current() {\n      return scope;\n    },\n  };\n}\n\n/**\n * Callback-based variant of useScope that guarantees scope availability.\n * The callback is executed once the scope is created and receives the scope as parameter.\n *\n * @example\n * ```svelte\n * <script lang=\"ts\">\n *   import { useScopeCallback } from 'effect-svelte';\n *\n *   useScopeCallback((scope) => {\n *     // Scope is guaranteed to be available here\n *     // Set up any scope-dependent resources\n *   });\n * </script>\n * ```\n */\nexport function useScopeCallback(callback: (scope: Scope.Closeable) => void | (() => void)): void {\n  $effect(() => {\n    // Create the scope when component mounts\n    const scope = Effect.runSync(Scope.make());\n\n    // Execute the callback with the scope. The callback runs untracked so\n    // that reactive state it touches does not become a dependency of this\n    // effect — the callback is a once-per-mount setup, not a reactive one.\n    const cleanup = untrack(() => callback(scope));\n\n    // Clean up\n    return () => {\n      // Call user's cleanup if provided\n      if (typeof cleanup === \"function\") {\n        cleanup();\n      }\n\n      // Close the scope\n      Effect.runSync(Scope.close(scope, Exit.void));\n    };\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,WAAsD;CACpE,IAAI,QAAQ,OAA+B,IAAI;CAE/C,cAAc;EAEZ,QAAQ,OAAO,QAAQ,MAAM,KAAK,CAAC;EAGnC,aAAa;GACX,IAAI,OACF,OAAO,QAAQ,MAAM,MAAM,OAAO,KAAK,IAAI,CAAC;EAEhD;CACF,CAAC;CAED,OAAO,EACL,IAAI,UAAU;EACZ,OAAO;CACT,EACF;AACF;;;;;;;;;;;;;;;;;AAkBA,SAAgB,iBAAiB,UAAiE;CAChG,cAAc;EAEZ,MAAM,QAAQ,OAAO,QAAQ,MAAM,KAAK,CAAC;EAKzC,MAAM,UAAU,cAAc,SAAS,KAAK,CAAC;EAG7C,aAAa;GAEX,IAAI,OAAO,YAAY,YACrB,QAAQ;GAIV,OAAO,QAAQ,MAAM,MAAM,OAAO,KAAK,IAAI,CAAC;EAC9C;CACF,CAAC;AACH"}

package/dist/stream.svelte.d.ts

@@ -0,0 +1,48 @@
+import { Stream } from "effect";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+
+//#region src/stream.svelte.d.ts
+interface UseStreamReturn<A, E> {
+  /**
+   * The current result state of the stream. `Initial`/`Success` carry a
+   * `waiting` flag while the stream is still live (stale-while-revalidate), and
+   * settle to a non-waiting `Success`/`Failure` once it completes.
+   */
+  readonly current: AsyncResult.AsyncResult<ReadonlyArray<A>, E>;
+  /**
+   * All values emitted by the stream so far
+   */
+  readonly values: ReadonlyArray<A>;
+  /**
+   * The most recent value emitted by the stream (undefined if none)
+   */
+  readonly latest: A | undefined;
+}
+/**
+ * Subscribe to a Stream and collect emissions.
+ *
+ * The subscription starts the first time `current`/`values`/`latest` is read
+ * inside an effect or template, and is interrupted automatically when the last
+ * reader is destroyed (via Svelte's `createSubscriber`).
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useStream } from '@thomasfosterau/effect-svelte';
+ *   import { Stream, Schedule } from 'effect';
+ *
+ *   const counter = useStream(
+ *     Stream.iterate(0, n => n + 1).pipe(
+ *       Stream.schedule(Schedule.spaced('1 second'))
+ *     )
+ *   );
+ * </script>
+ *
+ * <p>Latest: {counter.latest}</p>
+ * <p>All values: {counter.values.join(', ')}</p>
+ * ```
+ */
+declare function useStream<A, E, R>(stream: Stream.Stream<A, E, R>): UseStreamReturn<A, E>;
+//#endregion
+export { UseStreamReturn, useStream };
+//# sourceMappingURL=stream.svelte.d.ts.map