effect-atom-svelte 0.1.2 → 0.3.0

package/dist/SvelteKit.d.ts

@@ -4,7 +4,9 @@
  *
  * 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`.
+ * `HandleServerError` once `App.Error` declares `tag?: string`. In SvelteKit 2, whose `App.Error`
+ * requires a message, they are typed to return one when there is no `kind`, as they then always
+ * set one.
  *
  * @since 0.1.0
  */
@@ -38,6 +40,27 @@ export interface EffectErrorBody {
     readonly message?: string;
     readonly tag?: string;
 }
+/**
+ * SvelteKit 2's `handleError` input: no `kind`, and always a message, which the hooks fall back on.
+ *
+ * @stability unstable
+ * @since 0.2.1
+ * @category models
+ */
+export interface CaughtErrorWithoutKind extends CaughtError {
+    readonly kind?: undefined;
+    readonly message: string;
+}
+/**
+ * What the hooks return for SvelteKit 2's input: always a message, as its `App.Error` requires one.
+ *
+ * @stability unstable
+ * @since 0.2.1
+ * @category models
+ */
+export interface EffectErrorBodyWithMessage extends EffectErrorBody {
+    readonly message: 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
@@ -56,7 +79,8 @@ export interface EffectErrorBody {
  * @since 0.1.0
  * @category hooks
  */
-export declare const handleClientError: (input: CaughtError) => EffectErrorBody | undefined;
+export declare function handleClientError(input: CaughtErrorWithoutKind): EffectErrorBodyWithMessage;
+export declare function 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
@@ -75,4 +99,5 @@ export declare const handleClientError: (input: CaughtError) => EffectErrorBody
  * @since 0.1.0
  * @category hooks
  */
-export declare const handleServerError: (input: CaughtError) => EffectErrorBody | undefined;
+export declare function handleServerError(input: CaughtErrorWithoutKind): EffectErrorBodyWithMessage;
+export declare function handleServerError(input: CaughtError): EffectErrorBody | undefined;

package/dist/SvelteKit.js

@@ -4,7 +4,9 @@
  *
  * 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`.
+ * `HandleServerError` once `App.Error` declares `tag?: string`. In SvelteKit 2, whose `App.Error`
+ * requires a message, they are typed to return one when there is no `kind`, as they then always
+ * set one.
  *
  * @since 0.1.0
  */
@@ -31,52 +33,17 @@ const body = (message, tag) => {
     }
     return { ...(message ? { message } : {}), ...(tag ? { tag } : {}) };
 };
-/**
- * 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 const handleClientError = (input) => {
+export function handleClientError(input) {
     // Destructured here, not in the parameter list, so the API reference shows a named parameter.
     const { error, kind = "unknown" } = input;
     if (kind !== "unknown") {
         return undefined;
     }
     console.error(error);
-    return body(messageOf(error) ?? fallbackMessage(input), tagOf(error));
-};
-/**
- * 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 const handleServerError = (input) => {
+    // `||`, not `??`: an error with an empty message gets SvelteKit 2's instead.
+    return body(messageOf(error) || fallbackMessage(input), tagOf(error));
+}
+export function handleServerError(input) {
     const { error, issues, kind = "unknown" } = input;
     if (kind === "validation") {
         console.error("Remote function schema validation failed:", issues);
@@ -87,4 +54,4 @@ export const handleServerError = (input) => {
     }
     console.error(error);
     return body(fallbackMessage(input), tagOf(error));
-};
+}

package/dist/index.d.ts

@@ -47,4 +47,4 @@ export * as ScopedAtom from "./ScopedAtom.ts";
  * @since 0.1.0
  * @category re-exports
  */
-export { AsyncResult, Atom, AtomHttpApi, AtomRef, AtomRegistry, AtomRpc, Hydration, } from "effect/reactivity";
+export { AsyncResult, Atom, AtomHttpApi, AtomRef, AtomRegistry, AtomRpc, Hydration, Reactivity, } from "effect/reactivity";

package/dist/index.js

@@ -47,4 +47,4 @@ export * as ScopedAtom from "./ScopedAtom.js";
  * @since 0.1.0
  * @category re-exports
  */
-export { AsyncResult, Atom, AtomHttpApi, AtomRef, AtomRegistry, AtomRpc, Hydration, } from "effect/reactivity";
+export { AsyncResult, Atom, AtomHttpApi, AtomRef, AtomRegistry, AtomRpc, Hydration, Reactivity, } from "effect/reactivity";

