effect-atom-svelte 0.0.0-stage → 0.1.0

package/dist/HydrationBoundary.svelte

@@ -0,0 +1,127 @@
+<!--
+  @component
+  Hydrates dehydrated atom state, for example from `Hydration.dehydrate` returned by a remote
+  function. Atoms new to the registry are hydrated before children render; in the browser, atoms
+  that already exist are updated after render, so current UI does not jump to the incoming data
+  mid-render. On the server, where nothing renders again, they are updated at once.
+
+  A value for an atom nobody reads waits in the registry until something does. When the boundary
+  is destroyed, as at the end of a server render, the values it brought that are still unread are
+  dropped, so a registry that outlives the boundary doesn't hand them to a later reader.
+
+  **Example** (Hydrating the state a load function dehydrated)
+
+  ```svelte
+  <script lang="ts">
+    import { HydrationBoundary } from "effect-atom-svelte";
+
+    import TodoList from "./todo-list.svelte";
+
+    // `data.state` is `Hydration.dehydrate(registry)`, returned by +page.server.ts.
+    const { data } = $props();
+  </script>
+
+  <HydrationBoundary state={data.state}>
+    <TodoList />
+  </HydrationBoundary>
+  ```
+-->
+<script lang="ts">
+  import { Hydration } from "effect/reactivity";
+  import { BROWSER } from "esm-env";
+  import { onDestroy } from "svelte";
+  import type { Snippet } from "svelte";
+
+  import { getRegistry } from "./RegistryContext.js";
+
+  interface Props {
+    readonly state?: Iterable<Hydration.DehydratedAtom> | undefined;
+    readonly children: Snippet;
+  }
+
+  const { children, state }: Props = $props();
+  const registry = getRegistry();
+
+  // SAFETY: preloadedSerializable is on the registry implementation, not the interface (Effect
+  // 4.0.0). It holds the encoded values Hydration.hydrate queued, until a lookup of the key takes one.
+  const { preloadedSerializable: preloaded } = registry as unknown as {
+    readonly preloadedSerializable?: Map<string, unknown>;
+  };
+  // The values this boundary queued, by key, so it can drop the ones nobody took.
+  const queued = new Map<string, unknown>();
+
+  const queue = (atoms: readonly Hydration.DehydratedAtomValue[]): void => {
+    Hydration.hydrate(registry, atoms);
+    for (const { key, value } of atoms) {
+      queued.set(key, value);
+    }
+  };
+
+  const hydrateNew = (
+    incoming: Iterable<Hydration.DehydratedAtom> | undefined
+  ): Hydration.DehydratedAtomValue[] => {
+    const nodes = registry.getNodes();
+    const fresh: Hydration.DehydratedAtomValue[] = [];
+    const existing: Hydration.DehydratedAtomValue[] = [];
+    for (const atom of Hydration.toValues([...(incoming ?? [])])) {
+      (nodes.has(atom.key) ? existing : fresh).push(atom);
+    }
+    queue(fresh);
+    return existing;
+  };
+
+  const hydrateExisting = (
+    existing: readonly Hydration.DehydratedAtomValue[]
+  ): void => {
+    queue(existing);
+    // hydrate only queues values for existing nodes; the registry applies a queued value the next
+    // time the node is looked up, so look each one up now to update its subscribers.
+    const nodes = registry.getNodes();
+    for (const { key } of existing) {
+      const node = nodes.get(key);
+      if (node) {
+        registry.get(node.atom);
+      }
+    }
+  };
+
+  // Read once at init so children render with the new atoms already in place.
+  // svelte-ignore state_referenced_locally
+  let hydrated = state;
+  // svelte-ignore state_referenced_locally
+  let deferred = hydrateNew(state);
+  // Effects don't run on the server, and nothing there renders again, so the atoms that already
+  // exist are updated now, before the children read them.
+  if (!BROWSER) {
+    hydrateExisting(deferred);
+    deferred = [];
+  }
+
+  $effect(() => {
+    const incoming = state;
+    if (incoming !== hydrated) {
+      hydrated = incoming;
+      deferred = [...deferred, ...hydrateNew(incoming)];
+    }
+    if (deferred.length > 0) {
+      hydrateExisting(deferred);
+      deferred = [];
+    }
+  });
+
+  // A queued value stays in the registry until its key is looked up. With a registry that outlives
+  // the boundary, such as one the caller passes to the server's provider, it would reach a later
+  // request. Drop the ones still waiting, unless something queued another value since.
+  onDestroy(() => {
+    if (!preloaded) {
+      return;
+    }
+    for (const [key, value] of queued) {
+      if (preloaded.get(key) === value) {
+        preloaded.delete(key);
+      }
+    }
+  });
+</script>
+
+{@render children()}

