effectweb 0.1.1 → 0.2.2

package/dist/AsyncContent.js

@@ -1,4 +1,4 @@
-import * as _tv_dom from "./dom.js";
+import * as _ew_dom from "./dom.js";
 import { Cause, Effect, Option } from "effect";
 import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
 import { component } from "./component.js";
@@ -44,28 +44,28 @@ const implementation = component({
             ...model,
             visible: true
         } }),
-    view: _tv_dom.compiled((_tv_scope_1, _tv_parent_2, _tv_before_3) => {
-        const _tv_derived_4 = _tv_scope_1.derive(() => [_tv_scope_1.value?.props], () => ((_tv_capture_5) => _tv_capture_5.props)(_tv_scope_1.value));
-        const _tv_derived_6 = _tv_scope_1.derive(() => [_tv_derived_4()?.result], () => ((_tv_capture_7) => AsyncResult.value(_tv_capture_7.result))(_tv_derived_4()));
-        const _tv_derived_8 = _tv_scope_1.derive(() => [_tv_derived_4()?.result, _tv_derived_4()?.result?.waiting], () => ((_tv_capture_9) => AsyncResult.isFailure(_tv_capture_9.result) && !_tv_capture_9.result.waiting ? _tv_capture_9.result : undefined)(_tv_derived_4()));
-        _tv_dom.branch(_tv_scope_1, _tv_parent_2, _tv_before_3, () => Option.isSome(_tv_derived_6()), (_tv_scope_1, _tv_parent_10, _tv_before_11) => {
-            _tv_dom.text(_tv_scope_1, _tv_parent_10, _tv_before_11, () => [_tv_derived_4(), _tv_derived_6()?.value], () => _tv_derived_4().content(_tv_derived_6().value));
-            _tv_dom.branch(_tv_scope_1, _tv_parent_10, _tv_before_11, () => _tv_derived_4().result.waiting, (_tv_scope_1, _tv_parent_12, _tv_before_13) => {
-                _tv_dom.text(_tv_scope_1, _tv_parent_12, _tv_before_13, () => [_tv_derived_4()?.refreshing], () => _tv_derived_4().refreshing);
-            }, (_tv_scope_1, _tv_parent_12, _tv_before_13) => { });
-            _tv_dom.branch(_tv_scope_1, _tv_parent_10, _tv_before_11, () => _tv_derived_8() && _tv_derived_4().failure, (_tv_scope_1, _tv_parent_14, _tv_before_15) => {
-                _tv_dom.text(_tv_scope_1, _tv_parent_14, _tv_before_15, () => [_tv_derived_4(), _tv_derived_8()?.cause], () => _tv_derived_4().failure(_tv_derived_8().cause));
-            }, (_tv_scope_1, _tv_parent_14, _tv_before_15) => { });
-        }, (_tv_scope_1, _tv_parent_10, _tv_before_11) => {
-            _tv_dom.branch(_tv_scope_1, _tv_parent_10, _tv_before_11, () => _tv_derived_8() && _tv_derived_4().failure, (_tv_scope_1, _tv_parent_16, _tv_before_17) => {
-                _tv_dom.text(_tv_scope_1, _tv_parent_16, _tv_before_17, () => [_tv_derived_4(), _tv_derived_8()?.cause], () => _tv_derived_4().failure(_tv_derived_8().cause));
-            }, (_tv_scope_1, _tv_parent_16, _tv_before_17) => {
-                _tv_dom.branch(_tv_scope_1, _tv_parent_16, _tv_before_17, () => _tv_scope_1.value.pending, (_tv_scope_1, _tv_parent_18, _tv_before_19) => {
-                    _tv_dom.branch(_tv_scope_1, _tv_parent_18, _tv_before_19, () => _tv_scope_1.value.visible, (_tv_scope_1, _tv_parent_20, _tv_before_21) => {
-                        _tv_dom.text(_tv_scope_1, _tv_parent_20, _tv_before_21, () => [_tv_derived_4()?.pending], () => _tv_derived_4().pending);
-                    }, (_tv_scope_1, _tv_parent_20, _tv_before_21) => { });
-                }, (_tv_scope_1, _tv_parent_18, _tv_before_19) => {
-                    _tv_dom.text(_tv_scope_1, _tv_parent_18, _tv_before_19, () => [_tv_derived_4()?.empty], () => _tv_derived_4().empty);
+    view: /* @__PURE__ */ _ew_dom.compiled((_ew_scope_1, _ew_parent_2, _ew_before_3) => {
+        const _ew_derived_4 = _ew_scope_1.derive(() => [_ew_scope_1.value?.props], () => ((_ew_capture_5) => _ew_capture_5.props)(_ew_scope_1.value));
+        const _ew_derived_6 = _ew_scope_1.derive(() => [_ew_derived_4()?.result], () => ((_ew_capture_7) => AsyncResult.value(_ew_capture_7.result))(_ew_derived_4()));
+        const _ew_derived_8 = _ew_scope_1.derive(() => [_ew_derived_4()?.result, _ew_derived_4()?.result?.waiting], () => ((_ew_capture_9) => AsyncResult.isFailure(_ew_capture_9.result) && !_ew_capture_9.result.waiting ? _ew_capture_9.result : undefined)(_ew_derived_4()));
+        _ew_dom.branch(_ew_scope_1, _ew_parent_2, _ew_before_3, () => Option.isSome(_ew_derived_6()), (_ew_scope_1, _ew_parent_10, _ew_before_11) => {
+            _ew_dom.text(_ew_scope_1, _ew_parent_10, _ew_before_11, () => [_ew_derived_4(), _ew_derived_6()?.value], () => _ew_derived_4().content(_ew_derived_6().value));
+            _ew_dom.branch(_ew_scope_1, _ew_parent_10, _ew_before_11, () => _ew_derived_4().result.waiting, (_ew_scope_1, _ew_parent_12, _ew_before_13) => {
+                _ew_dom.text(_ew_scope_1, _ew_parent_12, _ew_before_13, () => [_ew_derived_4()?.refreshing], () => _ew_derived_4().refreshing);
+            }, (_ew_scope_1, _ew_parent_12, _ew_before_13) => { });
+            _ew_dom.branch(_ew_scope_1, _ew_parent_10, _ew_before_11, () => _ew_derived_8() && _ew_derived_4().failure, (_ew_scope_1, _ew_parent_14, _ew_before_15) => {
+                _ew_dom.text(_ew_scope_1, _ew_parent_14, _ew_before_15, () => [_ew_derived_4(), _ew_derived_8()?.cause], () => _ew_derived_4().failure(_ew_derived_8().cause));
+            }, (_ew_scope_1, _ew_parent_14, _ew_before_15) => { });
+        }, (_ew_scope_1, _ew_parent_10, _ew_before_11) => {
+            _ew_dom.branch(_ew_scope_1, _ew_parent_10, _ew_before_11, () => _ew_derived_8() && _ew_derived_4().failure, (_ew_scope_1, _ew_parent_16, _ew_before_17) => {
+                _ew_dom.text(_ew_scope_1, _ew_parent_16, _ew_before_17, () => [_ew_derived_4(), _ew_derived_8()?.cause], () => _ew_derived_4().failure(_ew_derived_8().cause));
+            }, (_ew_scope_1, _ew_parent_16, _ew_before_17) => {
+                _ew_dom.branch(_ew_scope_1, _ew_parent_16, _ew_before_17, () => _ew_scope_1.value.pending, (_ew_scope_1, _ew_parent_18, _ew_before_19) => {
+                    _ew_dom.branch(_ew_scope_1, _ew_parent_18, _ew_before_19, () => _ew_scope_1.value.visible, (_ew_scope_1, _ew_parent_20, _ew_before_21) => {
+                        _ew_dom.text(_ew_scope_1, _ew_parent_20, _ew_before_21, () => [_ew_derived_4()?.pending], () => _ew_derived_4().pending);
+                    }, (_ew_scope_1, _ew_parent_20, _ew_before_21) => { });
+                }, (_ew_scope_1, _ew_parent_18, _ew_before_19) => {
+                    _ew_dom.text(_ew_scope_1, _ew_parent_18, _ew_before_19, () => [_ew_derived_4()?.empty], () => _ew_derived_4().empty);
                 });
             });
         });

package/dist/cache.d.ts

@@ -2,14 +2,13 @@ import { Effect } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import * as Atom from 'effect/unstable/reactivity/Atom';
 import * as AtomRegistry from 'effect/unstable/reactivity/AtomRegistry';
-import { type UiLoad, type UiPage } from './load.js';
 import type { Query } from './query.js';
 import type { UiRuntime } from './runtime.js';
-export { loadEffect, type UiLoad, type UiPage } from './load.js';
+export { loadEffect, type UiLoad } from './load.js';
 export { shareValue } from './share.js';
-export declare function makeUiModel(): UiModel<never>;
-export declare function makeUiModel<R>(runtime: UiRuntime<R>): UiModel<R>;
-declare function createUiModel<R>(runtime?: UiRuntime<R>): {
+export declare function makeQueryCache(): QueryCache<never>;
+export declare function makeQueryCache<R>(runtime: UiRuntime<R>): QueryCache<R>;
+declare function createQueryCache<R>(runtime?: UiRuntime<R>): {
     registry: AtomRegistry.AtomRegistry;
     generation: Atom.Writable<number, number>;
     resource<A, E = unknown>(key: string, load: () => Effect.Effect<A, E>): Atom.Atom<AsyncResult.AsyncResult<A, E>>;
@@ -21,12 +20,4 @@ declare function createUiModel<R>(runtime?: UiRuntime<R>): {
     resetResources(): void;
     dispose(): void;
 };
-export type UiModel<R = never> = ReturnType<typeof createUiModel<R>>;
-/** Cursor progress and prior successful pages belong to the resource, including retries. */
-export declare function makePagedResource<A, Cursor>(registry: AtomRegistry.AtomRegistry, load: (cursor: Cursor | undefined) => UiLoad<UiPage<A, Cursor>>, itemKey: (item: A) => string): {
-    atom: Atom.Atom<AsyncResult.AsyncResult<UiPage<A, Cursor> & {
-        pageCount: number;
-    }, unknown>>;
-    more(): void;
-    refresh(): void;
-};
+export type QueryCache<R = never> = ReturnType<typeof createQueryCache<R>>;

package/dist/cache.js

@@ -6,14 +6,14 @@ import { loadEffect } from './load.js';
 import { shareValue } from './share.js';
 export { loadEffect } from './load.js';
 export { shareValue } from './share.js';
-export function makeUiModel(runtime) {
-    return createUiModel(runtime);
+export function makeQueryCache(runtime) {
+    return createQueryCache(runtime);
 }
-function createUiModel(runtime) {
+function createQueryCache(runtime) {
     const registry = AtomRegistry.make({ defaultIdleTTL: 30_000 });
     const generation = Atom.keepAlive(Atom.make(0));
     const resources = new Map();
-    const acquire = (key, load) => {
+    const acquire = (key, load, share = shareValue) => {
         let entry = resources.get(key);
         if (entry)
             entry.load = load;
@@ -24,7 +24,7 @@ function createUiModel(runtime) {
                     const previous = Option.flatMap(get.self(), AsyncResult.value);
                     return loadEffect(() => next.load()).pipe(Effect.map((value) => {
                         next.loadedAt = Date.now();
-                        return Option.isSome(previous) ? shareValue(previous.value, value) : value;
+                        return Option.isSome(previous) ? share(previous.value, value) : value;
                     }));
                 }),
             };
@@ -47,7 +47,7 @@ function createUiModel(runtime) {
         const { entry, atom } = acquire(queryKey(definition, args), () => {
             const effect = Effect.suspend(() => definition.load(args));
             return runtime ? runtime.provide(effect) : effect;
-        });
+        }, definition.share);
         entry.queryId = definition.id;
         if (registry.getNodes().has(atom) &&
             entry.loadedAt !== undefined &&
@@ -102,46 +102,3 @@ function createUiModel(runtime) {
         },
     };
 }
-/** Cursor progress and prior successful pages belong to the resource, including retries. */
-export function makePagedResource(registry, load, itemKey) {
-    const requested = Atom.make(1);
-    const atom = Atom.make((get) => {
-        const count = get(requested);
-        const previous = Option.getOrUndefined(Option.flatMap(get.self(), AsyncResult.value));
-        const append = previous && count === previous.pageCount + 1 ? previous : undefined;
-        return loadEffect(() => load(append?.next)).pipe(Effect.map((page) => {
-            const known = new Set(append?.items.map(itemKey));
-            const incoming = page.items.filter((item) => {
-                const key = itemKey(item);
-                if (known.has(key))
-                    return false;
-                known.add(key);
-                return true;
-            });
-            return {
-                ...page,
-                items: append ? [...append.items, ...incoming] : incoming,
-                pageCount: append ? count : 1,
-            };
-        }));
-    }).pipe(Atom.setIdleTTL(0));
-    return {
-        atom,
-        more() {
-            const result = registry.get(atom);
-            const previous = Option.getOrUndefined(AsyncResult.value(result));
-            if (result.waiting || !previous || previous.next === undefined)
-                return;
-            Atom.batch(() => {
-                registry.set(requested, previous.pageCount + 1);
-                registry.refresh(atom);
-            });
-        },
-        refresh() {
-            Atom.batch(() => {
-                registry.set(requested, 1);
-                registry.refresh(atom);
-            });
-        },
-    };
-}

package/dist/collection.d.ts

@@ -10,6 +10,14 @@ export interface Rows<A> {
 }
 export declare function collection<A>(identity: (item: A, index: number) => Identity): {
     from: (items: readonly A[]) => Rows<A>;
+    share: {
+        <B extends A>(previous: readonly B[], next: B[]): B[];
+        <B extends A>(previous: readonly B[], next: readonly B[]): readonly B[];
+    };
 };
-/** Ordered protocol structures such as keyboard rows and rich-text fragments have positional identity. */
+/** Use positional identity for ordered values without stable entity IDs. */
 export declare function sequence<A>(items: readonly A[]): Rows<A>;
+/** Rows keyed by their domain IDs. Reuses the wrapper for the same immutable array. */
+export declare function entities<A extends {
+    readonly id: Identity;
+}>(items: readonly A[] | undefined): Rows<A>;

package/dist/collection.js

@@ -1,5 +1,7 @@
+import { shareValue } from './share.js';
 export function collection(identity) {
     const cache = new WeakMap();
+    const comparisons = new WeakMap();
     const from = (items) => {
         const cached = cache.get(items);
         if (cached)
@@ -15,10 +17,58 @@ export function collection(identity) {
         cache.set(items, rows);
         return rows;
     };
-    return { from };
+    function share(previous, next) {
+        if (previous === next)
+            return previous;
+        let pairs = comparisons.get(previous);
+        const cached = pairs?.get(next);
+        if (cached)
+            return cached;
+        let byIdentity;
+        let result;
+        let equal = previous.length === next.length;
+        for (let index = 0; index < next.length; index++) {
+            const item = next[index];
+            if (index < previous.length && Object.is(previous[index], item))
+                continue;
+            const key = identity(item, index);
+            let old = previous[index];
+            if (index >= previous.length || !Object.is(identity(old, index), key)) {
+                if (!byIdentity) {
+                    byIdentity = new Map(previous.map((value, i) => [identity(value, i), value]));
+                    const keys = next.map(identity);
+                    if (byIdentity.size !== previous.length || new Set(keys).size !== keys.length)
+                        throw new Error('Duplicate collection identity. Identity must be unique within the collection.');
+                }
+                old = byIdentity.get(key);
+            }
+            const value = old === undefined ? item : shareValue(old, item);
+            if (!Object.is(value, previous[index]))
+                equal = false;
+            if (!Object.is(value, item) && !result)
+                result = next.slice();
+            if (result)
+                result[index] = value;
+        }
+        const shared = equal ? previous : (result ?? next);
+        if (!pairs) {
+            pairs = new WeakMap();
+            comparisons.set(previous, pairs);
+        }
+        pairs.set(next, shared);
+        return shared;
+    }
+    return { from, share };
 }
 const positions = collection((_item, index) => index);
-/** Ordered protocol structures such as keyboard rows and rich-text fragments have positional identity. */
+/** Use positional identity for ordered values without stable entity IDs. */
 export function sequence(items) {
     return positions.from(items);
 }
+const empty = [];
+const identified = collection((item) => item.id);
+/** Rows keyed by their domain IDs. Reuses the wrapper for the same immutable array. */
+export function entities(items) {
+    // The collection retains, filters and slices supplied items; it never inserts wider values.
+    return identified.from(items ?? empty);
+}

package/dist/dom.d.ts

@@ -45,7 +45,7 @@ export declare function slot<A = void>(_render: (value: A) => JSX.Element): Slot
 /** Compiler output. Captures follow their declaring scope; placements own independent scopes. */
 export declare function compiledSlot<M, E, A>(owner: Scope<M, E>, build: Build<A, E>): Slot<A>;
 /** This declaration is a compiler marker, never a component setup callback. */
-export declare function view<M, E>(_render: (model: M, send: Send<E>) => JSX.Element): View<M, E>;
+export declare function view<M, E = never>(_render: (model: M, send: Send<E>) => JSX.Element): View<M, E>;
 export declare function compiled<M, E>(build: Build<M, E>): View<M, E>;
 export declare function mountView<M, E>(parent: Node, definition: View<M, E>, source: Program<M, E>, options?: {
     onError?: ReportError;

package/dist/dom.js

@@ -78,7 +78,7 @@ export class Scope {
 const contentBrand = Symbol('compiled content');
 /** Compiler marker: declare inside view(), or directly in a compiled component prop. */
 export function slot(_render) {
-    throw new Error('MVU slot reached runtime without the snapshot JSX compiler');
+    throw new Error('EffectWeb slot reached runtime without the EffectWeb JSX compiler');
 }
 // Placement values are opaque to structural sharing, which only traverses plain data.
 class SlotPlacement {
@@ -143,7 +143,7 @@ export function compiledSlot(owner, build) {
 }
 /** This declaration is a compiler marker, never a component setup callback. */
 export function view(_render) {
-    throw new Error('MVU view reached runtime without the snapshot JSX compiler');
+    throw new Error('EffectWeb view reached runtime without the EffectWeb JSX compiler');
 }
 export function compiled(build) {
     return Object.assign(() => {
@@ -440,9 +440,9 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
                 throw new Error('Object lists need domain identity. Declare collection(identity) once; do not add JSX keys.');
             return key;
         });
-        if (new Set(identities).size !== identities.length)
-            throw new Error('Duplicate collection identity. Identity must be unique within the rendered collection.');
         const keep = new Set(identities);
+        if (keep.size !== identities.length)
+            throw new Error('Duplicate collection identity. Identity must be unique within the rendered collection.');
         for (const [key, row] of rows) {
             if (keep.has(key))
                 continue;
@@ -485,29 +485,40 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
                 row.scope.set([item, index]);
             }
         }
-        const positions = new Map(previousIdentities.map((key, index) => [key, index]));
-        const stationary = stationaryIndices(identities.map((key) => positions.get(key) ?? -1));
-        let anchor = end;
-        for (let index = identities.length - 1; index >= 0; index--) {
-            const row = rows.get(identities[index]);
-            if (!stationary.has(index) && row.end.nextSibling !== anchor) {
-                const focused = document.activeElement instanceof HTMLElement ? document.activeElement : undefined;
-                let node = row.start;
-                while (node) {
-                    const next = node.nextSibling;
-                    const move = Reflect.get(target, 'moveBefore');
-                    if (typeof move === 'function' && target.isConnected && node.isConnected)
-                        move.call(target, node, anchor);
-                    else
-                        target.insertBefore(node, anchor);
-                    if (node === row.end)
-                        break;
-                    node = next;
+        // Retained prefixes are already ordered. New tail rows were appended above and
+        // removed tail rows were disposed, so edits, appends and truncations need no moves.
+        let orderChanged = false;
+        for (let index = 0; index < Math.min(previousIdentities.length, identities.length); index++) {
+            if (previousIdentities[index] !== identities[index]) {
+                orderChanged = true;
+                break;
+            }
+        }
+        if (orderChanged) {
+            const positions = new Map(previousIdentities.map((key, index) => [key, index]));
+            const stationary = stationaryIndices(identities.map((key) => positions.get(key) ?? -1));
+            let anchor = end;
+            for (let index = identities.length - 1; index >= 0; index--) {
+                const row = rows.get(identities[index]);
+                if (!stationary.has(index) && row.end.nextSibling !== anchor) {
+                    const focused = document.activeElement instanceof HTMLElement ? document.activeElement : undefined;
+                    let node = row.start;
+                    while (node) {
+                        const next = node.nextSibling;
+                        const move = Reflect.get(target, 'moveBefore');
+                        if (typeof move === 'function' && target.isConnected && node.isConnected)
+                            move.call(target, node, anchor);
+                        else
+                            target.insertBefore(node, anchor);
+                        if (node === row.end)
+                            break;
+                        node = next;
+                    }
+                    if (focused?.isConnected && document.activeElement !== focused)
+                        focused.focus({ preventScroll: true });
                 }
-                if (focused?.isConnected && document.activeElement !== focused)
-                    focused.focus({ preventScroll: true });
+                anchor = row.start;
             }
-            anchor = row.start;
         }
         previousList = next;
         previousOuter = nextOuter;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-export { collection, sequence, type Rows } from './collection.js';
+export type { Snapshot } from './snapshot.js';
+export { modelOwner, type ModelOwner, type DisposableOwner, type TaskPolicy } from './owner.js';
+export { collection, entities, 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';
@@ -18,5 +20,5 @@ 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';
+export { makeQueryCache, type QueryCache } from './cache.js';
+export { queryResource, observeQuery, lifetime, projectionCache, sessionGroup, type SessionContext, type Read, } from './session.js';

package/dist/index.js

@@ -1,4 +1,5 @@
-export { collection, sequence } from './collection.js';
+export { modelOwner } 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';
@@ -17,5 +18,5 @@ 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';
+export { makeQueryCache } from './cache.js';
+export { queryResource, observeQuery, lifetime, projectionCache, sessionGroup, } from './session.js';

package/dist/owner.d.ts

@@ -0,0 +1,35 @@
+import { type Snapshot } from './snapshot.js';
+import { Effect } from 'effect';
+import { type Program } from './program.js';
+import { type ReportError } from './errors.js';
+import type { UiRuntime } from './runtime.js';
+export type TaskPolicy = 'replace' | 'drop' | 'parallel';
+export interface DisposableOwner {
+    readonly disposed: boolean;
+    readonly own: <A extends {
+        dispose(): void;
+    }>(resource: A) => A;
+}
+export interface ModelOwner<Model extends object, R = never> extends DisposableOwner {
+    readonly source: Program<Model, never>;
+    readonly read: () => Snapshot<Model>;
+    readonly patch: (changes: Partial<Model>) => void;
+    readonly edit: <K extends keyof Model>(key: K, change: (value: Snapshot<Model[K]>) => Snapshot<Model[K]>) => void;
+    /** Synchronous transaction. Reads see staged changes; a throw discards changes and work. */
+    readonly transaction: <A>(work: () => A & (A extends PromiseLike<unknown> ? never : unknown)) => A;
+    readonly run: (slot: string, effect: Effect.Effect<unknown, unknown, R>, policy?: TaskPolicy) => void;
+    readonly cancel: (slot: string) => void;
+    readonly isRunning: (slot: string) => boolean;
+    readonly awaitIdle: () => Promise<void>;
+    readonly dispose: () => void;
+}
+type Options = {
+    checkSnapshots?: boolean;
+    name?: string;
+    onDefect?: ReportError;
+};
+export declare function modelOwner<Model extends object>(initial: Model, options?: Options): ModelOwner<Model>;
+export declare function modelOwner<Model extends object, R>(initial: Model, options: Options & {
+    runtime: UiRuntime<R>;
+}): ModelOwner<Model, R>;
+export {};

package/dist/owner.js

@@ -0,0 +1,137 @@
+import { protectSnapshot, checkSnapshotsByDefault } from './snapshot.js';
+import { Effect } from 'effect';
+import { program } from './program.js';
+import { patchModel } from './state.js';
+import { runAll, reportError } from './errors.js';
+/** Immutable model publication and task ownership, using the same program queue as components. */
+export function modelOwner(initial, options = {}) {
+    let disposed = false, nextTask = 0;
+    let staged;
+    const groups = new Map();
+    const cleanups = [];
+    const source = program({
+        initial,
+        ...options,
+        update(model, operations) {
+            const single = operations.length === 1 ? operations[0] : undefined;
+            if (single?.type === 'Patch')
+                return { model: patchModel(model, single.changes) };
+            const commands = new Map();
+            const cancel = new Set();
+            const stop = (slot) => {
+                for (const key of groups.get(slot) ?? []) {
+                    cancel.add(key);
+                    commands.delete(key);
+                }
+                groups.delete(slot);
+            };
+            for (const operation of operations) {
+                if (operation.type === 'Patch')
+                    model = patchModel(model, operation.changes);
+                else if (operation.type === 'Cancel')
+                    stop(operation.slot);
+                else {
+                    const { slot, effect, policy } = operation;
+                    if (policy === 'drop' && groups.has(slot))
+                        continue;
+                    if (policy === 'replace')
+                        stop(slot);
+                    const key = `${slot}:${++nextTask}`;
+                    const group = groups.get(slot) ?? new Set();
+                    groups.set(slot, group);
+                    group.add(key);
+                    commands.set(key, {
+                        slot: key,
+                        action: Effect.asVoid(effect).pipe(Effect.ensuring(Effect.sync(() => {
+                            group.delete(key);
+                            if (!group.size && groups.get(slot) === group)
+                                groups.delete(slot);
+                        }))),
+                    });
+                }
+            }
+            return {
+                model,
+                cancel: [...cancel],
+                commands: [...commands.values()].map((command) => options.runtime ? options.runtime.command(command) : command),
+            };
+        },
+    });
+    const read = () => protectSnapshot(staged?.model ?? source.model(), options.checkSnapshots ?? checkSnapshotsByDefault);
+    const submit = (operation) => {
+        if (disposed)
+            return;
+        if (staged) {
+            staged.operations.push(operation);
+            if (operation.type === 'Patch')
+                staged.model = patchModel(staged.model, operation.changes);
+        }
+        else
+            source.send([operation]);
+    };
+    const patch = (changes) => submit({ type: 'Patch', changes });
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        source.dispose();
+        groups.clear();
+        runAll(cleanups.splice(0).reverse(), options.onDefect ?? reportError);
+    };
+    return {
+        source: { model: source.model, send: source.send, subscribe: source.subscribe, dispose },
+        read,
+        patch,
+        edit: (key, change) => {
+            if (!disposed) {
+                const changes = {};
+                // Readonly changes remain immutable model data; no clone is needed for a no-op.
+                changes[key] = change(read()[key]);
+                patch(changes);
+            }
+        },
+        transaction(work) {
+            if (disposed)
+                throw new Error('Cannot start a transaction on a disposed model owner.');
+            const parent = staged;
+            const batch = { model: read(), operations: [] };
+            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) {
+                        parent.model = batch.model;
+                        parent.operations.push(...batch.operations);
+                    }
+                    else if (batch.operations.length)
+                        source.send(batch.operations);
+                }
+                return result;
+            }
+            finally {
+                staged = parent;
+            }
+        },
+        run: (slot, effect, policy = 'replace') => submit({ type: 'Run', slot, effect, policy }),
+        cancel: (slot) => submit({ type: 'Cancel', slot }),
+        isRunning: (slot) => groups.has(slot),
+        awaitIdle: source.awaitIdle,
+        get disposed() {
+            return disposed;
+        },
+        own(resource) {
+            if (disposed)
+                resource.dispose();
+            else
+                cleanups.push(() => resource.dispose());
+            return resource;
+        },
+        dispose,
+    };
+}

package/dist/pages.d.ts

@@ -1,7 +1,7 @@
 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';
+import { type Transition, type Send } from './program.js';
 export interface PagesModel<Props, A, Cursor> {
     readonly props: Props;
     readonly key: string | undefined;
@@ -32,6 +32,16 @@ export declare function pages<Props, A, Cursor>(definition: {
     load: (props: Props, cursor: Cursor | undefined) => UiLoad<UiPage<A, Cursor>>;
     itemKey: (item: A) => string;
 }): {
+    /** Own pagination directly in a controller; components can use the same reducer. */
+    create(props: Props): {
+        send: Send<PagesMessage<A, Cursor>>;
+        receive: (props: Props) => void;
+        activeSlots: () => readonly string[];
+        awaitIdle: (slot?: string) => Promise<void>;
+        model: () => Readonly<PagesModel<Props, A, Cursor>>;
+        subscribe: (listener: (model: Readonly<PagesModel<Props, A, Cursor>>) => void) => () => void;
+        dispose: () => void;
+    };
     init: (props: Props) => PagesModel<Props, A, Cursor>;
     receive(model: PagesModel<Props, A, Cursor>, props: Props, options?: {
         refresh?: boolean;

package/dist/pages.js

@@ -1,6 +1,7 @@
+import { shareValue } from './share.js';
 import { Cause, Option } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
-import { effectCommand } from './program.js';
+import { effectCommand, program } from './program.js';
 import { available } from './resource.js';
 /**
  * Pagination owns the `page` command slot. Key changes clear results and replace the request;
@@ -25,7 +26,7 @@ export function pages(definition) {
             ],
         };
     };
-    return {
+    const pagination = {
         init: (props) => ({
             props,
             key: undefined,
@@ -35,7 +36,8 @@ export function pages(definition) {
         receive(model, props, options = {}) {
             const key = definition.key(props);
             if (key === model.key) {
-                const next = { ...model, props };
+                const shared = shareValue(model.props, props);
+                const next = shared === model.props ? model : { ...model, props: shared };
                 return options.refresh ? request(next, false) : { model: next };
             }
             const next = {
@@ -83,4 +85,19 @@ export function pages(definition) {
             }
         },
     };
+    return {
+        ...pagination,
+        /** Own pagination directly in a controller; components can use the same reducer. */
+        create(props) {
+            const source = program({
+                initial: pagination.init(props),
+                update: (model, message) => message.type === 'Input'
+                    ? pagination.receive(model, message.props)
+                    : pagination.update(model, message),
+            });
+            const receive = (props) => source.send({ type: 'Input', props });
+            receive(props);
+            return { ...source, send: source.send, receive };
+        },
+    };
 }

package/dist/program.d.ts

@@ -1,3 +1,4 @@
+import { type Snapshot } from './snapshot.js';
 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. */
@@ -30,9 +31,9 @@ export interface Transition<Model, Message, R = never> {
     readonly cancel?: readonly string[];
 }
 export interface Program<Model, Message> {
-    readonly model: () => Model;
+    readonly model: () => Snapshot<Model>;
     readonly send: Send<Message>;
-    readonly subscribe: (listener: (model: Model) => void) => () => void;
+    readonly subscribe: (listener: (model: Snapshot<Model>) => void) => () => void;
     readonly dispose: () => void;
 }
 export interface RunningProgram<Model, Message> extends Program<Model, Message> {
@@ -43,6 +44,7 @@ export interface RunningProgram<Model, Message> extends Program<Model, Message>
 export declare function program<Model, Message>(options: {
     initial: Model;
     name?: string;
-    update: (model: Model, message: Message) => Transition<Model, Message>;
+    checkSnapshots?: boolean;
+    update: (model: Snapshot<Model>, message: Message) => Transition<Model, Message>;
     onDefect?: (cause: unknown) => void;
 }): RunningProgram<Model, Message>;

package/dist/program.js

@@ -1,3 +1,4 @@
+import { protectSnapshot, checkSnapshotsByDefault } from './snapshot.js';
 import { reportError, reportSafely } from './errors.js';
 import { traceProgram, nextProgramId, hasProgramObservers } from './diagnostics.js';
 import { Cause, Effect, Fiber, Option, Stream } from 'effect';
@@ -20,6 +21,7 @@ export function mapCommand(command, map) {
 }
 /** One immutable source of truth. Reducers are synchronous; commands own async work. */
 export function program(options) {
+    const checkSnapshots = options.checkSnapshots ?? checkSnapshotsByDefault;
     const id = nextProgramId();
     const trace = (kind, slot, message) => hasProgramObservers() &&
         traceProgram({
@@ -45,7 +47,7 @@ export function program(options) {
         }
     };
     const registry = AtomRegistry.make();
-    const atom = Atom.make(options.initial);
+    const atom = Atom.make(protectSnapshot(options.initial, checkSnapshots));
     const release = registry.mount(atom);
     const running = new Map();
     let disposed = false;
@@ -73,7 +75,7 @@ export function program(options) {
                 trace('update', undefined, message);
                 for (const slot of transition.cancel ?? [])
                     cancel(slot);
-                registry.set(atom, transition.model);
+                registry.set(atom, protectSnapshot(transition.model, checkSnapshots));
                 for (const command of transition.commands ?? []) {
                     if (disposed)
                         break;

package/dist/query.d.ts

@@ -7,16 +7,20 @@ export interface Query<Args, A, E = never, R = never> {
     readonly load: (args: Args) => Effect.Effect<A, E, R>;
     /** Revalidate on activation/prefetch after this many milliseconds. No polling timer. */
     readonly staleTime: number;
+    /** Reuse unchanged domain entities before publishing a refreshed result. */
+    readonly share?: (previous: A, next: A) => A;
 }
-/** Identity belongs to arguments, never callback identity. Each application cache owns account isolation. */
+/** Identity belongs to arguments, never callback identity. Separate caches isolate independent data scopes. */
 export declare function query<A, E = never, R = never>(definition: {
     readonly name: string;
     readonly load: () => Effect.Effect<A, E, R>;
     readonly staleTime?: number;
+    readonly share?: (previous: A, next: A) => A;
 }): Query<true, A, E, R>;
 export declare function query<Args, A, E = never, R = never>(definition: {
     readonly name: string;
     readonly key: (args: Args) => string;
     readonly load: (args: Args) => Effect.Effect<A, E, R>;
     readonly staleTime?: number;
+    readonly share?: (previous: A, next: A) => A;
 }): Query<Args, A, E, R>;

package/dist/resource.js

@@ -5,7 +5,12 @@ import { component } from './component.js';
 import { defaultUiRuntime } from './runtime.js';
 import { effectCommand } from './program.js';
 export const available = (result) => Option.getOrUndefined(AsyncResult.value(result));
-export const resourceError = (result) => AsyncResult.isFailure(result) ? String(Cause.squash(result.cause)) : '';
+export const resourceError = (result) => {
+    if (!AsyncResult.isFailure(result))
+        return '';
+    const error = Cause.squash(result.cause);
+    return error instanceof Error ? error.message : String(error);
+};
 /** A replaceable request owns one result. Key changes clear it; refreshes preserve the last success. */
 export function resourceComponent(definition) {
     const runtime = definition.runtime ?? defaultUiRuntime;

package/dist/runtime.d.ts

@@ -1,3 +1,4 @@
+import type { Snapshot } from './snapshot.js';
 import { Context, Effect } from 'effect';
 import { type Command, type RunningProgram, type Transition } from './program.js';
 /** A binding to application-owned services, not a new scope or service lifetime. */
@@ -7,8 +8,9 @@ export interface UiRuntime<R> {
     readonly command: <M>(command: Command<M, R>) => Command<M>;
     readonly program: <M, Msg>(options: {
         initial: M;
-        update: (model: M, message: Msg) => Transition<M, Msg, R>;
+        update: (model: Snapshot<M>, message: Msg) => Transition<M, Msg, R>;
         name?: string;
+        checkSnapshots?: boolean;
         onDefect?: (cause: unknown) => void;
     }) => RunningProgram<M, Msg>;
 }

package/dist/session.d.ts

@@ -1,8 +1,8 @@
 import type { Query } from './query.js';
+import type { DisposableOwner } from './owner.js';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
-import type { UiLoad, UiModel } from './cache.js';
-import { type UiPage } from './cache.js';
-/** Explicit ownership for the application's DOM and Telegram adapters. */
+import type { QueryCache } from './cache.js';
+/** Own subscriptions, DOM adapters and other cleanup for one lifetime. */
 export declare function lifetime(): {
     add(cleanup: () => void): void;
     dispose(): void;
@@ -10,38 +10,29 @@ export declare function lifetime(): {
 };
 export type Read<A> = () => A;
 export interface SessionContext<R = never> {
-    readonly cache: UiModel<R>;
+    readonly cache: QueryCache<R>;
     readonly changed: () => void;
 }
-/** Explicit request selection. Reads are Effect values; no tracking context or reactive props. */
-export declare function resource<A>(context: SessionContext, namespace?: string): {
-    select(selected: string | undefined, load: () => UiLoad<A>): void;
-    read: () => AsyncResult.AsyncResult<A, unknown>;
-    refresh: () => void;
-    dispose: () => void;
-};
 /**
  * Idempotent query reconciliation for snapshot ticks. Freshness is checked when entering a
- * selection (including remount), not on every same-key tick; refresh explicitly revalidates.
+ * selection (including remount), not on every same-key tick; refresh revalidates unless a request is already in flight.
  */
-export declare function queryResource<Args, A, E, R>(context: SessionContext<R>, definition: Query<Args, A, E, NoInfer<R>>): {
+export declare function queryResource<Args, A, E, R>(context: {
+    cache: QueryCache<R>;
+    changed?: () => void;
+}, definition: Query<Args, A, E, NoInfer<R>>): {
     select(args: Args | undefined): void;
     read: () => AsyncResult.AsyncResult<A, E>;
+    subscribe(listener: (result: AsyncResult.AsyncResult<A, E>) => void): () => void;
     refresh: () => void;
     dispose: () => void;
 };
-export declare function pagedResource<A, Cursor>(context: SessionContext, itemKey: (item: A) => string): {
-    select(selected: string | undefined, load: (cursor: Cursor | undefined) => UiLoad<UiPage<A, Cursor>>): void;
-    snapshot(): {
-        items: A[];
-        totalCount: number | undefined;
-        loading: boolean;
-        loadingMore: boolean;
-        hasMore: boolean;
-        error: string;
-    };
-    more: () => void | undefined;
-    refresh: () => void | undefined;
+/** Publish Effect results directly; the owner releases the subscription on disposal. */
+export declare function observeQuery<Args, A, E, R>(owner: DisposableOwner, cache: QueryCache<R>, definition: Query<Args, A, E, NoInfer<R>>, changed: (result: AsyncResult.AsyncResult<A, E>) => void): {
+    select(args: Args | undefined): void;
+    read: () => AsyncResult.AsyncResult<A, E>;
+    subscribe(listener: (result: AsyncResult.AsyncResult<A, E>) => void): () => void;
+    refresh: () => void;
     dispose: () => void;
 };
 /** Application selectors run once per explicit input version, with optional prior output sharing. */

package/dist/session.js

@@ -1,9 +1,7 @@
-import { runAll } from './errors.js';
-import { Cause, Option } from 'effect';
+import { runAll, reportError, reportSafely } from './errors.js';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import * as Atom from 'effect/unstable/reactivity/Atom';
-import { loadEffect, makePagedResource } from './cache.js';
-/** Explicit ownership for the application's DOM and Telegram adapters. */
+/** Own subscriptions, DOM adapters and other cleanup for one lifetime. */
 export function lifetime() {
     const cleanups = [];
     let disposed = false;
@@ -25,47 +23,9 @@ export function lifetime() {
         },
     };
 }
-/** Explicit request selection. Reads are Effect values; no tracking context or reactive props. */
-export function resource(context, namespace) {
-    let key, atom;
-    let stop;
-    const initial = AsyncResult.initial();
-    return {
-        select(selected, load) {
-            const next = selected === undefined
-                ? undefined
-                : `${context.cache.registry.get(context.cache.generation)}:${selected}`;
-            if (next === key)
-                return;
-            stop?.();
-            stop = undefined;
-            key = next;
-            atom =
-                next === undefined
-                    ? undefined
-                    : namespace
-                        ? context.cache.resource(`${namespace}:${selected}`, load)
-                        : Atom.make(loadEffect(load)).pipe(Atom.setIdleTTL(0));
-            if (atom)
-                stop = context.cache.registry.subscribe(atom, context.changed, { immediate: true });
-            context.changed();
-        },
-        read: () => (atom ? context.cache.registry.get(atom) : initial),
-        refresh: () => {
-            if (atom)
-                context.cache.registry.refresh(atom);
-        },
-        dispose: () => {
-            stop?.();
-            stop = undefined;
-            atom = undefined;
-            key = undefined;
-        },
-    };
-}
 /**
  * Idempotent query reconciliation for snapshot ticks. Freshness is checked when entering a
- * selection (including remount), not on every same-key tick; refresh explicitly revalidates.
+ * selection (including remount), not on every same-key tick; refresh revalidates unless a request is already in flight.
  */
 export function queryResource(context, definition) {
     let key;
@@ -73,7 +33,71 @@ export function queryResource(context, definition) {
     let atom;
     let stop;
     let disposed = false;
+    let revision = 0;
     const initial = AsyncResult.initial();
+    const listeners = new Set();
+    const read = () => atom && !disposed && generation === context.cache.registry.get(context.cache.generation)
+        ? context.cache.registry.get(atom)
+        : initial;
+    let published;
+    let notifying = false;
+    let pending = false;
+    const call = (work) => {
+        try {
+            work();
+        }
+        catch (error) {
+            reportSafely(reportError, error);
+        }
+    };
+    const notify = () => {
+        if (disposed)
+            return;
+        pending = true;
+        if (notifying)
+            return;
+        notifying = true;
+        try {
+            while (pending && !disposed) {
+                pending = false;
+                if (context.changed)
+                    call(context.changed);
+                if (disposed)
+                    break;
+                const result = read();
+                if (result === published)
+                    continue;
+                published = result;
+                const selected = revision;
+                // A callback may select, reset, refresh or dispose. Finish only the current publication.
+                // oxlint-disable-next-line unicorn/no-useless-spread
+                for (const listener of [...listeners]) {
+                    if (disposed || selected !== revision || result !== read())
+                        break;
+                    if (listeners.has(listener))
+                        call(() => listener(result));
+                }
+            }
+        }
+        finally {
+            notifying = false;
+        }
+    };
+    const disconnect = () => {
+        const release = stop;
+        stop = undefined;
+        release?.();
+    };
+    // Initialize before subscribing; construction must not invoke application callbacks.
+    context.cache.registry.get(context.cache.generation);
+    const stopGeneration = context.cache.registry.subscribe(context.cache.generation, () => {
+        revision++;
+        disconnect();
+        atom = undefined;
+        key = undefined;
+        generation = -1;
+        notify();
+    });
     return {
         select(args) {
             if (disposed)
@@ -82,71 +106,59 @@ export function queryResource(context, definition) {
             const nextKey = args === undefined ? undefined : definition.key(args);
             if (nextKey === key && nextGeneration === generation)
                 return;
-            stop?.();
-            stop = undefined;
+            const selected = ++revision;
+            disconnect();
             key = nextKey;
             generation = nextGeneration;
-            atom = args === undefined ? undefined : context.cache.query(definition, args);
-            if (atom)
-                stop = context.cache.registry.subscribe(atom, context.changed, { immediate: true });
-            context.changed();
+            const nextAtom = args === undefined ? undefined : context.cache.query(definition, args);
+            if (disposed || selected !== revision)
+                return;
+            atom = nextAtom;
+            if (nextAtom) {
+                // Subscription setup itself can execute a synchronous Effect and reenter selection.
+                const release = context.cache.registry.subscribe(nextAtom, notify);
+                if (disposed || selected !== revision) {
+                    release();
+                    return;
+                }
+                stop = release;
+            }
+            notify();
+        },
+        read,
+        subscribe(listener) {
+            if (disposed)
+                return () => { };
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
         },
-        read: () => atom && !disposed && generation === context.cache.registry.get(context.cache.generation)
-            ? context.cache.registry.get(atom)
-            : initial,
         refresh: () => {
-            if (atom && !disposed)
+            if (atom &&
+                !disposed &&
+                generation === context.cache.registry.get(context.cache.generation) &&
+                !context.cache.registry.get(atom).waiting)
                 context.cache.registry.refresh(atom);
         },
         dispose: () => {
+            if (disposed)
+                return;
             disposed = true;
-            stop?.();
-            stop = undefined;
+            revision++;
+            listeners.clear();
+            stopGeneration();
+            disconnect();
             atom = undefined;
             key = undefined;
         },
     };
 }
-export function pagedResource(context, itemKey) {
-    let key, page, stop;
-    const initial = AsyncResult.initial();
-    const state = () => (page ? context.cache.registry.get(page.atom) : initial);
-    return {
-        select(selected, load) {
-            const next = selected === undefined
-                ? undefined
-                : `${context.cache.registry.get(context.cache.generation)}:${selected}`;
-            if (next === key)
-                return;
-            stop?.();
-            stop = undefined;
-            key = next;
-            page =
-                next === undefined ? undefined : makePagedResource(context.cache.registry, load, itemKey);
-            if (page)
-                stop = context.cache.registry.subscribe(page.atom, context.changed, { immediate: true });
-            context.changed();
-        },
-        snapshot() {
-            const result = state(), value = Option.getOrUndefined(AsyncResult.value(result));
-            return {
-                items: value?.items ?? [],
-                totalCount: value?.totalCount,
-                loading: result.waiting && !value,
-                loadingMore: result.waiting && Boolean(value),
-                hasMore: value?.next !== undefined,
-                error: AsyncResult.isFailure(result) ? String(Cause.squash(result.cause)) : '',
-            };
-        },
-        more: () => page?.more(),
-        refresh: () => page?.refresh(),
-        dispose: () => {
-            stop?.();
-            stop = undefined;
-            page = undefined;
-            key = undefined;
-        },
-    };
+/** Publish Effect results directly; the owner releases the subscription on disposal. */
+export function observeQuery(owner, cache, definition, changed) {
+    const resource = queryResource({ cache }, definition);
+    resource.subscribe(changed);
+    return owner.own(resource);
 }
 /** Application selectors run once per explicit input version, with optional prior output sharing. */
 export function projectionCache() {

package/dist/share.d.ts

@@ -1,2 +1,6 @@
+/** Override sharing for selected fields, for example a collection keyed by domain identity. */
+export type ShareFields<T> = {
+    readonly [K in keyof T]?: (previous: T[K], next: T[K]) => T[K];
+};
 /** Share JSON-shaped data; Blob, typed arrays and class instances retain their own identity. */
-export declare function shareValue<T>(previous: T, next: T): T;
+export declare function shareValue<T>(previous: T, next: T, fields?: ShareFields<T>): T;

package/dist/share.js

@@ -2,7 +2,7 @@
 // already compared object pair without retaining either snapshot after its owners release it.
 const sharedPairs = new WeakMap();
 /** Share JSON-shaped data; Blob, typed arrays and class instances retain their own identity. */
-export function shareValue(previous, next) {
+export function shareValue(previous, next, fields) {
     if (Object.is(previous, next))
         return previous;
     if (!previous || !next || typeof previous !== 'object' || typeof next !== 'object')
@@ -15,7 +15,7 @@ export function shareValue(previous, next) {
             Object.getPrototypeOf(previous) !== Object.prototype))
         return next;
     let pairs = sharedPairs.get(previous);
-    if (pairs?.has(next))
+    if (!fields && pairs?.has(next))
         return pairs.get(next);
     const old = previous;
     const value = next;
@@ -24,13 +24,19 @@ export function shareValue(previous, next) {
     let unchangedNext = true;
     const shared = array ? [] : {};
     for (const key of keys) {
-        shared[key] = shareValue(old[key], value[key]);
+        const custom = fields && Object.hasOwn(fields, key) ? fields[key] : undefined;
+        shared[key] =
+            custom && Object.hasOwn(old, key)
+                ? custom(old[key], value[key])
+                : shareValue(old[key], value[key]);
         if (!Object.hasOwn(old, key) || shared[key] !== old[key])
             equal = false;
         if (shared[key] !== value[key])
             unchangedNext = false;
     }
     const result = equal ? previous : unchangedNext ? next : shared;
+    if (fields)
+        return result;
     if (!pairs) {
         pairs = new WeakMap();
         sharedPairs.set(previous, pairs);

package/dist/snapshot.d.ts

@@ -0,0 +1,5 @@
+/** Published fields cannot be reassigned. Nested domain types should also declare readonly data. */
+export type Snapshot<T> = Readonly<T>;
+export declare const checkSnapshotsByDefault: boolean;
+/** Development guard for immutable plain data. Opaque objects keep their own lifecycle. */
+export declare function protectSnapshot<T>(value: T, enabled: boolean): T;

package/dist/snapshot.js

@@ -0,0 +1,31 @@
+import { isAsyncResult } from 'effect/unstable/reactivity/AsyncResult';
+export const checkSnapshotsByDefault = typeof __EFFECTWEB_DEV__ !== 'undefined' && __EFFECTWEB_DEV__;
+const checked = new WeakSet();
+/** Development guard for immutable plain data. Opaque objects keep their own lifecycle. */
+export function protectSnapshot(value, enabled) {
+    if (!enabled || !value || typeof value !== 'object' || checked.has(value))
+        return value;
+    // AsyncResult is an immutable Effect wrapper, but its successful UI data is plain data.
+    if (isAsyncResult(value)) {
+        checked.add(value);
+        if (value._tag === 'Success')
+            protectSnapshot(value.value, true);
+        else if (value._tag === 'Failure' && value.previousSuccess._tag === 'Some')
+            protectSnapshot(value.previousSuccess.value, true);
+        return value;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null)
+        return value;
+    // Mark before walking to allow cyclic data and reuse already checked shared branches.
+    checked.add(value);
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const key of Reflect.ownKeys(descriptors)) {
+        const descriptor = Reflect.get(descriptors, key);
+        // Never execute getters or traverse closures, class instances, Effects or DOM objects.
+        if ('value' in descriptor)
+            protectSnapshot(descriptor.value, true);
+    }
+    Object.freeze(value);
+    return value;
+}

package/dist/tasks.d.ts

@@ -1,3 +1,4 @@
+import type { ModelOwner, TaskPolicy } from './owner.js';
 import { Effect } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { View } from './dom.js';
@@ -44,6 +45,15 @@ type Init<Props, State> = {
     identity?: (props: Props) => unknown;
     name?: string;
 };
+interface ControllerTask<R> {
+    readonly run: (...args: never[]) => Effect.Effect<unknown, unknown, R>;
+    readonly policy: TaskPolicy;
+    /** Actions sharing a slot share cancellation and concurrency rules. Defaults to the action name. */
+    readonly slot?: string;
+}
+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): {
+    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>>;

package/dist/tasks.js

@@ -4,7 +4,14 @@ import { programView } from './component.js';
 import { effectCommand, program } from './program.js';
 import { defaultUiRuntime } from './runtime.js';
 import { patchModel } from './state.js';
-export function defineTasks(definition) {
+export function defineTasks(definition, definitions) {
+    if ('run' in definition) {
+        const actions = Object.create(null);
+        for (const [name, task] of Object.entries(definitions)) {
+            actions[name] = (...args) => definition.run(task.slot ?? name, Effect.suspend(() => task.run(...args)), task.policy);
+        }
+        return actions;
+    }
     return taskBuilder(definition, definition.runtime ?? defaultUiRuntime);
 }
 function stopWaiting(result) {

package/dist/testing.d.ts

@@ -5,9 +5,9 @@ import { type UiRuntime } from './runtime.js';
 export declare function programDriver<M, Msg>(source: RunningProgram<M, Msg>): ReturnType<typeof makeDriver<M, Msg, never>>;
 export declare function programDriver<M, Msg, R>(source: RunningProgram<M, Msg>, runtime: UiRuntime<R>): ReturnType<typeof makeDriver<M, Msg, R>>;
 declare function makeDriver<M, Msg, R>(source: RunningProgram<M, Msg>, runtime: UiRuntime<R>): {
-    model: () => M;
+    model: () => Readonly<M>;
     send: import("./program.js").Send<Msg>;
-    subscribe: (listener: (model: M) => void) => () => void;
+    subscribe: (listener: (model: Readonly<M>) => void) => () => void;
     dispose: () => void;
     activeSlots: () => readonly string[];
     awaitSlot: (slot: string) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effectweb",
-  "version": "0.1.1",
+  "version": "0.2.2",
   "description": "Immutable Effect models and compiled JSX with direct DOM rendering",
   "homepage": "https://github.com/DerpyCrabs/EffectWeb",
   "bugs": {