package/dist/internal/boundaries.d.ts

@@ -0,0 +1,9 @@
+import type { AtomRegistry } from "effect/reactivity";
+/**
+ * Per registry, key and queued value, how many live boundaries queued it. Boundaries given the
+ * same state, as a layout and its page might be, queue the same values, and one destroyed first
+ * must leave them for the other's children.
+ */
+export declare const queuedBy: WeakMap<AtomRegistry.AtomRegistry, Map<string, Map<unknown, number>>>;
+/** Whether a live boundary brought a value for the key: it sends that value to the browser itself. */
+export declare const queuedByBoundary: (registry: AtomRegistry.AtomRegistry, key: string) => boolean;

package/dist/internal/boundaries.js

@@ -0,0 +1,8 @@
+/**
+ * Per registry, key and queued value, how many live boundaries queued it. Boundaries given the
+ * same state, as a layout and its page might be, queue the same values, and one destroyed first
+ * must leave them for the other's children.
+ */
+export const queuedBy = new WeakMap();
+/** Whether a live boundary brought a value for the key: it sends that value to the browser itself. */
+export const queuedByBoundary = (registry, key) => queuedBy.get(registry)?.has(key) === true;

package/dist/internal/disposal.d.ts

@@ -0,0 +1,13 @@
+import type { AtomRegistry } from "effect/reactivity";
+/** Calls `f` once if `registry` is disposed of through `disposeRegistry`; returns the canceler. */
+export declare const onDispose: (registry: AtomRegistry.AtomRegistry, f: () => void) => (() => void);
+/**
+ * Disposes of `registry`, then runs what waited on it, even when a finalizer the disposal runs
+ * throws.
+ *
+ * In the browser that error is rethrown on a microtask, so it is still reported as uncaught but
+ * stays out of Svelte's teardown: thrown from the `onDestroy` of a component being destroyed, it
+ * escapes Svelte's flush and leaves every `$derived` on the page running again on every read. On
+ * the server it is thrown here.
+ */
+export declare const disposeRegistry: (registry: AtomRegistry.AtomRegistry) => void;

package/dist/internal/disposal.js

@@ -0,0 +1,43 @@
+import { BROWSER } from "esm-env";
+const callbacks = new WeakMap();
+/** Calls `f` once if `registry` is disposed of through `disposeRegistry`; returns the canceler. */
+export const onDispose = (registry, f) => {
+    let set = callbacks.get(registry);
+    if (set === undefined) {
+        set = new Set();
+        callbacks.set(registry, set);
+    }
+    set.add(f);
+    return () => {
+        set.delete(f);
+    };
+};
+/**
+ * Disposes of `registry`, then runs what waited on it, even when a finalizer the disposal runs
+ * throws.
+ *
+ * In the browser that error is rethrown on a microtask, so it is still reported as uncaught but
+ * stays out of Svelte's teardown: thrown from the `onDestroy` of a component being destroyed, it
+ * escapes Svelte's flush and leaves every `$derived` on the page running again on every read. On
+ * the server it is thrown here.
+ */
+export const disposeRegistry = (registry) => {
+    try {
+        registry.dispose();
+    }
+    catch (error) {
+        if (!BROWSER) {
+            throw error;
+        }
+        queueMicrotask(() => {
+            throw error;
+        });
+    }
+    finally {
+        const set = callbacks.get(registry);
+        callbacks.delete(registry);
+        for (const f of set ?? []) {
+            f();
+        }
+    }
+};

package/dist/internal/hydration.d.ts

@@ -6,6 +6,11 @@ export declare const setRevalidateOnHydrate: (value: boolean) => void;
  * provider's, else no (JND-19). Call during component init.
  */
 export declare const revalidatesOnHydrate: (option: boolean | undefined) => boolean;
+/**
+ * What the server sends for a result it doesn't pass on, so the browser computes the atom itself.
+ * An encoded `AsyncResult` is an object, never `null`.
+ */
+export declare const noSeed: null;
 /**
  * Encodes the server's result for the page, or returns the no-seed marker for a result that must
  * not or cannot travel:
@@ -17,8 +22,12 @@ export declare const revalidatesOnHydrate: (option: boolean | undefined) => bool
  *   failing the whole render. Development builds warn.
  */
 export declare const encodeSeed: (key: string, encode: (value: AsyncResult.AsyncResult<unknown, unknown>) => unknown, result: AsyncResult.AsyncResult<unknown, unknown>) => unknown;
