effectweb 0.2.2 → 0.3.0

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,
     });
 }

package/dist/tasks.d.ts

@@ -1,18 +1,22 @@
+import type { Snapshot } from './snapshot.js';
 import type { ModelOwner, TaskPolicy } from './owner.js';
 import { Effect } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { View } from './dom.js';
-import { type Send, type RunningProgram } from './program.js';
+import { type CommandSlot, type Send, type RunningProgram } from './program.js';
 import { type UiRuntime } from './runtime.js';
 export interface TaskDefinition<Model, Input, A, E, R = never> {
-    readonly policy: 'drop' | 'replace';
-    readonly run: (model: Model, input: Input) => Effect.Effect<A, E, R>;
+    readonly policy: Exclude<TaskPolicy, 'parallel'>;
+    readonly run: (model: Snapshot<Model>, input: Input) => Effect.Effect<A, E, R>;
     /** Domain identity, compared after fields or props change. Resets this slot only. */
-    readonly identity?: (model: Model) => unknown;
+    readonly identity?: (model: Snapshot<Model>) => unknown;
 }
 type Definitions<Model, R> = Record<string, TaskDefinition<Model, never, unknown, unknown, R>>;
-type AnyDefinitions = Definitions<never, unknown>;
-type Input<T extends AnyDefinitions[string]> = Parameters<T['run']> extends [unknown, infer I, ...unknown[]] ? I : void;
+type AnyDefinitions = Record<string, {
+    readonly run: (...args: never[]) => Effect.Effect<unknown, unknown, unknown>;
+}>;
+type Input<T extends AnyDefinitions[string]> = Parameters<T['run']> extends [unknown, ...infer Inputs] ? Inputs extends [] ? void : Inputs[0] : void;
+type InputArguments<T extends AnyDefinitions[string]> = Input<T> extends void ? [input?: Input<T>] : Parameters<T['run']> extends [unknown, unknown, ...unknown[]] ? [input: Input<T>] : [input?: Input<T>];
 export type TaskResults<T extends AnyDefinitions> = {
     readonly [K in keyof T]: AsyncResult.AsyncResult<Effect.Success<ReturnType<T[K]['run']>>, Effect.Error<ReturnType<T[K]['run']>>>;
 };