package/dist/HydrationBoundary.svelte.d.ts

@@ -0,0 +1,36 @@
+import { Hydration } from "effect/reactivity";
+import type { Snippet } from "svelte";
+interface Props {
+    readonly state?: Iterable<Hydration.DehydratedAtom> | undefined;
+    readonly children: Snippet;
+}
+/**
+ * Hydrates dehydrated atom state, for example from `Hydration.dehydrate` returned by a remote
+ * function. Atoms new to the registry are hydrated before children render; in the browser, atoms
+ * that already exist are updated after render, so current UI does not jump to the incoming data
+ * mid-render. On the server, where nothing renders again, they are updated at once.
+ *
+ * A value for an atom nobody reads waits in the registry until something does. When the boundary
+ * is destroyed, as at the end of a server render, the values it brought that are still unread are
+ * dropped, so a registry that outlives the boundary doesn't hand them to a later reader.
+ *
+ * **Example** (Hydrating the state a load function dehydrated)
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   import { HydrationBoundary } from "effect-atom-svelte";
+ *
+ *   import TodoList from "./todo-list.svelte";
+ *
+ *   // `data.state` is `Hydration.dehydrate(registry)`, returned by +page.server.ts.
+ *   const { data } = $props();
+ * </script>
+ *
+ * <HydrationBoundary state={data.state}>
+ *   <TodoList />
+ * </HydrationBoundary>
+ * ```
+ */
+declare const HydrationBoundary: import("svelte").Component<Props, {}, "">;
+type HydrationBoundary = ReturnType<typeof HydrationBoundary>;
+export default HydrationBoundary;

package/dist/RegistryContext.d.ts