-/** The server's result, decoded, or undefined when the server sent none. */
-export declare const decodeSeed: (value: unknown, decode: (value: unknown) => unknown) => unknown;
+/**
+ * The server's result, decoded, or undefined when the server sent none or it doesn't decode with
+ * the browser's schema: the browser then computes the atom itself, as for a result the server
+ * couldn't encode. Development builds warn.
+ */
+export declare const decodeSeed: (key: string, value: unknown, decode: (value: unknown) => unknown) => unknown;
 /**
  * Whether a seed is still waiting, as a stream's result is between its values. The browser runs
  * the atom again from it, as the server's run ended with the render.

package/dist/internal/hydration.js

@@ -19,7 +19,7 @@ export const revalidatesOnHydrate = (option) => option ?? (hasDefault() ? getDef
  * What the server sends for a result it doesn't pass on, so the browser computes the atom itself.
  * An encoded `AsyncResult` is an object, never `null`.
  */
-const noSeed = null;
+export const noSeed = null;
 /**
  * Encodes the server's result for the page, or returns the no-seed marker for a result that must
  * not or cannot travel:
@@ -48,8 +48,28 @@ export const encodeSeed = (key, encode, result) => {
         return noSeed;
     }
 };
-/** The server's result, decoded, or undefined when the server sent none. */
-export const decodeSeed = (value, decode) => (value === noSeed ? undefined : decode(value));
+/**
+ * The server's result, decoded, or undefined when the server sent none or it doesn't decode with
+ * the browser's schema: the browser then computes the atom itself, as for a result the server
+ * couldn't encode. Development builds warn.
+ */
+export const decodeSeed = (key, value, decode) => {
+    if (value === noSeed) {
+        return undefined;
+    }
+    try {
+        return decode(value);
+    }
+    catch (error) {
+        if (!Schema.isSchemaError(error)) {
+            throw error;
+        }
+        if (DEV) {
+            console.warn(`effect-atom-svelte: the server's result for the serializable atom "${key}" doesn't decode with its schema, so the browser computes the atom again.`, error);
+        }
+        return undefined;
+    }
+};
 /**
  * Whether a seed is still waiting, as a stream's result is between its values. The browser runs
  * the atom again from it, as the server's run ended with the render.

package/dist/internal/nodeInternals.d.ts

@@ -0,0 +1,30 @@
+import type { AtomRegistry } from "effect/reactivity";
+/** What `instrumentNode` reports. */
+export interface NodeHooks {
+    /** The node is about to compute its value. */
+    readonly build: () => void;
+    /** The computation `build` announced has returned or thrown. */
+    readonly built: () => void;
+    /** The node's value changed from `previous` to `next`. */
+    readonly value: (previous: unknown, next: unknown) => void;
+    /**
+     * What the last computation started is about to be torn down: `finalizers` is how many will run,
+     * and `value` is the node's value, still the one that computation produced.
+     */
+    readonly dispose: (finalizers: number, value: unknown) => void;
+    /** A listener was added or removed; the node's `listeners` hold the new set. */
+    readonly readers: () => void;
+    /** The node's remove() has returned. */
+    readonly removed: () => void;
+}
+/** Reports what happens to a node, or returns false if it isn't the implementation this expects. */
+export declare const instrumentNode: (node: AtomRegistry.Node<unknown>, hooks: NodeHooks) => boolean;
+/**
+ * The idle TTL a registry gives atoms without their own (`AtomRegistry.make`'s `defaultIdleTTL`),
+ * which the implementation keeps but the interface doesn't show.
+ */
+export declare const defaultIdleTTL: (registry: AtomRegistry.AtomRegistry) => number | undefined;
+/** Whether the node holds an initial value it hasn't computed (setInitialValue on a new node). */
+export declare const holdsInitialValue: (node: AtomRegistry.Node<unknown>) => boolean;
+/** Whether the node is building and its running build has not read `parent` yet. */
+export declare const buildWillRead: (node: AtomRegistry.Node<unknown>, parent: AtomRegistry.Node<unknown>) => boolean;

package/dist/internal/nodeInternals.js

