effectweb 0.1.0

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+export type ReportError = (error: unknown) => void;
+export declare const reportError: ReportError;
+/** Reporters are observers. A broken reporter must not prevent cleanup or sibling updates. */
+export declare function reportSafely(report: ReportError, error: unknown): void;
+export declare function runAll(work: readonly (() => void)[], report?: ReportError): void;

package/dist/errors.js

@@ -0,0 +1,23 @@
+export const reportError = (error) => console.error(error);
+/** Reporters are observers. A broken reporter must not prevent cleanup or sibling updates. */
+export function reportSafely(report, error) {
+    try {
+        report(error);
+    }
+    catch (reporterError) {
+        console.error(reporterError);
+    }
+}
+export function runAll(work, report = reportError) {
+    const errors = [];
+    for (const run of work) {
+        try {
+            run();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    if (errors.length)
+        reportSafely(report, new AggregateError(errors, 'UI work failed'));
+}

package/dist/form.d.ts

@@ -0,0 +1,19 @@
+import type { EffectEventRequest } from './effectEvent.js';
+type EventResult = void | boolean | EffectEventRequest;
+type ValueEvent<T> = {
+    readonly currentTarget: T;
+};
+/** Capture native values synchronously; returned Effect requests retain the listener's owner. */
+export declare const inputText: (change: (value: string) => EventResult) => (event: ValueEvent<{
+    readonly value: string;
+}>) => EventResult;
+export declare const inputChecked: (change: (value: boolean) => EventResult) => (event: ValueEvent<{
+    readonly checked: boolean;
+}>) => EventResult;
+/** Empty and invalid numeric inputs stay absent rather than becoming zero or NaN. */
+export declare const inputNumber: (change: (value: number | undefined) => EventResult) => (event: ValueEvent<{
+    readonly valueAsNumber: number;
+}>) => EventResult;
+/** Prevention always runs during the native event, before task drop/replace policy is applied. */
+export declare const submit: (run: () => EventResult) => (event: Pick<SubmitEvent, "preventDefault">) => EventResult;
+export {};

package/dist/form.js

@@ -0,0 +1,13 @@
+/** Capture native values synchronously; returned Effect requests retain the listener's owner. */
+export const inputText = (change) => (event) => change(event.currentTarget.value);
+export const inputChecked = (change) => (event) => change(event.currentTarget.checked);
+/** Empty and invalid numeric inputs stay absent rather than becoming zero or NaN. */
+export const inputNumber = (change) => (event) => {
+    const value = event.currentTarget.valueAsNumber;
+    return change(Number.isNaN(value) ? undefined : value);
+};
+/** Prevention always runs during the native event, before task drop/replace policy is applied. */
+export const submit = (run) => (event) => {
+    event.preventDefault();
+    return run();
+};

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { collection, sequence, type Rows } 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, type View } from './dom.js';
+export type { JSX } from './jsx.js';
+export { Portal, domBinding, domMount, type DomMount } from './mount.js';
+export { pages, type PagesMessage, type PagesModel } from './pages.js';
+export { program, actionCommand, effectCommand, 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, observePrograms, type BindingUpdate, type ProgramUpdate, } from './diagnostics.js';
+export { inputText, inputChecked, inputNumber, submit } from './form.js';
+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 } from './query.js';
+export { makeUiModel, makeUiModel as makeQueryCache, makePagedResource, type UiModel, } from './cache.js';
+export { queryResource, resource, pagedResource, lifetime, projectionCache, sessionGroup, type SessionContext, type Read, } from './session.js';

package/dist/index.js

@@ -0,0 +1,21 @@
+export { collection, 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 } from './dom.js';
+export { Portal, domBinding, domMount } from './mount.js';
+export { pages } from './pages.js';
+export { program, actionCommand, effectCommand, } from './program.js';
+export { available, resourceComponent, resourceError, } from './resource.js';
+export { fromPromise } from './load.js';
+export { observeBindings, observePrograms, } from './diagnostics.js';
+export { inputText, inputChecked, inputNumber, submit } from './form.js';
+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 { makeUiModel, makeUiModel as makeQueryCache, makePagedResource, } from './cache.js';
+export { queryResource, resource, pagedResource, lifetime, projectionCache, sessionGroup, } from './session.js';

package/dist/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export type { JSX } from './jsx.js';

package/dist/jsx-runtime.js

@@ -0,0 +1 @@
+export {};

package/dist/jsx.d.ts

