@tempots/dom 33.0.0 → 33.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tempots/dom",
-  "version": "33.0.0",
+  "version": "33.1.1",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",

package/std/signal.d.ts

@@ -18,6 +18,12 @@ export type ListenerOptions = {
     skipInitial?: boolean;
     once?: boolean;
     abortSignal?: AbortSignal;
+    /**
+     * If true, the listener will not be automatically disposed when the current scope ends.
+     * Use this when you need explicit control over the listener lifecycle.
+     * @internal
+     */
+    noAutoDispose?: boolean;
 };
 /**
  * A reactive signal that holds a value and notifies listeners when the value changes.
@@ -153,8 +159,28 @@ export declare class Signal<T> {
      * The listener function will be immediately called with the current value of the signal.
      * Returns a function that can be called to unregister the listener.
      *
+     * When called within a DisposalScope (e.g., inside a renderable), the listener is
+     * automatically cleaned up when the scope is disposed. This prevents memory leaks
+     * when listening to outer-scope signals from inner scopes.
+     *
      * @param listener - The listener function to be called when the value of the signal changes.
      * @param options - Options for the listener.
+     *
+     * @example
+     * ```typescript
+     * // Automatic cleanup when scope disposes
+     * const MyComponent = () => {
+     *   const outerSignal = prop(0)
+     *
+     *   return html.div(
+     *     When(someCondition, () => {
+     *       // This listener is automatically cleaned up when the When() disposes
+     *       outerSignal.on(value => console.log(value))
+     *       return html.span('Inner content')
+     *     })
+     *   )
+     * }
+     * ```
      */
     readonly on: (listener: (value: T, previousValue: T | undefined) => void, options?: ListenerOptions) => () => void;
     /**
@@ -187,6 +213,7 @@ export declare class Signal<T> {
     readonly onDispose: (listener: () => void) => void;
     /**
      * Disposes the signal, releasing any resources associated with it.
+     * This clears all listeners, derivatives, and disposal callbacks.
      */
     readonly dispose: () => void;
     /**