@@ -0,0 +1,107 @@
+const isNodeImpl = (node) => Object.hasOwn(node, "_value") &&
+    Object.hasOwn(node, "lifetime") &&
+    typeof node.build === "function" &&
+    node.listeners instanceof Set;
+/** A node's listeners that report each one added or removed. */
+class Listeners extends Set {
+    #changed;
+    constructor(listeners, changed) {
+        super();
+        for (const listener of listeners) {
+            super.add(listener);
+        }
+        this.#changed = changed;
+    }
+    add(listener) {
+        const added = !this.has(listener);
+        super.add(listener);
+        if (added) {
+            this.#changed();
+        }
+        return this;
+    }
+    clear() {
+        const had = this.size > 0;
+        super.clear();
+        if (had) {
+            this.#changed();
+        }
+    }
+    delete(listener) {
+        const deleted = super.delete(listener);
+        if (deleted) {
+            this.#changed();
+        }
+        return deleted;
+    }
+}
+/** Reports what happens to a node, or returns false if it isn't the implementation this expects. */
+export const instrumentNode = (node, hooks) => {
+    if (!isNodeImpl(node)) {
+        return false;
+    }
+    const { build: compute, remove: removeNode } = node;
+    node.remove = function remove() {
+        try {
+            removeNode.call(this);
+        }
+        finally {
+            hooks.removed();
+        }
+    };
+    let value = node._value;
+    let { lifetime } = node;
+    node.build = function build() {
+        hooks.build();
+        try {
+            compute.call(this);
+        }
+        finally {
+            hooks.built();
+        }
+    };
+    Object.defineProperties(node, {
+        _value: {
+            configurable: true,
+            enumerable: true,
+            get: () => value,
+            set: (next) => {
+                const previous = value;
+                value = next;
+                hooks.value(previous, next);
+            },
+        },
+        lifetime: {
+            configurable: true,
+            enumerable: true,
+            get: () => lifetime,
+            set: (next) => {
+                const previous = lifetime;
+                lifetime = next;
+                if (next === undefined && previous !== undefined) {
+                    hooks.dispose(previous.finalizers?.length ?? 0, value);
+                }
+            },
+        },
+    });
+    node.listeners = new Listeners(node.listeners, hooks.readers);
+    return true;
+};
+/**
+ * The idle TTL a registry gives atoms without their own (`AtomRegistry.make`'s `defaultIdleTTL`),
+ * which the implementation keeps but the interface doesn't show.
+ */
+export const defaultIdleTTL = (registry) => {
+    const ttl = registry
+        .defaultIdleTTL;
+    return typeof ttl === "number" ? ttl : undefined;
+};
+/** Whether the node holds an initial value it hasn't computed (setInitialValue on a new node). */
+export const holdsInitialValue = (node) => node
+    .preserveInitialValueOnBuild === true;
+/** Whether the node is building and its running build has not read `parent` yet. */
+export const buildWillRead = (node, parent) => {
+    const reads = node.lifetime
+        ?.reads;
+    return reads !== undefined && !reads.has(parent);
+};

package/dist/internal/registries.d.ts

@@ -0,0 +1,6 @@
+import type { AtomRegistry } from "effect/reactivity";
+export declare const list: () => readonly AtomRegistry.AtomRegistry[];
+/** Adds a registry to the list; returns the function that takes it off again. */
+export declare const track: (registry: AtomRegistry.AtomRegistry) => (() => void);
+/** Calls `f` with the list now and whenever it changes; returns the function that stops it. */
+export declare const watch: (f: (registries: readonly AtomRegistry.AtomRegistry[]) => void) => (() => void);

package/dist/internal/registries.js

@@ -0,0 +1,40 @@
+// How many providers hold each registry: one passed to several providers stays until all unmount.
+const holders = new Map();
+const watchers = new Set();
+export const list = () => [
+    ...holders.keys(),
+];
+const announce = () => {
+    const registries = list();
+    for (const watcher of watchers) {
+        watcher(registries);
+    }
+};
+/** Adds a registry to the list; returns the function that takes it off again. */
+export const track = (registry) => {
+    holders.set(registry, (holders.get(registry) ?? 0) + 1);
+    announce();
+    let released = false;
+    return () => {
+        if (released) {
+            return;
+        }
+        released = true;
+        const count = (holders.get(registry) ?? 1) - 1;
+        if (count === 0) {
+            holders.delete(registry);
+        }
+        else {
+            holders.set(registry, count);
+        }
+        announce();
+    };
+};
+/** Calls `f` with the list now and whenever it changes; returns the function that stops it. */
+export const watch = (f) => {
+    watchers.add(f);
+    f(list());
+    return () => {
+        watchers.delete(f);
+    };
+};

