effectweb 0.3.1 → 0.4.0

package/dist/index.d.ts

@@ -6,7 +6,7 @@ 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';

package/dist/index.js

@@ -5,7 +5,7 @@ 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';

package/dist/infinite-query.d.ts

@@ -1,4 +1,4 @@
-import { Effect } from 'effect';
+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';

package/dist/infinite-query.js

@@ -1,4 +1,4 @@
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import { query, encodeQueryKey, } from './query.js';
 import { cacheInternals } from './cache-internals.js';
 import { queryResource } from './session.js';

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

@@ -1,4 +1,5 @@
-import { Cause, Effect } from 'effect';
+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';
@@ -13,7 +14,7 @@ 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: {
@@ -23,7 +24,7 @@ export declare function keyedTasks<Key, Input, A, E = never, R = never>(owner: D
 }, ...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]): 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,39 +30,42 @@ 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));
+            })).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)
@@ -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,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';
@@ -28,20 +30,18 @@ export function lazyView(load, ...provided) {
         const finished = scope.settlement.begin();
         try {
             fiber = Effect.runFork(runtime.provide(Effect.suspend(load)));
-            fiber.addObserver(finished);
         }
         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 +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,9 +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: Promise<void>;
-    close(): Promise<void>;
+    closed: Effect.Effect<void, never, never>;
+    start(): void;
+    close: () => Effect.Effect<void, never, never>;
     update(next: DomMount<T>): boolean;
     dispose: () => void;
 };

package/dist/mount.js

@@ -1,5 +1,8 @@
 import { reportError, reportSafely } from './errors.js';
-import { Effect, Fiber } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Deferred from 'effect/Deferred';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
 import { defaultUiRuntime } from './runtime.js';
 export { Portal } from './dom.js';
 /** Element-owned work. Changed acquisition functions replace and interrupt the prior lifetime. */
@@ -26,24 +29,22 @@ export function domBinding(data, acquire, ...provided) {
         },
     };
 }