@@ -0,0 +1,117 @@
+/**
+ * The registry that hooks read from, and how a component tree gets one.
+ *
+ * @since 0.1.0
+ */
+import { AtomRegistry } from "effect/reactivity";
+/**
+ * Options for a registry created by `provideRegistry` or `RegistryProvider`: the options of
+ * Effect's `AtomRegistry.make`, all optional.
+ *
+ * - `initialValues`: pairs of an atom and its starting value, such as `[[tokenAtom, token]]`.
+ * - `scheduleTask`: schedules the registry's deferred work, such as disposing of atoms nobody
+ *   reads. It takes a task and returns a function that cancels it.
+ * - `defaultIdleTTL`: in milliseconds, how long an atom nobody reads is kept before it is disposed
+ *   of, for atoms without an idle TTL of their own. Without it, such atoms are disposed of shortly
+ *   after their last reader goes.
+ * - `timeoutResolution`: in milliseconds, how finely idle timeouts are grouped. Defaults to half
+ *   of `defaultIdleTTL`, or 1000.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category models
+ */
+export type RegistryOptions = NonNullable<Parameters<typeof AtomRegistry.make>[0]>;
+/**
+ * Returns the registry from the nearest `provideRegistry` or `RegistryProvider`.
+ *
+ * In the browser a shared default registry is used when none is provided. On the server there is
+ * no default: one module-level registry would share atom state between concurrent requests.
+ *
+ * **Example** (Writing an atom from code that is not reactive)
+ *
+ * ```ts
+ * import { getRegistry } from "effect-atom-svelte";
+ * import { countAtom } from "./atoms.ts";
+ *
+ * const registry = getRegistry(); // while the component initializes
+ * const reset = () => registry.set(countAtom, 0);
+ * ```
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category registry
+ */
+export declare const getRegistry: () => AtomRegistry.AtomRegistry;
+/**
+ * The options `provideRegistry` and `RegistryProvider` take whether they create a registry or are
+ * given one.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category models
+ */
+export interface ProvideRegistryCommon {
+    /**
+     * Run server-rendered async atoms again once the page has hydrated. Defaults to `false`: the
+     * server's value is milliseconds old. Children inherit it; the async hooks' own option overrides
+     * it. `@effect/atom-react` runs atoms wrapped by `withReactivity` and similar again.
+     */
+    readonly revalidateOnHydrate?: boolean | undefined;
+}
+/**
+ * Provides a registry made elsewhere. The `AtomRegistry.make` options apply only to a registry the
+ * provider creates, so they are not accepted here.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category models
+ */
+export interface ProvideExistingRegistry extends ProvideRegistryCommon {
+    /** An existing registry to provide instead of creating one. The caller disposes of it. */
+    readonly registry: AtomRegistry.AtomRegistry;
+    readonly initialValues?: undefined;
+    readonly scheduleTask?: undefined;
+    readonly timeoutResolution?: undefined;
+    readonly defaultIdleTTL?: undefined;
+}
+/**
+ * Creates a registry with the `AtomRegistry.make` options, owned by the component.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category models
+ */
+export interface ProvideNewRegistry extends RegistryOptions, ProvideRegistryCommon {
+    readonly registry?: undefined;
+}
+/**
+ * Options for `provideRegistry` and `RegistryProvider`: an existing `registry`, or the options for
+ * a new one, not both (JND-61).
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category models
+ */
+export type ProvideRegistryOptions = ProvideExistingRegistry | ProvideNewRegistry;
+/**
+ * Puts a registry in context for this component and its children.
+ *
+ * A registry created here is owned by the component and disposed of with it, which on the server
+ * means at the end of the request. A registry passed in is left for the caller to dispose of.
+ *
+ * **Example** (Giving the app a registry from the root layout)
+ *
+ * ```ts
+ * import { provideRegistry } from "effect-atom-svelte";
+ *
+ * // In src/routes/+layout.svelte: one registry per server request,
+ * // disposed of when the request ends
+ * provideRegistry();
+ * ```
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category registry
+ */
+export declare const provideRegistry: (options?: ProvideRegistryOptions) => AtomRegistry.AtomRegistry;

package/dist/RegistryContext.js

@@ -0,0 +1,85 @@
+/**
+ * The registry that hooks read from, and how a component tree gets one.
+ *
+ * @since 0.1.0
+ */
+import { AtomRegistry } from "effect/reactivity";
+import { BROWSER } from "esm-env";
+import { createContext, onDestroy } from "svelte";
+import { setRevalidateOnHydrate } from "./internal/hydration.js";
+const [getContextRegistry, setContextRegistry, hasContextRegistry] = createContext();
+let browserRegistry;
+/**
+ * Returns the registry from the nearest `provideRegistry` or `RegistryProvider`.
+ *
+ * In the browser a shared default registry is used when none is provided. On the server there is
+ * no default: one module-level registry would share atom state between concurrent requests.
+ *
+ * **Example** (Writing an atom from code that is not reactive)
+ *
+ * ```ts
+ * import { getRegistry } from "effect-atom-svelte";
+ * import { countAtom } from "./atoms.ts";
+ *
+ * const registry = getRegistry(); // while the component initializes
+ * const reset = () => registry.set(countAtom, 0);
+ * ```
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category registry
+ */
+export const getRegistry = () => {
+    if (hasContextRegistry()) {
+        return getContextRegistry();
+    }
+    if (!BROWSER) {
+        throw new Error("No AtomRegistry in context. Wrap the app in <RegistryProvider> so each server request gets its own registry.");
+    }
+    browserRegistry ??= AtomRegistry.make();
+    return browserRegistry;
+};
+/**
+ * Puts a registry in context for this component and its children.
+ *
+ * A registry created here is owned by the component and disposed of with it, which on the server
+ * means at the end of the request. A registry passed in is left for the caller to dispose of.
+ *
+ * **Example** (Giving the app a registry from the root layout)
+ *
+ * ```ts
+ * import { provideRegistry } from "effect-atom-svelte";
+ *
+ * // In src/routes/+layout.svelte: one registry per server request,
+ * // disposed of when the request ends
+ * provideRegistry();
+ * ```
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category registry
+ */
+export const provideRegistry = (options = {}) => {
+    const { defaultIdleTTL, initialValues, registry: provided, revalidateOnHydrate, scheduleTask, timeoutResolution, } = options;
+    // Picked one by one, as RegistryProvider passes its props here, children included.
+    const registryOptions = {
+        defaultIdleTTL,
+        initialValues,
+        scheduleTask,
+        timeoutResolution,
+    };
+    if (provided &&
+        Object.values(registryOptions).some((value) => value !== undefined)) {
+        // The types rule this out; a caller without them would otherwise lose the options silently.
+        throw new Error("provideRegistry takes an existing registry or options for a new one, not both. Apply initialValues to the existing registry yourself.");
+    }
+    const registry = provided ?? AtomRegistry.make(registryOptions);
+    setContextRegistry(registry);
+    if (revalidateOnHydrate !== undefined) {
+        setRevalidateOnHydrate(revalidateOnHydrate);
+    }
+    if (!provided) {
+        onDestroy(() => registry.dispose());
+    }
+    return registry;
+};