package/dist/internal/renderEnd.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Runs `f` once when the server render ends: in `onDestroy`, and failing that when the render's
+ * abort signal fires. A `<svelte:boundary>` with a `failed` snippet discards the content of children
+ * that throw while setting up, and their `onDestroy` callbacks with it, so a component set up before
+ * the throw would otherwise keep its mounts and holds on a caller-owned registry, and the next
+ * request would render this one's initial values (JND-17). On the server `getAbortSignal` returns the
+ * render's signal, which Svelte aborts once every `onDestroy` has run. A dropped component whose
+ * script awaits before calling this resumes after the render has ended and the signal has aborted,
+ * where a listener would never fire, so `f` then runs in a microtask: callers take what `f` releases
+ * synchronously after calling this. Call it during component init. Svelte bug workaround, to be
+ * removed with the fix (https://github.com/jarrednorrisdev/effect-atom-svelte/issues/35).
+ */
+export declare const onRenderEnd: (f: () => void) => void;

package/dist/internal/renderEnd.js

@@ -0,0 +1,34 @@
+// When a server render ends, for the hooks that release what they hold in a registry the caller may
+// keep across requests. Internal: not exported from the package.
+import { getAbortSignal, onDestroy } from "svelte";
+/**
+ * Runs `f` once when the server render ends: in `onDestroy`, and failing that when the render's
+ * abort signal fires. A `<svelte:boundary>` with a `failed` snippet discards the content of children
+ * that throw while setting up, and their `onDestroy` callbacks with it, so a component set up before
+ * the throw would otherwise keep its mounts and holds on a caller-owned registry, and the next
+ * request would render this one's initial values (JND-17). On the server `getAbortSignal` returns the
+ * render's signal, which Svelte aborts once every `onDestroy` has run. A dropped component whose
+ * script awaits before calling this resumes after the render has ended and the signal has aborted,
+ * where a listener would never fire, so `f` then runs in a microtask: callers take what `f` releases
+ * synchronously after calling this. Call it during component init. Svelte bug workaround, to be
+ * removed with the fix (https://github.com/jarrednorrisdev/effect-atom-svelte/issues/35).
+ */
+export const onRenderEnd = (f) => {
+    let done = false;
+    const once = () => {
+        if (!done) {
+            done = true;
+            f();
+        }
+    };
+    onDestroy(once);
+    const signal = getAbortSignal();
+    if (signal.aborted) {
+        // The render already ended, as for a component a failed boundary dropped whose script resumed
+        // after an await. Deferred, as callers register before taking what `f` releases.
+        queueMicrotask(once);
+    }
+    else {
+        signal.addEventListener("abort", once, { once: true });
+    }
+};

package/dist/internal/scope.svelte.d.ts

@@ -0,0 +1,29 @@
+import type { Atom, AtomRegistry } from "effect/reactivity";
+/** How a hook uses its atom: reads it, holds it mounted, subscribes to it, or writes it. */
+export type ReadKind = "read" | "mount" | "subscribe" | "write";
+/** A component, as the atomLabels plugin names it: `Counter`, from `/src/routes/counter.svelte`. */
+export interface ComponentName {
+    readonly name: string;
+    readonly file: string | undefined;
+    /** One per instance of the component, so two `<Counter>`s are told apart. */
+    readonly instance: number;
+}
+/** What a scope takes from the hooks. */
+export interface Reporter {
+    /** A hook started using `atom`; returns the function to call when it stops. */
+    readonly report: (read: {
+        readonly registry: AtomRegistry.AtomRegistry;
+        readonly atom: Atom.Atom<unknown>;
+        readonly kind: ReadKind;
+        readonly component: ComponentName | undefined;
+    }) => () => void;
+}
+declare const setReporter: (context: Reporter) => Reporter;
+export { setReporter };
+/** Names the component being set up, for the scopes its hooks report to. */
+export declare const nameComponent: (name: string, file?: string) => void;
+/**
+ * Reports the atom a hook uses, following its getter, while the component lives. Called while the
+ * hook sets up; adds an effect only in the browser, and only under a scope.
+ */
+export declare const reportReads: (registry: AtomRegistry.AtomRegistry, getAtom: () => Atom.Atom<unknown>, kind: ReadKind) => void;

package/dist/internal/scope.svelte.js

@@ -0,0 +1,23 @@
+import { BROWSER } from "esm-env";
+import { createContext } from "svelte";
+const [getReporter, setReporter, hasReporter] = createContext();
+const [getComponent, setComponent, hasComponent] = createContext();
+export { setReporter };
+let instances = 0;
+/** Names the component being set up, for the scopes its hooks report to. */
+export const nameComponent = (name, file) => {
+    instances += 1;
+    setComponent({ file, instance: instances, name });
+};
+/**
+ * Reports the atom a hook uses, following its getter, while the component lives. Called while the
+ * hook sets up; adds an effect only in the browser, and only under a scope.
+ */
+export const reportReads = (registry, getAtom, kind) => {
+    if (!BROWSER || !hasReporter()) {
+        return;
+    }
+    const reporter = getReporter();
+    const component = hasComponent() ? getComponent() : undefined;
+    $effect(() => reporter.report({ atom: getAtom(), component, kind, registry }));
+};

package/dist/internal/teardown.svelte.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Runs `f` when the component is destroyed, even while its script is still awaiting. In the browser
+ * `onDestroy` only takes effect once the component mounts, so a component removed while pending
+ * would never call it. A pre effect runs during init and is torn down with the component (JND-16).
+ * On the server, `f` runs when the render ends, even for a component a failed boundary dropped.
+ */
+export declare const onTeardown: (f: () => void) => void;
+/**
+ * As `onTeardown`, but for a mounted component `f` runs after its children are destroyed, as with
+ * `onDestroy`: a pre effect is torn down before the children, whose own teardown may still use what
+ * `f` ends, such as a provider's registry. The pre effect only covers a component destroyed before
+ * it mounted. On the server `f` runs through `onRenderEnd`, so `provideRegistry` disposes its
+ * registry even when a failed boundary dropped the provider. A successful render keeps the
+ * children-first order through `onDestroy`; when the render ends without it, `f` may run before
+ * the children's releases, which are then no-ops on the disposed registry.
+ */
+export declare const onTeardownAfterChildren: (f: () => void) => void;

package/dist/internal/teardown.svelte.js

@@ -0,0 +1,44 @@
+// When a component is destroyed, for the hooks and providers. Internal: not exported from the
+// package.
+import { BROWSER } from "esm-env";
+import { onDestroy, onMount } from "svelte";
+import { onRenderEnd } from "./renderEnd.js";
+/**
+ * Runs `f` when the component is destroyed, even while its script is still awaiting. In the browser
+ * `onDestroy` only takes effect once the component mounts, so a component removed while pending
+ * would never call it. A pre effect runs during init and is torn down with the component (JND-16).
+ * On the server, `f` runs when the render ends, even for a component a failed boundary dropped.
+ */
+export const onTeardown = (f) => {
+    if (BROWSER) {
+        $effect.pre(() => f);
+    }
+    else {
+        onRenderEnd(f);
+    }
+};
+/**
+ * As `onTeardown`, but for a mounted component `f` runs after its children are destroyed, as with
+ * `onDestroy`: a pre effect is torn down before the children, whose own teardown may still use what
+ * `f` ends, such as a provider's registry. The pre effect only covers a component destroyed before
+ * it mounted. On the server `f` runs through `onRenderEnd`, so `provideRegistry` disposes its
+ * registry even when a failed boundary dropped the provider. A successful render keeps the
+ * children-first order through `onDestroy`; when the render ends without it, `f` may run before
+ * the children's releases, which are then no-ops on the disposed registry.
+ */
+export const onTeardownAfterChildren = (f) => {
+    if (!BROWSER) {
+        onRenderEnd(f);
+        return;
+    }
+    let mounted = false;
+    $effect.pre(() => () => {
+        if (!mounted) {
+            f();
+        }
+    });
+    onMount(() => {
+        mounted = true;
+    });
+    onDestroy(f);
+};

package/dist/internal/troubleshooting.d.ts

@@ -0,0 +1,2 @@
+/** The sentence that ends an error message: a link to its entry on the troubleshooting page. */
+export declare const troubleshooting: (entry: string) => string;

package/dist/internal/troubleshooting.js

@@ -0,0 +1,3 @@
+// Where error messages point for more. Internal: not exported from the package.
+/** The sentence that ends an error message: a link to its entry on the troubleshooting page. */
+export const troubleshooting = (entry) => `See https://atom.jarrednorris.dev/troubleshooting#${entry}`;