effectweb 0.2.1 → 0.2.3

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 TeleVecha contributors
+Copyright (c) 2026 EffectWeb contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,6 +4,6 @@ Immutable Effect models and JSX compiled to direct DOM updates, without signals,
 
 Use with `@effectweb/compiler/vite` and Effect `4.0.0-rc.112`. The package includes programs, named tasks, async presentation, query caching, DOM lifetimes, and `effectweb/testing` helpers.
 
-See [setup and example](https://github.com/DerpyCrabs/EffectWeb#vite-setup) and the [authoring guide](https://github.com/DerpyCrabs/EffectWeb/blob/main/docs/authoring.md).
+See [setup and example](https://github.com/DerpyCrabs/EffectWeb#vite-setup).
 
 Early API; runtime and compiler versions advance together. Client-side only. Persistence and multi-tab coordination belong to the application.

package/dist/AsyncContent.js

@@ -45,27 +45,36 @@ const implementation = component({
             visible: true
         } }),
     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);
+        const _ew_derived_4 = _ew_scope_1.derive(() => [_ew_scope_1.value?.props], () => {
+            const _ew_capture_6 = _ew_scope_1.value;
+            return _ew_capture_6.props;
+        });
+        const _ew_derived_7 = _ew_scope_1.derive(() => [_ew_derived_4()?.result], () => {
+            const _ew_capture_9 = _ew_derived_4();
+            return AsyncResult.value(_ew_capture_9.result);
+        });
+        const _ew_derived_10 = _ew_scope_1.derive(() => [_ew_derived_4()?.result, _ew_derived_4()?.result?.waiting], () => {
+            const _ew_capture_12 = _ew_derived_4();
+            return AsyncResult.isFailure(_ew_capture_12.result) && !_ew_capture_12.result.waiting ? _ew_capture_12.result : undefined;
+        });
+        _ew_dom.branch(_ew_scope_1, _ew_parent_2, _ew_before_3, () => Option.isSome(_ew_derived_7()), (_ew_scope_1, _ew_parent_13, _ew_before_14) => {
+            _ew_dom.text(_ew_scope_1, _ew_parent_13, _ew_before_14, () => [_ew_derived_4(), _ew_derived_7()?.value], () => _ew_derived_4().content(_ew_derived_7().value));
+            _ew_dom.branch(_ew_scope_1, _ew_parent_13, _ew_before_14, () => _ew_derived_4().result.waiting, (_ew_scope_1, _ew_parent_15, _ew_before_16) => {
+                _ew_dom.text(_ew_scope_1, _ew_parent_15, _ew_before_16, () => [_ew_derived_4()?.refreshing], () => _ew_derived_4().refreshing);
+            }, (_ew_scope_1, _ew_parent_15, _ew_before_16) => { });
+            _ew_dom.branch(_ew_scope_1, _ew_parent_13, _ew_before_14, () => _ew_derived_10() && _ew_derived_4().failure, (_ew_scope_1, _ew_parent_17, _ew_before_18) => {
+                _ew_dom.text(_ew_scope_1, _ew_parent_17, _ew_before_18, () => [_ew_derived_4(), _ew_derived_10()?.cause], () => _ew_derived_4().failure(_ew_derived_10().cause));
+            }, (_ew_scope_1, _ew_parent_17, _ew_before_18) => { });
+        }, (_ew_scope_1, _ew_parent_13, _ew_before_14) => {
+            _ew_dom.branch(_ew_scope_1, _ew_parent_13, _ew_before_14, () => _ew_derived_10() && _ew_derived_4().failure, (_ew_scope_1, _ew_parent_19, _ew_before_20) => {
+                _ew_dom.text(_ew_scope_1, _ew_parent_19, _ew_before_20, () => [_ew_derived_4(), _ew_derived_10()?.cause], () => _ew_derived_4().failure(_ew_derived_10().cause));
+            }, (_ew_scope_1, _ew_parent_19, _ew_before_20) => {
+                _ew_dom.branch(_ew_scope_1, _ew_parent_19, _ew_before_20, () => _ew_scope_1.value.pending, (_ew_scope_1, _ew_parent_21, _ew_before_22) => {
+                    _ew_dom.branch(_ew_scope_1, _ew_parent_21, _ew_before_22, () => _ew_scope_1.value.visible, (_ew_scope_1, _ew_parent_23, _ew_before_24) => {
+                        _ew_dom.text(_ew_scope_1, _ew_parent_23, _ew_before_24, () => [_ew_derived_4()?.pending], () => _ew_derived_4().pending);
+                    }, (_ew_scope_1, _ew_parent_23, _ew_before_24) => { });
+                }, (_ew_scope_1, _ew_parent_21, _ew_before_22) => {
+                    _ew_dom.text(_ew_scope_1, _ew_parent_21, _ew_before_22, () => [_ew_derived_4()?.empty], () => _ew_derived_4().empty);
                 });
             });
         });