package/dist/RegistryProvider.svelte

@@ -0,0 +1,60 @@
+<!--
+  @component
+  Puts an atom registry in context for its children: one per request on the server, and in the
+  browser one per mount of the provider, disposed of when it unmounts. A root layout's provider
+  stays mounted, so its registry lasts the whole visit. Takes the AtomRegistry.make options, or an
+  existing `registry`, and `revalidateOnHydrate` to run server-rendered async atoms again once the
+  page has hydrated.
+
+  The props are read once, when the provider sets up: changing them later doesn't change the
+  registry or create a new one. Development builds warn when `registry` or `revalidateOnHydrate`
+  changes. To start over with other options, remount the provider, for example with `{#key}`.
+
+  **Example** (Providing a registry from the root layout)
+
+  ```svelte
+  <script lang="ts">
+    import { RegistryProvider } from "effect-atom-svelte";
+
+    const { children } = $props();
+  </script>
+
+  <RegistryProvider>{@render children()}</RegistryProvider>
+  ```
+-->
+<script lang="ts">
+  import { DEV } from "esm-env";
+  import type { Snippet } from "svelte";
+
+  import { provideRegistry } from "./RegistryContext.js";
+  import type { ProvideRegistryOptions } from "./RegistryContext.js";
+
+  type Props = ProvideRegistryOptions & { readonly children: Snippet };
+
+  const props: Props = $props();
+  // Props are read once: a registry is created for the provider's lifetime, not per prop change.
+  // provideRegistry passes on only the options it knows, so `children` is ignored there.
+  // svelte-ignore state_referenced_locally
+  provideRegistry(props);
+
+  if (DEV) {
+    // Only the props compared by identity: an option written inline, such as `initialValues`, can
+    // be a new array on every read without having changed.
+    // svelte-ignore state_referenced_locally
+    const { registry, revalidateOnHydrate } = props;
+    let warned = false;
+    $effect(() => {
+      const changed =
+        props.registry !== registry ||
+        props.revalidateOnHydrate !== revalidateOnHydrate;
+      if (changed && !warned) {
+        warned = true;
+        console.warn(
+          "effect-atom-svelte: RegistryProvider reads its props once, so the new `registry` or `revalidateOnHydrate` is ignored. Remount the provider, for example with {#key}, to apply it."
+        );
+      }
+    });
+  }
+</script>
+
+{@render props.children()}

package/dist/RegistryProvider.svelte.d.ts

