effectweb 0.4.0 → 0.5.1

package/dist/query.d.ts

@@ -1,5 +1,7 @@
 import type * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import { type QueryDefinition } from './query-internals.js';
+import type { Snapshot } from './snapshot.js';
 /** Canonical data identity: plain objects, dense arrays, and finite scalar values. */
 export type QueryKey = string | number | boolean | null | undefined | readonly QueryKey[] | {
     readonly [key: string]: QueryKey;
@@ -14,18 +16,27 @@ declare const queryType: unique symbol;
 /** An opaque typed definition. Every request argument participates in cache identity. */
 export interface Query<Args, A, E = never, R = never> {
     readonly name: string;
-    readonly [queryType]: (args: Args) => Effect.Effect<A, E, R>;
+    readonly [queryType]: (args: Args) => Effect.Effect<A, E, R | Scope.Scope>;
 }
 type Definition<Args, A, E, R> = Omit<QueryDefinition<Args, A, E, R>, 'staleTime'> & {
     readonly staleTime?: number;
     /** Custom projections can silently reuse a different request's result. */
     readonly key?: never;
 };
-export declare function query<Args, A, E = never, R = never>(definition: Definition<Args, A, E, R> & (Args extends QueryArgs<Args> ? unknown : {
-    readonly nonSerializableQueryArguments: never;
-})): Query<Args, A, E, R>;
+/** Encode the complete argument value explicitly when its representation is not plain data. */
+export type QueryEncoding<Args> = [Args] extends [QueryArgs<Args>] ? {
+    readonly encode?: (args: Snapshot<Args>) => QueryKey;
+} : {
+    readonly encode: (args: Snapshot<Args>) => QueryKey;
+};
+/** Shared identity contract for lookup, selection, writes, invalidation and pagination. */
+export declare function encodeQueryArguments<Args, A, E, R>(definition: Query<Args, A, E, R>, args: Args | Snapshot<Args>): string;
+export declare function query<Args, A, E = never, R = never>(definition: Definition<Args, A, E, R> & {
+    readonly encode: (args: Snapshot<Args>) => QueryKey;
+}): Query<Args, A, E, R>;
+export declare function query<Args, A, E = never, R = never>(definition: Definition<Args, A, E, R> & QueryEncoding<Args>): Query<Args, A, E, R>;
 export declare function query<A, E = never, R = never>(definition: Definition<true, A, E, R> & {
-    readonly load: () => Effect.Effect<A, E, R>;
+    readonly load: () => Effect.Effect<A, E, R | Scope.Scope>;
 }): Query<true, A, E, R>;
 declare const groupType: unique symbol;
 export type QueryGroup = symbol & {

package/dist/query.js

@@ -1,4 +1,4 @@
-import { registerQuery } from './query-internals.js';
+import { registerQuery, queryDefinition } from './query-internals.js';
 /** Shared by cache lookup and resource reconciliation. Object property order is irrelevant. */
 export function encodeQueryKey(key) {
     const ancestors = new Set();
@@ -53,6 +53,11 @@ export function encodeQueryKey(key) {
     };
     return encode(key);
 }
+/** Shared identity contract for lookup, selection, writes, invalidation and pagination. */
+export function encodeQueryArguments(definition, args) {
+    const config = queryDefinition(definition);
+    return encodeQueryKey(config.encode ? config.encode(args) : args);
+}
 export function query(definition) {
     const staleTime = definition.staleTime ?? Infinity;
     if (Number.isNaN(staleTime) || staleTime < 0)

package/dist/render.d.ts

@@ -0,0 +1,17 @@
+import * as Effect from 'effect/Effect';
+import * as Scope from 'effect/Scope';
+import { type Mounted, type View } from './dom.js';
+import type { Source } from './source.js';
+import type { Send } from './program.js';
+import { type ReportError } from './errors.js';
+/**
+ * Mount values or Effect-based view setup in a child resource scope.
+ * The surrounding Effect owns the mount; the source keeps its own lifetime.
+ */
+export declare function mount<M, Message = never, E = never, R = never>(parent: Node, definition: View<M, Message> | Effect.Effect<View<M, Message>, E, R>, source: Source<M> & ([Message] extends [never] ? {
+    readonly send?: Send<Message>;
+} : {
+    readonly send: Send<Message>;
+}), options?: {
+    readonly onError?: ReportError;
+}): Effect.Effect<Mounted, E, R | Scope.Scope>;

package/dist/render.js

@@ -0,0 +1,48 @@
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Scope from 'effect/Scope';
+import { mountViewWithSettlement, unboundSend } from './dom.js';
+import { makeUiRuntime } from './runtime.js';
+import { reportError, reportSafely } from './errors.js';
+import { Settlement } from './settlement.js';
+/**
+ * Mount values or Effect-based view setup in a child resource scope.
+ * The surrounding Effect owns the mount; the source keeps its own lifetime.
+ */
+export function mount(parent, definition, source, options = {}) {
+    return Effect.gen(function* () {
+        const lifetime = yield* Effect.acquireRelease(Effect.sync(() => {
+            const scope = Scope.makeUnsafe();
+            let closingExit;
+            const closed = Effect.runSync(Effect.cached(Effect.uninterruptible(Effect.suspend(() => Scope.close(scope, closingExit ?? Exit.void)))));
+            const beginClose = (exit) => {
+                closingExit ??= exit;
+                return closed;
+            };
+            const close = (exit) => Effect.suspend(() => beginClose(exit));
+            return { scope, close, beginClose };
+        }), (lifetime, exit) => lifetime.close(exit));
+        return yield* Effect.gen(function* () {
+            const runtime = yield* makeUiRuntime();
+            const view = Effect.isEffect(definition) ? yield* definition : definition;
+            const settlement = new Settlement(runtime);
+            // Acquisition can throw after starting child cleanup, before a Mounted exists.
+            yield* Effect.addFinalizer(() => settlement.wait());
+            const mounted = yield* Effect.acquireRelease(Effect.sync(() => mountViewWithSettlement(parent, view, source, { ...options, send: source.send ?? unboundSend }, settlement)), (mounted, exit) => Effect.suspend(() => {
+                settlement.exit = exit;
+                return mounted.close();
+            }));
+            const close = lifetime.close(Exit.void);
+            const dispose = () => {
+                // Claim the exit before user unsubscriptions can reenter application shutdown.
+                const closed = lifetime.beginClose(Exit.void);
+                mounted.dispose();
+                Effect.runFork(closed).addObserver((exit) => {
+                    if (exit._tag === 'Failure')
+                        reportSafely(options.onError ?? reportError, exit.cause);
+                });
+            };
+            return Object.assign(dispose, { dispose, close: () => close });
+        }).pipe(Scope.provide(lifetime.scope), Effect.onError((cause) => lifetime.close(Exit.failCause(cause))));
+    });
+}

package/dist/resource.d.ts

@@ -1,7 +1,8 @@
 import type { Snapshot } from './snapshot.js';
+import type * as Scope from 'effect/Scope';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { UiLoad } from './load.js';
-import { type UiRuntime } from './runtime.js';
+import type { UiRuntime } from './runtime.js';
 import type { View } from './dom.js';
 export interface ResourceModel<Props, A, E = unknown> {
     readonly props: Props;
@@ -17,11 +18,11 @@ export declare const resourceError: (result: AsyncResult.AsyncResult<unknown, un
 export declare function resourceComponent<Props, A, E = unknown, R = never>(definition: {
     request: (props: Snapshot<Props>) => {
         key: string;
-        load: () => UiLoad<A, E, R>;
+        load: () => UiLoad<A, E, R | Scope.Scope>;
         delay?: number;
     } | undefined;
     view: View<ResourceModel<Props, A, E>, ResourceMessage>;
-} & ([R] extends [never] ? {
+} & ([Exclude<R, Scope.Scope>] extends [never] ? {
     runtime?: UiRuntime<R>;
 } : {
     runtime: UiRuntime<R>;

package/dist/resource.js

@@ -5,7 +5,6 @@ import * as Option from 'effect/Option';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { loadEffect } from './load.js';
 import { component } from './component.js';
-import { defaultUiRuntime } from './runtime.js';
 import { effectCommand } from './program.js';
 const commandLoad = commandSlot('load');
 export const available = (result) => Option.getOrUndefined(AsyncResult.value(result));
@@ -17,7 +16,7 @@ export const resourceError = (result) => {
 };
 /** A replaceable request owns one result. Key changes clear it; refreshes preserve the last success. */
 export function resourceComponent(definition) {
-    const runtime = definition.runtime ?? defaultUiRuntime;
+    const runtime = definition.runtime;
     const request = (model, retry = false) => {
         const selected = definition.request(model.props);
         if (!retry && selected?.key === model.key)
@@ -34,9 +33,14 @@ export function resourceComponent(definition) {
                 result: AsyncResult.waiting(selected.key === model.key ? model.result : AsyncResult.initial()),
             },
             commands: [
-                effectCommand(commandLoad, () => runtime.provide(selected.delay
-                    ? Effect.sleep(selected.delay).pipe(Effect.andThen(loadEffect(selected.load)))
-                    : loadEffect(selected.load)), {
+                effectCommand(commandLoad, () => {
+                    const work = selected.delay
+                        ? Effect.sleep(selected.delay).pipe(Effect.andThen(loadEffect(selected.load)))
+                        : loadEffect(selected.load);
+                    return runtime
+                        ? runtime.provideScoped(work)
+                        : work;
+                }, {
                     policy: 'replace',
                     onSuccess: (value) => ({ type: 'Loaded', value }),
                     onFailure: (cause) => ({ type: 'Failed', cause }),

package/dist/runtime.d.ts

@@ -1,11 +1,19 @@
 import type { Snapshot } from './snapshot.js';
 import * as Context from 'effect/Context';
+import * as Clock from 'effect/Clock';
 import * as Effect from 'effect/Effect';
+import type * as Fiber from 'effect/Fiber';
+import * as Scope from 'effect/Scope';
 import { type Command, type RunningProgram, type Transition } from './program.js';
 /** A binding to application-owned services, not a new scope or service lifetime. */
 export interface UiRuntime<R> {
     readonly context: Context.Context<R>;
+    readonly clock: Clock.Clock;
+    /** Execute work with a fresh resource scope and the captured application context. */
+    readonly runFork: <A, E>(effect: Effect.Effect<A, E, R | Scope.Scope>) => Fiber.Fiber<A, E>;
     readonly provide: <A, E>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E>;
+    /** Supply services while preserving the resource owner's scope. */
+    readonly provideScoped: <A, E>(effect: Effect.Effect<A, E, R | Scope.Scope>) => Effect.Effect<A, E, Scope.Scope>;
     readonly command: <M>(command: Command<M, R>) => Command<M>;
     readonly program: <M, Msg>(options: {
         initial: M | Snapshot<M>;
@@ -15,4 +23,6 @@ export interface UiRuntime<R> {
     }) => RunningProgram<M, Msg>;
 }
 export declare function uiRuntime<R>(context: Context.Context<R>): UiRuntime<R>;
+/** Capture the current Effect environment. The surrounding scope owns all started fibers. */
+export declare const makeUiRuntime: <R = never>() => Effect.Effect<UiRuntime<R>, never, R | Scope.Scope>;
 export declare const defaultUiRuntime: UiRuntime<never>;

package/dist/runtime.js

@@ -1,20 +1,40 @@
 import * as Context from 'effect/Context';
+import * as Clock from 'effect/Clock';
 import * as Effect from 'effect/Effect';
+import * as FiberSet from 'effect/FiberSet';
+import * as Scope from 'effect/Scope';
 import * as Stream from 'effect/Stream';
 import { program } from './program.js';
 export function uiRuntime(context) {
+    return createRuntime(context, Effect.runForkWith(context));
+}
+/** Capture the current Effect environment. The surrounding scope owns all started fibers. */
+export const makeUiRuntime = () => Effect.gen(function* () {
+    const context = yield* Effect.context();
+    const fibers = yield* FiberSet.make();
+    const run = yield* FiberSet.runtime(fibers)();
+    return createRuntime(context, run);
+});
+function createRuntime(context, run) {
     const provide = (effect) => Effect.provideContext(effect, context);
     const command = (value) => value.stream
-        ? { ...value, stream: value.stream.pipe(Stream.provideContext(context)) }
+        ? {
+            ...value,
+            stream: Stream.unwrap(Effect.map(Effect.scope, (scope) => value.stream.pipe(Stream.provideContext(Context.add(context, Scope.Scope, scope))))),
+        }
         : value.action
-            ? { ...value, action: provide(value.action) }
-            : { ...value, effect: provide(value.effect) };
+            ? { ...value, action: provide(Effect.scoped(value.action)) }
+            : { ...value, effect: provide(Effect.scoped(value.effect)) };
     return {
         context,
+        clock: Context.get(context, Clock.Clock),
+        runFork: (effect) => run(Effect.scoped(effect)),
         provide,
+        provideScoped: (effect) => Effect.flatMap(Effect.scope, (scope) => provide(Scope.provide(effect, scope))),
         command,
         program: (options) => program({
             ...options,
+            runtime: { runFork: (effect) => run(Effect.scoped(effect)) },
             update: (model, message) => {
                 const next = options.update(model, message);
                 return {
@@ -26,4 +46,4 @@ export function uiRuntime(context) {
         }),
     };
 }
-export const defaultUiRuntime = uiRuntime(Context.empty());
+export const defaultUiRuntime = /* @__PURE__ */ uiRuntime(Context.empty());

package/dist/session.d.ts

@@ -1,3 +1,4 @@
+import type * as Scope from 'effect/Scope';
 import type { Snapshot } from './snapshot.js';
 import { type Query } from './query.js';
 import type { DisposableOwner } from './owner.js';
@@ -28,8 +29,8 @@ export interface QueryResource<Args, A, E = never> {
 export declare function queryResource<Args, A, E, R>(context: {
     cache: QueryCache<R>;
     changed?: () => void;
-}, definition: Query<Args, A, E, NoInfer<R>>): QueryResource<Args, A, E>;
-export declare function observeQuery<Args, A, E, R>(owner: DisposableOwner, cache: QueryCache<R>, definition: Query<Args, A, E, NoInfer<R>>, changed: (result: AsyncResult.AsyncResult<Snapshot<A>, E>) => void): QueryResource<Args, A, E>;
+}, definition: Query<Args, A, E, NoInfer<R> | Scope.Scope>): QueryResource<Args, A, E>;
+export declare function observeQuery<Args, A, E, R>(owner: DisposableOwner, cache: QueryCache<R>, definition: Query<Args, A, E, NoInfer<R> | Scope.Scope>, changed: (result: AsyncResult.AsyncResult<Snapshot<A>, E>) => void): QueryResource<Args, A, E>;
 /** Application selectors run once per explicit input version, with optional prior output sharing. */
 export declare function projectionCache(): {
     invalidate: () => void;

package/dist/session.js

@@ -1,5 +1,5 @@
 import { runAll, reportError, reportSafely } from './errors.js';
-import { encodeQueryKey } from './query.js';
+import { encodeQueryArguments } from './query.js';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import * as Atom from 'effect/unstable/reactivity/Atom';
 import { cacheInternals } from './cache-internals.js';
@@ -108,11 +108,14 @@ export function queryResource(context, definition) {
             if (disposed || internal.disposed())
                 return;
             const nextGeneration = internal.registry.get(internal.generation);
-            const nextKey = args === undefined ? undefined : encodeQueryKey(args);
+            const nextKey = args === undefined ? undefined : encodeQueryArguments(definition, args);
             if (nextKey === key && nextGeneration === generation)
                 return;
             const selected = ++revision;
             disconnect();
+            // Releasing the previous query can run finalizers that select or dispose again.
+            if (disposed || selected !== revision)
+                return;
             key = nextKey;
             generation = nextGeneration;
             const nextAtom = args === undefined ? undefined : internal.query(definition, args);

package/dist/settlement.d.ts

@@ -1,8 +1,14 @@
 /** Internal completion accounting, including reentrant acquisition before a fiber is available. */
 export declare class Settlement {
+    readonly runtime?: UiRuntime<never> | undefined;
+    constructor(runtime?: UiRuntime<never> | undefined);
+    /** Exit of the owning mount; element replacement/removal uses a successful exit. */
+    exit: Exit.Exit<unknown, unknown>;
     private pending;
     private waiters;
     begin(): () => void;
     wait(): Effect.Effect<void>;
 }
 import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import type { UiRuntime } from './runtime.js';

package/dist/settlement.js

@@ -1,5 +1,11 @@
 /** Internal completion accounting, including reentrant acquisition before a fiber is available. */
 export class Settlement {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    /** Exit of the owning mount; element replacement/removal uses a successful exit. */
+    exit = Exit.void;
     pending = 0;
     waiters = new Set();
     begin() {
@@ -30,3 +36,4 @@ export class Settlement {
     }
 }
 import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';

package/dist/source.d.ts

@@ -0,0 +1,38 @@
+import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
+import * as Stream from 'effect/Stream';
+import * as SubscriptionRef from 'effect/SubscriptionRef';
+import type * as Atom from 'effect/unstable/reactivity/Atom';
+import * as AtomRegistry from 'effect/unstable/reactivity/AtomRegistry';
+import { type Snapshot } from './snapshot.js';
+/** A current immutable value and its publications. Observation does not own the producer. */
+export interface Source<A> {
+    readonly model: () => Snapshot<A>;
+    readonly subscribe: (listener: (value: Snapshot<A>) => void) => () => void;
+}
+/** Select explicit inputs. Equal results retain their identity and do not notify subscribers. */
+export declare function mapSource<A, B>(source: Source<A>, project: (value: Snapshot<A>) => B | Snapshot<B>, equals?: (previous: Snapshot<B>, next: Snapshot<B>) => boolean): Source<B>;
+/** Observe a snapshot stream in the current Effect scope. Handle typed stream errors as values upstream. */
+export declare const fromStream: <A, R>(stream: Stream.Stream<A, never, R>, initial: A | Snapshot<A>) => Effect.Effect<Source<A>, never, R | Scope.Scope>;
+/** Observe the existing ref; closing the observation leaves the ref and its other users alive. */
+export declare const fromSubscriptionRef: <A>(ref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<Source<A>, never, Scope.Scope>;
+export declare function fromAtom<A>(atom: Atom.Atom<A>): Effect.Effect<Source<A>, never, AtomRegistry.AtomRegistry | Scope.Scope>;
+export declare function fromAtom<A>(atom: Atom.Atom<A>, registry: AtomRegistry.AtomRegistry): Effect.Effect<Source<A>, never, Scope.Scope>;
+/** A batched publication boundary for independently owned sessions with explicit invalidation. */
+export declare function projectionSource<Model>(options: {
+    invalidate?: () => void;
+    refresh?: () => void;
+    project: () => Model | Snapshot<Model>;
+    reconcile?: (previous: Snapshot<Model>, next: Model | Snapshot<Model>) => Model | Snapshot<Model>;
+    afterPublish?: () => void;
+}): {
+    readonly disposed: boolean;
+    changed: () => void;
+    watch(source: {
+        subscribe: (changed: () => void) => () => void;
+    }): () => void;
+    start(): void;
+    model(this: void): Snapshot<Model>;
+    subscribe(this: void, listener: (model: Snapshot<Model>) => void): () => void;
+    dispose(): void;
+};

package/dist/source.js

@@ -0,0 +1,218 @@
+import * as Effect from 'effect/Effect';
+import * as Cause from 'effect/Cause';
+import * as Stream from 'effect/Stream';
+import * as SubscriptionRef from 'effect/SubscriptionRef';
+import * as AtomRegistry from 'effect/unstable/reactivity/AtomRegistry';
+import { protectSnapshot } from './snapshot.js';
+import { reportError, reportSafely } from './errors.js';
+/** Select explicit inputs. Equal results retain their identity and do not notify subscribers. */
+export function mapSource(source, project, equals = Object.is) {
+    let initialized = false;
+    let previousInput;
+    let current;
+    const select = (input) => {
+        if (initialized && Object.is(previousInput, input))
+            return current;
+        const next = protectSnapshot(project(input));
+        if (!initialized || !equals(current, next))
+            current = next;
+        previousInput = input;
+        initialized = true;
+        return current;
+    };
+    const model = () => select(source.model());
+    return {
+        model,
+        subscribe(listener) {
+            let previous = model();
+            return source.subscribe((value) => {
+                const next = select(value);
+                if (Object.is(previous, next))
+                    return;
+                previous = next;
+                listener(next);
+            });
+        },
+    };
+}
+function publication(initial) {
+    let current = protectSnapshot(initial);
+    let disposed = false;
+    const listeners = new Set();
+    const source = {
+        model: () => current,
+        subscribe: (listener) => {
+            if (disposed)
+                return () => { };
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+    return {
+        source,
+        publish(value) {
+            if (disposed || Object.is(current, value))
+                return;
+            current = protectSnapshot(value);
+            const next = current;
+            // oxlint-disable-next-line unicorn/no-useless-spread -- Reentrant subscriptions must not join the publication in progress.
+            for (const listener of [...listeners]) {
+                if (disposed || current !== next)
+                    break;
+                if (listeners.has(listener)) {
+                    try {
+                        listener(next);
+                    }
+                    catch (error) {
+                        reportSafely(reportError, error);
+                    }
+                }
+            }
+        },
+        dispose() {
+            disposed = true;
+            listeners.clear();
+        },
+    };
+}
+/** Observe a snapshot stream in the current Effect scope. Handle typed stream errors as values upstream. */
+export const fromStream = (stream, initial) => Effect.gen(function* () {
+    const state = yield* Effect.acquireRelease(Effect.sync(() => publication(initial)), (state) => Effect.sync(() => state.dispose()));
+    yield* Stream.runForEach(stream, (value) => Effect.sync(() => state.publish(value))).pipe(Effect.catchCause((cause) => Effect.sync(() => {
+        if (!Cause.hasInterruptsOnly(cause))
+            reportSafely(reportError, cause);
+    })), Effect.forkScoped({ startImmediately: true }));
+    return state.source;
+});
+/** Observe the existing ref; closing the observation leaves the ref and its other users alive. */
+export const fromSubscriptionRef = (ref) => Effect.gen(function* () {
+    const initial = yield* SubscriptionRef.get(ref);
+    return yield* fromStream(SubscriptionRef.changes(ref), initial);
+});
+export function fromAtom(atom, provided) {
+    return Effect.gen(function* () {
+        const registry = provided ?? (yield* AtomRegistry.AtomRegistry);
+        const state = yield* Effect.acquireRelease(Effect.sync(() => publication(registry.get(atom))), (state) => Effect.sync(() => state.dispose()));
+        yield* Effect.acquireRelease(Effect.sync(() => registry.subscribe(atom, (value) => state.publish(value), { immediate: true })), (unsubscribe) => Effect.sync(unsubscribe));
+        return state.source;
+    });
+}
+/** A batched publication boundary for independently owned sessions with explicit invalidation. */
+export function projectionSource(options) {
+    const listeners = new Set();
+    const subscriptions = new Set();
+    let published;
+    let started = false;
+    let disposed = false;
+    let queued = false;
+    let revision = 0;
+    const changed = () => {
+        if (disposed)
+            return;
+        revision++;
+        options.invalidate?.();
+        if (!started || queued)
+            return;
+        queued = true;
+        queueMicrotask(flush);
+    };
+    function flush() {
+        queued = false;
+        if (disposed)
+            return;
+        options.refresh?.();
+        if (disposed)
+            return;
+        const version = revision;
+        const value = options.project();
+        const next = protectSnapshot(options.reconcile ? options.reconcile(published, value) : value);
+        if (disposed || version !== revision)
+            return;
+        if (next !== published) {
+            published = next;
+            // oxlint-disable-next-line unicorn/no-useless-spread -- Reentrant subscriptions start with the next publication.
+            for (const listener of [...listeners]) {
+                if (disposed)
+                    break;
+                if (listeners.has(listener)) {
+                    try {
+                        listener(next);
+                    }
+                    catch (error) {
+                        reportSafely(reportError, error);
+                    }
+                }
+            }
+        }
+        if (!disposed)
+            options.afterPublish?.();
+    }
+    return {
+        get disposed() {
+            return disposed;
+        },
+        changed,
+        watch(source) {
+            if (disposed)
+                return () => { };
+            const unsubscribe = source.subscribe(changed);
+            let active = true;
+            const stop = () => {
+                if (!active)
+                    return;
+                active = false;
+                subscriptions.delete(stop);
+                unsubscribe();
+            };
+            if (disposed)
+                stop();
+            else
+                subscriptions.add(stop);
+            return stop;
+        },
+        start() {
+            if (disposed || started)
+                return;
+            options.refresh?.();
+            if (disposed)
+                return;
+            const version = revision;
+            published = protectSnapshot(options.project());
+            started = true;
+            if (version !== revision)
+                changed();
+        },
+        model() {
+            if (!started)
+                throw new Error('Start projection publication before reading its model');
+            return published;
+        },
+        subscribe(listener) {
+            if (disposed)
+                return () => { };
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            listeners.clear();
+            const errors = [];
+            for (const stop of [...subscriptions].reverse()) {
+                try {
+                    stop();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            if (errors.length)
+                throw new AggregateError(errors, 'Projection subscription cleanup failed');
+        },
+    };
+}

package/dist/tasks.d.ts

@@ -1,13 +1,14 @@
 import type { Snapshot } from './snapshot.js';
-import type { ModelOwner, TaskPolicy } from './owner.js';
+import type { TaskPolicy } from './owner.js';
 import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { View } from './dom.js';
 import { type CommandSlot, type Send, type RunningProgram } from './program.js';
 import { type UiRuntime } from './runtime.js';
 export interface TaskDefinition<Model, Input, A, E, R = never> {
     readonly policy: Exclude<TaskPolicy, 'parallel'>;
-    readonly run: (model: Snapshot<Model>, input: Input) => Effect.Effect<A, E, R>;
+    readonly run: (model: Snapshot<Model>, input: Input) => Effect.Effect<A, E, R | Scope.Scope>;
     /** Domain identity, compared after fields or props change. Resets this slot only. */
     readonly identity?: (model: Snapshot<Model>) => unknown;
 }
@@ -55,19 +56,21 @@ interface ControllerTask<R> {
     /** Actions sharing a slot share cancellation and concurrency rules. Defaults to a fresh operation identity for this definition. */
     readonly slot?: CommandSlot;
 }
-export declare function defineTasks<Owner extends Pick<ModelOwner<object>, 'run'>, T extends Record<string, ControllerTask<Effect.Services<Parameters<Owner['run']>[1]>>>>(owner: Owner, definitions: T): {
+export declare function defineTasks<Owner extends {
+    readonly run: (slot: CommandSlot, effect: Effect.Effect<never>, policy: TaskPolicy) => void;
+}, T extends Record<string, ControllerTask<Effect.Services<Parameters<Owner['run']>[1]>>>>(owner: Owner, definitions: T): {
     readonly [K in keyof T]: (...args: Parameters<T[K]['run']>) => void;
 };
 export declare function defineTasks<Props, State extends object, R>(definition: Init<Props, State> & {
     runtime: UiRuntime<R>;
 }): ReturnType<typeof taskBuilder<Props, State, R>>;
 export declare function defineTasks<Props, State extends object>(definition: Init<Props, State>): ReturnType<typeof taskBuilder<Props, State, never>>;
-declare function taskBuilder<Props, State extends object, R>(definition: Init<Props, State>, runtime: UiRuntime<R>): {
+declare function taskBuilder<Props, State extends object, R>(definition: Init<Props, State>, runtime: UiRuntime<R> | undefined): {
     tasks<T extends Definitions<State & {
         readonly props: Props;
     }, R>>(definitions: T): {
         slot: (name: keyof T) => CommandSlot;
-        create: (props: Props | Snapshot<Props>) => RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>;
+        create: (props: Props | Snapshot<Props>, ownerRuntime?: UiRuntime<never>) => RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>;
         receive: (source: RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>, props: Props | Snapshot<Props>) => void;
         controls: (send: Send<TasksMessage<State, T>>) => {
             run: <K extends keyof T>(task: K, ...input: InputArguments<T[K]>) => void;