package/dist/actions.d.ts

@@ -18,7 +18,6 @@ type Creators<Handlers> = {
 type Dispatch<Handlers> = {
     [Name in keyof Handlers]: (...args: Arguments<Handlers[Name]>) => void;
 };
-/** Declare action names and payloads once. Dispatch still crosses the ordinary program message queue. */
 export declare function defineActions<Model>(): <Handlers extends Record<string, Handler<Model>>>(handlers: Handlers) => {
     message: Creators<Handlers>;
     bind(this: void, send: Send<HandlerMessage<Handlers>>): Dispatch<Handlers>;

package/dist/actions.js

@@ -1,4 +1,3 @@
-/** Declare action names and payloads once. Dispatch still crosses the ordinary program message queue. */
 export function defineActions() {
     return (handlers) => {
         const message = Object.create(null);

package/dist/cache.d.ts

@@ -13,7 +13,6 @@ declare function createQueryCache<R>(runtime?: UiRuntime<R>): {
     generation: Atom.Writable<number, number>;
     resource<A, E = unknown>(key: string, load: () => Effect.Effect<A, E>): Atom.Atom<AsyncResult.AsyncResult<A, E>>;
     query: <Args, A, E>(definition: Query<Args, A, E, R>, args: Args) => Atom.Atom<AsyncResult.AsyncResult<A, E>>;
-    /** Prefetch and views observe the same atom; failure types and shared cancellation remain intact. */
     prefetch<Args, A, E>(definition: Query<Args, A, E, R>, args: Args): Effect.Effect<A, E>;
     invalidateQuery<Args, A, E>(definition: Query<Args, A, E, R>, ...selected: [] | [Args]): void;
     invalidate(prefix: string): void;

package/dist/cache.js

@@ -13,7 +13,7 @@ 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 createQueryCache(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 createQueryCache(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 &&
@@ -65,7 +65,6 @@ function createQueryCache(runtime) {
             return acquire(key, load).atom;
         },
         query: selectQuery,
-        /** Prefetch and views observe the same atom; failure types and shared cancellation remain intact. */
         prefetch(definition, args) {
             return Effect.suspend(() => AtomRegistry.getResult(registry, selectQuery(definition, args), { suspendOnWaiting: true }));
         },

package/dist/collection.d.ts

@@ -1,5 +1,4 @@
 export type Identity = string | number;
-/** Identity belongs to the domain collection, not to each place that renders it. */
 export interface Rows<A> {
     readonly items: readonly A[];
     readonly identity: (item: A, index: number) => Identity;
@@ -10,6 +9,10 @@ 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[];
+    };
 };
 /** Use positional identity for ordered values without stable entity IDs. */
 export declare function sequence<A>(items: readonly A[]): 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,7 +17,48 @@ 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);
 /** Use positional identity for ordered values without stable entity IDs. */

package/dist/dom.d.ts

@@ -52,6 +52,8 @@ export declare function mountView<M, E>(parent: Node, definition: View<M, E>, so
 }): () => void;
 export declare function element(parent: Node, before: Node | null, tag: string): Element;
 export declare function attribute(element: Element, name: string, value: unknown): void;
+/** Compiler output for attributes whose unchanged value needs no DOM refresh. */
+export declare function bindAttribute<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown, source?: BindingSource): void;
 export declare function text<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, dependencies: Dependencies, read: () => unknown, source?: BindingSource): void;
 export declare function event<M, E>(scope: Scope<M, E>, element: Element, name: string, handler: (event: Event) => unknown): void;
 export declare function branch<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, choose: () => boolean, yes: Build<M, E>, no: Build<M, E>): void;
@@ -61,6 +63,6 @@ export declare function child<M, E, C, F>(scope: Scope<M, E>, parent: Node, befo
 export declare function attach<M, E>(scope: Scope<M, E>, element: Element, dependencies: Dependencies, read: () => DomMount | undefined): void;
 export declare function portal<M, E>(scope: Scope<M, E>, build: Build<M, E>): void;
 /** Build static markup once per document/namespace, then clone native nodes at each use. */
-export declare function template(build: (parent: Node, before: Node | null) => void): (parent: Node, before: Node | null) => void;
+export declare function template(build: string | ((parent: Node, before: Node | null) => void), depth?: number): (parent: Node, before: Node | null) => Node;
 export declare function literal(parent: Node, before: Node | null, value: string): void;
 export {};

package/dist/dom.js

@@ -325,6 +325,29 @@ export function attribute(element, name, value) {
     if (name === 'style' && (value == null || typeof value !== 'object'))
         styleProperties.delete(element);
 }
+/** Compiler output for attributes whose unchanged value needs no DOM refresh. */
+export function bindAttribute(scope, element, name, dependencies, read, source) {
+    let previous = dependencies();
+    let value = read();
+    attribute(element, name, value);
+    traceBinding(source, undefined, previous, 'binding');
+    if (!previous.length)
+        return;
+    // Keep the value cache in the dependency job itself, without an extra closure
+    // for every row. Controlled input properties keep using ordinary watches.
+    scope.jobs.push(() => {
+        const next = dependencies();
+        if (equal(previous, next))
+            return;
+        const nextValue = read();
+        if (!Object.is(value, nextValue)) {
+            attribute(element, name, nextValue);
+            value = nextValue;
+        }
+        traceBinding(source, previous, next, 'binding');
+        previous = next;
+    });
+}
 export function text(scope, parent, before, dependencies, read, source) {
     const node = document.createTextNode('');
     parent.insertBefore(node, before);
@@ -430,10 +453,31 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
         const next = read();
         const nextOuter = outer();
         const outerChanged = !equal(previousOuter, nextOuter);
-        if (next === previousList && !outerChanged)
+        if (next === previousList) {
+            if (outerChanged)
+                for (const row of rows.values())
+                    row.scope.set(row.scope.value);
+            previousOuter = nextOuter;
             return;
+        }
         const collection = 'items' in next ? next : undefined;
         const items = collection ? collection.items : next;
+        // A list filling its container can clear the DOM in one operation. Root lists
+        // and lists with adjacent content retain their bounded per-row removal path.
+        if (!items.length &&
+            rows.size &&
+            target instanceof Element &&
+            target.firstChild === rows.get(previousIdentities[0])?.start &&
+            target.lastChild === end) {
+            for (const row of rows.values())
+                row.scope.dispose();
+            target.replaceChildren(end);
+            rows.clear();
+            previousList = next;
+            previousOuter = nextOuter;
+            previousIdentities = [];
+            return;
+        }
         const identities = items.map((item, index) => {
             const key = collection ? collection.identity(item, index) : item;
             if (typeof key !== 'string' && typeof key !== 'number')
@@ -593,8 +637,30 @@ export function portal(scope, build) {
     build(child, host, null);
     scope.jobs.push(() => child.set(scope.value));
 }
+// HTML parsing supplies the initial nodes. Unusual placements, such as mounting
+// an HTML-named view inside SVG, still follow the same namespace rules as element().
+function placeTemplate(parent, node) {
+    if (node.nodeType !== 1) {
+        parent.appendChild(node);
+        return;
+    }
+    const source = node;
+    const namespace = source.localName === 'svg' || svgChildren(parent)
+        ? svgNamespace
+        : 'http://www.w3.org/1999/xhtml';
+    if (source.namespaceURI === namespace) {
+        parent.appendChild(source);
+        return;
+    }
+    const target = element(parent, null, source.localName);
+    for (const attr of source.attributes)
+        target.setAttribute(attr.name, attr.value);
+    while (source.firstChild)
+        placeTemplate(target, source.firstChild);
+    source.remove();
+}
 /** Build static markup once per document/namespace, then clone native nodes at each use. */
-export function template(build) {
+export function template(build, depth = 0) {
     const documents = new WeakMap();
     return (parent, before) => {
         const doc = parent.ownerDocument ?? document;
@@ -609,7 +675,16 @@ export function template(build) {
             const host = svg
                 ? doc.createElementNS('http://www.w3.org/2000/svg', 'svg')
                 : doc.createElement('div');
-            build(host, null);
+            if (typeof build === 'string') {
+                const source = doc.createElement('template');
+                source.innerHTML = build;
+                let node = source.content.firstChild;
+                for (let index = 0; index < depth; index++)
+                    node = node.firstChild;
+                placeTemplate(host, node);
+            }
+            else
+                build(host, null);
             if (host.firstChild && !host.firstChild.nextSibling) {
                 fragment = host.removeChild(host.firstChild);
             }
@@ -620,7 +695,9 @@ export function template(build) {
             }
             variants.set(svg, fragment);
         }
-        parent.insertBefore(fragment.cloneNode(true), before);
+        const clone = fragment.cloneNode(true);
+        parent.insertBefore(clone, before);
+        return clone;
     };
 }
 export function literal(parent, before, value) {

package/dist/load.d.ts

@@ -1,5 +1,4 @@
 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. */

package/dist/owner.js

@@ -3,7 +3,6 @@ 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;
@@ -85,7 +84,6 @@ export function modelOwner(initial, options = {}) {
         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);
             }

package/dist/pages.d.ts

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

package/dist/pages.js

@@ -87,7 +87,6 @@ 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),

package/dist/program.d.ts

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

package/dist/program.js

@@ -2,8 +2,6 @@ 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';
-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)) };
@@ -19,7 +17,6 @@ export function mapCommand(command, map) {
         ? { 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 checkSnapshots = options.checkSnapshots ?? checkSnapshotsByDefault;
     const id = nextProgramId();
@@ -46,9 +43,10 @@ export function program(options) {
             }
         }
     };
-    const registry = AtomRegistry.make();
-    const atom = Atom.make(protectSnapshot(options.initial, checkSnapshots));
-    const release = registry.mount(atom);
+    // A program publishes one immutable value. It needs no reactive dependency graph;
+    // Effect still owns all command fibers, streams, and cancellation below.
+    let current = protectSnapshot(options.initial, checkSnapshots);
+    const listeners = new Set();
     const running = new Map();
     let disposed = false;
     let draining = false;
@@ -71,11 +69,16 @@ export function program(options) {
         try {
             while (queue.length && !disposed) {
                 const message = queue.shift();
-                const transition = options.update(registry.get(atom), message);
+                const transition = options.update(current, message);
                 trace('update', undefined, message);
                 for (const slot of transition.cancel ?? [])
                     cancel(slot);
-                registry.set(atom, protectSnapshot(transition.model, checkSnapshots));
+                const next = protectSnapshot(transition.model, checkSnapshots);
+                if (!Object.is(current, next)) {
+                    current = next;
+                    for (const listener of listeners)
+                        listener(current);
+                }
                 for (const command of transition.commands ?? []) {
                     if (disposed)
                         break;
@@ -124,7 +127,7 @@ export function program(options) {
         }
     };
     return {
-        model: () => registry.get(atom),
+        model: () => current,
         activeSlots: () => [...running.keys()],
         awaitIdle: (slot) => disposed || (!draining && (slot ? !running.has(slot) : running.size === 0))
             ? Promise.resolve()
@@ -132,14 +135,22 @@ export function program(options) {
                 waiters.add({ slot, done });
             }),
         send,
-        subscribe: (listener) => registry.subscribe(atom, (model) => {
-            try {
-                listener(model);
-            }
-            catch (error) {
-                reportSafely(options.onDefect ?? reportError, error);
-            }
-        }),
+        subscribe(listener) {
+            if (disposed)
+                return () => { };
+            const receive = (model) => {
+                try {
+                    listener(model);
+                }
+                catch (error) {
+                    reportSafely(options.onDefect ?? reportError, error);
+                }
+            };
+            listeners.add(receive);
+            return () => {
+                listeners.delete(receive);
+            };
+        },
         dispose() {
             if (disposed)
                 return;
@@ -147,8 +158,7 @@ export function program(options) {
             queue.length = 0;
             for (const slot of running.keys())
                 cancel(slot);
-            release();
-            registry.dispose();
+            listeners.clear();
             trace('dispose');
             notify();
         },

package/dist/query.d.ts

@@ -1,5 +1,4 @@
 import type { Effect } from 'effect';
-/** One logical read. Share its definition between consumers, prefetching and mutations. */
 export interface Query<Args, A, E = never, R = never> {
     readonly id: number;
     readonly name: string;
@@ -7,16 +6,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. 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/session.d.ts

@@ -2,7 +2,6 @@ import type { Query } from './query.js';
 import type { DisposableOwner } from './owner.js';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 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;
@@ -27,7 +26,6 @@ export declare function queryResource<Args, A, E, R>(context: {
     refresh: () => void;
     dispose: () => void;
 };
-/** 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>;
@@ -48,7 +46,6 @@ interface OwnedSession {
     refresh?(): void;
     subscribe?(changed: () => void): () => void;
 }
-/** One declaration owns subscriptions, refresh order and disposal for a group of sessions. */
 export declare function sessionGroup(sessions: readonly OwnedSession[], changed: () => void): {
     refresh: () => void;
     dispose: () => void;

package/dist/session.js

@@ -1,7 +1,6 @@
 import { runAll, reportError, reportSafely } from './errors.js';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import * as Atom from 'effect/unstable/reactivity/Atom';
-/** Own subscriptions, DOM adapters and other cleanup for one lifetime. */
 export function lifetime() {
     const cleanups = [];
     let disposed = false;
@@ -154,7 +153,6 @@ export function queryResource(context, definition) {
         },
     };
 }
-/** 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);
@@ -180,7 +178,6 @@ export function projectionCache() {
         select,
     };
 }
-/** One declaration owns subscriptions, refresh order and disposal for a group of sessions. */
 export function sessionGroup(sessions, changed) {
     const scope = lifetime();
     for (const session of sessions) {

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/state.d.ts

@@ -1,2 +1 @@
-/** Shallow immutable update; unchanged fields preserve identity and skip publication. */
 export declare function patchModel<Model extends object>(model: Model, patch: Partial<NoInfer<Model>>): Model;

package/dist/state.js

@@ -1,4 +1,3 @@
-/** Shallow immutable update; unchanged fields preserve identity and skip publication. */
 export function patchModel(model, patch) {
     return Reflect.ownKeys(patch).some((key) => Object.prototype.propertyIsEnumerable.call(patch, key) &&
         (!Object.hasOwn(model, key) || !Object.is(model[key], patch[key])))

package/dist/testing.d.ts

@@ -1,7 +1,6 @@
 import { Effect } from 'effect';
 import type { RunningProgram } from './program.js';
 import { type UiRuntime } from './runtime.js';
-/** Drive the real queue. Test services and TestClock effects use the same supplied context. */
 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>): {

package/package.json

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