-export function startMount(element, mount, report = reportError) {
+/** Allocate the lifetime before acquisition so reentrant publications can update or close it. */
+export function prepareMount(element, mount, report = reportError) {
     let data = mount.data;
-    const work = mount.acquire(element, () => data);
-    const fiber = Effect.isEffect(work) ? Effect.runFork(work) : undefined;
+    let work;
+    let fiber;
+    let started = false;
     let disposed = false;
-    let finish;
-    const closed = new Promise((resolve) => {
-        finish = resolve;
-    });
-    fiber?.addObserver((exit) => {
-        if (exit._tag === 'Failure' && !disposed)
-            reportSafely(report, exit.cause);
-        finish();
-    });
-    const dispose = () => {
-        if (disposed)
+    let released = false;
+    let changedDuringSetup = false;
+    const completed = Deferred.makeUnsafe();
+    const closed = Deferred.await(completed);
+    const finish = () => Deferred.doneUnsafe(completed, Effect.void);
+    const release = () => {
+        if (released || work === undefined || (Effect.isEffect(work) && !fiber))
             return;
-        disposed = true;
+        released = true;
         if (fiber)
             Effect.runFork(Fiber.interrupt(fiber));
         else {
@@ -58,20 +59,62 @@ export function startMount(element, mount, report = reportError) {
             }
         }
     };
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        if (!started)
+            finish();
+        else
+            release();
+    };
     return {
         closed,
-        close() {
+        start() {
+            if (started || disposed)
+                return;
+            started = true;
+            try {
+                work = mount.acquire(element, () => data);
+                if (Effect.isEffect(work)) {
+                    fiber = Effect.runFork(work);
+                    fiber.addObserver((exit) => {
+                        if (exit._tag === 'Failure' && (!disposed || !Cause.hasInterruptsOnly(exit.cause)))
+                            reportSafely(report, exit.cause);
+                        finish();
+                    });
+                }
+                if (disposed)
+                    release();
+                else if (changedDuringSetup && !fiber && typeof work === 'object' && 'update' in work)
+                    work.update?.();
+            }
+            catch (error) {
+                dispose();
+                if (work === undefined)
+                    finish();
+                throw error;
+            }
+        },
+        close: () => Effect.suspend(() => {
             dispose();
             return closed;
-        },
+        }),
         update(next) {
-            if (next.identity !== mount.identity)
+            if (disposed || next.identity !== mount.identity)
                 return false;
             data = next.data;
-            if (!fiber && typeof work === 'object' && 'update' in work)
+            if (started && work === undefined)
+                changedDuringSetup = true;
+            else if (!fiber && typeof work === 'object' && work && 'update' in work)
                 work.update?.();
             return true;
         },
         dispose,
     };
 }
+export function startMount(element, mount, report = reportError) {
+    const lifetime = prepareMount(element, mount, report);
+    lifetime.start();
+    return lifetime;
+}

package/dist/owner.d.ts

@@ -1,14 +1,16 @@
 import { type Snapshot } from './snapshot.js';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import { type Program, type TaskPolicy, type CommandSlot } from './program.js';
 import { type ReportError } from './errors.js';
 import type { UiRuntime } from './runtime.js';
 export type { TaskPolicy } from './program.js';
+interface OwnedResource {
+    dispose(): void;
+    close?(): Effect.Effect<void, unknown>;
+}
 export interface DisposableOwner {
     readonly disposed: boolean;
-    readonly own: <A extends {
-        dispose(): void;
-    }>(resource: A) => A;
+    readonly own: <A extends OwnedResource>(resource: A) => A;
 }
 export interface ModelOwner<Model extends object, R = never> extends DisposableOwner {
     readonly source: Program<Model, never>;
@@ -24,9 +26,9 @@ export interface ModelOwner<Model extends object, R = never> extends DisposableO
     readonly run: (slot: CommandSlot, effect: Effect.Effect<unknown, unknown, R>, policy: TaskPolicy) => void;
     readonly cancel: (slot: CommandSlot) => void;
     readonly isRunning: (slot: CommandSlot) => boolean;
-    readonly awaitIdle: (slot?: CommandSlot) => Promise<void>;
+    readonly awaitIdle: (slot?: CommandSlot) => Effect.Effect<void>;
     /** Interrupt and join work before closing owned dependencies in reverse order. */
-    readonly close: () => Promise<void>;
+    readonly close: () => Effect.Effect<void, AggregateError>;
     readonly dispose: () => void;
 }
 type Options = {

package/dist/owner.js

@@ -1,5 +1,7 @@
 import { protectSnapshot } from './snapshot.js';
-import { Effect } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
 import { program, } from './program.js';
 import { patchModel } from './state.js';
 import { runAll, reportError } from './errors.js';
@@ -7,7 +9,7 @@ export function modelOwner(initial, options = {}) {
     let disposed = false;
     let staged;
     const cleanups = [];
-    let closing;
+    let resourcesDisposed = false;
     const source = program({
         initial,
         ...options,
@@ -57,42 +59,27 @@ export function modelOwner(initial, options = {}) {
             return;
         disposed = true;
         source.dispose();
-        runAll(cleanups
-            .splice(0)
-            .reverse()
-            .map((resource) => () => resource.dispose()), options.onDefect ?? reportError);
+        resourcesDisposed = true;
+        runAll([...cleanups].reverse().map((resource) => () => resource.dispose()), options.onDefect ?? reportError);
     };
-    const close = () => {
-        if (closing)
-            return closing;
+    const closing = Effect.runSync(Effect.cached(Effect.uninterruptible(Effect.gen(function* () {
         disposed = true;
         const resources = cleanups.splice(0).reverse();
-        let finish;
-        let fail;
-        closing = new Promise((resolve, reject) => {
-            finish = resolve;
-            fail = reject;
-        });
-        const closeResources = async () => {
-            await source.close();
-            const errors = [];
-            for (const resource of resources) {
-                try {
-                    if (resource.close)
-                        await resource.close();
-                    else
-                        resource.dispose();
-                }
-                catch (error) {
-                    errors.push(error);
-                }
-            }
-            if (errors.length)
-                throw new AggregateError(errors, 'Owner cleanup failed.');
-        };
-        closeResources().then(finish, fail);
-        return closing;
-    };
+        yield* source.close();
+        const errors = [];
+        for (const resource of resources) {
+            const exit = yield* Effect.exit(Effect.suspend(() => resource.close
+                ? resource.close()
+                : resourcesDisposed
+                    ? Effect.void
+                    : Effect.sync(() => resource.dispose())));
+            if (Exit.isFailure(exit))
+                errors.push(Cause.squash(exit.cause));
+        }
+        if (errors.length)
+            return yield* Effect.fail(new AggregateError(errors, 'Owner cleanup failed.'));
+    }))));
+    const close = () => closing;
     return {
         source: { model: source.model, send: source.send, subscribe: source.subscribe, dispose, close },
         read,
@@ -122,11 +109,6 @@ export function modelOwner(initial, options = {}) {
             staged = batch;
             try {
                 const result = work();
-                if (result &&
-                    (typeof result === 'object' || typeof result === 'function') &&
-                    'then' in result &&
-                    typeof result.then === 'function')
-                    throw new TypeError('Model transactions must be synchronous. Run async work as an owned Effect.');
                 staged = parent;
                 if (!disposed) {
                     if (parent) {

package/dist/pages.d.ts

@@ -1,5 +1,5 @@
 import type { Snapshot } from './snapshot.js';
-import { Cause } from 'effect';
+import * as Cause from 'effect/Cause';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { UiLoad, UiPage } from './load.js';
 import { type Transition, type RunningProgram } from './program.js';

package/dist/pages.js

@@ -1,6 +1,7 @@
 import { commandSlot } from './program.js';
 import { shareData } from './sharing.js';
-import { Cause, Option } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Option from 'effect/Option';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { effectCommand, program, } from './program.js';
 import { defaultUiRuntime } from './runtime.js';

package/dist/program.d.ts

@@ -1,5 +1,7 @@
 import { type Snapshot } from './snapshot.js';
-import { Cause, Effect, Stream } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Stream from 'effect/Stream';
 export type Send<Message> = (message: Message) => void;
 /** queue retains FIFO requests; latest-queued retains only the newest pending request. */
 export type TaskPolicy = 'replace' | 'drop' | 'parallel' | 'queue' | 'latest-queued';
@@ -51,14 +53,14 @@ export interface Program<Model, Message> {
     readonly send: Send<Message>;
     readonly subscribe: (listener: (model: Snapshot<Model>) => void) => () => void;
     readonly dispose: () => void;
-    readonly close?: () => Promise<void>;
+    readonly close?: () => Effect.Effect<void, unknown>;
 }
 export interface RunningProgram<Model, Message> extends Program<Model, Message> {
     /** Wait for interrupted work and its finalizers as well as admitted work. */
-    readonly awaitStopped: () => Promise<void>;
-    readonly close: () => Promise<void>;
+    readonly awaitStopped: () => Effect.Effect<void>;
+    readonly close: () => Effect.Effect<void>;
     readonly activeSlots: () => readonly CommandSlot[];
-    readonly awaitIdle: (slot?: CommandSlot) => Promise<void>;
+    readonly awaitIdle: (slot?: CommandSlot) => Effect.Effect<void>;
 }
 export declare function program<Model, Message>(options: {
     initial: Model | Snapshot<Model>;