effectweb 0.2.3 → 0.3.0

package/dist/session.d.ts

@@ -1,4 +1,5 @@
-import type { Query } from './query.js';
+import type { Snapshot } from './snapshot.js';
+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';
@@ -12,6 +13,14 @@ export interface SessionContext<R = never> {
     readonly cache: QueryCache<R>;
     readonly changed: () => void;
 }
+/** One owned selection and immutable observation of a shared query resource. */
+export interface QueryResource<Args, A, E = never> {
+    select(this: void, args: Args | Snapshot<Args> | undefined): void;
+    read(this: void): AsyncResult.AsyncResult<Snapshot<A>, E>;
+    subscribe(this: void, listener: (result: AsyncResult.AsyncResult<Snapshot<A>, E>) => void): () => void;
+    refresh(this: void): void;
+    dispose(this: void): void;
+}
 /**
  * Idempotent query reconciliation for snapshot ticks. Freshness is checked when entering a
  * selection (including remount), not on every same-key tick; refresh revalidates unless a request is already in flight.
@@ -19,20 +28,8 @@ export interface SessionContext<R = never> {
 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 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;
-};
+}, definition: Query<Args, A, E, NoInfer<R>>): QueryResource<Args, A, E>;
+export declare function observeQuery<Args, A, E, R>(owner: DisposableOwner, cache: QueryCache<R>, definition: Query<Args, A, E, NoInfer<R>>, changed: (result: AsyncResult.AsyncResult<Snapshot<A>, E>) => void): QueryResource<Args, A, E>;
 /** Application selectors run once per explicit input version, with optional prior output sharing. */
 export declare function projectionCache(): {
     invalidate: () => void;

package/dist/session.js

@@ -1,6 +1,8 @@
 import { runAll, reportError, reportSafely } from './errors.js';
+import { encodeQueryKey } from './query.js';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import * as Atom from 'effect/unstable/reactivity/Atom';
+import { cacheInternals } from './cache-internals.js';
 export function lifetime() {
     const cleanups = [];
     let disposed = false;
@@ -27,6 +29,7 @@ export function lifetime() {
  * selection (including remount), not on every same-key tick; refresh revalidates unless a request is already in flight.
  */
 export function queryResource(context, definition) {
+    const internal = cacheInternals(context.cache);
     let key;
     let generation = -1;
     let atom;
@@ -35,8 +38,8 @@ export function queryResource(context, definition) {
     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)
+    const read = () => atom && !disposed && generation === internal.registry.get(internal.generation)
+        ? internal.registry.get(atom)
         : initial;
     let published;
     let notifying = false;
@@ -69,7 +72,7 @@ export function queryResource(context, definition) {
                 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
+                // oxlint-disable-next-line unicorn/no-useless-spread -- Iterate a snapshot because listeners can add or remove subscriptions.
                 for (const listener of [...listeners]) {
                     if (disposed || selected !== revision || result !== read())
                         break;
@@ -88,8 +91,8 @@ export function queryResource(context, definition) {
         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, () => {
+    internal.registry.get(internal.generation);
+    const stopGeneration = internal.registry.subscribe(internal.generation, () => {
         revision++;
         disconnect();
         atom = undefined;
@@ -101,21 +104,21 @@ export function queryResource(context, definition) {
         select(args) {
             if (disposed)
                 return;
-            const nextGeneration = context.cache.registry.get(context.cache.generation);
-            const nextKey = args === undefined ? undefined : definition.key(args);
+            const nextGeneration = internal.registry.get(internal.generation);
+            const nextKey = args === undefined ? undefined : encodeQueryKey(args);
             if (nextKey === key && nextGeneration === generation)
                 return;
             const selected = ++revision;
             disconnect();
             key = nextKey;
             generation = nextGeneration;
-            const nextAtom = args === undefined ? undefined : context.cache.query(definition, args);
+            const nextAtom = args === undefined ? undefined : internal.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);
+                const release = internal.registry.subscribe(nextAtom, notify);
                 if (disposed || selected !== revision) {
                     release();
                     return;
@@ -136,9 +139,9 @@ export function queryResource(context, definition) {
         refresh: () => {
             if (atom &&
                 !disposed &&
-                generation === context.cache.registry.get(context.cache.generation) &&
-                !context.cache.registry.get(atom).waiting)
-                context.cache.registry.refresh(atom);
+                generation === internal.registry.get(internal.generation) &&
+                !internal.registry.get(atom).waiting)
+                internal.registry.refresh(atom);
         },
         dispose: () => {
             if (disposed)

package/dist/share.d.ts

@@ -1,6 +1,7 @@
-/** Override sharing for selected fields, for example a collection keyed by domain identity. */
+import type { Snapshot } from './snapshot.js';
+/** Field sharers borrow both inputs; returned branches are published as readonly data. */
 export type ShareFields<T> = {
-    readonly [K in keyof T]?: (previous: T[K], next: T[K]) => T[K];
+    readonly [K in keyof T]?: (previous: Snapshot<T[K]>, next: Snapshot<T[K]>) => T[K] | Snapshot<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, fields?: ShareFields<T>): T;
+/** Borrow shared immutable data. The result may retain either input and its nested branches. */
+export declare function shareValue<T>(previous: T | Snapshot<T>, next: T | Snapshot<T>, fields?: ShareFields<T>): Snapshot<T>;

package/dist/share.js

@@ -1,46 +1,7 @@
-// Immutable snapshots can reach the renderer through several projections. Reuse an
-// 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. */
+import { shareData } from './sharing.js';
+/** Borrow shared immutable data. The result may retain either input and its nested branches. */
 export function shareValue(previous, next, fields) {
-    if (Object.is(previous, next))
-        return previous;
-    if (!previous || !next || typeof previous !== 'object' || typeof next !== 'object')
-        return next;
-    const array = Array.isArray(next);
-    if (array !== Array.isArray(previous))
-        return next;
-    if (!array &&
-        (Object.getPrototypeOf(next) !== Object.prototype ||
-            Object.getPrototypeOf(previous) !== Object.prototype))
-        return next;
-    let pairs = sharedPairs.get(previous);
-    if (!fields && pairs?.has(next))
-        return pairs.get(next);
-    const old = previous;
-    const value = next;
-    const keys = Object.keys(value);
-    let equal = keys.length === Object.keys(old).length;
-    let unchangedNext = true;
-    const shared = array ? [] : {};
-    for (const key of keys) {
-        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);
-    }
-    pairs.set(next, result);
-    return result;
+    // Snapshot changes access permissions, not representation. The private algorithm only
+    // borrows data; this boundary never exposes mutable aliases to its retained branches.
+    return shareData(previous, next, fields);
 }

package/dist/sharing.d.ts

@@ -0,0 +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 immutable plain data; opaque objects, accessors, hidden fields and cycles retain next. */
+export declare function shareData<T>(previous: T, next: T, fields?: ShareFields<T>): T;

package/dist/sharing.js

@@ -0,0 +1,93 @@
+// Internal representation-level sharing. Public callers borrow through share.ts.
+// Immutable snapshots can reach the renderer through several projections. Reuse an
+// already compared object pair without retaining either snapshot after its owners release it.
+const sharedPairs = new WeakMap();
+const cyclicData = new WeakMap();
+function cyclic(value, active) {
+    const cached = cyclicData.get(value);
+    if (cached !== undefined)
+        return cached;
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) && prototype !== Object.prototype)
+        return false;
+    if (active.has(value))
+        return true;
+    active.add(value);
+    const found = Reflect.ownKeys(value).some((key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        const child = descriptor.value;
+        return child !== null && typeof child === 'object' && cyclic(child, active);
+    });
+    active.delete(value);
+    cyclicData.set(value, found);
+    return found;
+}
+/** Share immutable plain data; opaque objects, accessors, hidden fields and cycles retain next. */
+export function shareData(previous, next, fields) {
+    if (Object.is(previous, next))
+        return previous;
+    // Check the entire next graph, including new branches with no previous counterpart.
+    // Otherwise a partial clone could keep a back-reference to the unshared root.
+    if (next && typeof next === 'object' && cyclic(next, new Set()))
+        return next;
+    return share(previous, next, fields);
+}
+function share(previous, next, fields) {
+    if (Object.is(previous, next))
+        return previous;
+    if (!previous || !next || typeof previous !== 'object' || typeof next !== 'object')
+        return next;
+    const array = Array.isArray(next);
+    if (array !== Array.isArray(previous))
+        return next;
+    if (!array &&
+        (Object.getPrototypeOf(next) !== Object.prototype ||
+            Object.getPrototypeOf(previous) !== Object.prototype))
+        return next;
+    let pairs = sharedPairs.get(previous);
+    if (!fields && pairs?.has(next))
+        return pairs.get(next);
+    const old = previous;
+    const value = next;
+    const keys = Object.keys(value);
+    const oldKeys = Object.keys(old);
+    // Symbol and nonenumerable fields are outside the plain-data sharing contract.
+    // Returning next preserves them instead of accidentally claiming value equality.
+    const extra = array ? 1 : 0; // Array length is nonenumerable.
+    if (Reflect.ownKeys(next).length !== keys.length + extra ||
+        Reflect.ownKeys(previous).length !== oldKeys.length + extra ||
+        keys.some((key) => !Object.hasOwn(Object.getOwnPropertyDescriptor(next, key), 'value')) ||
+        oldKeys.some((key) => !Object.hasOwn(Object.getOwnPropertyDescriptor(previous, key), 'value')))
+        return next;
+    let equal = keys.length === oldKeys.length && (!array || value.length === old.length);
+    let unchangedNext = true;
+    const shared = array ? [] : {};
+    if (array)
+        shared.length = value.length;
+    for (const key of keys) {
+        const custom = fields && Object.hasOwn(fields, key) ? fields[key] : undefined;
+        const item = custom && Object.hasOwn(old, key)
+            ? custom(old[key], value[key])
+            : share(Object.hasOwn(old, key) ? old[key] : undefined, value[key], undefined);
+        // Define an own data property, including __proto__, without invoking setters.
+        Object.defineProperty(shared, key, {
+            value: item,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+        if (!Object.hasOwn(old, key) || !Object.is(item, old[key]))
+            equal = false;
+        if (!Object.is(item, value[key]))
+            unchangedNext = false;
+    }
+    const result = equal ? previous : unchangedNext ? next : shared;
+    if (fields)
+        return result;
+    if (!pairs) {
+        pairs = new WeakMap();
+        sharedPairs.set(previous, pairs);
+    }
+    pairs.set(next, result);
+    return result;
+}

package/dist/snapshot.d.ts

@@ -1,5 +1,16 @@
-/** 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;
+import type { Effect } from 'effect';
+import type * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
+/** Mark an application service as opaque to snapshot typing; this is a type-only brand. */
+export declare const snapshotOpaque: unique symbol;
+export interface SnapshotOpaque {
+    readonly [snapshotOpaque]?: true;
+}
+/** Recursively immutable published data. Effects, functions and external resources retain their API. */
+export type Snapshot<T> = ImmutableValue<T>;
+type SnapshotRecord<T> = {
+    readonly [K in keyof T]: ImmutableValue<T[K]>;
+};
+type ImmutableValue<T> = T extends string | number | bigint | boolean | symbol | null | undefined ? T : T extends (...args: never[]) => unknown ? T : typeof snapshotOpaque extends keyof T ? symbol extends keyof T ? SnapshotRecord<T> : T : T extends AsyncResult.AsyncResult<infer A, infer E> ? AsyncResult.With<T, ImmutableValue<A>, E> : T extends Effect.Effect<unknown, unknown, unknown> | Date | RegExp | Error | PromiseLike<unknown> | Node | EventTarget | Blob | ArrayBuffer | ArrayBufferView ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<ImmutableValue<K>, ImmutableValue<V>> : T extends ReadonlySet<infer A> ? ReadonlySet<ImmutableValue<A>> : T extends object ? SnapshotRecord<T> : T;
+/** Protect published plain data in every build. Opaque objects keep their own lifecycle. */
+export declare function protectSnapshot<T>(value: T): T;
+export {};

package/dist/snapshot.js

@@ -1,17 +1,16 @@
 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))
+/** Protect published plain data in every build. Opaque objects keep their own lifecycle. */
+export function protectSnapshot(value) {
+    if (!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);
+            protectSnapshot(value.value);
         else if (value._tag === 'Failure' && value.previousSuccess._tag === 'Some')
-            protectSnapshot(value.previousSuccess.value, true);
+            protectSnapshot(value.previousSuccess.value);
         return value;
     }
     const prototype = Object.getPrototypeOf(value);
@@ -24,7 +23,7 @@ export function protectSnapshot(value, enabled) {
         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);
+            protectSnapshot(descriptor.value);
     }
     Object.freeze(value);
     return value;

package/dist/svg-attributes.d.ts

@@ -0,0 +1,12 @@
+/** SVG content and presentation attributes, including Filter Effects and SMIL.
+ * https://svgwg.org/svg2-draft/attindex.html
+ * Browser spellings are preserved: animated IDL objects are never assigned as attributes.
+ */
+export type SvgAttributes = Partial<Record<'accumulate' | 'additive' | 'alignment-baseline' | 'amplitude' | 'attributeName' | 'attributeType' | 'azimuth' | 'baseFrequency' | 'baseline-shift' | 'begin' | 'bias' | 'by' | 'calcMode' | 'clip' | 'clip-path' | 'clip-rule' | 'clipPathUnits' | 'color' | 'color-interpolation' | 'color-interpolation-filters' | 'crossorigin' | 'cursor' | 'cx' | 'cy' | 'd' | 'diffuseConstant' | 'direction' | 'display' | 'divisor' | 'dominant-baseline' | 'dur' | 'dx' | 'dy' | 'edgeMode' | 'elevation' | 'end' | 'exponent' | 'fill' | 'fill-opacity' | 'fill-rule' | 'filter' | 'filterUnits' | 'flood-color' | 'flood-opacity' | 'font-family' | 'font-size' | 'font-size-adjust' | 'font-stretch' | 'font-style' | 'font-variant' | 'font-weight' | 'fr' | 'from' | 'fx' | 'fy' | 'glyph-orientation-horizontal' | 'glyph-orientation-vertical' | 'gradientTransform' | 'gradientUnits' | 'height' | 'href' | 'hreflang' | 'image-rendering' | 'in' | 'in2' | 'intercept' | 'k1' | 'k2' | 'k3' | 'k4' | 'kernelMatrix' | 'kernelUnitLength' | 'keyPoints' | 'keySplines' | 'keyTimes' | 'lang' | 'lengthAdjust' | 'letter-spacing' | 'lighting-color' | 'limitingConeAngle' | 'marker-end' | 'marker-mid' | 'marker-start' | 'markerHeight' | 'markerUnits' | 'markerWidth' | 'mask' | 'mask-type' | 'maskContentUnits' | 'maskUnits' | 'max' | 'media' | 'method' | 'min' | 'mode' | 'numOctaves' | 'offset' | 'opacity' | 'operator' | 'order' | 'orient' | 'origin' | 'overflow' | 'paint-order' | 'path' | 'pathLength' | 'patternContentUnits' | 'patternTransform' | 'patternUnits' | 'ping' | 'pointer-events' | 'points' | 'pointsAtX' | 'pointsAtY' | 'pointsAtZ' | 'preserveAspectRatio' | 'primitiveUnits' | 'r' | 'radius' | 'refX' | 'refY' | 'repeatCount' | 'repeatDur' | 'requiredExtensions' | 'restart' | 'result' | 'rotate' | 'rx' | 'ry' | 'scale' | 'seed' | 'shape-rendering' | 'side' | 'slope' | 'spacing' | 'specularConstant' | 'specularExponent' | 'spreadMethod' | 'startOffset' | 'stdDeviation' | 'stitchTiles' | 'stop-color' | 'stop-opacity' | 'stroke' | 'stroke-dasharray' | 'stroke-dashoffset' | 'stroke-linecap' | 'stroke-linejoin' | 'stroke-miterlimit' | 'stroke-opacity' | 'stroke-width' | 'surfaceScale' | 'systemLanguage' | 'tableValues' | 'target' | 'targetX' | 'targetY' | 'text-anchor' | 'text-decoration' | 'text-rendering' | 'textLength' | 'to' | 'transform' | 'transform-origin' | 'type' | 'unicode-bidi' | 'values' | 'vector-effect' | 'viewBox' | 'visibility' | 'width' | 'word-spacing' | 'writing-mode' | 'x' | 'x1' | 'x2' | 'xChannelSelector' | 'xmlns' | 'y' | 'y1' | 'y2' | 'yChannelSelector' | 'z', string | number | undefined>> & {
+    /** SVG uses an enumerated string here, not an HTML presence attribute. */
+    preserveAlpha?: 'true' | 'false' | undefined;
+};
+/** Presentation attributes shared by SVG tags whose names also exist in HTML.
+ * https://svgwg.org/svg2-draft/styling.html#PresentationAttributes
+ */
+export type SvgPresentationAttributes = Pick<SvgAttributes, 'alignment-baseline' | 'baseline-shift' | 'clip' | 'clip-path' | 'clip-rule' | 'color' | 'color-interpolation' | 'color-interpolation-filters' | 'cursor' | 'direction' | 'display' | 'dominant-baseline' | 'fill' | 'fill-opacity' | 'fill-rule' | 'filter' | 'flood-color' | 'flood-opacity' | 'font-family' | 'font-size' | 'font-size-adjust' | 'font-stretch' | 'font-style' | 'font-variant' | 'font-weight' | 'glyph-orientation-horizontal' | 'glyph-orientation-vertical' | 'image-rendering' | 'letter-spacing' | 'lighting-color' | 'marker-end' | 'marker-mid' | 'marker-start' | 'mask' | 'mask-type' | 'opacity' | 'overflow' | 'paint-order' | 'pointer-events' | 'shape-rendering' | 'stop-color' | 'stop-opacity' | 'stroke' | 'stroke-dasharray' | 'stroke-dashoffset' | 'stroke-linecap' | 'stroke-linejoin' | 'stroke-miterlimit' | 'stroke-opacity' | 'stroke-width' | 'text-anchor' | 'text-decoration' | 'text-rendering' | 'transform' | 'transform-origin' | 'unicode-bidi' | 'vector-effect' | 'visibility' | 'word-spacing' | 'writing-mode'>;

package/dist/svg-attributes.js

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

package/dist/task.d.ts

@@ -1,7 +1,8 @@
+import type { Snapshot } from './snapshot.js';
 import { Effect } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { View } from './dom.js';
-import { type Send } from './program.js';
+import { type Send, type TaskPolicy } from './program.js';
 import { type UiRuntime } from './runtime.js';
 export type TaskModel<Props, State, A, E = unknown> = State & {
     readonly props: Props;
@@ -12,7 +13,7 @@ export type TaskMessage<State, Input> = {
     input: Input;
 } | {
     type: 'Fields';
-    fields: Partial<State> & {
+    fields: (Partial<State> | Partial<Snapshot<State>>) & {
         props?: never;
         task?: never;
     };
@@ -25,16 +26,16 @@ export type TaskMessage<State, Input> = {
  * defineTasks(...).tasks(...).view(view(...)) to establish inference before JSX.
  */
 export declare function taskComponent<Props, State extends object, Input, A, E = unknown, R = never>(definition: {
-    init: (props: Props) => State & {
+    init: (props: Snapshot<Props>) => (State | Snapshot<State>) & {
         props?: never;
         task?: never;
     };
-    identity?: (props: Props) => unknown;
+    identity?: (props: Snapshot<Props>) => unknown;
     task: {
-        policy: 'drop' | 'replace';
-        run: (model: State & {
+        policy: Exclude<TaskPolicy, 'parallel'>;
+        run: (model: Snapshot<State & {
             readonly props: Props;
-        }, input: Input) => Effect.Effect<A, E, R>;
+        }>, input: Input) => Effect.Effect<A, E, R>;
     };
     view: View<TaskModel<Props, State, A, E>, TaskMessage<State, Input>>;
 } & ([R] extends [never] ? {
@@ -45,7 +46,7 @@ export declare function taskComponent<Props, State extends object, Input, A, E =
 /** Stable methods when bound once in a compiled view's const declaration. */
 export declare function taskControls<State, Input>(send: Send<TaskMessage<State, Input>>): {
     run: (input: Input) => void;
-    patch: (fields: Partial<State> & {
+    patch: (fields: (Partial<State> | Partial<Snapshot<State>>) & {
         props?: never;
         task?: never;
     }) => void;

package/dist/task.js

@@ -1,9 +1,11 @@
+import { commandSlot } from './program.js';
 import { Cause, Effect, Option } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
-import { component } from './component.js';
-import { effectCommand } from './program.js';
+import { programView } from './component.js';
+import { effectCommand, } from './program.js';
 import { patchModel } from './state.js';
 import { defaultUiRuntime } from './runtime.js';
+const commandTask = commandSlot('task');
 /**
  * One owned async action and local editable fields; policy is part of its public behavior.
  * Compatibility factory for existing single-task components. New components can use
@@ -11,52 +13,78 @@ import { defaultUiRuntime } from './runtime.js';
  */
 export function taskComponent(definition) {
     const runtime = definition.runtime ?? defaultUiRuntime;
-    const init = (props) => ({
-        ...definition.init(props),
-        props,
-        task: AsyncResult.initial(),
-    });
-    return component({
-        init,
-        receive: (model, props) => definition.identity &&
-            !Object.is(definition.identity(model.props), definition.identity(props))
-            ? { model: init(props), cancel: ['task'] }
-            : { model: Object.is(model.props, props) ? model : { ...model, props } },
-        update: (model, message) => {
-            switch (message.type) {
-                case 'Fields': {
-                    const next = patchModel(model, message.fields);
-                    return {
-                        model: next === model ? model : { ...next, props: model.props, task: model.task },
-                    };
-                }
-                case 'Run':
-                    if (definition.task.policy === 'drop' && model.task.waiting)
-                        return { model };
-                    return {
-                        model: { ...model, task: AsyncResult.waiting(model.task) },
-                        commands: [
-                            effectCommand('task', () => runtime.provide(definition.task.run(model, message.input)), {
-                                onSuccess: (value) => ({ type: 'Succeeded', value }),
-                                onFailure: (cause) => ({ type: 'Failed', cause }),
-                            }),
-                        ],
-                    };
-                case 'Cancel':
-                    return { model: { ...model, task: AsyncResult.initial() }, cancel: ['task'] };
-                case 'Succeeded':
-                    return { model: { ...model, task: AsyncResult.success(message.value) } };
-                case 'Failed':
-                    return {
-                        model: {
-                            ...model,
-                            task: AsyncResult.failureWithPrevious(message.cause, {
-                                previous: Option.some(model.task),
-                            }),
-                        },
-                    };
-            }
+    const init = (props) => ({ ...definition.init(props), props, task: AsyncResult.initial() });
+    const owners = new WeakMap();
+    return programView({
+        create(props) {
+            const source = runtime.program({
+                initial: init(props),
+                update: (snapshot, message) => {
+                    // The public task receives the immutable snapshot; reconstruction stays internal.
+                    const model = snapshot;
+                    switch (message.type) {
+                        case 'Input':
+                            return definition.identity &&
+                                !Object.is(definition.identity(model.props), definition.identity(message.props))
+                                ? { model: init(message.props), cancel: [commandTask] }
+                                : {
+                                    model: Object.is(model.props, message.props)
+                                        ? model
+                                        : { ...model, props: message.props },
+                                };
+                        case 'Fields': {
+                            const next = patchModel(model, message.fields);
+                            return {
+                                model: next === model ? model : { ...next, props: model.props, task: model.task },
+                            };
+                        }
+                        case 'Run':
+                            if (definition.task.policy === 'drop' && model.task.waiting)
+                                return { model };
+                            return {
+                                model: { ...model, task: AsyncResult.waiting(model.task) },
+                                commands: [
+                                    {
+                                        ...effectCommand(commandTask, () => definition.task.run(snapshot, message.input), {
+                                            policy: definition.task.policy,
+                                            onSuccess: (value) => ({ type: 'Succeeded', value }),
+                                            onFailure: (cause) => ({ type: 'Failed', cause }),
+                                        }),
+                                        policy: definition.task.policy,
+                                    },
+                                ],
+                            };
+                        case 'Cancel':
+                            return {
+                                model: { ...model, task: AsyncResult.initial() },
+                                cancel: [commandTask],
+                            };
+                        case 'Succeeded':
+                            return {
+                                model: {
+                                    ...model,
+                                    task: AsyncResult.success(message.value, {
+                                        waiting: source.activeSlots().includes(commandTask),
+                                    }),
+                                },
+                            };
+                        case 'Failed':
+                            return {
+                                model: {
+                                    ...model,
+                                    task: AsyncResult.failureWithPrevious(message.cause, {
+                                        previous: Option.some(model.task),
+                                        waiting: source.activeSlots().includes(commandTask),
+                                    }),
+                                },
+                            };
+                    }
+                },
+            });
+            owners.set(source, source);
+            return source;
         },
+        receive: (source, props) => owners.get(source).send({ type: 'Input', props }),
         view: definition.view,
     });
 }