@@ -0,0 +1,86 @@
+import type { EffectEventRequest } from './effectEvent.js';
+import type { CompiledContent } from './dom.js';
+import type { DomMount } from './mount.js';
+/** JSX is a compiler input. No renderer library owns its types. */
+export declare namespace JSX {
+    export type Element = Node | string | number | boolean | null | undefined | CompiledContent | Element[];
+    export type EventHandler<T, E extends Event> = (event: E & {
+        currentTarget: T;
+        target: EventTarget & globalThis.Element;
+    }) => void | boolean | EffectEventRequest;
+    export type EventHandlerUnion<T, E extends Event> = EventHandler<T, E>;
+    export type CSSProperties = {
+        [property: string]: string | number | undefined | null;
+    };
+    export interface Events<T> {
+        onClick?: EventHandler<T, MouseEvent> | undefined;
+        onDblClick?: EventHandler<T, MouseEvent> | undefined;
+        onContextMenu?: EventHandler<T, MouseEvent> | undefined;
+        onInput?: EventHandler<T, InputEvent> | undefined;
+        onChange?: EventHandler<T, Event> | undefined;
+        onSubmit?: EventHandler<T, SubmitEvent> | undefined;
+        onKeyDown?: EventHandler<T, KeyboardEvent> | undefined;
+        onKeyUp?: EventHandler<T, KeyboardEvent> | undefined;
+        onPointerDown?: EventHandler<T, PointerEvent> | undefined;
+        onPointerUp?: EventHandler<T, PointerEvent> | undefined;
+        onPointerMove?: EventHandler<T, PointerEvent> | undefined;
+        onPointerEnter?: EventHandler<T, PointerEvent> | undefined;
+        onPointerLeave?: EventHandler<T, PointerEvent> | undefined;
+        onPointerCancel?: EventHandler<T, PointerEvent> | undefined;
+        onMouseDown?: EventHandler<T, MouseEvent> | undefined;
+        onMouseEnter?: EventHandler<T, MouseEvent> | undefined;
+        onMouseLeave?: EventHandler<T, MouseEvent> | undefined;
+        onFocus?: EventHandler<T, FocusEvent> | undefined;
+        onBlur?: EventHandler<T, FocusEvent> | undefined;
+        onScroll?: EventHandler<T, Event> | undefined;
+        onWheel?: EventHandler<T, WheelEvent> | undefined;
+        onLoad?: EventHandler<T, Event> | undefined;
+        onError?: EventHandler<T, Event> | undefined;
+        onLoadedMetadata?: EventHandler<T, Event> | undefined;
+        onTimeUpdate?: EventHandler<T, Event> | undefined;
+        onEnded?: EventHandler<T, Event> | undefined;
+        onPlay?: EventHandler<T, Event> | undefined;
+        onPause?: EventHandler<T, Event> | undefined;
+        onPaste?: EventHandler<T, ClipboardEvent> | undefined;
+        onDragOver?: EventHandler<T, DragEvent> | undefined;
+        onDragLeave?: EventHandler<T, DragEvent> | undefined;
+        onDrop?: EventHandler<T, DragEvent> | undefined;
+    }
+    type Scalar = string | number | boolean;
+    type DomAttributes<T> = {
+        [K in keyof T as K extends string ? T[K] extends Scalar | null ? K | Lowercase<K> : never : never]?: K extends 'min' | 'max' | 'step' | 'value' ? string | number | undefined : T[K] extends boolean ? boolean | undefined : T[K] extends number ? number | string | undefined : T[K] | undefined;
+    };
+    type CaptureEvents<T> = {
+        [K in keyof Events<T> as `${K}Capture`]?: Events<T>[K];
+    };
+    export type Attributes<T> = Events<T> & CaptureEvents<T> & DomAttributes<T> & {
+        children?: Element | undefined;
+        class?: string | undefined;
+        className?: string | undefined;
+        classList?: Record<string, boolean | undefined> | undefined;
+        style?: string | CSSProperties | undefined;
+        use?: DomMount | undefined;
+        role?: string | undefined;
+        tabindex?: number | undefined;
+        loading?: 'lazy' | 'eager' | undefined;
+        download?: string | boolean | undefined;
+        autocomplete?: string | undefined;
+        inputmode?: string | undefined;
+        spellcheck?: boolean | 'true' | 'false' | undefined;
+        contenteditable?: boolean | 'true' | 'false' | undefined;
+        [data: `data-${string}`]: Scalar | null | undefined;
+        [aria: `aria-${string}`]: Scalar | null | undefined;
+    };
+    type SvgAttributes = Partial<Record<'viewBox' | 'fill' | 'stroke' | 'stroke-width' | 'stroke-linecap' | 'stroke-linejoin' | 'stroke-dasharray' | 'stroke-dashoffset' | 'stroke-miterlimit' | 'fill-rule' | 'clip-rule' | 'fill-opacity' | 'stroke-opacity' | 'd' | 'points' | 'x' | 'y' | 'x1' | 'x2' | 'y1' | 'y2' | 'cx' | 'cy' | 'r' | 'rx' | 'ry' | 'width' | 'height' | 'xmlns' | 'transform' | 'preserveAspectRatio' | 'offset' | 'stop-color' | 'stop-opacity' | 'clip-path' | 'mask' | 'opacity' | 'pathLength', string | number | undefined>>;
+    type Html = {
+        [Tag in keyof HTMLElementTagNameMap]: Attributes<HTMLElementTagNameMap[Tag]>;
+    };
+    type Svg = {
+        [Tag in Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>]: Attributes<SVGElementTagNameMap[Tag]> & SvgAttributes;
+    };
+    export type IntrinsicElements = Html & Svg;
+    export interface ElementChildrenAttribute {
+        children: unknown;
+    }
+    export {};
+}