@@ -22,7 +26,7 @@ export type TasksModel<Props, State, T extends AnyDefinitions> = State & {
 };
 export type TasksMessage<State, T extends AnyDefinitions> = {
     readonly type: 'Fields';
-    readonly fields: Partial<State> & {
+    readonly fields: (Partial<State> | Partial<Snapshot<State>>) & {
         readonly props?: never;
         readonly tasks?: never;
     };
@@ -37,19 +41,19 @@ export type TasksMessage<State, T extends AnyDefinitions> = {
     };
 }[keyof T];
 type Init<Props, State> = {
-    init: (props: Props) => State & {
+    init: (props: Snapshot<Props>) => (State | Snapshot<State>) & {
         readonly props?: never;
         readonly tasks?: never;
     };
     /** Changing the component entity also resets editable fields and all its tasks. */
-    identity?: (props: Props) => unknown;
+    identity?: (props: Snapshot<Props>) => unknown;
     name?: string;
 };
 interface ControllerTask<R> {
     readonly run: (...args: never[]) => Effect.Effect<unknown, unknown, R>;
     readonly policy: TaskPolicy;
-    /** Actions sharing a slot share cancellation and concurrency rules. Defaults to the action name. */
-    readonly slot?: string;
+    /** Actions sharing a slot share cancellation and concurrency rules. Defaults to a fresh operation identity for this definition. */
+    readonly slot?: CommandSlot;
 }
 export declare function defineTasks<Owner extends Pick<ModelOwner<object>, 'run'>, T extends Record<string, ControllerTask<Effect.Services<Parameters<Owner['run']>[1]>>>>(owner: Owner, definitions: T): {
     readonly [K in keyof T]: (...args: Parameters<T[K]['run']>) => void;
@@ -62,11 +66,12 @@ declare function taskBuilder<Props, State extends object, R>(definition: Init<Pr
     tasks<T extends Definitions<State & {
         readonly props: Props;
     }, R>>(definitions: T): {
-        create: (props: Props) => RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>;
-        receive: (source: RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>, props: Props) => void;
+        slot: (name: keyof T) => CommandSlot;
+        create: (props: Props | Snapshot<Props>) => RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>;
+        receive: (source: RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>, props: Props | Snapshot<Props>) => void;
         controls: (send: Send<TasksMessage<State, T>>) => {
-            run: <K extends keyof T>(task: K, ...input: Input<T[K]> extends void ? [input?: Input<T[K]>] : [input: Input<T[K]>]) => void;
-            patch: (fields: Partial<State> & {
+            run: <K extends keyof T>(task: K, ...input: InputArguments<T[K]>) => void;
+            patch: (fields: (Partial<State> | Partial<Snapshot<State>>) & {
                 readonly props?: never;
                 readonly tasks?: never;
             }) => void;

package/dist/tasks.js

@@ -1,14 +1,15 @@
 import { Effect, Option } from 'effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { programView } from './component.js';
-import { effectCommand, program } from './program.js';
+import { commandSlot, effectCommand, program, } from './program.js';
 import { defaultUiRuntime } from './runtime.js';
 import { patchModel } from './state.js';
 export function defineTasks(definition, definitions) {
     if ('run' in definition) {
         const actions = Object.create(null);
         for (const [name, task] of Object.entries(definitions)) {
-            actions[name] = (...args) => definition.run(task.slot ?? name, Effect.suspend(() => task.run(...args)), task.policy);
+            const slot = task.slot ?? commandSlot(name);
+            actions[name] = (...args) => definition.run(slot, Effect.suspend(() => task.run(...args)), task.policy);
         }
         return actions;
     }
@@ -27,19 +28,17 @@ function taskBuilder(definition, runtime) {
     return {
         tasks(definitions) {
             const names = Object.keys(definitions);
-            const slot = (name) => `task:${String(name)}`;
+            const slots = new Map(names.map((name) => [name, commandSlot(`task:${name}`)]));
+            const slot = (name) => slots.get(name);
             const initialResults = () => Object.fromEntries(names.map((name) => [name, AsyncResult.initial()]));
-            const init = (props) => ({
-                ...definition.init(props),
-                props,
-                tasks: initialResults(),
-            });
+            const init = (props) => ({ ...definition.init(props), props, tasks: initialResults() });
             const withResult = (model, task, result) => ({ ...model, tasks: { ...model.tasks, [task]: result } });
             const resetIdentities = (before, model) => {
                 const cancel = [];
                 for (const name of names) {
                     const identity = definitions[name].identity;
-                    if (identity && !Object.is(identity(before), identity(model))) {
+                    if (identity &&
+                        !Object.is(identity(before), identity(model))) {
                         model = withResult(model, name, AsyncResult.initial());
                         cancel.push(slot(name));
                     }
@@ -51,7 +50,9 @@ function taskBuilder(definition, runtime) {
                 const source = program({
                     initial: init(props),
                     ...(definition.name ? { name: definition.name } : {}),
-                    update: (model, message) => {
+                    update: (snapshot, message) => {
+                        // Internal immutable reconstruction retains the declared domain types.
+                        const model = snapshot;
                         switch (message.type) {
                             case 'Input':
                                 if (definition.identity &&
@@ -70,20 +71,22 @@ function taskBuilder(definition, runtime) {
                                 return {
                                     model: withResult(model, message.task, AsyncResult.waiting(previous)),
                                     commands: [
-                                        effectCommand(slot(message.task), () => runtime.provide(task.run(model, message.input)), {
-                                            onSuccess: (value) => ({
-                                                type: 'Settled',
-                                                task: message.task,
-                                                result: AsyncResult.success(value),
-                                            }),
-                                            onFailure: (cause) => ({
-                                                type: 'Settled',
-                                                task: message.task,
-                                                result: AsyncResult.failureWithPrevious(cause, {
-                                                    previous: Option.some(previous),
+                                        {
+                                            ...effectCommand(slot(message.task), () => runtime.provide(task.run(snapshot, message.input)), {
+                                                policy: task.policy,
+                                                onSuccess: (value) => ({
+                                                    type: 'Settled',
+                                                    task: message.task,
+                                                    result: AsyncResult.success(value),
+                                                }),
+                                                onFailure: (cause) => ({
+                                                    type: 'Settled',
+                                                    task: message.task,
+                                                    result: AsyncResult.failure(cause),
                                                 }),
                                             }),
-                                        }),
+                                            policy: task.policy,
+                                        },
                                     ],
                                 };
                             }
@@ -97,8 +100,18 @@ function taskBuilder(definition, runtime) {
                                     model: withResult(model, message.task, AsyncResult.initial()),
                                     cancel: [slot(message.task)],
                                 };
-                            case 'Settled':
-                                return { model: withResult(model, message.task, message.result) };
+                            case 'Settled': {
+                                const result = AsyncResult.isFailure(message.result)
+                                    ? AsyncResult.failureWithPrevious(message.result.cause, {
+                                        previous: Option.some(model.tasks[message.task]),
+                                    })
+                                    : message.result;
+                                return {
+                                    model: withResult(model, message.task, source.activeSlots().includes(slot(message.task))
+                                        ? AsyncResult.waiting(result)
+                                        : result),
+                                };
+                            }
                         }
                     },
                 });
@@ -110,7 +123,7 @@ function taskBuilder(definition, runtime) {
                 const owner = owners.get(source);
                 if (!owner)
                     throw new Error('Task source belongs to a different definition');
-                owner.send({ type: 'Input', props });
+                owner.send({ type: 'Input', props: props });
             };
             const controls = (send) => ({
                 run: (task, ...input) => send({ type: 'Run', task, input: input[0] }),
@@ -119,6 +132,7 @@ function taskBuilder(definition, runtime) {
                 reset: (task) => send({ type: 'Reset', task }),
             });
             return {
+                slot,
                 create,
                 receive,
                 controls,

package/dist/testing.d.ts

@@ -1,19 +1,15 @@
 import { Effect } from 'effect';
-import type { RunningProgram } from './program.js';
+import type { CommandSlot, Program, RunningProgram } from './program.js';
 import { type UiRuntime } from './runtime.js';
-/** Drive the real queue. Test services and TestClock effects use the same supplied context. */
-export declare function programDriver<M, Msg>(source: RunningProgram<M, Msg>): ReturnType<typeof makeDriver<M, Msg, never>>;
-export declare function programDriver<M, Msg, R>(source: RunningProgram<M, Msg>, runtime: UiRuntime<R>): ReturnType<typeof makeDriver<M, Msg, R>>;
-declare function makeDriver<M, Msg, R>(source: RunningProgram<M, Msg>, runtime: UiRuntime<R>): {
-    model: () => Readonly<M>;
-    send: import("./program.js").Send<Msg>;
-    subscribe: (listener: (model: Readonly<M>) => void) => () => void;
-    dispose: () => void;
-    activeSlots: () => readonly string[];
-    awaitSlot: (slot: string) => Promise<void>;
-    awaitIdle: () => Promise<void>;
-    run: <A, E>(effect: Effect.Effect<A, E, R>) => Promise<A>;
-};
+/** Program inspection and controlled Effect execution with application-owned services. */
+export interface ProgramDriver<M, Msg, R = never> extends Program<M, Msg> {
+    readonly activeSlots: RunningProgram<M, Msg>['activeSlots'];
+    readonly awaitSlot: (slot: CommandSlot) => Promise<void>;
+    readonly awaitIdle: () => Promise<void>;
+    readonly run: <A, E>(effect: Effect.Effect<A, E, R>) => Promise<A>;
+}
+export declare function programDriver<M, Msg>(source: RunningProgram<M, Msg>): ProgramDriver<M, Msg>;
+export declare function programDriver<M, Msg, R>(source: RunningProgram<M, Msg>, runtime: UiRuntime<R>): ProgramDriver<M, Msg, R>;
 /** A reusable controlled request, with cancellation visible to tests. No renderer or private messages. */
 export declare function controlledEffect<A, E = never>(): {
     effect: Effect.Effect<A, E, never>;
@@ -23,4 +19,3 @@ export declare function controlledEffect<A, E = never>(): {
     fail: (error: E) => void;
     die: (defect: unknown) => void;
 };
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effectweb",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Immutable Effect models and compiled JSX with direct DOM rendering",
   "homepage": "https://github.com/DerpyCrabs/EffectWeb",
   "bugs": {
@@ -123,6 +123,10 @@
     "./testing": {
       "types": "./dist/testing.d.ts",
       "import": "./dist/testing.js"
+    },
+    "./http": {
+      "types": "./dist/http.d.ts",
+      "import": "./dist/http.js"
     }
   },
   "publishConfig": {