effectweb 0.2.3 → 0.3.1

package/dist/resource.d.ts

@@ -1,4 +1,4 @@
-import { Cause } from 'effect';
+import type { Snapshot } from './snapshot.js';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { UiLoad } from './load.js';
 import { type UiRuntime } from './runtime.js';
@@ -8,25 +8,19 @@ export interface ResourceModel<Props, A, E = unknown> {
     readonly key: string | undefined;
     readonly result: AsyncResult.AsyncResult<A, E>;
 }
-export type ResourceMessage<A, E = unknown> = {
+export type ResourceMessage = {
     type: 'Retry';
-} | {
-    type: 'Loaded';
-    value: A;
-} | {
-    type: 'Failed';
-    cause: Cause.Cause<E>;
 };
 export declare const available: <A>(result: AsyncResult.AsyncResult<A, unknown>) => A | undefined;
 export declare const resourceError: (result: AsyncResult.AsyncResult<unknown, unknown>) => string;
 /** A replaceable request owns one result. Key changes clear it; refreshes preserve the last success. */
 export declare function resourceComponent<Props, A, E = unknown, R = never>(definition: {
-    request: (props: Props) => {
+    request: (props: Snapshot<Props>) => {
         key: string;
         load: () => UiLoad<A, E, R>;
         delay?: number;
     } | undefined;
-    view: View<ResourceModel<Props, A, E>, ResourceMessage<A, E>>;
+    view: View<ResourceModel<Props, A, E>, ResourceMessage>;
 } & ([R] extends [never] ? {
     runtime?: UiRuntime<R>;
 } : {

package/dist/resource.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 { loadEffect } from './load.js';
 import { component } from './component.js';
 import { defaultUiRuntime } from './runtime.js';
 import { effectCommand } from './program.js';
+const commandLoad = commandSlot('load');
 export const available = (result) => Option.getOrUndefined(AsyncResult.value(result));
 export const resourceError = (result) => {
     if (!AsyncResult.isFailure(result))
@@ -21,7 +23,7 @@ export function resourceComponent(definition) {
         if (!selected)
             return {
                 model: { ...model, key: undefined, result: AsyncResult.initial() },
-                cancel: ['load'],
+                cancel: [commandLoad],
             };
         return {
             model: {
@@ -30,9 +32,10 @@ export function resourceComponent(definition) {
                 result: AsyncResult.waiting(selected.key === model.key ? model.result : AsyncResult.initial()),
             },
             commands: [
-                effectCommand('load', () => runtime.provide(selected.delay
+                effectCommand(commandLoad, () => runtime.provide(selected.delay
                     ? Effect.sleep(selected.delay).pipe(Effect.andThen(loadEffect(selected.load)))
                     : loadEffect(selected.load)), {
+                    policy: 'replace',
                     onSuccess: (value) => ({ type: 'Loaded', value }),
                     onFailure: (cause) => ({ type: 'Failed', cause }),
                 }),
@@ -40,9 +43,15 @@ export function resourceComponent(definition) {
         };
     };
     return component({
-        init: (props) => ({ props, key: undefined, result: AsyncResult.initial() }),
-        receive: (model, props) => request({ ...model, props }),
-        update: (model, message) => {
+        init: (props) => ({
+            props: props,
+            key: undefined,
+            result: AsyncResult.initial(),
+        }),
+        receive: (model, props) => request({ ...model, props: props }),
+        update: (snapshot, message) => {
+            // Internal commands preserve domain types; the public reducer boundary is immutable.
+            const model = snapshot;
             switch (message.type) {
                 case 'Retry':
                     return request(model, true);

package/dist/runtime.d.ts

@@ -7,10 +7,9 @@ export interface UiRuntime<R> {
     readonly provide: <A, E>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E>;
     readonly command: <M>(command: Command<M, R>) => Command<M>;
     readonly program: <M, Msg>(options: {
-        initial: M;
+        initial: M | Snapshot<M>;
         update: (model: Snapshot<M>, message: Msg) => Transition<M, Msg, R>;
         name?: string;
-        checkSnapshots?: boolean;
         onDefect?: (cause: unknown) => void;
     }) => RunningProgram<M, Msg>;
 }

package/dist/runtime.js

@@ -3,10 +3,10 @@ import { program } from './program.js';
 export function uiRuntime(context) {
     const provide = (effect) => Effect.provideContext(effect, context);
     const command = (value) => value.stream
-        ? { slot: value.slot, stream: value.stream.pipe(Stream.provideContext(context)) }
+        ? { ...value, stream: value.stream.pipe(Stream.provideContext(context)) }
         : value.action
-            ? { slot: value.slot, action: provide(value.action) }
-            : { slot: value.slot, effect: provide(value.effect) };
+            ? { ...value, action: provide(value.action) }
+            : { ...value, effect: provide(value.effect) };
     return {
         context,
         provide,

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,11 @@ 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 &&
+        !internal.disposed() &&
+        generation === internal.registry.get(internal.generation)
+        ? internal.registry.get(atom)
         : initial;
     let published;
     let notifying = false;
@@ -69,7 +75,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 +94,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;
@@ -99,23 +105,28 @@ export function queryResource(context, definition) {
     });
     return {
         select(args) {
-            if (disposed)
+            if (disposed || internal.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 releaseUse = internal.retain(nextAtom);
+                const unsubscribe = internal.registry.subscribe(nextAtom, notify);
+                const release = () => {
+                    unsubscribe();
+                    releaseUse();
+                };
                 if (disposed || selected !== revision) {
                     release();
                     return;
@@ -136,9 +147,10 @@ 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);
+                !internal.disposed() &&
+                generation === internal.registry.get(internal.generation) &&
+                !internal.registry.get(atom).waiting)
+                internal.refresh(atom);
         },
         dispose: () => {
             if (disposed)

package/dist/settlement.d.ts

@@ -0,0 +1,7 @@
+/** Internal completion accounting, including reentrant acquisition before a fiber is available. */
+export declare class Settlement {
+    private pending;
+    private waiters;
+    begin(): () => void;
+    wait(): Promise<void>;
+}

package/dist/settlement.js

@@ -0,0 +1,27 @@
+/** Internal completion accounting, including reentrant acquisition before a fiber is available. */
+export class Settlement {
+    pending = 0;
+    waiters = [];
+    begin() {
+        this.pending++;
+        let finished = false;
+        return () => {
+            if (finished)
+                return;
+            finished = true;
+            if (--this.pending)
+                return;
+            for (const done of this.waiters)
+                done();
+            this.waiters.length = 0;
+        };
+    }
+    wait() {
+        return new Promise((done) => {
+            if (this.pending)
+                this.waiters.push(done);
+            else
+                done();
+        });
+    }
+}

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,96 @@
+// 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 changed;
+    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);
+        if (!Object.hasOwn(old, key) || !Object.is(item, old[key]))
+            equal = false;
+        if (!Object.is(item, value[key]))
+            (changed ??= new Map()).set(key, item);
+    }
+    let result = equal ? previous : next;
+    if (!equal && changed) {
+        const shared = array ? [] : {};
+        if (array)
+            shared.length = value.length;
+        for (const key of keys)
+            Object.defineProperty(shared, key, {
+                value: changed.has(key) ? changed.get(key) : value[key],
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        result = shared;
+    }
+    if (fields)
+        return result;
+    if (!pairs) {
+        pairs = new WeakMap();
+        sharedPairs.set(previous, pairs);
+    }
+    pairs.set(next, result);
+    return result;
+}

package/dist/slotIdentity.d.ts

@@ -0,0 +1 @@
+export declare const compiledSlots: WeakSet<object>;

package/dist/slotIdentity.js

@@ -0,0 +1,2 @@
+// Shared only by compiler runtime helpers; user functions cannot acquire this proof.
+export const compiledSlots = new WeakSet();

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,31 +1,38 @@
 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);
+/** Protect published plain data in every build. Opaque objects keep their own lifecycle. */
+export function protectSnapshot(value) {
+    const seen = new Set();
+    const plain = [];
+    const validate = (item) => {
+        if (!item || typeof item !== 'object' || checked.has(item) || seen.has(item))
+            return;
+        seen.add(item);
+        // Effect wrappers remain opaque, but their successful UI data is plain data.
+        if (isAsyncResult(item)) {
+            if (item._tag === 'Success')
+                validate(item.value);
+            else if (item._tag === 'Failure' && item.previousSuccess._tag === 'Some')
+                validate(item.previousSuccess.value);
+            return;
+        }
+        const prototype = Object.getPrototypeOf(item);
+        if (!Array.isArray(item) && prototype !== Object.prototype && prototype !== null)
+            return;
+        for (const key of Reflect.ownKeys(item)) {
+            const descriptor = Object.getOwnPropertyDescriptor(item, key);
+            if (!Object.hasOwn(descriptor, 'value'))
+                throw new Error(`Snapshot data cannot contain an accessor (${String(key)}). Materialize its value before publication; keep services in opaque instances.`);
+            validate(descriptor.value);
+        }
+        plain.push(item);
+    };
+    // Validate the complete graph before caching any proof. A rejected cyclic graph
+    // must not make a later publication skip validation through a previously seen child.
+    validate(value);
+    for (const item of plain)
+        Object.freeze(item);
+    for (const item of seen)
+        checked.add(item);
     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;