package/dist/jsx.js

@@ -0,0 +1 @@
+export {};

package/dist/load.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from 'effect';
+/** Loaders stay lazy and use one error/cancellation model, whether their work is sync or async. */
+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. */
+export declare const fromPromise: <A>(load: (signal: AbortSignal) => PromiseLike<A>) => UiLoad<A>;
+export interface UiPage<A, Cursor> {
+    items: A[];
+    totalCount?: number;
+    next: Cursor | undefined;
+}
+/** Read a local cache when executed, then acquire missing data through the same Effect contract. */
+export declare function cachedLoad<A, E, R>(read: () => A | undefined, load: () => UiLoad<A, E, R>): UiLoad<A, E, R>;

package/dist/load.js

@@ -0,0 +1,11 @@
+import { Effect } from '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 });
+/** Read a local cache when executed, then acquire missing data through the same Effect contract. */
+export function cachedLoad(read, load) {
+    return Effect.suspend(() => {
+        const value = read();
+        return value === undefined ? load() : Effect.succeed(value);
+    });
+}

package/dist/mount.d.ts

@@ -0,0 +1,25 @@
+import { type ReportError } from './errors.js';
+import { Effect } from 'effect';
+import { type UiRuntime } from './runtime.js';
+import type { JSX } from './jsx.js';
+type Work<R = never> = (() => void) | {
+    dispose: () => void;
+    update?: () => void;
+} | Effect.Effect<never, unknown, R>;
+export declare function Portal(_props: {
+    children?: JSX.Element;
+}): JSX.Element;
+export interface DomMount {
+    readonly identity: unknown;
+    readonly data: unknown;
+    readonly acquire: (element: Element, input: () => unknown) => Work;
+}
+/** Element-owned work. Changed acquisition functions replace and interrupt the prior lifetime. */
+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;
+/** 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, acquire: (element: T, input: () => A) => Work<R>, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): DomMount;
+export declare function startMount(element: Element, mount: DomMount, report?: ReportError): {
+    update(next: DomMount): boolean;
+    dispose(): void;
+};
+export {};

package/dist/mount.js

@@ -0,0 +1,61 @@
+import { reportError, reportSafely } from './errors.js';
+import { Effect, Fiber } from 'effect';
+import { defaultUiRuntime } from './runtime.js';
+export function Portal(_props) {
+    throw new Error('Portal must be compiled inside a view');
+}
+/** Element-owned work. Changed acquisition functions replace and interrupt the prior lifetime. */
+export function domMount(start, ...provided) {
+    const runtime = provided[0] ?? defaultUiRuntime;
+    return {
+        identity: start,
+        data: undefined,
+        acquire: (element) => {
+            const work = start(element);
+            return Effect.isEffect(work) ? runtime.provide(work) : work;
+        },
+    };
+}
+/** A stable DOM lifecycle with fresh immutable inputs, for focus, measurements and native events. */
+export function domBinding(data, acquire, ...provided) {
+    return {
+        identity: acquire,
+        data,
+        acquire: (element, input) => {
+            const work = acquire(element, input);
+            const runtime = provided[0] ?? defaultUiRuntime;
+            return Effect.isEffect(work) ? runtime.provide(work) : work;
+        },
+    };
+}
+export function startMount(element, mount, report = reportError) {
+    let data = mount.data;
+    const work = mount.acquire(element, () => data);
+    const fiber = Effect.isEffect(work) ? Effect.runFork(work) : undefined;
+    let disposed = false;
+    fiber?.addObserver((exit) => {
+        if (exit._tag === 'Failure' && !disposed)
+            reportSafely(report, exit.cause);
+    });
+    return {
+        update(next) {
+            if (next.identity !== mount.identity)
+                return false;
+            data = next.data;
+            if (!fiber && typeof work === 'object' && 'update' in work)
+                work.update?.();
+            return true;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            if (fiber)
+                Effect.runFork(Fiber.interrupt(fiber));
+            else if (typeof work === 'function')
+                work();
+            else if ('dispose' in work)
+                work.dispose();
+        },
+    };
+}

