effectweb 0.3.1 → 0.5.0

package/dist/effectEvent.js

@@ -1,65 +1,69 @@
-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';
+import { uiRuntime } from './runtime.js';
 const tag = Symbol('Effect event');
 export function effectEvent(policy, load, runtime) {
-    const owner = runtime ?? defaultUiRuntime;
-    return (event) => ({ [tag]: true, policy, effect: owner.provide(load(event)) });
+    return (event) => ({
+        [tag]: true,
+        policy,
+        effect: runtime
+            ? runtime.provideScoped(load(event))
+            : load(event),
+    });
 }
-/** Internal listener owner, allocated only when an event returns a value needing inspection. */
+/** Capture an operation's services in Effect setup; its event listener supplies the work scope. */
+export const makeEffectHandler = (work) => Effect.map(Effect.context(), (context) => {
+    const runtime = uiRuntime(context);
+    return (...args) => runtime.provideScoped(Effect.suspend(() => work(...args)));
+});
+/** Internal listener owner, allocated only when an event returns an owned request. */
 export function eventEffects(report, settlement) {
-    let active;
+    const active = new Set();
     let disposed = false;
     const stop = () => {
-        const previous = active;
-        active = undefined;
-        if (previous?.fiber)
-            Effect.runFork(Fiber.interrupt(previous.fiber));
+        const previous = [...active];
+        active.clear();
+        for (const token of previous)
+            if (token.fiber)
+                Effect.runFork(Fiber.interrupt(token.fiber));
     };
     return {
         accept(value) {
+            // Direct Effects admit every event. Other policies are explicit requests.
+            const request = Effect.isEffect(value)
+                ? { policy: 'parallel', effect: value }
+                : value;
             if (disposed)
                 return;
-            if (value && typeof value === 'object' && tag in value) {
-                const request = value;
-                if (request.policy === 'drop' && active)
-                    return;
+            if (request.policy === 'drop' && active.size)
+                return;
+            if (request.policy === 'replace')
                 stop();
-                const token = {};
-                active = token;
-                const finished = settlement?.begin();
-                try {
-                    const fiber = Effect.runFork(request.effect);
-                    fiber.addObserver(() => finished?.());
-                    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) {
+            const token = {};
+            active.add(token);
+            const finished = settlement?.begin();
+            try {
+                const fiber = settlement?.runtime
+                    ? settlement.runtime.runFork(request.effect)
+                    : Effect.runFork(Effect.scoped(request.effect));
+                token.fiber = fiber;
+                fiber.addObserver((exit) => {
+                    const current = !disposed && active.has(token);
+                    active.delete(token);
+                    if (exit._tag === 'Failure' && (current || !Cause.hasInterruptsOnly(exit.cause)))
+                        reportSafely(report, exit.cause);
                     finished?.();
-                    if (active === token)
-                        active = undefined;
-                    reportSafely(report, error);
+                });
+                if (disposed || !active.has(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?.();
+                active.delete(token);
+                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

@@ -1,17 +1,19 @@
 export type { Snapshot, SnapshotOpaque, snapshotOpaque } from './snapshot.js';
-export { modelOwner, type ModelOwner, type DisposableOwner, type TaskPolicy } from './owner.js';
+export { modelOwner, makeModelOwner, type ModelOwner, type DisposableOwner, type TaskPolicy, } from './owner.js';
 export { collection, entities, sequence, type Rows, type Collection } from './collection.js';
 export { component, localComponent, programView } from './component.js';
 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 { effectEvent, makeEffectHandler } from './effectEvent.js';
+export { mountView, view, list, listView, memoView, observe, ViewBinding, type View, type Mounted, } from './dom.js';
+export { mount } from './render.js';
+export { mapSource, fromStream, fromSubscriptionRef, fromAtom, projectionSource, type Source, } from './source.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 { Portal, domBinding, domMount, makeDomMount, makeDomBinding, type DomMount, type PortalProps, } from './mount.js';
 export { pages, type PagesMessage, type PagesRequest, type PagesModel, type PagesProgram, type Pagination, } from './pages.js';
-export { program, mapTransition, actionCommand, effectCommand, commandSlot, type CommandSlot, type Command, type Program, type Send, type Transition, } from './program.js';
+export { program, makeProgram, 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';
@@ -19,9 +21,9 @@ export { inputText, inputChecked, inputNumber, submit, defineField, type FieldRe
 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, queryGroup, type Query, type QueryKey, type QueryGroup } from './query.js';
-export { makeQueryCache, type QueryCache, type QueryCacheOptions } from './cache.js';
+export { uiRuntime, makeUiRuntime, type UiRuntime } from './runtime.js';
+export { query, queryGroup, type Query, type QueryKey, type QueryGroup, type QueryEncoding, } from './query.js';
+export { makeQueryCache, scopedQueryCache, 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';

package/dist/index.js

@@ -1,15 +1,17 @@
-export { modelOwner } from './owner.js';
+export { modelOwner, makeModelOwner, } from './owner.js';
 export { collection, entities, sequence } from './collection.js';
 export { component, localComponent, programView } from './component.js';
 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 { effectEvent, makeEffectHandler } from './effectEvent.js';
+export { mountView, view, list, listView, memoView, observe, ViewBinding, } from './dom.js';
+export { mount } from './render.js';
+export { mapSource, fromStream, fromSubscriptionRef, fromAtom, projectionSource, } from './source.js';
 export { lazyView } from './lazy.js';
-export { Portal, domBinding, domMount } from './mount.js';
+export { Portal, domBinding, domMount, makeDomMount, makeDomBinding, } from './mount.js';
 export { pages, } from './pages.js';
-export { program, mapTransition, actionCommand, effectCommand, commandSlot, } from './program.js';
+export { program, makeProgram, 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';
@@ -17,9 +19,9 @@ export { inputText, inputChecked, inputNumber, submit, defineField, } from './fo
 export { slot } from './dom.js';
 export { AsyncContent } from './AsyncContent.js';
 export { defineTasks, } from './tasks.js';
-export { uiRuntime } from './runtime.js';
-export { query, queryGroup } from './query.js';
-export { makeQueryCache } from './cache.js';
+export { uiRuntime, makeUiRuntime } from './runtime.js';
+export { query, queryGroup, } from './query.js';
+export { makeQueryCache, scopedQueryCache, } from './cache.js';
 export { queryResource, observeQuery, lifetime, projectionCache, sessionGroup, } from './session.js';
 export { httpJson } from './http.js';
 export { infiniteQuery, infiniteResource, } from './infinite-query.js';

package/dist/infinite-query.d.ts

@@ -1,5 +1,6 @@
-import { Effect } from 'effect';
-import { type Query, type QueryArgs, type QueryGroup } from './query.js';
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
+import { type Query, type QueryKey, 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';
@@ -18,20 +19,23 @@ export interface InfiniteQuery<Args, A, Param, E = never, R = never> {
     }, A, E, R>;
     readonly maxPages: number;
     readonly next: (value: Snapshot<A>, param: Snapshot<Param>) => Param | undefined;
+    readonly paramKey: (param: Param | Snapshot<Param> | undefined) => string;
 }
 /** 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 load: (args: Snapshot<Args>, param: Snapshot<Param>) => Effect.Effect<A, E, R | Scope.Scope>;
     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;
+    readonly encodeArgs?: (args: Snapshot<Args>) => QueryKey;
+    readonly encodeParam?: (param: Snapshot<Param>) => QueryKey;
+} & ([Args] extends [QueryArgs<Args>] ? unknown : {
+    readonly encodeArgs: (args: Snapshot<Args>) => QueryKey;
+}) & ([Param] extends [QueryArgs<Param>] ? unknown : {
+    readonly encodeParam: (param: Snapshot<Param>) => QueryKey;
 })): 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>;
@@ -39,4 +43,4 @@ export interface InfiniteResource<Args, A, Param, E = never> extends QueryResour
     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>;
+export declare function infiniteResource<Args, A, Param, E, R>(cache: QueryCache<R>, definition: InfiniteQuery<Args, A, Param, E, NoInfer<R> | Scope.Scope>): InfiniteResource<Args, A, Param, E>;

package/dist/infinite-query.js

@@ -1,5 +1,5 @@
-import { Effect } from 'effect';
-import { query, encodeQueryKey, } from './query.js';
+import * as Effect from 'effect/Effect';
+import { query, encodeQueryKey, encodeQueryArguments, } from './query.js';
 import { cacheInternals } from './cache-internals.js';
 import { queryResource } from './session.js';
 import { protectSnapshot } from './snapshot.js';
@@ -9,19 +9,27 @@ export function infiniteQuery(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 encodeArgs = (args) => config.encodeArgs ? config.encodeArgs(args) : args;
+    const encodeParam = (param) => config.encodeParam ? config.encodeParam(param) : param;
+    const paramKey = (param) => encodeQueryKey(param === undefined ? undefined : encodeParam(param));
+    paramKey(config.initial);
     const initial = protectSnapshot(config.initial);
     const next = (value, param) => {
         const result = config.next(value, param);
-        encodeQueryKey(result);
+        paramKey(result);
         return result;
     };
     const page = query({
         name: `${config.name}:page`,
+        encode: ({ args, param }) => ({
+            args: encodeArgs(args),
+            param: encodeParam(param),
+        }),
         load: ({ args, param }) => config.load(args, param),
     });
     const root = query({
         name: config.name,
+        encode: encodeArgs,
         ...(config.groups ? { groups: config.groups } : {}),
         load: (args, previous) => {
             const params = config.refresh !== 'first' && previous?.pages.length
@@ -36,7 +44,7 @@ export function infiniteQuery(definition) {
             }));
         },
     });
-    return Object.freeze({ query: root, page, maxPages, next });
+    return Object.freeze({ query: root, page, maxPages, next, paramKey });
 }
 const operations = new WeakMap();
 function operationBook(cache, definition) {
@@ -70,11 +78,11 @@ export function infiniteResource(cache, definition) {
         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)
+        const pageKey = definition.paramKey(param);
+        const retained = current.pages.some((page) => definition.paramKey(page.param) === pageKey);
+        if (retry && !retained && definition.paramKey(current.next) !== pageKey)
             return yield* Effect.die(new RangeError('Retry a retained page or the next page parameter.'));
-        const key = encodeQueryKey(args);
+        const key = encodeQueryArguments(definition.query, args);
         const revision = internal.revision(definition.query, args);
         let operation = book.get(key);
         if (!operation || operation.revision !== revision) {
@@ -95,8 +103,8 @@ export function infiniteResource(cache, definition) {
                     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))
+                const index = latest.pages.findIndex((page) => definition.paramKey(page.param) === pageKey);
+                if (index < 0 && (retained || definition.paramKey(latest.next) !== pageKey))
                     return;
                 if (index >= 0 && latest.pages[index].value === value)
                     return;
@@ -134,8 +142,8 @@ export function infiniteResource(cache, definition) {
         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));
+            definition.paramKey(data.next);
+            const keys = data.pages.map((page) => definition.paramKey(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);

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

@@ -4,6 +4,8 @@ import type { SnapshotOpaque } from './snapshot.js';
 import type { EffectEventRequest } from './effectEvent.js';
 import type { CompiledContent } from './dom.js';
 import type { DomMount } from './mount.js';
+import type * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 /** Nominal eligibility for compiled JSX components and compiler primitives. */
 export declare const jsxComponent: unique symbol;
 /** JSX is a compiler input. No renderer library owns its types. */
@@ -16,10 +18,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 | Effect.Effect<unknown, unknown, Scope.Scope>;
     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

@@ -1,4 +1,6 @@
-import { Cause, Effect } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import { type TaskPolicy } from './program.js';
 import type { DisposableOwner } from './owner.js';
 import { type UiRuntime } from './runtime.js';
@@ -13,17 +15,17 @@ export type TaskOutcome<A, E> = {
     readonly _tag: 'Cancelled' | 'Superseded' | 'Dropped';
 };
 export interface TaskHandle<A, E> {
-    readonly outcome: Promise<TaskOutcome<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>]): {
+    readonly run: (key: Key, input: Snapshot<Input>) => Effect.Effect<A, E, R | Scope.Scope>;
+}, ...provided: [Exclude<R, Scope.Scope>] 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]): Promise<void>;
-    close: () => Promise<void>;
+    drain(...selected: [] | [Key]): Effect.Effect<void>;
+    close: () => Effect.Effect<void, never, never>;
     dispose: () => void;
 };

package/dist/keyed-tasks.js

@@ -1,4 +1,7 @@
-import { Cause, Effect, Exit } from 'effect';
+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';
@@ -27,40 +30,43 @@ export function keyedTasks(owner, definition, ...provided) {
         for (const entry of entries.values())
             entry.source.dispose();
     };
-    const close = async () => {
+    const close = () => Effect.gen(function* () {
         dispose();
-        await Promise.all([...entries.values()].map((entry) => entry.source.close()));
+        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: Promise.resolve(Object.freeze({ _tag: 'Cancelled' })) };
+                return { outcome: Effect.succeed(Object.freeze({ _tag: 'Cancelled' })) };
             const captured = protectSnapshot(input);
             const entry = get(key);
             entry.version++;
-            let settle;
-            const outcome = new Promise((resolve) => {
-                settle = (result) => resolve(protectSnapshot(result));
-            });
-            outcome
-                .then(async () => {
+            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;
-                    await entry.source.awaitStopped();
+                    yield* entry.source.awaitStopped();
                 } while (version !== entry.version);
                 if (entries.get(key) === entry) {
                     entries.delete(key);
                     entry.source.dispose();
                 }
-            })
-                .catch((error) => reportSafely(reportError, error));
-            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)
+            })).addObserver((exit) => {
+                if (Exit.isFailure(exit))
+                    reportSafely(reportError, exit.cause);
+            });
+            const action = Effect.uninterruptibleMask((restore) => restore(Effect.scoped(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' }
@@ -69,7 +75,7 @@ export function keyedTasks(owner, definition, ...provided) {
                 command: {
                     slot,
                     policy: definition.policy,
-                    action: runtime.provide(action),
+                    action: runtime.provideScoped(action),
                     onDiscard: (_tag) => settle({ _tag }),
                 },
             });
@@ -82,14 +88,13 @@ export function keyedTasks(owner, definition, ...provided) {
                 entry.source.send({ cancel: true });
             }
         },
-        async drain(...selected) {
-            const pending = selected.length
-                ? [entries.get(selected[0])].filter((entry) => !!entry)
-                : [...entries.values()];
-            await Promise.all(pending.map(async (entry) => {
-                await entry.source.awaitIdle();
-                await entry.source.awaitStopped();
-            }));
+        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,6 @@
-import { Effect, type Cause } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import { type View } from './dom.js';
 import { type UiRuntime } from './runtime.js';
 export interface LazyViewOptions<Model, Message, E> {
@@ -12,7 +14,7 @@ export interface LazyViewOptions<Model, Message, E> {
  * Mount-owned loading with current inputs and a reusable successful definition.
  * Unresolved placements own independent requests; unmount interrupts their work.
  */
-export declare function lazyView<Model, Message = never, E = never, R = never>(load: () => Effect.Effect<View<Model, Message>, E, R>, ...provided: [R] extends [never] ? [
+export declare function lazyView<Model, Message = never, E = never, R = never>(load: () => Effect.Effect<View<Model, Message>, E, R | Scope.Scope>, ...provided: [Exclude<R, Scope.Scope>] extends [never] ? [
     options?: LazyViewOptions<NoInfer<Model>, NoInfer<Message>, NoInfer<E>> & {
         readonly runtime?: UiRuntime<R>;
     }

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';
@@ -8,9 +10,10 @@ import { defaultUiRuntime } from './runtime.js';
  */
 export function lazyView(load, ...provided) {
     const options = provided[0];
-    const runtime = options?.runtime ?? defaultUiRuntime;
     let loaded;
     return compiled((scope, parent, before) => {
+        const ownerRuntime = scope.settlement.runtime ?? defaultUiRuntime;
+        const runtime = options?.runtime ?? ownerRuntime;
         const render = viewRegion(scope, parent, before);
         if (loaded) {
             render(loaded);
@@ -27,21 +30,19 @@ export function lazyView(load, ...provided) {
             return;
         const finished = scope.settlement.begin();
         try {
-            fiber = Effect.runFork(runtime.provide(Effect.suspend(load)));
-            fiber.addObserver(finished);
+            fiber = ownerRuntime.runFork(runtime.provideScoped(Effect.suspend(load)));
         }
         catch (error) {
             finished();
             throw error;
         }
-        if (scope.disposed) {
-            interrupt();
-            return;
-        }
         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);
@@ -61,6 +62,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 });