effectweb 0.2.3 → 0.3.1

package/dist/cache.js

@@ -1,35 +1,102 @@
-import { Effect, Option } from 'effect';
+import { Settlement } from './settlement.js';
+import { protectSnapshot } from './snapshot.js';
+import { Deferred, Effect, Option } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import * as Atom from 'effect/unstable/reactivity/Atom';
 import * as AtomRegistry from 'effect/unstable/reactivity/AtomRegistry';
 import { loadEffect } from './load.js';
-import { shareValue } from './share.js';
+import { shareData } from './sharing.js';
+import { encodeQueryKey } from './query.js';
+import { registerCache } from './cache-internals.js';
+import { queryDefinition } from './query-internals.js';
 export { loadEffect } from './load.js';
 export { shareValue } from './share.js';
-export function makeQueryCache(runtime) {
-    return createQueryCache(runtime);
+export function makeQueryCache(runtimeOrOptions, options = {}) {
+    return runtimeOrOptions && 'provide' in runtimeOrOptions
+        ? createQueryCache(runtimeOrOptions, options)
+        : createQueryCache(undefined, runtimeOrOptions);
 }
-function createQueryCache(runtime) {
-    const registry = AtomRegistry.make({ defaultIdleTTL: 30_000 });
+function createQueryCache(runtime, options = {}) {
+    const retention = options.retention ?? 30_000;
+    if (!Number.isFinite(retention) || retention < 0)
+        throw new RangeError('Query retention must be finite and nonnegative.');
+    const registry = AtomRegistry.make({ defaultIdleTTL: retention });
+    const cancelValue = Symbol('cancel');
+    const removeValue = Symbol('remove');
     const generation = Atom.keepAlive(Atom.make(0));
     const resources = new Map();
-    const acquire = (key, load, share = shareValue) => {
+    const entriesByAtom = new WeakMap();
+    // Follow registry-node lifetime; retaining definitions must not retain evicted data.
+    const values = new WeakMap();
+    const identities = new WeakMap();
+    let disposed = false;
+    const settlement = new Settlement();
+    let closing;
+    let nextId = 0;
+    let nextRevision = 0;
+    const identity = (definition) => {
+        let id = identities.get(definition);
+        if (id === undefined) {
+            id = ++nextId;
+            identities.set(definition, id);
+        }
+        return id;
+    };
+    const acquire = (key, load, share = (previous, next) => shareData(previous, next)) => {
         let entry = resources.get(key);
         if (entry)
             entry.load = load;
         else {
+            const loaded = Atom.make((get) => {
+                const previous = Option.flatMap(get.self(), AsyncResult.value);
+                next.revision = ++nextRevision;
+                next.canceled = false;
+                const revision = next.revision;
+                return Effect.suspend(() => {
+                    const finish = settlement.begin();
+                    return loadEffect(() => next.load()).pipe(Effect.map((value) => {
+                        const shared = Option.isSome(previous)
+                            ? share(previous.value, value)
+                            : value;
+                        const snapshot = protectSnapshot(shared);
+                        if (!disposed && revision === next.revision)
+                            remember(next, snapshot);
+                        return snapshot;
+                    }), Effect.ensuring(Effect.sync(finish)));
+                });
+            });
             const next = {
                 load,
-                atom: Atom.make((get) => {
-                    const previous = Option.flatMap(get.self(), AsyncResult.value);
-                    return loadEffect(() => next.load()).pipe(Effect.map((value) => {
-                        next.loadedAt = Date.now();
-                        return Option.isSome(previous) ? share(previous.value, value) : value;
-                    }));
+                users: 0,
+                prefetches: new Set(),
+                revision: 0,
+                atom: Atom.writable(loaded.read, (context, value) => {
+                    Atom.batch(() => {
+                        next.revision = ++nextRevision;
+                        // Refresh disposes the load lifetime; setSelf publishes without starting another load.
+                        context.refreshSelf();
+                        if (value === cancelValue || value === removeValue) {
+                            const previous = value === removeValue ? undefined : previousValue(next);
+                            next.canceled = true;
+                            if (value === removeValue) {
+                                delete next.loadedAt;
+                                const node = registry.getNodes().get(next.atom);
+                                if (node)
+                                    values.delete(node);
+                            }
+                            context.setSelf(previous ? AsyncResult.success(previous.value) : AsyncResult.initial());
+                        }
+                        else {
+                            next.canceled = false;
+                            remember(next, value);
+                            context.setSelf(AsyncResult.success(value));
+                        }
+                    });
                 }),
             };
             entry = next;
             resources.set(key, entry);
+            entriesByAtom.set(entry.atom, entry);
         }
         // Bound definitions as well as the registry's values. Mounted resources stay shared.
         if (resources.size > 512) {
@@ -42,62 +109,216 @@ function createQueryCache(runtime) {
         }
         return { entry, atom: entry.atom };
     };
-    const queryKey = (definition, args) => `query:${definition.id}:${definition.key(args)}`;
-    const selectQuery = (definition, args) => {
+    const remember = (entry, value) => {
+        entry.loadedAt = Date.now();
+        const node = registry.getNodes().get(entry.atom);
+        if (node)
+            values.set(node, { value });
+    };
+    const previousValue = (entry) => {
+        const node = entry && registry.getNodes().get(entry.atom);
+        return node ? values.get(node) : undefined;
+    };
+    const checkWritable = () => {
+        if (disposed)
+            throw new Error('Cannot write to a disposed query cache.');
+    };
+    const queryKey = (definition, args) => `query:${identity(definition)}:${encodeQueryKey(args)}`;
+    const acquireQuery = (definition, args) => {
+        const config = queryDefinition(definition);
+        protectSnapshot(args);
         const { entry, atom } = acquire(queryKey(definition, args), () => {
-            const effect = Effect.suspend(() => definition.load(args));
+            const effect = Effect.suspend(() => config.load(args, previousValue(resources.get(queryKey(definition, args)))?.value));
             return runtime ? runtime.provide(effect) : effect;
-        }, definition.share);
-        entry.queryId = definition.id;
+        }, config.share);
+        entry.query = definition;
+        entry.args = args;
+        entry.groups = config.groups;
+        entry.unused = config.unused ?? options.unused;
+        return { entry, atom, config };
+    };
+    const refresh = (entry) => {
+        entry.revision = ++nextRevision;
+        registry.refresh(entry.atom);
+    };
+    const selectQuery = (definition, args) => {
+        const { entry, atom, config } = acquireQuery(definition, args);
+        if (entry.canceled && !previousValue(entry))
+            refresh(entry);
         if (registry.getNodes().has(atom) &&
             entry.loadedAt !== undefined &&
-            Date.now() - entry.loadedAt >= definition.staleTime) {
+            Date.now() - entry.loadedAt >= config.staleTime) {
             const current = registry.get(atom);
             if (!current.waiting)
-                registry.refresh(atom);
+                refresh(entry);
         }
         return atom;
     };
-    return {
-        registry,
-        generation,
-        resource(key, load) {
-            return acquire(key, load).atom;
+    const retain = (atom) => {
+        const entry = entriesByAtom.get(atom);
+        if (!entry)
+            return () => { };
+        entry.users++;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            entry.users--;
+            if (!disposed &&
+                entry.users === 0 &&
+                entry.unused === 'cancel' &&
+                registry.getNodes().has(entry.atom) &&
+                registry.get(entry.atom).waiting)
+                registry.set(entry.atom, cancelValue);
+        };
+    };
+    const abortPrefetches = (entry) => {
+        // oxlint-disable-next-line unicorn/no-useless-spread -- Cancellation can add or remove observers reentrantly.
+        for (const abort of [...entry.prefetches])
+            abort();
+    };
+    const cache = {
+        batch: Atom.batch,
+        getQueryData(definition, args) {
+            return previousValue(resources.get(queryKey(definition, args)))?.value;
         },
-        query: selectQuery,
-        prefetch(definition, args) {
-            return Effect.suspend(() => AtomRegistry.getResult(registry, selectQuery(definition, args), { suspendOnWaiting: true }));
+        invalidateWhere(definition, predicate) {
+            const selected = [...resources.values()].filter((entry) => entry.query === definition && predicate(entry.args));
+            Atom.batch(() => {
+                for (const entry of selected)
+                    refresh(entry);
+            });
+        },
+        invalidateGroup(group) {
+            Atom.batch(() => {
+                for (const entry of resources.values())
+                    if (entry.groups?.includes(group))
+                        refresh(entry);
+            });
+        },
+        cancelQuery(definition, ...selected) {
+            Atom.batch(() => {
+                for (const [key, entry] of resources)
+                    if (entry.query === definition &&
+                        (!selected.length || key === queryKey(definition, selected[0])))
+                        if (registry.getNodes().has(entry.atom) && registry.get(entry.atom).waiting) {
+                            abortPrefetches(entry);
+                            registry.set(entry.atom, cancelValue);
+                        }
+            });
+        },
+        removeQuery(definition, ...selected) {
+            Atom.batch(() => {
+                for (const [key, entry] of resources)
+                    if (entry.query === definition &&
+                        (!selected.length || key === queryKey(definition, selected[0])))
+                        if (registry.getNodes().has(entry.atom)) {
+                            abortPrefetches(entry);
+                            registry.set(entry.atom, removeValue);
+                        }
+            });
+        },
+        prefetch(definition, args, options) {
+            return Effect.suspend(() => {
+                checkWritable();
+                const atom = selectQuery(definition, args);
+                const release = retain(atom);
+                const entry = entriesByAtom.get(atom);
+                const signal = Deferred.makeUnsafe();
+                const abort = () => {
+                    Deferred.doneUnsafe(signal, Effect.interrupt);
+                };
+                entry.prefetches.add(abort);
+                return Effect.suspend(() => {
+                    if (options?.refresh && registry.getNodes().has(atom) && !registry.get(atom).waiting)
+                        refresh(entry);
+                    return Effect.raceFirst(Deferred.await(signal), AtomRegistry.getResult(registry, atom, { suspendOnWaiting: true }));
+                }).pipe(Effect.ensuring(Effect.sync(() => {
+                    entry.prefetches.delete(abort);
+                    release();
+                })));
+            });
+        },
+        setQueryData(definition, args, value) {
+            checkWritable();
+            const { entry, config } = acquireQuery(definition, args);
+            const previous = previousValue(entry);
+            const next = protectSnapshot(value);
+            const shared = previous
+                ? config.share
+                    ? config.share(previous.value, next)
+                    : shareData(previous.value, next)
+                : next;
+            const snapshot = protectSnapshot(shared);
+            checkWritable();
+            registry.set(entry.atom, snapshot);
+            return snapshot;
+        },
+        updateQueryData(definition, args, update) {
+            checkWritable();
+            queryDefinition(definition);
+            protectSnapshot(args);
+            const previous = previousValue(resources.get(queryKey(definition, args)));
+            if (!previous)
+                return undefined;
+            const next = update(previous.value);
+            return next === undefined ? undefined : cache.setQueryData(definition, args, next);
         },
         invalidateQuery(definition, ...selected) {
             if (selected.length) {
                 const entry = resources.get(queryKey(definition, selected[0]));
                 if (entry)
-                    registry.refresh(entry.atom);
+                    refresh(entry);
             }
             else {
-                for (const entry of resources.values())
-                    if (entry.queryId === definition.id)
-                        registry.refresh(entry.atom);
+                cache.invalidateWhere(definition, () => true);
             }
         },
-        invalidate(prefix) {
-            for (const [key, entry] of resources)
-                if (key.startsWith(prefix))
-                    registry.refresh(entry.atom);
+        onReset(listener) {
+            registry.get(generation);
+            return registry.subscribe(generation, listener);
         },
         resetResources() {
             Atom.batch(() => {
                 for (const entry of resources.values()) {
+                    abortPrefetches(entry);
                     entry.load = () => Effect.interrupt;
-                    registry.refresh(entry.atom);
+                    refresh(entry);
                 }
                 resources.clear();
                 registry.update(generation, (value) => value + 1);
             });
         },
+        close() {
+            if (!closing) {
+                cache.dispose();
+                closing = settlement.wait();
+            }
+            return closing;
+        },
         dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            for (const entry of resources.values())
+                abortPrefetches(entry);
             registry.dispose();
             resources.clear();
         },
     };
+    registerCache(cache, {
+        disposed: () => disposed,
+        refresh: (atom) => {
+            const entry = entriesByAtom.get(atom);
+            if (entry)
+                refresh(entry);
+        },
+        registry,
+        generation,
+        query: selectQuery,
+        retain,
+        revision: (definition, args) => resources.get(queryKey(definition, args))?.revision,
+    });
+    return Object.freeze(cache);
 }

package/dist/collection.d.ts

@@ -1,3 +1,4 @@
+import type { Snapshot } from './snapshot.js';
 export type Identity = string | number;
 export interface Rows<A> {
     readonly items: readonly A[];
@@ -7,16 +8,16 @@ export interface Rows<A> {
     filter(predicate: (item: A, index: number) => boolean): Rows<A>;
     slice(start?: number, end?: number): Rows<A>;
 }
-export declare function collection<A>(identity: (item: A, index: number) => Identity): {
-    from: (items: readonly A[]) => Rows<A>;
-    share: {
-        <B extends A>(previous: readonly B[], next: B[]): B[];
-        <B extends A>(previous: readonly B[], next: readonly B[]): readonly B[];
-    };
-};
+/** Validate without retaining values. Positions are zero-based array indices. */
+export declare function validateIdentities<A>(items: readonly A[], identity: (item: A, index: number) => Identity): Identity[];
+export interface Collection<A> {
+    from(this: void, items: readonly (A | Snapshot<A>)[]): Rows<Snapshot<A>>;
+    share<B extends A | Snapshot<A>>(this: void, previous: readonly B[], next: readonly B[]): readonly Snapshot<B>[];
+}
+export declare function collection<A>(identity: (item: Snapshot<A>, index: number) => Identity): Collection<A>;
 /** Use positional identity for ordered values without stable entity IDs. */
-export declare function sequence<A>(items: readonly A[]): Rows<A>;
+export declare function sequence<A>(items: readonly A[]): Rows<Snapshot<A>>;
 /** Rows keyed by their domain IDs. Reuses the wrapper for the same immutable array. */
 export declare function entities<A extends {
     readonly id: Identity;
-}>(items: readonly A[] | undefined): Rows<A>;
+}>(items: readonly A[] | undefined): Rows<Snapshot<A>>;

package/dist/collection.js

@@ -1,8 +1,30 @@
-import { shareValue } from './share.js';
-export function collection(identity) {
+import { shareData } from './sharing.js';
+/** Validate without retaining values. Positions are zero-based array indices. */
+export function validateIdentities(items, identity) {
+    const seen = new Map();
+    return items.map((item, index) => {
+        const key = identity(item, index);
+        if (typeof key !== 'string' && typeof key !== 'number')
+            throw new Error(`Invalid collection identity at index ${index}. Use a string or number domain identity, or sequence(items) for positional identity.`);
+        const previous = seen.get(key);
+        if (previous !== undefined)
+            throw new Error(`Duplicate collection identity at indices ${previous} and ${index}. Identity must be unique within the collection; use a composite domain identity when IDs are only locally unique.`);
+        seen.set(key, index);
+        return key;
+    });
+}
+function makeCollection(identity) {
     const cache = new WeakMap();
+    const validated = new WeakSet();
+    const validate = (items) => {
+        if (validated.has(items))
+            return;
+        validateIdentities(items, identity);
+        validated.add(items);
+    };
     const comparisons = new WeakMap();
     const from = (items) => {
+        validate(items);
         const cached = cache.get(items);
         if (cached)
             return cached;
@@ -18,6 +40,8 @@ export function collection(identity) {
         return rows;
     };
     function share(previous, next) {
+        validate(previous);
+        validate(next);
         if (previous === next)
             return previous;
         let pairs = comparisons.get(previous);
@@ -36,13 +60,10 @@ export function collection(identity) {
             if (index >= previous.length || !Object.is(identity(old, index), key)) {
                 if (!byIdentity) {
                     byIdentity = new Map(previous.map((value, i) => [identity(value, i), value]));
-                    const keys = next.map(identity);
-                    if (byIdentity.size !== previous.length || new Set(keys).size !== keys.length)
-                        throw new Error('Duplicate collection identity. Identity must be unique within the collection.');
                 }
                 old = byIdentity.get(key);
             }
-            const value = old === undefined ? item : shareValue(old, item);
+            const value = old === undefined ? item : shareData(old, item);
             if (!Object.is(value, previous[index]))
                 equal = false;
             if (!Object.is(value, item) && !result)
@@ -60,6 +81,11 @@ export function collection(identity) {
     }
     return { from, share };
 }
+export function collection(identity) {
+    // Snapshot changes access permissions, not runtime representation. The implementation
+    // only borrows supplied items, and never inserts values of a wider type.
+    return makeCollection(identity);
+}
 const positions = collection((_item, index) => index);
 /** Use positional identity for ordered values without stable entity IDs. */
 export function sequence(items) {

package/dist/component.d.ts

@@ -1,14 +1,16 @@
+import type { Snapshot } from './snapshot.js';
 import type { View } from './dom.js';
 import type { Transition } from './program.js';
 import { type UiRuntime } from './runtime.js';
 /** Local fields with no command lifecycle. Sends are shallow patches, never updater callbacks. */
 export declare function localComponent<Props, State extends object>(definition: {
-    init: (props: Props) => State & {
+    identity?: (props: Snapshot<Props>) => unknown;
+    init: (props: Snapshot<Props>) => (State | Snapshot<State>) & {
         readonly props?: never;
     };
     view: View<State & {
         readonly props: Props;
-    }, Partial<State> & {
+    }, (Partial<State> | Partial<Snapshot<State>>) & {
         readonly props?: never;
     }>;
 }): View<Props, never>;
@@ -16,9 +18,10 @@ export declare function localComponent<Props, State extends object>(definition:
 export declare function component<Props, Model extends {
     readonly props: Props;
 }, Message, R = never>(definition: {
-    init: (props: Props) => Model;
-    receive?: (model: Model, props: Props) => Transition<Model, Message, R>;
-    update: (model: Model, message: Message) => Transition<Model, Message, R>;
+    identity?: (props: Snapshot<Props>) => unknown;
+    init: (props: Snapshot<Props>) => Model | Snapshot<Model>;
+    receive?: (model: Snapshot<Model>, props: Snapshot<Props>) => Transition<Model, Message, R>;
+    update: (model: Snapshot<Model>, message: Message) => Transition<Model, Message, R>;
     view: View<Model, Message>;
 } & ([R] extends [never] ? {
     runtime?: UiRuntime<R>;
@@ -27,7 +30,8 @@ export declare function component<Props, Model extends {
 })): View<Props, never>;
 /** Mount an existing program without introducing a second state owner. */
 export declare function programView<Props, Model, Message>(definition: {
-    create: (props: Props) => import('./program').Program<Model, Message>;
-    receive: (source: import('./program').Program<Model, Message>, props: Props) => void;
+    identity?: (props: Snapshot<Props>) => unknown;
+    create: (props: Snapshot<Props>) => import('./program').Program<Model, Message>;
+    receive: (source: import('./program').Program<Model, Message>, props: Snapshot<Props>) => void;
     view: View<Model, Message>;
 }): View<Props, never>;

package/dist/component.js

@@ -1,10 +1,12 @@
-import { compiled, Scope } from './dom.js';
+import { compiled, Scope, viewRegion } from './dom.js';
 import { mapCommand, program } from './program.js';
 import { patchModel } from './state.js';
+import { reportSafely } from './errors.js';
 import { defaultUiRuntime } from './runtime.js';
 /** Local fields with no command lifecycle. Sends are shallow patches, never updater callbacks. */
 export function localComponent(definition) {
     return component({
+        ...(definition.identity ? { identity: definition.identity } : {}),
         init: (props) => ({ ...definition.init(props), props }),
         update: (model, patch) => {
             const next = patchModel(model, patch);
@@ -16,7 +18,7 @@ export function localComponent(definition) {
 /** A child model receives immutable parent inputs and owns its own message/command loop. */
 export function component(definition) {
     const runtime = definition.runtime ?? defaultUiRuntime;
-    return compiled((scope, parent, before) => {
+    return identify(compiled((scope, parent, before) => {
         const wrap = (next) => ({
             model: next.model,
             ...(next.cancel ? { cancel: next.cancel } : {}),
@@ -37,22 +39,80 @@ export function component(definition) {
                 })
                 : definition.update(model, envelope.message)),
         });
-        const child = new Scope(source.model(), (message) => source.send({ type: 'Message', message }), scope.report);
-        scope.cleanups.push(() => source.dispose(), () => child.dispose(), () => unsubscribe());
-        const unsubscribe = source.subscribe((model) => child.set(model));
+        if (scope.disposed) {
+            closeProgram(scope, source);
+            return;
+        }
+        const child = new Scope(source.model(), (message) => source.send({ type: 'Message', message }), scope.report, scope.settlement);
+        let unsubscribe = () => { };
+        scope.cleanups.push(() => closeProgram(scope, source), () => child.dispose(), () => unsubscribe());
+        const release = source.subscribe((model) => child.set(model));
+        if (scope.disposed) {
+            release();
+            return;
+        }
+        unsubscribe = release;
         definition.view.build(child, parent, before);
         scope.jobs.push(() => source.send({ type: 'Input', props: scope.value }));
         source.send({ type: 'Input', props: scope.value });
-    });
+    }), definition.identity);
 }
 /** Mount an existing program without introducing a second state owner. */
 export function programView(definition) {
-    return compiled((scope, parent, before) => {
+    return identify(compiled((scope, parent, before) => {
         const source = definition.create(scope.value);
-        const child = new Scope(source.model(), source.send, scope.report);
-        const unsubscribe = source.subscribe((model) => child.set(model));
-        scope.cleanups.push(() => source.dispose(), () => child.dispose(), () => unsubscribe());
+        if (scope.disposed) {
+            closeProgram(scope, source);
+            return;
+        }
+        const child = new Scope(source.model(), source.send, scope.report, scope.settlement);
+        let unsubscribe = () => { };
+        scope.cleanups.push(() => closeProgram(scope, source), () => child.dispose(), () => unsubscribe());
+        const release = source.subscribe((model) => child.set(model));
+        if (scope.disposed) {
+            release();
+            return;
+        }
+        unsubscribe = release;
         definition.view.build(child, parent, before);
         scope.jobs.push(() => definition.receive(source, scope.value));
+    }), definition.identity);
+}
+function closeProgram(scope, source) {
+    const finish = scope.settlement.begin();
+    try {
+        if (source.close) {
+            source.close().then(finish, (error) => {
+                finish();
+                reportSafely(scope.report, error);
+            });
+        }
+        else {
+            source.dispose();
+            finish();
+        }
+    }
+    catch (error) {
+        finish();
+        throw error;
+    }
+}
+function identify(definition, identity) {
+    if (!identity)
+        return definition;
+    return compiled((scope, parent, before) => {
+        const render = viewRegion(scope, parent, before, { manual: true });
+        let current;
+        let active;
+        const update = () => {
+            const next = identity(scope.value);
+            if (!active || !Object.is(current, next)) {
+                current = next;
+                active = compiled(definition.build);
+            }
+            render(active);
+        };
+        scope.jobs.push(update);
+        update();
     });
 }

package/dist/diagnostics.d.ts

@@ -10,6 +10,7 @@ export interface BindingUpdate {
     readonly source: BindingSource;
     readonly changed: readonly string[];
     readonly kind: 'derive' | 'binding';
+    readonly reason: 'initial' | 'dependencies';
 }
 /** Each registration has its own lifetime; observers can be stopped in any order. */
 export declare function observeBindings(next: (update: BindingUpdate) => void): () => void;
@@ -30,3 +31,27 @@ export declare function observePrograms(limit?: number): {
     events: () => ProgramUpdate[];
     dispose: () => boolean;
 };
+/** Counts aggregate all mounted instances of a source expression. */
+export interface BindingInspection {
+    readonly source: BindingSource;
+    readonly derives: number;
+    readonly bindings: number;
+    readonly changed: readonly string[];
+    readonly reason: BindingUpdate['reason'];
+}
+export interface BindingInspector {
+    /** Most recently updated first; bounded by limit (default 200, maximum 1000). */
+    entries(): readonly BindingInspection[];
+    subscribe(next: () => void): () => void;
+    clear(): void;
+    /** Unsubscribe and release all metadata and listeners. */
+    dispose(): void;
+}
+/** Development metadata only: never reads or retains models, values, or DOM nodes. */
+export declare function inspectBindings(options?: {
+    readonly limit?: number;
+}): BindingInspector;
+/** Mount a live source inspector. Mount before the application to include initial evaluations.
+ * The returned cleanup removes the panel; an externally supplied inspector keeps its lifetime.
+ */
+export declare function mountBindingInspector(target: HTMLElement, inspector?: BindingInspector): () => void;