package/dist/pages.d.ts

@@ -0,0 +1,40 @@
+import { Cause } from 'effect';
+import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
+import type { UiLoad, UiPage } from './load.js';
+import { type Transition } from './program.js';
+export interface PagesModel<Props, A, Cursor> {
+    readonly props: Props;
+    readonly key: string | undefined;
+    readonly result: AsyncResult.AsyncResult<UiPage<A, Cursor>, unknown>;
+    readonly append: boolean;
+}
+export type PagesMessage<A, Cursor> = {
+    type: 'More';
+} | {
+    type: 'Retry';
+} | {
+    type: 'Refresh';
+} | {
+    type: 'Loaded';
+    page: UiPage<A, Cursor>;
+    append: boolean;
+} | {
+    type: 'Failed';
+    cause: Cause.Cause<unknown>;
+};
+/**
+ * Pagination owns the `page` command slot. Key changes clear results and replace the request;
+ * same-key refreshes keep the last success, and retries repeat the failed cursor.
+ * Feed request inputs through receive; pass { refresh: true } for explicit same-key submissions.
+ */
+export declare function pages<Props, A, Cursor>(definition: {
+    key: (props: Props) => string | undefined;
+    load: (props: Props, cursor: Cursor | undefined) => UiLoad<UiPage<A, Cursor>>;
+    itemKey: (item: A) => string;
+}): {
+    init: (props: Props) => PagesModel<Props, A, Cursor>;
+    receive(model: PagesModel<Props, A, Cursor>, props: Props, options?: {
+        refresh?: boolean;
+    }): Transition<PagesModel<Props, A, Cursor>, PagesMessage<A, Cursor>>;
+    update(model: PagesModel<Props, A, Cursor>, message: PagesMessage<A, Cursor>): Transition<PagesModel<Props, A, Cursor>, PagesMessage<A, Cursor>>;
+};

package/dist/pages.js

@@ -0,0 +1,86 @@
+import { Cause, Option } from 'effect';
+import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
+import { effectCommand } from './program.js';
+import { available } from './resource.js';
+/**
+ * Pagination owns the `page` command slot. Key changes clear results and replace the request;
+ * same-key refreshes keep the last success, and retries repeat the failed cursor.
+ * Feed request inputs through receive; pass { refresh: true } for explicit same-key submissions.
+ */
+export function pages(definition) {
+    const request = (model, append) => {
+        const previous = available(model.result);
+        if (append && (model.result.waiting || !previous || previous.next === undefined))
+            return { model };
+        if (model.key === undefined)
+            return { model };
+        const cursor = append ? previous?.next : undefined;
+        return {
+            model: { ...model, append, result: AsyncResult.waiting(model.result) },
+            commands: [
+                effectCommand('page', () => definition.load(model.props, cursor), {
+                    onSuccess: (page) => ({ type: 'Loaded', page, append }),
+                    onFailure: (cause) => ({ type: 'Failed', cause }),
+                }),
+            ],
+        };
+    };
+    return {
+        init: (props) => ({
+            props,
+            key: undefined,
+            result: AsyncResult.initial(),
+            append: false,
+        }),
+        receive(model, props, options = {}) {
+            const key = definition.key(props);
+            if (key === model.key) {
+                const next = { ...model, props };
+                return options.refresh ? request(next, false) : { model: next };
+            }
+            const next = {
+                ...model,
+                props,
+                key,
+                append: false,
+                result: AsyncResult.initial(),
+            };
+            return key === undefined ? { model: next, cancel: ['page'] } : request(next, false);
+        },
+        update(model, message) {
+            switch (message.type) {
+                case 'More':
+                    return request(model, true);
+                case 'Retry':
+                    return request(model, model.append);
+                case 'Refresh':
+                    return request(model, false);
+                case 'Failed':
+                    return {
+                        model: {
+                            ...model,
+                            result: AsyncResult.failureWithPrevious(message.cause, {
+                                previous: Option.some(model.result),
+                            }),
+                        },
+                    };
+                case 'Loaded': {
+                    const previous = message.append ? available(model.result) : undefined;
+                    const known = new Set(previous?.items.map(definition.itemKey));
+                    const incoming = message.page.items.filter((item) => {
+                        const key = definition.itemKey(item);
+                        if (known.has(key))
+                            return false;
+                        known.add(key);
+                        return true;
+                    });
+                    const page = {
+                        ...message.page,
+                        items: previous ? [...previous.items, ...incoming] : incoming,
+                    };
+                    return { model: { ...model, result: AsyncResult.success(page) } };
+                }
+            }
+        },
+    };
+}

