effectweb 0.3.0 → 0.3.1

package/dist/AsyncContent.js

@@ -50,7 +50,7 @@ const implementation = component({
     view: /* @__PURE__ */ _ew_dom.compiled((_ew_scope_1, _ew_parent_2, _ew_before_3) => {
         const _ew_derived_4 = _ew_scope_1.derive(() => [_ew_scope_1.value?.props], () => {
             const _ew_capture_6 = _ew_scope_1.value;
-            return _ew_capture_6.props;
+            return _ew_dom.intrinsic(_ew_dom.intrinsic(_ew_capture_6, ["props", "content"], "@slot"), ["props", "failure"], "@slot").props;
         });
         const _ew_derived_7 = _ew_scope_1.derive(() => [_ew_derived_4()?.result], () => {
             const _ew_capture_9 = _ew_derived_4();

package/dist/boundary.d.ts

@@ -0,0 +1,11 @@
+import { type View } from './dom.js';
+import { type ReportError } from './errors.js';
+import { type Snapshot } from './snapshot.js';
+export declare function errorBoundary<Model, Message>(content: View<Model, Message>, options: {
+    readonly fallback: View<{
+        readonly model: NoInfer<Model>;
+        readonly error: unknown;
+    }, NoInfer<Message>>;
+    readonly reset?: (model: Snapshot<NoInfer<Model>>) => unknown;
+    readonly onError?: ReportError;
+}): View<Model, Message>;

package/dist/boundary.js

@@ -0,0 +1,66 @@
+import { child, compiled, viewRegion } from './dom.js';
+import { reportError, reportSafely } from './errors.js';
+import { protectSnapshot } from './snapshot.js';
+export function errorBoundary(content, options) {
+    return compiled((scope, parent, before) => {
+        let failed = false;
+        let error;
+        let generation = 0;
+        let reset = options.reset?.(scope.value);
+        const fallback = compiled((scope, parent, before) => {
+            child(scope, parent, before, options.fallback, () => [scope.value], () => protectSnapshot({ model: scope.value, error }), scope.send);
+        });
+        const region = { manual: true, report: scope.report };
+        const render = viewRegion(scope, parent, before, region);
+        function showFallback() {
+            if (scope.disposed || !failed)
+                return;
+            region.report = scope.report;
+            try {
+                render(fallback);
+            }
+            catch (error) {
+                reportSafely(scope.report, error);
+            }
+        }
+        function fail(cause, attempt) {
+            if (scope.disposed || attempt !== generation) {
+                reportSafely(options.onError ?? reportError, cause);
+                return;
+            }
+            failed = true;
+            error = cause;
+            const token = ++generation;
+            render(undefined);
+            reportSafely(options.onError ?? reportError, cause);
+            queueMicrotask(() => {
+                if (token === generation)
+                    showFallback();
+            });
+        }
+        const update = () => {
+            const next = options.reset?.(scope.value);
+            if (!Object.is(reset, next)) {
+                reset = next;
+                generation++;
+                render(undefined);
+                failed = false;
+                error = undefined;
+            }
+            if (failed)
+                showFallback();
+            else {
+                const attempt = generation;
+                region.report = (cause) => fail(cause, attempt);
+                try {
+                    render(content);
+                }
+                catch (error) {
+                    fail(error, attempt);
+                }
+            }
+        };
+        scope.jobs.push(update);
+        update();
+    });
+}

package/dist/cache-internals.d.ts

@@ -5,6 +5,10 @@ import type { QueryCache } from './cache.js';
 import type { Query } from './query.js';
 import type { Snapshot } from './snapshot.js';
 export interface CacheInternals<R> {
+    refresh(atom: Atom.Atom<unknown>): void;
+    readonly disposed: () => boolean;
+    revision<Args, A, E>(definition: Query<Args, A, E, R>, args: Args | Snapshot<Args>): number | undefined;
+    retain(atom: Atom.Atom<unknown>): () => void;
     readonly registry: AtomRegistry.AtomRegistry;
     readonly generation: Atom.Writable<number>;
     query<Args, A, E>(definition: Query<Args, A, E, R>, args: Args | Snapshot<Args>): Atom.Atom<AsyncResult.AsyncResult<Snapshot<A>, E>>;

package/dist/cache.d.ts

@@ -1,14 +1,28 @@
 import { type Snapshot } from './snapshot.js';
 import { Effect } from 'effect';
-import { type Query } from './query.js';
+import { type Query, type QueryGroup } from './query.js';
 import type { UiRuntime } from './runtime.js';
 export { loadEffect, type UiLoad } from './load.js';
 export { shareValue } from './share.js';
-export declare function makeQueryCache(): QueryCache<never>;
-export declare function makeQueryCache<R>(runtime: UiRuntime<R>): QueryCache<R>;
+export interface QueryCacheOptions {
+    readonly retention?: number;
+    readonly unused?: 'retain' | 'cancel' | undefined;
+}
+export declare function makeQueryCache(options?: QueryCacheOptions): QueryCache<never>;
+export declare function makeQueryCache<R>(runtime: UiRuntime<R>, options?: QueryCacheOptions): QueryCache<R>;
 /** A cache owns one registry and the query resources published through it. */
 export interface QueryCache<R = never> {
-    prefetch<Args, A, E>(definition: Query<Args, A, E, R>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>): Effect.Effect<Snapshot<A>, E>;
+    batch(work: () => void): void;
+    getQueryData<Args, A, E>(definition: Query<Args, A, E, R>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>): Snapshot<A> | undefined;
+    invalidateWhere<Args, A, E>(definition: Query<Args, A, E, R>, predicate: (args: Snapshot<Args>) => boolean): void;
+    invalidateGroup(group: QueryGroup): void;
+    /** Cancel requests while retaining the last success. Explicit refresh restarts them. */
+    cancelQuery<Args, A, E>(definition: Query<Args, A, E, R>, ...selected: [] | [NoInfer<Args> | Snapshot<NoInfer<Args>>]): void;
+    /** Clear cached data and cancel requests; a subsequent selection or refresh reloads. */
+    removeQuery<Args, A, E>(definition: Query<Args, A, E, R>, ...selected: [] | [NoInfer<Args> | Snapshot<NoInfer<Args>>]): void;
+    prefetch<Args, A, E>(definition: Query<Args, A, E, R>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>, options?: {
+        readonly refresh?: boolean;
+    }): Effect.Effect<Snapshot<A>, E>;
     /** Publish a protected success, including undefined, and supersede any pending load for this key. */
     setQueryData<Args, A, E>(definition: Query<Args, A, E, R>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>, value: NoInfer<A> | Snapshot<NoInfer<A>>): Snapshot<A>;
     /**
@@ -21,5 +35,7 @@ export interface QueryCache<R = never> {
     /** Observe account resets without exposing registry mutation. */
     onReset(listener: () => void): () => void;
     resetResources(): void;
+    /** Interrupt every request and wait for its finalizers, including previously canceled requests. */
+    close(): Promise<void>;
     dispose(): void;
 }

package/dist/cache.js

@@ -1,5 +1,6 @@
+import { Settlement } from './settlement.js';
 import { protectSnapshot } from './snapshot.js';
-import { Effect, Option } from 'effect';
+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';
@@ -10,18 +11,29 @@ 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 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) {
@@ -37,28 +49,54 @@ function createQueryCache(runtime) {
         else {
             const loaded = Atom.make((get) => {
                 const previous = Option.flatMap(get.self(), AsyncResult.value);
-                return loadEffect(() => next.load()).pipe(Effect.map((value) => {
-                    const shared = Option.isSome(previous)
-                        ? share(previous.value, value)
-                        : value;
-                    const snapshot = protectSnapshot(shared);
-                    remember(next, snapshot);
-                    return snapshot;
-                }));
+                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,
+                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();
-                        remember(next, value);
-                        context.setSelf(AsyncResult.success(value));
+                        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) {
@@ -90,26 +128,117 @@ function createQueryCache(runtime) {
         const config = queryDefinition(definition);
         protectSnapshot(args);
         const { entry, atom } = acquire(queryKey(definition, args), () => {
-            const effect = Effect.suspend(() => config.load(args));
+            const effect = Effect.suspend(() => config.load(args, previousValue(resources.get(queryKey(definition, args)))?.value));
             return runtime ? runtime.provide(effect) : effect;
         }, 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 >= config.staleTime) {
             const current = registry.get(atom);
             if (!current.waiting)
-                registry.refresh(atom);
+                refresh(entry);
         }
         return 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 = {
-        prefetch(definition, args) {
-            return Effect.suspend(() => AtomRegistry.getResult(registry, selectQuery(definition, args), { suspendOnWaiting: true }));
+        batch: Atom.batch,
+        getQueryData(definition, args) {
+            return previousValue(resources.get(queryKey(definition, args)))?.value;
+        },
+        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();
@@ -140,12 +269,10 @@ function createQueryCache(runtime) {
             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.query === definition)
-                        registry.refresh(entry.atom);
+                cache.invalidateWhere(definition, () => true);
             }
         },
         onReset(listener) {
@@ -155,21 +282,43 @@ function createQueryCache(runtime) {
         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, { registry, generation, query: selectQuery });
+    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/component.d.ts

@@ -4,6 +4,7 @@ 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: {
+    identity?: (props: Snapshot<Props>) => unknown;
     init: (props: Snapshot<Props>) => (State | Snapshot<State>) & {
         readonly props?: never;
     };
@@ -17,6 +18,7 @@ export declare function localComponent<Props, State extends object>(definition:
 export declare function component<Props, Model extends {
     readonly props: Props;
 }, Message, R = never>(definition: {
+    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>;
@@ -28,6 +30,7 @@ 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: {
+    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>;

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/dom.d.ts

@@ -4,6 +4,7 @@ import { type BindingSource } from './diagnostics.js';
 import type { Rows } from './index.js';
 import { jsxComponent, type JSX } from './jsx.js';
 import type { DomMount } from './mount.js';
+import { Settlement } from './settlement.js';
 import type { Program, Send } from './program.js';
 type Dependencies = () => readonly unknown[];
 type Cleanup = () => void;
@@ -13,11 +14,12 @@ export declare class Scope<M, E> {
     value: M;
     readonly send: Send<E>;
     readonly report: ReportError;
+    readonly settlement: Settlement;
     readonly jobs: Cleanup[];
     readonly cleanups: Cleanup[];
     disposed: boolean;
     private revision;
-    constructor(value: M, send: Send<E>, report?: ReportError);
+    constructor(value: M, send: Send<E>, report?: ReportError, settlement?: Settlement);
     derive<A>(dependencies: Dependencies, compute: () => A, source?: BindingSource): () => A;
     watch(dependencies: Dependencies, apply: () => void, source?: BindingSource): void;
     set(value: M): void;
@@ -62,7 +64,10 @@ export interface PortalProps {
 export declare const Portal: View<PortalProps, never>;
 export declare function mountView<M, E>(parent: Node, definition: View<M, E>, source: Program<M, E>, options?: {
     onError?: ReportError;
-}): () => void;
+}): (() => void) & {
+    dispose: () => void;
+    close: () => Promise<void>;
+};
 export declare function element(parent: Node, before: Node | null, tag: string): Element;
 export declare function attribute(element: Element, name: string, value: unknown): void;
 /** Compiler output for attributes whose unchanged value needs no DOM refresh. */
@@ -80,10 +85,13 @@ export declare function each<M, E, A>(scope: Scope<M, E>, parent: Node, before:
 export declare function invoke<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, dependencies: Dependencies, read: () => readonly unknown[], build: Build<readonly unknown[], E>): void;
 export declare function child<M, E, C, F>(scope: Scope<M, E>, parent: Node, before: Node | null, definition: View<C, F>, dependencies: Dependencies, model: () => C, send: Send<F>): void;
 /** A late-bound compiled definition owns one replaceable DOM region. */
-export declare function viewRegion<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null): (next: View<M, E> | undefined) => void;
+export declare function viewRegion<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, options?: {
+    manual?: boolean;
+    report?: ReportError;
+}): (next: View<M, E> | undefined) => void;
 export declare function attach<M, E, T extends Element>(scope: Scope<M, E>, element: T, dependencies: Dependencies, read: () => DomMount<NoInfer<T>> | undefined): void;
 export declare function portal<M, E>(scope: Scope<M, E>, build: Build<M, E>, mount?: () => Element | undefined): void;
 /** Build static markup once per document/namespace, then clone native nodes at each use. */
 export declare function template(build: string | ((parent: Node, before: Node | null) => void), depth?: number): (parent: Node, before: Node | null) => Node;
 export declare function literal(parent: Node, before: Node | null, value: string): void;
-export {};
+export { intrinsic } from './intrinsic.js';