@@ -0,0 +1,31 @@
+import type { Snippet } from "svelte";
+import type { ProvideRegistryOptions } from "./RegistryContext.ts";
+type Props = ProvideRegistryOptions & {
+    readonly children: Snippet;
+};
+/**
+ * Puts an atom registry in context for its children: one per request on the server, and in the
+ * browser one per mount of the provider, disposed of when it unmounts. A root layout's provider
+ * stays mounted, so its registry lasts the whole visit. Takes the AtomRegistry.make options, or an
+ * existing `registry`, and `revalidateOnHydrate` to run server-rendered async atoms again once the
+ * page has hydrated.
+ *
+ * The props are read once, when the provider sets up: changing them later doesn't change the
+ * registry or create a new one. Development builds warn when `registry` or `revalidateOnHydrate`
+ * changes. To start over with other options, remount the provider, for example with `{#key}`.
+ *
+ * **Example** (Providing a registry from the root layout)
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   import { RegistryProvider } from "effect-atom-svelte";
+ *
+ *   const { children } = $props();
+ * </script>
+ *
+ * <RegistryProvider>{@render children()}</RegistryProvider>
+ * ```
+ */
+declare const RegistryProvider: import("svelte").Component<Props, {}, "">;
+type RegistryProvider = ReturnType<typeof RegistryProvider>;
+export default RegistryProvider;

package/dist/ScopedAtom.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Atoms scoped to a component subtree.
+ *
+ * @since 0.1.0
+ */
+import type { Atom } from "effect/reactivity";
+/**
+ * Marks a value as a `ScopedAtom`: every scoped atom has this key, set to this same string, as
+ * Effect's own types carry a type id.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category type ids
+ */
+export declare const TypeId: "~effect-atom-svelte/ScopedAtom";
+/**
+ * The type of `TypeId`.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId;
+/**
+ * An atom created per component subtree. `provide` builds it once in a parent and puts it in
+ * context; `use` reads it in descendants. `provide` takes the factory's input, which may be left
+ * out when the factory's input is optional.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category models
+ */
+export interface ScopedAtom<A extends Atom.Atom<unknown>, Input = never> {
+    readonly [TypeId]: TypeId;
+    readonly provide: [Input] extends [never] ? () => A : undefined extends Input ? (input?: Input) => A : (input: Input) => A;
+    readonly use: () => A;
+}
+/**
+ * Options for `ScopedAtom.make`.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category models
+ */
+export interface MakeOptions {
+    /** A name for error messages, such as the one thrown when `use` finds no provider. */
+    readonly name?: string | undefined;
+}
+/**
+ * Creates a scoped atom from a factory, which runs once per providing component.
+ *
+ * Each provider gets its own atom, so a factory that adds `Atom.serializable` with a fixed key
+ * gives every copy the same key: once two providers are on a page, reading them with
+ * `useAtomResult` or `useAtomSuspense` throws, as two different atoms share the serialization
+ * key. Put the input in the key, or leave scoped atoms unserialized.
+ *
+ * **Example** (A counter per subtree, started from an input)
+ *
+ * ```ts
+ * import { ScopedAtom } from "effect-atom-svelte";
+ * import { Atom } from "effect/reactivity";
+ *
+ * export const Counter = ScopedAtom.make((start: number) => Atom.make(start), {
+ *   name: "Counter",
+ * });
+ * // A parent's script calls Counter.provide(0); descendants call Counter.use()
+ * ```
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: <A extends Atom.Atom<unknown>, Input = never>(f: (() => A) | ((input: Input) => A), options?: MakeOptions) => ScopedAtom<A, Input>;

package/dist/ScopedAtom.js

@@ -0,0 +1,55 @@
+import { createContext } from "svelte";
+// A const and a type of the same name, as in Effect's modules.
+/* oxlint-disable eslint/no-redeclare */
+/**
+ * Marks a value as a `ScopedAtom`: every scoped atom has this key, set to this same string, as
+ * Effect's own types carry a type id.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category type ids
+ */
+export const TypeId = "~effect-atom-svelte/ScopedAtom";
+/**
+ * Creates a scoped atom from a factory, which runs once per providing component.
+ *
+ * Each provider gets its own atom, so a factory that adds `Atom.serializable` with a fixed key
+ * gives every copy the same key: once two providers are on a page, reading them with
+ * `useAtomResult` or `useAtomSuspense` throws, as two different atoms share the serialization
+ * key. Put the input in the key, or leave scoped atoms unserialized.
+ *
+ * **Example** (A counter per subtree, started from an input)
+ *
+ * ```ts
+ * import { ScopedAtom } from "effect-atom-svelte";
+ * import { Atom } from "effect/reactivity";
+ *
+ * export const Counter = ScopedAtom.make((start: number) => Atom.make(start), {
+ *   name: "Counter",
+ * });
+ * // A parent's script calls Counter.provide(0); descendants call Counter.use()
+ * ```
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category constructors
+ */
+export const make = (f, options) => {
+    const [get, set, has] = createContext();
+    const provide = (...args) => set(args.length === 0
+        ? f()
+        : f(args[0]));
+    return {
+        [TypeId]: TypeId,
+        provide: provide,
+        use: () => {
+            if (!has()) {
+                const name = options?.name;
+                const which = name ? `ScopedAtom "${name}"` : "ScopedAtom";
+                const call = name ? `${name}.provide()` : "its provide()";
+                throw new Error(`${which} used outside of the component that provides it. Call ${call} in a parent component's script.`);
+            }
+            return get();
+        },
+    };
+};