package/dist/program.d.ts

@@ -0,0 +1,48 @@
+import { Cause, Effect, Stream } from 'effect';
+export type Send<Message> = (message: Message) => void;
+/** A slot owns either one completion or a stream of progress/events, canceled together. */
+export type Command<Message, R = never> = {
+    readonly slot: string;
+} & ({
+    readonly effect: Effect.Effect<Message, never, R>;
+    readonly stream?: never;
+    readonly action?: never;
+} | {
+    readonly stream: Stream.Stream<Message, never, R>;
+    readonly effect?: never;
+    readonly action?: never;
+} | {
+    readonly action: Effect.Effect<void, unknown, R>;
+    readonly effect?: never;
+    readonly stream?: never;
+});
+/** A lazy request settles successes, typed failures and defects through one message contract. */
+export declare function effectCommand<A, E, Success, Failure, R = never>(slot: string, load: () => Effect.Effect<A, E, R>, handlers: {
+    readonly onSuccess: (value: A) => Success;
+    readonly onFailure: (cause: Cause.Cause<E>) => Failure;
+}): Command<Success | Failure, R>;
+/** Owned work with no model result. Failures use the program's error reporter. */
+export declare function actionCommand<R = never>(slot: string, action: () => Effect.Effect<unknown, unknown, R>): Command<never, R>;
+export declare function mapCommand<A, B, R = never>(command: Command<A, R>, map: (message: A) => B): Command<B, R>;
+export interface Transition<Model, Message, R = never> {
+    readonly model: Model;
+    readonly commands?: readonly Command<Message, R>[];
+    readonly cancel?: readonly string[];
+}
+export interface Program<Model, Message> {
+    readonly model: () => Model;
+    readonly send: Send<Message>;
+    readonly subscribe: (listener: (model: Model) => void) => () => void;
+    readonly dispose: () => void;
+}
+export interface RunningProgram<Model, Message> extends Program<Model, Message> {
+    readonly activeSlots: () => readonly string[];
+    readonly awaitIdle: (slot?: string) => Promise<void>;
+}
+/** One immutable source of truth. Reducers are synchronous; commands own async work. */
+export declare function program<Model, Message>(options: {
+    initial: Model;
+    name?: string;
+    update: (model: Model, message: Message) => Transition<Model, Message>;
+    onDefect?: (cause: unknown) => void;
+}): RunningProgram<Model, Message>;

package/dist/program.js

