effectweb 0.3.0 → 0.4.0

package/dist/effectEvent.js

@@ -1,4 +1,6 @@
-import { Effect, Fiber } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
 import { reportSafely } from './errors.js';
 import { defaultUiRuntime } from './runtime.js';
 const tag = Symbol('Effect event');
@@ -6,8 +8,8 @@ export function effectEvent(policy, load, runtime) {
     const owner = runtime ?? defaultUiRuntime;
     return (event) => ({ [tag]: true, policy, effect: owner.provide(load(event)) });
 }
-/** Internal listener owner, allocated only when an event returns a value needing inspection. */
-export function eventEffects(report) {
+/** Internal listener owner, allocated only when an event returns an owned request. */
+export function eventEffects(report, settlement) {
     let active;
     let disposed = false;
     const stop = () => {
@@ -17,46 +19,35 @@ export function eventEffects(report) {
             Effect.runFork(Fiber.interrupt(previous.fiber));
     };
     return {
-        accept(value) {
+        accept(request) {
             if (disposed)
                 return;
-            if (value && typeof value === 'object' && tag in value) {
-                const request = value;
-                if (request.policy === 'drop' && active)
-                    return;
-                stop();
-                const token = {};
-                active = token;
-                try {
-                    const fiber = Effect.runFork(request.effect);
-                    token.fiber = fiber;
-                    if (disposed || active !== token) {
-                        Effect.runFork(Fiber.interrupt(fiber));
-                        return;
-                    }
-                    fiber.addObserver((exit) => {
-                        if (disposed || active !== token)
-                            return;
-                        active = undefined;
-                        if (exit._tag === 'Failure')
-                            reportSafely(report, exit.cause);
-                    });
-                }
-                catch (error) {
-                    if (active === token)
+            if (request.policy === 'drop' && active)
+                return;
+            stop();
+            const token = {};
+            active = token;
+            const finished = settlement?.begin();
+            try {
+                const fiber = Effect.runFork(request.effect);
+                token.fiber = fiber;
+                fiber.addObserver((exit) => {
+                    const current = !disposed && active === token;
+                    if (current)
                         active = undefined;
-                    reportSafely(report, error);
+                    if (exit._tag === 'Failure' && (current || !Cause.hasInterruptsOnly(exit.cause)))
+                        reportSafely(report, exit.cause);
+                    finished?.();
+                });
+                if (disposed || active !== token) {
+                    Effect.runFork(Fiber.interrupt(fiber));
                 }
             }
-            else if (Effect.isEffect(value)) {
-                reportSafely(report, new Error('Event returned an unowned Effect. Use effectEvent(policy, factory) or dispatch a command.'));
-            }
-            else if (value &&
-                typeof value === 'object' &&
-                'then' in value &&
-                typeof value.then === 'function') {
-                void Promise.resolve(value).catch((error) => reportSafely(report, error));
-                reportSafely(report, new Error('Event returned an unowned Promise. Adapt it with fromPromise inside effectEvent or a command.'));
+            catch (error) {
+                finished?.();
+                if (active === token)
+                    active = undefined;
+                reportSafely(report, error);
             }
         },
         dispose() {

package/dist/form.d.ts

@@ -1,4 +1,5 @@
-import type { Cause, Effect } from 'effect';
+import type * as Cause from 'effect/Cause';
+import type * as Effect from 'effect/Effect';
 import { type Transition } from './program.js';
 import type { Snapshot } from './snapshot.js';
 import type { EffectEventRequest } from './effectEvent.js';

package/dist/http.d.ts

@@ -1,4 +1,5 @@
-import { Effect, type Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import type * as Schema from 'effect/Schema';
 import * as HttpClient from 'effect/unstable/http/HttpClient';
 import type * as HttpClientRequest from 'effect/unstable/http/HttpClientRequest';
 /** Decode successful JSON through a schema, retaining transport, decoding and service types. */

package/dist/http.js

@@ -1,4 +1,4 @@
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import * as HttpClient from 'effect/unstable/http/HttpClient';
 import * as HttpClientResponse from 'effect/unstable/http/HttpClientResponse';
 /** Decode successful JSON through a schema, retaining transport, decoding and service types. */

package/dist/index.d.ts

@@ -6,12 +6,12 @@ export { patchModel } from './state.js';
 export { defineActions, type ActionMessage } from './actions.js';
 export { taskComponent, taskControls, type TaskModel, type TaskMessage } from './task.js';
 export { effectEvent } from './effectEvent.js';
-export { mountView, view, ViewBinding, type View } from './dom.js';
+export { mountView, view, list, ViewBinding, type View } from './dom.js';
 export { lazyView, type LazyViewOptions } from './lazy.js';
 export type { JSX } from './jsx.js';
 export { Portal, domBinding, domMount, type DomMount, type PortalProps } from './mount.js';
 export { pages, type PagesMessage, type PagesRequest, type PagesModel, type PagesProgram, type Pagination, } from './pages.js';
-export { program, actionCommand, effectCommand, commandSlot, type CommandSlot, type Command, type Program, type Send, type Transition, } from './program.js';
+export { program, mapTransition, actionCommand, effectCommand, commandSlot, type CommandSlot, type Command, type Program, type Send, type Transition, } from './program.js';
 export { available, resourceComponent, resourceError, type ResourceMessage, type ResourceModel, } from './resource.js';
 export { fromPromise, type UiLoad, type UiPage } from './load.js';
 export { observeBindings, inspectBindings, mountBindingInspector, type BindingInspector, type BindingInspection, observePrograms, type BindingUpdate, type ProgramUpdate, } from './diagnostics.js';
@@ -20,7 +20,10 @@ export { slot, type Slot, type CompiledContent } from './dom.js';
 export { AsyncContent, type AsyncContentProps } from './AsyncContent.js';
 export { defineTasks, type TaskDefinition, type TasksModel, type TasksMessage, type TaskResults, } from './tasks.js';
 export { uiRuntime, type UiRuntime } from './runtime.js';
-export { query, type Query, type QueryKey } from './query.js';
-export { makeQueryCache, type QueryCache } from './cache.js';
+export { query, queryGroup, type Query, type QueryKey, type QueryGroup } from './query.js';
+export { makeQueryCache, type QueryCache, type QueryCacheOptions } from './cache.js';
 export { queryResource, type QueryResource, observeQuery, lifetime, projectionCache, sessionGroup, type SessionContext, type Read, } from './session.js';
 export { httpJson } from './http.js';
+export { infiniteQuery, infiniteResource, type InfiniteData, type InfiniteQuery, type InfiniteResource, } from './infinite-query.js';
+export { keyedTasks, type TaskHandle, type TaskOutcome } from './keyed-tasks.js';
+export { errorBoundary } from './boundary.js';

package/dist/index.js

@@ -5,11 +5,11 @@ export { patchModel } from './state.js';
 export { defineActions } from './actions.js';
 export { taskComponent, taskControls } from './task.js';
 export { effectEvent } from './effectEvent.js';
-export { mountView, view, ViewBinding } from './dom.js';
+export { mountView, view, list, ViewBinding } from './dom.js';
 export { lazyView } from './lazy.js';
 export { Portal, domBinding, domMount } from './mount.js';
 export { pages, } from './pages.js';
-export { program, actionCommand, effectCommand, commandSlot, } from './program.js';
+export { program, mapTransition, actionCommand, effectCommand, commandSlot, } from './program.js';
 export { available, resourceComponent, resourceError, } from './resource.js';
 export { fromPromise } from './load.js';
 export { observeBindings, inspectBindings, mountBindingInspector, observePrograms, } from './diagnostics.js';
@@ -18,7 +18,10 @@ export { slot } from './dom.js';
 export { AsyncContent } from './AsyncContent.js';
 export { defineTasks, } from './tasks.js';
 export { uiRuntime } from './runtime.js';
-export { query } from './query.js';
+export { query, queryGroup } from './query.js';
 export { makeQueryCache } from './cache.js';
 export { queryResource, observeQuery, lifetime, projectionCache, sessionGroup, } from './session.js';
 export { httpJson } from './http.js';
+export { infiniteQuery, infiniteResource, } from './infinite-query.js';
+export { keyedTasks } from './keyed-tasks.js';
+export { errorBoundary } from './boundary.js';

package/dist/infinite-query.d.ts

@@ -0,0 +1,42 @@
+import * as Effect from 'effect/Effect';
+import { type Query, type QueryArgs, type QueryGroup } from './query.js';
+import type { QueryCache } from './cache.js';
+import { type QueryResource } from './session.js';
+import { type Snapshot } from './snapshot.js';
+export interface InfiniteData<A, Param> {
+    readonly pages: readonly {
+        readonly param: Param;
+        readonly value: A;
+    }[];
+    readonly next: Param | undefined;
+}
+export interface InfiniteQuery<Args, A, Param, E = never, R = never> {
+    readonly query: Query<Args, InfiniteData<A, Param>, E, R>;
+    readonly page: Query<{
+        args: Args;
+        param: Param;
+    }, A, E, R>;
+    readonly maxPages: number;
+    readonly next: (value: Snapshot<A>, param: Snapshot<Param>) => Param | undefined;
+}
+/** Shared pages with explicit cursor identity. Refresh preserves retained page parameters by default. */
+export declare function infiniteQuery<Args, A, Param, E = never, R = never>(definition: {
+    readonly name: string;
+    readonly initial: Param;
+    readonly load: (args: Snapshot<Args>, param: Snapshot<Param>) => Effect.Effect<A, E, R>;
+    readonly next: (value: Snapshot<A>, param: Snapshot<Param>) => Param | undefined;
+    readonly maxPages?: number;
+    readonly refresh?: 'retained' | 'first';
+    readonly groups?: readonly QueryGroup[];
+} & (Args extends QueryArgs<Args> ? unknown : {
+    readonly nonSerializableQueryArguments: never;
+}) & (Param extends QueryArgs<Param> ? unknown : {
+    readonly nonSerializablePageParameters: never;
+})): InfiniteQuery<Args, A, Param, E, R>;
+export interface InfiniteResource<Args, A, Param, E = never> extends QueryResource<Args, InfiniteData<A, Param>, E> {
+    loadNext(): Effect.Effect<Snapshot<InfiniteData<A, Param>>, E>;
+    retryPage(param: Param | Snapshot<Param>): Effect.Effect<Snapshot<InfiniteData<A, Param>>, E>;
+    seed(args: Args | Snapshot<Args>, data: InfiniteData<A, Param> | Snapshot<InfiniteData<A, Param>>): Snapshot<InfiniteData<A, Param>>;
+}
+/** Cache-owned results, observer-owned subscriptions. Operations return typed Effects for task composition. */
+export declare function infiniteResource<Args, A, Param, E, R>(cache: QueryCache<R>, definition: InfiniteQuery<Args, A, Param, E, NoInfer<R>>): InfiniteResource<Args, A, Param, E>;

package/dist/infinite-query.js

@@ -0,0 +1,150 @@
+import * as Effect from 'effect/Effect';
+import { query, encodeQueryKey, } from './query.js';
+import { cacheInternals } from './cache-internals.js';
+import { queryResource } from './session.js';
+import { protectSnapshot } from './snapshot.js';
+/** Shared pages with explicit cursor identity. Refresh preserves retained page parameters by default. */
+export function infiniteQuery(definition) {
+    const config = Object.freeze({ ...definition });
+    const maxPages = config.maxPages ?? Infinity;
+    if (maxPages !== Infinity && (!Number.isInteger(maxPages) || maxPages < 1))
+        throw new RangeError('maxPages must be a positive integer.');
+    encodeQueryKey(config.initial);
+    const initial = protectSnapshot(config.initial);
+    const next = (value, param) => {
+        const result = config.next(value, param);
+        encodeQueryKey(result);
+        return result;
+    };
+    const page = query({
+        name: `${config.name}:page`,
+        load: ({ args, param }) => config.load(args, param),
+    });
+    const root = query({
+        name: config.name,
+        ...(config.groups ? { groups: config.groups } : {}),
+        load: (args, previous) => {
+            const params = config.refresh !== 'first' && previous?.pages.length
+                ? previous.pages.map((page) => page.param)
+                : [initial];
+            return Effect.forEach(params, (param) => config.load(args, param).pipe(Effect.map((value) => ({ param: param, value })))).pipe(Effect.map((pages) => {
+                const last = pages[pages.length - 1];
+                return {
+                    pages,
+                    next: next(protectSnapshot(last.value), last.param),
+                };
+            }));
+        },
+    });
+    return Object.freeze({ query: root, page, maxPages, next });
+}
+const operations = new WeakMap();
+function operationBook(cache, definition) {
+    let definitions = operations.get(cache);
+    if (!definitions) {
+        definitions = new WeakMap();
+        operations.set(cache, definitions);
+    }
+    let book = definitions.get(definition);
+    if (!book) {
+        book = new Map();
+        definitions.set(definition, book);
+    }
+    return book;
+}
+/** Cache-owned results, observer-owned subscriptions. Operations return typed Effects for task composition. */
+export function infiniteResource(cache, definition) {
+    const resource = queryResource({ cache }, definition.query);
+    const internal = cacheInternals(cache);
+    let selected;
+    let disposed = false;
+    const stopReset = cache.onReset(() => {
+        selected = undefined;
+    });
+    const book = operationBook(cache, definition.query);
+    const updatePage = (retry) => Effect.gen(function* () {
+        if (disposed || selected === undefined)
+            return yield* Effect.interrupt;
+        const args = selected;
+        const current = yield* cache.prefetch(definition.query, args);
+        const param = retry ? retry.param : current.next;
+        if (param === undefined)
+            return current;
+        const pageKey = encodeQueryKey(param);
+        const retained = current.pages.some((page) => encodeQueryKey(page.param) === pageKey);
+        if (retry && !retained && encodeQueryKey(current.next) !== pageKey)
+            return yield* Effect.die(new RangeError('Retry a retained page or the next page parameter.'));
+        const key = encodeQueryKey(args);
+        const revision = internal.revision(definition.query, args);
+        let operation = book.get(key);
+        if (!operation || operation.revision !== revision) {
+            operation = { revision, active: 0 };
+            book.set(key, operation);
+        }
+        const state = operation;
+        state.active++;
+        return yield* Effect.gen(function* () {
+            const pageArgs = { args, param };
+            const value = yield* cache.prefetch(definition.page, pageArgs, { refresh: true });
+            let result;
+            cache.batch(() => {
+                const latest = cache.getQueryData(definition.query, args);
+                result = latest;
+                // Other page operations can merge. External refresh, writes and reset own a new revision.
+                if (!latest ||
+                    book.get(key) !== state ||
+                    state.revision !== internal.revision(definition.query, args))
+                    return;
+                const index = latest.pages.findIndex((page) => encodeQueryKey(page.param) === pageKey);
+                if (index < 0 && (retained || encodeQueryKey(latest.next) !== pageKey))
+                    return;
+                if (index >= 0 && latest.pages[index].value === value)
+                    return;
+                const pages = [...latest.pages];
+                const page = { param, value };
+                if (index >= 0)
+                    pages[index] = page;
+                else
+                    pages.push(page);
+                const kept = pages.slice(-definition.maxPages);
+                const last = kept[kept.length - 1];
+                result = cache.setQueryData(definition.query, args, {
+                    pages: kept,
+                    next: definition.next(last.value, last.param),
+                });
+                state.revision = internal.revision(definition.query, args);
+            });
+            return result ?? (yield* Effect.interrupt);
+        }).pipe(Effect.ensuring(Effect.sync(() => {
+            state.active--;
+            if (state.active === 0 && book.get(key) === state)
+                book.delete(key);
+        })));
+    });
+    return {
+        read: resource.read,
+        subscribe: resource.subscribe,
+        select(args) {
+            selected = args;
+            resource.select(args);
+        },
+        refresh: resource.refresh,
+        loadNext: () => updatePage(),
+        retryPage: (param) => updatePage({ param }),
+        seed(args, data) {
+            if (!data.pages.length || data.pages.length > definition.maxPages)
+                throw new RangeError('Seed pages must fit the retained page range.');
+            encodeQueryKey(data.next);
+            const keys = data.pages.map((page) => encodeQueryKey(page.param));
+            if (new Set(keys).size !== keys.length)
+                throw new TypeError('Seed page parameters must be unique.');
+            return cache.setQueryData(definition.query, args, data);
+        },
+        dispose() {
+            disposed = true;
+            selected = undefined;
+            stopReset();
+            resource.dispose();
+        },
+    };
+}

package/dist/jsx-runtime.d.ts

@@ -1 +1,7 @@
 export type { JSX } from './jsx.js';
+import type { JSX } from './jsx.js';
+export declare function Fragment(props: {
+    readonly children?: JSX.Element;
+}): JSX.Element;
+export declare function jsx(type: string | ((props: never) => JSX.Element), props: Readonly<Record<string, unknown>>): JSX.Element;
+export { jsx as jsxs, jsx as jsxDEV };

package/dist/jsx-runtime.js

@@ -1 +1,14 @@
-export {};
+import { markup } from './dom.js';
+export function Fragment(props) {
+    return props.children;
+}
+const tags = new Map();
+export function jsx(type, props) {
+    if (typeof type !== 'string')
+        return type(props);
+    let render = tags.get(type);
+    if (!render)
+        tags.set(type, (render = markup(type)));
+    return render(props);
+}
+export { jsx as jsxs, jsx as jsxDEV };

package/dist/jsx.d.ts

@@ -16,10 +16,11 @@ export declare namespace JSX {
     export interface ElementArray extends ReadonlyArray<Element>, SnapshotOpaque {
     }
     export type Element = string | number | boolean | null | undefined | CompiledContent | ElementArray;
+    export type EventResult = void | boolean | EffectEventRequest;
     export type EventHandler<T, E extends Event> = (event: E & {
         currentTarget: T;
         target: EventTarget & globalThis.Element;
-    }) => void | boolean | EffectEventRequest;
+    }) => EventResult;
     export type EventHandlerUnion<T, E extends Event> = EventHandler<T, E>;
     export type CSSProperties = {
         [property: string]: string | number | undefined | null;

package/dist/keyed-tasks.d.ts

@@ -0,0 +1,30 @@
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import { type TaskPolicy } from './program.js';
+import type { DisposableOwner } from './owner.js';
+import { type UiRuntime } from './runtime.js';
+import { type Snapshot } from './snapshot.js';
+export type TaskOutcome<A, E> = {
+    readonly _tag: 'Success';
+    readonly value: Snapshot<A>;
+} | {
+    readonly _tag: 'Failure';
+    readonly cause: Cause.Cause<E>;
+} | {
+    readonly _tag: 'Cancelled' | 'Superseded' | 'Dropped';
+};
+export interface TaskHandle<A, E> {
+    readonly outcome: Effect.Effect<TaskOutcome<A, E>>;
+}
+/** Per-entity serialization. Inputs are captured now; run reads services when work starts. */
+export declare function keyedTasks<Key, Input, A, E = never, R = never>(owner: DisposableOwner, definition: {
+    readonly name: string;
+    readonly policy: TaskPolicy;
+    readonly run: (key: Key, input: Snapshot<Input>) => Effect.Effect<A, E, R>;
+}, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): {
+    submit(key: Key, input: Input | Snapshot<Input>): TaskHandle<A, E>;
+    cancel(key: Key): void;
+    drain(...selected: [] | [Key]): Effect.Effect<void>;
+    close: () => Effect.Effect<void, never, never>;
+    dispose: () => void;
+};

package/dist/keyed-tasks.js

@@ -0,0 +1,102 @@
+import * as Cause from 'effect/Cause';
+import * as Deferred from 'effect/Deferred';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import { commandSlot, program } from './program.js';
+import { defaultUiRuntime } from './runtime.js';
+import { reportError, reportSafely } from './errors.js';
+import { protectSnapshot } from './snapshot.js';
+/** Per-entity serialization. Inputs are captured now; run reads services when work starts. */
+export function keyedTasks(owner, definition, ...provided) {
+    const runtime = provided[0] ?? defaultUiRuntime;
+    const entries = new Map();
+    let disposed = false;
+    const slot = commandSlot(definition.name);
+    const makeSource = () => program({
+        initial: null,
+        update: (model, message) => 'command' in message ? { model, commands: [message.command] } : { model, cancel: [slot] },
+    });
+    // Each key owns a program, including its interrupted fibers, so drain never waits on other keys.
+    const get = (key) => {
+        let entry = entries.get(key);
+        if (!entry) {
+            entry = { source: makeSource(), version: 0, retiring: false };
+            entries.set(key, entry);
+        }
+        return entry;
+    };
+    const dispose = () => {
+        disposed = true;
+        for (const entry of entries.values())
+            entry.source.dispose();
+    };
+    const close = () => Effect.gen(function* () {
+        dispose();
+        yield* Effect.all([...entries.values()].map((entry) => entry.source.close()), { concurrency: 'unbounded' });
+        entries.clear();
+    });
+    owner.own({ dispose, close });
+    return {
+        submit(key, input) {
+            if (disposed || owner.disposed)
+                return { outcome: Effect.succeed(Object.freeze({ _tag: 'Cancelled' })) };
+            const captured = protectSnapshot(input);
+            const entry = get(key);
+            entry.version++;
+            const result = Deferred.makeUnsafe();
+            const outcome = Deferred.await(result);
+            const settle = (value) => {
+                Deferred.doneUnsafe(result, Effect.succeed(protectSnapshot(value)));
+            };
+            Effect.runFork(Effect.gen(function* () {
+                yield* outcome;
+                if (entry.retiring)
+                    return;
+                entry.retiring = true;
+                let version;
+                do {
+                    version = entry.version;
+                    yield* entry.source.awaitStopped();
+                } while (version !== entry.version);
+                if (entries.get(key) === entry) {
+                    entries.delete(key);
+                    entry.source.dispose();
+                }
+            })).addObserver((exit) => {
+                if (Exit.isFailure(exit))
+                    reportSafely(reportError, exit.cause);
+            });
+            const action = Effect.uninterruptibleMask((restore) => restore(Effect.suspend(() => definition.run(key, captured)).pipe(Effect.map((value) => protectSnapshot(value)))).pipe(Effect.exit, Effect.flatMap((exit) => Effect.sync(() => settle(Exit.isSuccess(exit)
+                ? { _tag: 'Success', value: exit.value }
+                : Cause.hasInterruptsOnly(exit.cause)
+                    ? { _tag: 'Cancelled' }
+                    : { _tag: 'Failure', cause: exit.cause })))));
+            entry.source.send({
+                command: {
+                    slot,
+                    policy: definition.policy,
+                    action: runtime.provide(action),
+                    onDiscard: (_tag) => settle({ _tag }),
+                },
+            });
+            return { outcome };
+        },
+        cancel(key) {
+            const entry = entries.get(key);
+            if (entry) {
+                entry.version++;
+                entry.source.send({ cancel: true });
+            }
+        },
+        drain(...selected) {
+            return Effect.suspend(() => {
+                const pending = selected.length
+                    ? [entries.get(selected[0])].filter((entry) => !!entry)
+                    : [...entries.values()];
+                return Effect.all(pending.map((entry) => Effect.andThen(entry.source.awaitIdle(), entry.source.awaitStopped())), { concurrency: 'unbounded', discard: true });
+            });
+        },
+        close,
+        dispose,
+    };
+}

package/dist/lazy.d.ts

@@ -1,4 +1,5 @@
-import { Effect, type Cause } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
 import { type View } from './dom.js';
 import { type UiRuntime } from './runtime.js';
 export interface LazyViewOptions<Model, Message, E> {

package/dist/lazy.js

@@ -1,4 +1,6 @@
-import { Effect, Fiber } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
 import { child, compiled, viewRegion } from './dom.js';
 import { reportSafely } from './errors.js';
 import { defaultUiRuntime } from './runtime.js';
@@ -25,15 +27,21 @@ export function lazyView(load, ...provided) {
         scope.cleanups.push(interrupt);
         if (scope.disposed)
             return;
-        fiber = Effect.runFork(runtime.provide(Effect.suspend(load)));
-        if (scope.disposed) {
-            interrupt();
-            return;
+        const finished = scope.settlement.begin();
+        try {
+            fiber = Effect.runFork(runtime.provide(Effect.suspend(load)));
+        }
+        catch (error) {
+            finished();
+            throw error;
         }
         fiber.addObserver((exit) => {
-            if (scope.disposed)
-                return;
             try {
+                if (scope.disposed) {
+                    if (exit._tag === 'Failure' && !Cause.hasInterruptsOnly(exit.cause))
+                        reportSafely(scope.report, exit.cause);
+                    return;
+                }
                 if (exit._tag === 'Success') {
                     loaded = exit.value;
                     render(loaded);
@@ -53,6 +61,11 @@ export function lazyView(load, ...provided) {
             catch (error) {
                 reportSafely(scope.report, error);
             }
+            finally {
+                finished();
+            }
         });
+        if (scope.disposed)
+            interrupt();
     });
 }

package/dist/load.d.ts

@@ -1,4 +1,4 @@
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 export type UiLoad<A, E = unknown, R = never> = Effect.Effect<A, E, R>;
 export declare const loadEffect: <A, E, R>(load: () => UiLoad<A, E, R>) => UiLoad<A, E, R>;
 /** Adapt Promise libraries at the integration boundary. Pass the signal to APIs that support it. */

package/dist/load.js

@@ -1,4 +1,4 @@
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 export const loadEffect = (load) => Effect.suspend(load);
 /** Adapt Promise libraries at the integration boundary. Pass the signal to APIs that support it. */
 export const fromPromise = (load) => Effect.tryPromise({ try: load, catch: (error) => error });

package/dist/mount.d.ts

@@ -1,6 +1,6 @@
 import type { Snapshot } from './snapshot.js';
 import { type ReportError } from './errors.js';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import { type UiRuntime } from './runtime.js';
 export { Portal, type PortalProps } from './dom.js';
 type Work<R = never> = (() => void) | {
@@ -16,7 +16,18 @@ export interface DomMount<T extends Element = Element> {
 export declare function domMount<T extends Element, R = never>(start: (element: T) => Work<R>, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): DomMount<T>;
 /** A stable DOM lifecycle with fresh immutable inputs, for focus, measurements and native events. */
 export declare function domBinding<T extends Element, A, R = never>(data: A | Snapshot<A>, acquire: (element: T, input: () => Snapshot<A>) => Work<R>, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): DomMount<T>;
+/** Allocate the lifetime before acquisition so reentrant publications can update or close it. */
+export declare function prepareMount<T extends Element>(element: T, mount: DomMount<T>, report?: ReportError): {
+    closed: Effect.Effect<void, never, never>;
+    start(): void;
+    close: () => Effect.Effect<void, never, never>;
+    update(next: DomMount<T>): boolean;
+    dispose: () => void;
+};
 export declare function startMount<T extends Element>(element: T, mount: DomMount<T>, report?: ReportError): {
+    closed: Effect.Effect<void, never, never>;
+    start(): void;
+    close: () => Effect.Effect<void, never, never>;
     update(next: DomMount<T>): boolean;
-    dispose(): void;
+    dispose: () => void;
 };