package/dist/SvelteKit.d.ts

@@ -0,0 +1,78 @@
+/**
+ * SvelteKit `handleError` hooks that keep an Effect error's `_tag`, so a `<svelte:boundary>`
+ * `failed` snippet can tell typed errors apart. Import them from `effect-atom-svelte/sveltekit`.
+ *
+ * The module does not import SvelteKit: the hooks take the fields of SvelteKit's input they read
+ * and return the fields they set, so they type-check against `HandleClientError` and
+ * `HandleServerError` once `App.Error` declares `tag?: string`.
+ *
+ * @since 0.1.0
+ */
+/**
+ * The part of SvelteKit's `handleError` input that the hooks read. In SvelteKit 3, `kind` is
+ * `"unknown"` for errors thrown by your code, `"app"` for `error(...)`, `"framework"` for
+ * SvelteKit's own errors (such as 404s) and, on the server, `"validation"` for invalid remote
+ * function arguments. SvelteKit 2 passes no `kind`, so the hooks treat every error as `"unknown"`,
+ * and use the `message` it passes instead when they set none.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category models
+ */
+export interface CaughtError {
+    readonly kind?: string | undefined;
+    readonly error: unknown;
+    readonly issues?: unknown;
+    /** SvelteKit 2's message for the error, read only when there is no `kind`. */
+    readonly message?: string | undefined;
+}
+/**
+ * The `App.Error` fields the hooks set. SvelteKit keeps its own `status` and `message` for any
+ * field left out.
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category models
+ */
+export interface EffectErrorBody {
+    readonly message?: string;
+    readonly tag?: string;
+}
+/**
+ * A client `handleError` hook (`src/hooks.client.ts`) that keeps the message and `_tag` of errors
+ * thrown by your code, so a boundary's `failed` snippet shows them instead of
+ * `{ status: 500, message: "Internal Error" }`. It logs those errors like SvelteKit's default
+ * hook, and leaves `error(...)` and SvelteKit's own errors as they are. Made for SvelteKit 3:
+ * SvelteKit 2 doesn't say which errors are its own, so there every error is kept and logged.
+ *
+ * **Example** (Using it as the client hook)
+ *
+ * ```ts
+ * // src/hooks.client.ts
+ * export { handleClientError as handleError } from "effect-atom-svelte/sveltekit";
+ * ```
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category hooks
+ */
+export declare const handleClientError: (input: CaughtError) => EffectErrorBody | undefined;
+/**
+ * A server `handleError` hook (`src/hooks.server.ts`) that keeps the `_tag` of errors thrown by
+ * your code but not their message, which could expose details of the server to users: the
+ * message stays SvelteKit's `"Internal Error"`. It logs errors with `console.error`.
+ * Server errors reach a boundary's `failed` snippet when it renders on the server. Made for
+ * SvelteKit 3: SvelteKit 2 doesn't say which errors are its own, so there every error is logged.
+ *
+ * **Example** (Using it as the server hook)
+ *
+ * ```ts
+ * // src/hooks.server.ts
+ * export { handleServerError as handleError } from "effect-atom-svelte/sveltekit";
+ * ```
+ *
+ * @stability unstable
+ * @since 0.1.0
+ * @category hooks
+ */
+export declare const handleServerError: (input: CaughtError) => EffectErrorBody | undefined;