@@ -0,0 +1,154 @@
+import { reportError, reportSafely } from './errors.js';
+import { traceProgram, nextProgramId, hasProgramObservers } from './diagnostics.js';
+import { Cause, Effect, Fiber, Option, Stream } from 'effect';
+import * as Atom from 'effect/unstable/reactivity/Atom';
+import * as AtomRegistry from 'effect/unstable/reactivity/AtomRegistry';
+/** A lazy request settles successes, typed failures and defects through one message contract. */
+export function effectCommand(slot, load, handlers) {
+    return { slot, effect: Effect.suspend(load).pipe(Effect.matchCause(handlers)) };
+}
+/** Owned work with no model result. Failures use the program's error reporter. */
+export function actionCommand(slot, action) {
+    return { slot, action: Effect.suspend(action).pipe(Effect.asVoid) };
+}
+export function mapCommand(command, map) {
+    if (command.action)
+        return { slot: command.slot, action: command.action };
+    return command.stream
+        ? { slot: command.slot, stream: command.stream.pipe(Stream.map(map)) }
+        : { slot: command.slot, effect: command.effect.pipe(Effect.map(map)) };
+}
+/** One immutable source of truth. Reducers are synchronous; commands own async work. */
+export function program(options) {
+    const id = nextProgramId();
+    const trace = (kind, slot, message) => hasProgramObservers() &&
+        traceProgram({
+            program: id,
+            ...(options.name ? { name: options.name } : {}),
+            kind,
+            ...(slot ? { slot } : {}),
+            ...(message &&
+                typeof message === 'object' &&
+                'type' in message &&
+                typeof message.type === 'string'
+                ? { message: message.type }
+                : {}),
+        });
+    const waiters = new Set();
+    const notify = () => {
+        for (const waiter of waiters) {
+            if (disposed ||
+                (!draining && (waiter.slot ? !running.has(waiter.slot) : running.size === 0))) {
+                waiters.delete(waiter);
+                waiter.done();
+            }
+        }
+    };
+    const registry = AtomRegistry.make();
+    const atom = Atom.make(options.initial);
+    const release = registry.mount(atom);
+    const running = new Map();
+    let disposed = false;
+    let draining = false;
+    const queue = [];
+    const cancel = (slot) => {
+        const previous = running.get(slot);
+        running.delete(slot);
+        if (previous)
+            trace('cancel', slot);
+        if (previous?.fiber)
+            Effect.runFork(Fiber.interrupt(previous.fiber));
+    };
+    const send = (message) => {
+        if (disposed)
+            return;
+        queue.push(message);
+        if (draining)
+            return;
+        draining = true;
+        try {
+            while (queue.length && !disposed) {
+                const message = queue.shift();
+                const transition = options.update(registry.get(atom), message);
+                trace('update', undefined, message);
+                for (const slot of transition.cancel ?? [])
+                    cancel(slot);
+                registry.set(atom, transition.model);
+                for (const command of transition.commands ?? []) {
+                    if (disposed)
+                        break;
+                    cancel(command.slot);
+                    const token = {};
+                    const runningCommand = { token };
+                    running.set(command.slot, runningCommand);
+                    trace('start', command.slot);
+                    const effect = command.stream
+                        ? command.stream.pipe(Stream.runForEach((message) => Effect.sync(() => {
+                            if (!disposed && running.get(command.slot)?.token === token)
+                                send(message);
+                        })), Effect.as(Option.none()))
+                        : command.action
+                            ? command.action.pipe(Effect.as(Option.none()))
+                            : command.effect.pipe(Effect.map(Option.some));
+                    const fiber = Effect.runFork(effect);
+                    runningCommand.fiber = fiber;
+                    if (disposed) {
+                        Effect.runFork(Fiber.interrupt(fiber));
+                        break;
+                    }
+                    fiber.addObserver((exit) => {
+                        if (disposed || running.get(command.slot)?.token !== token)
+                            return;
+                        running.delete(command.slot);
+                        trace(exit._tag === 'Success' ? 'complete' : 'defect', command.slot);
+                        if (exit._tag === 'Success') {
+                            if (Option.isSome(exit.value))
+                                send(exit.value.value);
+                        }
+                        else
+                            reportSafely(options.onDefect ?? reportError, exit.cause);
+                        notify();
+                    });
+                }
+            }
+        }
+        catch (error) {
+            queue.length = 0;
+            throw error;
+        }
+        finally {
+            draining = false;
+            notify();
+        }
+    };
+    return {
+        model: () => registry.get(atom),
+        activeSlots: () => [...running.keys()],
+        awaitIdle: (slot) => disposed || (!draining && (slot ? !running.has(slot) : running.size === 0))
+            ? Promise.resolve()
+            : new Promise((done) => {
+                waiters.add({ slot, done });
+            }),
+        send,
+        subscribe: (listener) => registry.subscribe(atom, (model) => {
+            try {
+                listener(model);
+            }
+            catch (error) {
+                reportSafely(options.onDefect ?? reportError, error);
+            }
+        }),
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            queue.length = 0;
+            for (const slot of running.keys())
+                cancel(slot);
+            release();
+            registry.dispose();
+            trace('dispose');
+            notify();
+        },
+    };
+}