effectweb 0.2.3 → 0.3.0

package/dist/pages.js

@@ -1,8 +1,10 @@
-import { shareValue } from './share.js';
+import { commandSlot } from './program.js';
+import { shareData } from './sharing.js';
 import { Cause, Option } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
-import { effectCommand, program } from './program.js';
+import { effectCommand, program, } from './program.js';
 import { available } from './resource.js';
+const commandPage = commandSlot('page');
 /**
  * Pagination owns the `page` command slot. Key changes clear results and replace the request;
  * same-key refreshes keep the last success, and retries repeat the failed cursor.
@@ -19,7 +21,8 @@ export function pages(definition) {
         return {
             model: { ...model, append, result: AsyncResult.waiting(model.result) },
             commands: [
-                effectCommand('page', () => definition.load(model.props, cursor), {
+                effectCommand(commandPage, () => definition.load(model.props, cursor), {
+                    policy: 'replace',
                     onSuccess: (page) => ({ type: 'Loaded', page, append }),
                     onFailure: (cause) => ({ type: 'Failed', cause }),
                 }),
@@ -28,15 +31,17 @@ export function pages(definition) {
     };
     const pagination = {
         init: (props) => ({
-            props,
+            props: props,
             key: undefined,
             result: AsyncResult.initial(),
             append: false,
         }),
-        receive(model, props, options = {}) {
+        receive(snapshot, input, options = {}) {
+            const model = snapshot;
+            const props = input;
             const key = definition.key(props);
             if (key === model.key) {
-                const shared = shareValue(model.props, props);
+                const shared = shareData(model.props, props);
                 const next = shared === model.props ? model : { ...model, props: shared };
                 return options.refresh ? request(next, false) : { model: next };
             }
@@ -47,9 +52,10 @@ export function pages(definition) {
                 append: false,
                 result: AsyncResult.initial(),
             };
-            return key === undefined ? { model: next, cancel: ['page'] } : request(next, false);
+            return key === undefined ? { model: next, cancel: [commandPage] } : request(next, false);
         },
-        update(model, message) {
+        update(snapshot, message) {
+            const model = snapshot;
             switch (message.type) {
                 case 'More':
                     return request(model, true);
@@ -68,7 +74,7 @@ export function pages(definition) {
                     };
                 case 'Loaded': {
                     const previous = message.append ? available(model.result) : undefined;
-                    const known = new Set(previous?.items.map(definition.itemKey));
+                    const known = new Set(previous?.items.map((item) => definition.itemKey(item)));
                     const incoming = message.page.items.filter((item) => {
                         const key = definition.itemKey(item);
                         if (known.has(key))

package/dist/program.d.ts

@@ -1,9 +1,18 @@
 import { type Snapshot } from './snapshot.js';
 import { Cause, Effect, Stream } from 'effect';
 export type Send<Message> = (message: Message) => void;
+/** queue retains FIFO requests; latest-queued retains only the newest pending request. */
+export type TaskPolicy = 'replace' | 'drop' | 'parallel' | 'queue' | 'latest-queued';
+declare const slotType: unique symbol;
+/** Stable operation identity. Equal diagnostic names never share cancellation. */
+export type CommandSlot = symbol & {
+    readonly [slotType]: true;
+};
+export declare const commandSlot: (name: string) => CommandSlot;
 /** A slot owns either one completion or a stream of progress/events, canceled together. */
 export type Command<Message, R = never> = {
-    readonly slot: string;
+    readonly slot: CommandSlot;
+    readonly policy: TaskPolicy;
 } & ({
     readonly effect: Effect.Effect<Message, never, R>;
     readonly stream?: never;
@@ -18,17 +27,18 @@ export type Command<Message, R = never> = {
     readonly stream?: never;
 });
 /** A lazy request settles successes, typed failures and defects through one message contract. */
-export declare function effectCommand<A, E, Success, Failure, R = never>(slot: string, load: () => Effect.Effect<A, E, R>, handlers: {
+export declare function effectCommand<A, E, Success, Failure, R = never>(slot: CommandSlot, load: () => Effect.Effect<A, E, R>, handlers: {
+    readonly policy: TaskPolicy;
     readonly onSuccess: (value: A) => Success;
     readonly onFailure: (cause: Cause.Cause<E>) => Failure;
 }): Command<Success | Failure, R>;
 /** Owned work with no model result. Failures use the program's error reporter. */
-export declare function actionCommand<R = never>(slot: string, action: () => Effect.Effect<unknown, unknown, R>): Command<never, R>;
+export declare function actionCommand<R = never>(slot: CommandSlot, action: () => Effect.Effect<unknown, unknown, R>, policy: TaskPolicy): Command<never, R>;
 export declare function mapCommand<A, B, R = never>(command: Command<A, R>, map: (message: A) => B): Command<B, R>;
 export interface Transition<Model, Message, R = never> {
-    readonly model: Model;
+    readonly model: Model | Snapshot<Model>;
     readonly commands?: readonly Command<Message, R>[];
-    readonly cancel?: readonly string[];
+    readonly cancel?: readonly CommandSlot[];
 }
 export interface Program<Model, Message> {
     readonly model: () => Snapshot<Model>;
@@ -37,13 +47,13 @@ export interface Program<Model, Message> {
     readonly dispose: () => void;
 }
 export interface RunningProgram<Model, Message> extends Program<Model, Message> {
-    readonly activeSlots: () => readonly string[];
-    readonly awaitIdle: (slot?: string) => Promise<void>;
+    readonly activeSlots: () => readonly CommandSlot[];
+    readonly awaitIdle: (slot?: CommandSlot) => Promise<void>;
 }
 export declare function program<Model, Message>(options: {
-    initial: Model;
+    initial: Model | Snapshot<Model>;
     name?: string;
-    checkSnapshots?: boolean;
     update: (model: Snapshot<Model>, message: Message) => Transition<Model, Message>;
     onDefect?: (cause: unknown) => void;
 }): RunningProgram<Model, Message>;
+export {};

package/dist/program.js

@@ -1,31 +1,36 @@
-import { protectSnapshot, checkSnapshotsByDefault } from './snapshot.js';
+import { protectSnapshot } from './snapshot.js';
 import { reportError, reportSafely } from './errors.js';
 import { traceProgram, nextProgramId, hasProgramObservers } from './diagnostics.js';
 import { Cause, Effect, Fiber, Option, Stream } from 'effect';
+export const commandSlot = (name) => Symbol(name);
+const taskPolicies = ['replace', 'drop', 'parallel', 'queue', 'latest-queued'];
 /** 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)) };
+    return {
+        slot,
+        policy: handlers.policy,
+        effect: Effect.suspend(load).pipe(Effect.matchCause(handlers)),
+    };
 }
 /** Owned work with no model result. Failures use the program's error reporter. */
-export function actionCommand(slot, action) {
-    return { slot, action: Effect.suspend(action).pipe(Effect.asVoid) };
+export function actionCommand(slot, action, policy) {
+    return { slot, policy, action: Effect.suspend(action).pipe(Effect.asVoid) };
 }
 export function mapCommand(command, map) {
     if (command.action)
-        return { slot: command.slot, action: command.action };
+        return { ...command, action: command.action };
     return command.stream
-        ? { slot: command.slot, stream: command.stream.pipe(Stream.map(map)) }
-        : { slot: command.slot, effect: command.effect.pipe(Effect.map(map)) };
+        ? { ...command, stream: command.stream.pipe(Stream.map(map)) }
+        : { ...command, effect: command.effect.pipe(Effect.map(map)) };
 }
 export function program(options) {
-    const checkSnapshots = options.checkSnapshots ?? checkSnapshotsByDefault;
     const id = nextProgramId();
     const trace = (kind, slot, message) => hasProgramObservers() &&
         traceProgram({
             program: id,
             ...(options.name ? { name: options.name } : {}),
             kind,
-            ...(slot ? { slot } : {}),
+            ...(slot ? { slot: slot.description ?? 'command' } : {}),
             ...(message &&
                 typeof message === 'object' &&
                 'type' in message &&
@@ -45,79 +50,168 @@ export function program(options) {
     };
     // 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);
+    let current = protectSnapshot(options.initial);
     const listeners = new Set();
     const running = new Map();
     let disposed = false;
     let draining = false;
     const queue = [];
+    const deferred = [];
     const cancel = (slot) => {
+        // A synchronous Effect can enqueue completion behind a reset/replacement message.
+        // Its fiber is already done, but cancellation still owns that unpublished completion.
+        for (let index = queue.length - 1; index >= 0; index--)
+            if (queue[index].slot === slot)
+                queue.splice(index, 1);
         const previous = running.get(slot);
         running.delete(slot);
-        if (previous)
+        if (previous) {
             trace('cancel', slot);
-        if (previous?.fiber)
-            Effect.runFork(Fiber.interrupt(previous.fiber));
+            previous.pending.length = 0;
+            for (const task of previous.active)
+                if (task.fiber)
+                    Effect.runFork(Fiber.interrupt(task.fiber));
+            previous.active.clear();
+        }
     };
-    const send = (message) => {
+    const ready = [];
+    let launching = false;
+    const launch = (command, group, task) => {
+        ready.push({ command, group, task });
+        if (launching)
+            return;
+        launching = true;
+        try {
+            while (ready.length) {
+                const next = ready.shift();
+                start(next.command, next.group, next.task);
+            }
+        }
+        finally {
+            launching = false;
+        }
+    };
+    const start = (command, group, task) => {
+        const valid = () => !disposed && running.get(command.slot) === group && group.active.has(task);
+        if (!valid())
+            return;
+        trace('start', command.slot);
+        const effect = command.stream
+            ? command.stream.pipe(Stream.runForEach((message) => Effect.sync(() => {
+                if (valid())
+                    enqueue(message, command.slot);
+            })), Effect.as(Option.none()))
+            : command.action
+                ? command.action.pipe(Effect.as(Option.none()))
+                : command.effect.pipe(Effect.map(Option.some));
+        const fiber = Effect.runFork(effect);
+        task.fiber = fiber;
+        if (!valid()) {
+            Effect.runFork(Fiber.interrupt(fiber));
+            return;
+        }
+        fiber.addObserver((exit) => {
+            if (!valid())
+                return;
+            group.active.delete(task);
+            if (!group.active.size && !group.pending.length)
+                running.delete(command.slot);
+            trace(exit._tag === 'Success' ? 'complete' : 'defect', command.slot);
+            if (exit._tag === 'Success') {
+                if (Option.isSome(exit.value))
+                    enqueue(exit.value.value, command.slot);
+            }
+            else
+                reportSafely(options.onDefect ?? reportError, exit.cause);
+            if (!disposed && running.get(command.slot) === group && !group.active.size) {
+                // Process earlier reducer messages and completion subscribers before choosing the
+                // next write, so cancellation and latest-queued still apply to all pending work.
+                if (draining)
+                    deferred.push({ slot: command.slot, group });
+                else
+                    advance(command.slot, group);
+            }
+            notify();
+        });
+    };
+    const advance = (slot, group) => {
+        if (disposed || running.get(slot) !== group || group.active.size)
+            return;
+        const next = group.pending.shift();
+        if (!next)
+            return;
+        const task = {};
+        group.active.add(task);
+        launch(next, group, task);
+    };
+    const enqueue = (message, slot) => {
         if (disposed)
             return;
-        queue.push(message);
+        queue.push(slot === undefined ? { message } : { message, slot });
         if (draining)
             return;
         draining = true;
         try {
-            while (queue.length && !disposed) {
-                const message = queue.shift();
+            while ((queue.length || deferred.length) && !disposed) {
+                if (!queue.length) {
+                    const next = deferred.shift();
+                    advance(next.slot, next.group);
+                    continue;
+                }
+                const { message } = queue.shift();
                 const transition = options.update(current, message);
+                for (const command of transition.commands ?? []) {
+                    if (typeof command.slot !== 'symbol' || !taskPolicies.includes(command.policy))
+                        throw new TypeError('Commands require a commandSlot() token and an explicit concurrency policy.');
+                }
                 trace('update', undefined, message);
                 for (const slot of transition.cancel ?? [])
                     cancel(slot);
-                const next = protectSnapshot(transition.model, checkSnapshots);
+                const next = protectSnapshot(transition.model);
                 if (!Object.is(current, next)) {
                     current = next;
                     for (const listener of listeners)
                         listener(current);
                 }
+                const starts = [];
+                // Admit the entire transition before launching Effects, so a later replacement can
+                // supersede earlier work in the same transaction without executing it.
                 for (const command of transition.commands ?? []) {
                     if (disposed)
                         break;
-                    cancel(command.slot);
-                    const token = {};
-                    const runningCommand = { token };
-                    running.set(command.slot, runningCommand);
-                    trace('start', command.slot);
-                    const effect = command.stream
-                        ? command.stream.pipe(Stream.runForEach((message) => Effect.sync(() => {
-                            if (!disposed && running.get(command.slot)?.token === token)
-                                send(message);
-                        })), Effect.as(Option.none()))
-                        : command.action
-                            ? command.action.pipe(Effect.as(Option.none()))
-                            : command.effect.pipe(Effect.map(Option.some));
-                    const fiber = Effect.runFork(effect);
-                    runningCommand.fiber = fiber;
-                    if (disposed) {
-                        Effect.runFork(Fiber.interrupt(fiber));
-                        break;
+                    const policy = command.policy;
+                    let group = running.get(command.slot);
+                    if (policy === 'drop' && group)
+                        continue;
+                    if (policy === 'replace') {
+                        cancel(command.slot);
+                        group = undefined;
                     }
-                    fiber.addObserver((exit) => {
-                        if (disposed || running.get(command.slot)?.token !== token)
-                            return;
-                        running.delete(command.slot);
-                        trace(exit._tag === 'Success' ? 'complete' : 'defect', command.slot);
-                        if (exit._tag === 'Success') {
-                            if (Option.isSome(exit.value))
-                                send(exit.value.value);
-                        }
-                        else
-                            reportSafely(options.onDefect ?? reportError, exit.cause);
-                        notify();
-                    });
+                    if (group && (policy === 'queue' || policy === 'latest-queued')) {
+                        if (policy === 'latest-queued')
+                            group.pending.length = 0;
+                        group.pending.push(command);
+                        continue;
+                    }
+                    if (!group) {
+                        group = { active: new Set(), pending: [] };
+                        running.set(command.slot, group);
+                    }
+                    const task = {};
+                    group.active.add(task);
+                    const admitted = group;
+                    starts.push(() => launch(command, admitted, task));
                 }
+                for (const launch of starts)
+                    launch();
             }
         }
         catch (error) {
+            // A failed reducer must not leave deferred work keeping awaitIdle pending.
+            for (const { slot, group } of deferred)
+                if (running.get(slot) === group)
+                    cancel(slot);
+            deferred.length = 0;
             queue.length = 0;
             throw error;
         }
@@ -126,6 +220,7 @@ export function program(options) {
             notify();
         }
     };
+    const send = (message) => enqueue(message);
     return {
         model: () => current,
         activeSlots: () => [...running.keys()],
@@ -156,6 +251,7 @@ export function program(options) {
                 return;
             disposed = true;
             queue.length = 0;
+            deferred.length = 0;
             for (const slot of running.keys())
                 cancel(slot);
             listeners.clear();

package/dist/query-internals.d.ts

@@ -0,0 +1,11 @@
+import type { Effect } from 'effect';
+import type { Snapshot } from './snapshot.js';
+import type { Query } from './query.js';
+export interface QueryDefinition<Args, A, E, R> {
+    readonly name: string;
+    readonly load: (args: Snapshot<Args>) => Effect.Effect<A, E, R>;
+    readonly staleTime: number;
+    readonly share?: (previous: Snapshot<A>, next: A | Snapshot<A>) => A | Snapshot<A>;
+}
+export declare function registerQuery<Args, A, E, R>(query: Query<Args, A, E, R>, definition: QueryDefinition<Args, A, E, R>): void;
+export declare function queryDefinition<Args, A, E, R>(query: Query<Args, A, E, R>): QueryDefinition<Args, A, E, R>;

package/dist/query-internals.js

@@ -0,0 +1,10 @@
+const definitions = new WeakMap();
+export function registerQuery(query, definition) {
+    definitions.set(query, definition);
+}
+export function queryDefinition(query) {
+    const definition = definitions.get(query);
+    if (!definition)
+        throw new TypeError('Use query() to create a query definition.');
+    return definition;
+}

package/dist/query.d.ts

@@ -1,25 +1,30 @@
 import type { Effect } from 'effect';
+import { type QueryDefinition } from './query-internals.js';
+/** Canonical data identity: plain objects, dense arrays, and finite scalar values. */
+export type QueryKey = string | number | boolean | null | undefined | readonly QueryKey[] | {
+    readonly [key: string]: QueryKey;
+};
+/** Shared by cache lookup and resource reconciliation. Object property order is irrelevant. */
+export declare function encodeQueryKey(key: QueryKey): string;
+/** Data-only request arguments. Services belong in the Effect environment. */
+export type QueryArgs<A> = A extends string | number | boolean | null | undefined ? A : A extends (...args: never[]) => unknown ? never : A extends object ? {
+    readonly [K in keyof A]: K extends symbol ? never : QueryArgs<A[K]>;
+} : never;
+declare const queryType: unique symbol;
+/** An opaque typed definition. Every request argument participates in cache identity. */
 export interface Query<Args, A, E = never, R = never> {
-    readonly id: number;
     readonly name: string;
-    readonly key: (args: Args) => string;
-    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;
+    readonly [queryType]: (args: Args) => Effect.Effect<A, E, R>;
 }
-/** 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>;
+type Definition<Args, A, E, R> = Omit<QueryDefinition<Args, A, E, R>, 'staleTime'> & {
     readonly staleTime?: number;
-    readonly share?: (previous: A, next: A) => A;
+    /** Custom projections can silently reuse a different request's result. */
+    readonly key?: never;
+};
+export declare function query<Args, A, E = never, R = never>(definition: Definition<Args, A, E, R> & (Args extends QueryArgs<Args> ? unknown : {
+    readonly nonSerializableQueryArguments: never;
+})): Query<Args, A, E, R>;
+export declare function query<A, E = never, R = never>(definition: Definition<true, A, E, R> & {
+    readonly load: () => Effect.Effect<A, E, R>;
 }): 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>;
+export {};

package/dist/query.js

@@ -1,12 +1,65 @@
-let nextQueryId = 0;
+import { registerQuery } from './query-internals.js';
+/** Shared by cache lookup and resource reconciliation. Object property order is irrelevant. */
+export function encodeQueryKey(key) {
+    const ancestors = new Set();
+    const encode = (value) => {
+        if (value === undefined)
+            return 'u';
+        if (value === null)
+            return 'n';
+        if (typeof value === 'string')
+            return `s${JSON.stringify(value)}`;
+        if (typeof value === 'boolean')
+            return value ? 'b1' : 'b0';
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value))
+                throw new TypeError('Query keys require finite numbers.');
+            return Object.is(value, -0) ? 'd-0' : `d${value}`;
+        }
+        if (typeof value !== 'object')
+            throw new TypeError('Unsupported query key value.');
+        if (ancestors.has(value))
+            throw new TypeError('Query keys cannot contain cycles.');
+        const prototype = Object.getPrototypeOf(value);
+        if (Array.isArray(value)
+            ? prototype !== Array.prototype
+            : prototype !== Object.prototype && prototype !== null)
+            throw new TypeError('Query keys require plain objects and arrays.');
+        ancestors.add(value);
+        try {
+            const descriptors = Object.getOwnPropertyDescriptors(value);
+            if (Reflect.ownKeys(value).some((key) => typeof key === 'symbol'))
+                throw new TypeError('Query keys cannot contain symbol properties.');
+            for (const [name, descriptor] of Object.entries(descriptors)) {
+                if (Array.isArray(value) && name === 'length')
+                    continue;
+                if (!descriptor.enumerable || !('value' in descriptor))
+                    throw new TypeError('Query keys require enumerable data properties.');
+            }
+            if (Array.isArray(value)) {
+                if (Object.keys(value).length !== value.length ||
+                    Object.keys(value).some((key, index) => key !== String(index)))
+                    throw new TypeError('Query keys require dense arrays without extra properties.');
+                return `a[${value.map(encode).join(',')}]`;
+            }
+            return `o{${Object.keys(value)
+                .sort()
+                .map((key) => `${JSON.stringify(key)}:${encode(descriptors[key].value)}`)
+                .join(',')}}`;
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    };
+    return encode(key);
+}
 export function query(definition) {
+    if ('key' in definition)
+        throw new TypeError('Query identity includes all arguments. Remove key and provide services through the Effect environment.');
     const staleTime = definition.staleTime ?? Infinity;
     if (Number.isNaN(staleTime) || staleTime < 0)
         throw new RangeError('Query staleTime must be nonnegative.');
-    return Object.freeze({
-        ...definition,
-        key: definition.key ?? (() => ''),
-        id: ++nextQueryId,
-        staleTime,
-    });
+    const result = Object.freeze({ name: definition.name });
+    registerQuery(result, Object.freeze({ ...definition, staleTime }));
+    return result;
 }

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,