effectweb 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,15 +1,17 @@
-export { modelOwner } from './owner.js';
+export { modelOwner, makeModelOwner, } from './owner.js';
 export { collection, entities, sequence } from './collection.js';
 export { component, localComponent, programView } from './component.js';
 export { patchModel } from './state.js';
 export { defineActions } from './actions.js';
 export { taskComponent, taskControls } from './task.js';
-export { effectEvent } from './effectEvent.js';
-export { mountView, view, list, ViewBinding } from './dom.js';
+export { effectEvent, makeEffectHandler } from './effectEvent.js';
+export { mountView, view, list, listView, memoView, observe, ViewBinding, } from './dom.js';
+export { mount } from './render.js';
+export { mapSource, fromStream, fromSubscriptionRef, fromAtom, projectionSource, } from './source.js';
 export { lazyView } from './lazy.js';
-export { Portal, domBinding, domMount } from './mount.js';
+export { Portal, domBinding, domMount, makeDomMount, makeDomBinding, } from './mount.js';
 export { pages, } from './pages.js';
-export { program, mapTransition, actionCommand, effectCommand, commandSlot, } from './program.js';
+export { program, makeProgram, mapTransition, actionCommand, effectCommand, commandSlot, } from './program.js';
 export { available, resourceComponent, resourceError, } from './resource.js';
 export { fromPromise } from './load.js';
 export { observeBindings, inspectBindings, mountBindingInspector, observePrograms, } from './diagnostics.js';
@@ -17,9 +19,9 @@ export { inputText, inputChecked, inputNumber, submit, defineField, } from './fo
 export { slot } from './dom.js';
 export { AsyncContent } from './AsyncContent.js';
 export { defineTasks, } from './tasks.js';
-export { uiRuntime } from './runtime.js';
-export { query, queryGroup } from './query.js';
-export { makeQueryCache } from './cache.js';
+export { uiRuntime, makeUiRuntime } from './runtime.js';
+export { query, queryGroup, } from './query.js';
+export { makeQueryCache, scopedQueryCache, } from './cache.js';
 export { queryResource, observeQuery, lifetime, projectionCache, sessionGroup, } from './session.js';
 export { httpJson } from './http.js';
 export { infiniteQuery, infiniteResource, } from './infinite-query.js';

package/dist/infinite-query.d.ts

@@ -1,5 +1,6 @@
 import * as Effect from 'effect/Effect';
-import { type Query, type QueryArgs, type QueryGroup } from './query.js';
+import type * as Scope from 'effect/Scope';
+import { type Query, type QueryKey, type QueryArgs, type QueryGroup } from './query.js';
 import type { QueryCache } from './cache.js';
 import { type QueryResource } from './session.js';
 import { type Snapshot } from './snapshot.js';
@@ -18,20 +19,23 @@ export interface InfiniteQuery<Args, A, Param, E = never, R = never> {
     }, A, E, R>;
     readonly maxPages: number;
     readonly next: (value: Snapshot<A>, param: Snapshot<Param>) => Param | undefined;
+    readonly paramKey: (param: Param | Snapshot<Param> | undefined) => string;
 }
 /** Shared pages with explicit cursor identity. Refresh preserves retained page parameters by default. */
 export declare function infiniteQuery<Args, A, Param, E = never, R = never>(definition: {
     readonly name: string;
     readonly initial: Param;
-    readonly load: (args: Snapshot<Args>, param: Snapshot<Param>) => Effect.Effect<A, E, R>;
+    readonly load: (args: Snapshot<Args>, param: Snapshot<Param>) => Effect.Effect<A, E, R | Scope.Scope>;
     readonly next: (value: Snapshot<A>, param: Snapshot<Param>) => Param | undefined;
     readonly maxPages?: number;
     readonly refresh?: 'retained' | 'first';
     readonly groups?: readonly QueryGroup[];
-} & (Args extends QueryArgs<Args> ? unknown : {
-    readonly nonSerializableQueryArguments: never;
-}) & (Param extends QueryArgs<Param> ? unknown : {
-    readonly nonSerializablePageParameters: never;
+    readonly encodeArgs?: (args: Snapshot<Args>) => QueryKey;
+    readonly encodeParam?: (param: Snapshot<Param>) => QueryKey;
+} & ([Args] extends [QueryArgs<Args>] ? unknown : {
+    readonly encodeArgs: (args: Snapshot<Args>) => QueryKey;
+}) & ([Param] extends [QueryArgs<Param>] ? unknown : {
+    readonly encodeParam: (param: Snapshot<Param>) => QueryKey;
 })): InfiniteQuery<Args, A, Param, E, R>;
 export interface InfiniteResource<Args, A, Param, E = never> extends QueryResource<Args, InfiniteData<A, Param>, E> {
     loadNext(): Effect.Effect<Snapshot<InfiniteData<A, Param>>, E>;
@@ -39,4 +43,4 @@ export interface InfiniteResource<Args, A, Param, E = never> extends QueryResour
     seed(args: Args | Snapshot<Args>, data: InfiniteData<A, Param> | Snapshot<InfiniteData<A, Param>>): Snapshot<InfiniteData<A, Param>>;
 }
 /** Cache-owned results, observer-owned subscriptions. Operations return typed Effects for task composition. */
-export declare function infiniteResource<Args, A, Param, E, R>(cache: QueryCache<R>, definition: InfiniteQuery<Args, A, Param, E, NoInfer<R>>): InfiniteResource<Args, A, Param, E>;
+export declare function infiniteResource<Args, A, Param, E, R>(cache: QueryCache<R>, definition: InfiniteQuery<Args, A, Param, E, NoInfer<R> | Scope.Scope>): InfiniteResource<Args, A, Param, E>;

package/dist/infinite-query.js

@@ -1,5 +1,5 @@
 import * as Effect from 'effect/Effect';
-import { query, encodeQueryKey, } from './query.js';
+import { query, encodeQueryKey, encodeQueryArguments, } from './query.js';
 import { cacheInternals } from './cache-internals.js';
 import { queryResource } from './session.js';
 import { protectSnapshot } from './snapshot.js';
@@ -9,19 +9,27 @@ export function infiniteQuery(definition) {
     const maxPages = config.maxPages ?? Infinity;
     if (maxPages !== Infinity && (!Number.isInteger(maxPages) || maxPages < 1))
         throw new RangeError('maxPages must be a positive integer.');
-    encodeQueryKey(config.initial);
+    const encodeArgs = (args) => config.encodeArgs ? config.encodeArgs(args) : args;
+    const encodeParam = (param) => config.encodeParam ? config.encodeParam(param) : param;
+    const paramKey = (param) => encodeQueryKey(param === undefined ? undefined : encodeParam(param));
+    paramKey(config.initial);
     const initial = protectSnapshot(config.initial);
     const next = (value, param) => {
         const result = config.next(value, param);
-        encodeQueryKey(result);
+        paramKey(result);
         return result;
     };
     const page = query({
         name: `${config.name}:page`,
+        encode: ({ args, param }) => ({
+            args: encodeArgs(args),
+            param: encodeParam(param),
+        }),
         load: ({ args, param }) => config.load(args, param),
     });
     const root = query({
         name: config.name,
+        encode: encodeArgs,
         ...(config.groups ? { groups: config.groups } : {}),
         load: (args, previous) => {
             const params = config.refresh !== 'first' && previous?.pages.length
@@ -36,7 +44,7 @@ export function infiniteQuery(definition) {
             }));
         },
     });
-    return Object.freeze({ query: root, page, maxPages, next });
+    return Object.freeze({ query: root, page, maxPages, next, paramKey });
 }
 const operations = new WeakMap();
 function operationBook(cache, definition) {
@@ -70,11 +78,11 @@ export function infiniteResource(cache, definition) {
         const param = retry ? retry.param : current.next;
         if (param === undefined)
             return current;
-        const pageKey = encodeQueryKey(param);
-        const retained = current.pages.some((page) => encodeQueryKey(page.param) === pageKey);
-        if (retry && !retained && encodeQueryKey(current.next) !== pageKey)
+        const pageKey = definition.paramKey(param);
+        const retained = current.pages.some((page) => definition.paramKey(page.param) === pageKey);
+        if (retry && !retained && definition.paramKey(current.next) !== pageKey)
             return yield* Effect.die(new RangeError('Retry a retained page or the next page parameter.'));
-        const key = encodeQueryKey(args);
+        const key = encodeQueryArguments(definition.query, args);
         const revision = internal.revision(definition.query, args);
         let operation = book.get(key);
         if (!operation || operation.revision !== revision) {
@@ -95,8 +103,8 @@ export function infiniteResource(cache, definition) {
                     book.get(key) !== state ||
                     state.revision !== internal.revision(definition.query, args))
                     return;
-                const index = latest.pages.findIndex((page) => encodeQueryKey(page.param) === pageKey);
-                if (index < 0 && (retained || encodeQueryKey(latest.next) !== pageKey))
+                const index = latest.pages.findIndex((page) => definition.paramKey(page.param) === pageKey);
+                if (index < 0 && (retained || definition.paramKey(latest.next) !== pageKey))
                     return;
                 if (index >= 0 && latest.pages[index].value === value)
                     return;
@@ -134,8 +142,8 @@ export function infiniteResource(cache, definition) {
         seed(args, data) {
             if (!data.pages.length || data.pages.length > definition.maxPages)
                 throw new RangeError('Seed pages must fit the retained page range.');
-            encodeQueryKey(data.next);
-            const keys = data.pages.map((page) => encodeQueryKey(page.param));
+            definition.paramKey(data.next);
+            const keys = data.pages.map((page) => definition.paramKey(page.param));
             if (new Set(keys).size !== keys.length)
                 throw new TypeError('Seed page parameters must be unique.');
             return cache.setQueryData(definition.query, args, data);

package/dist/jsx.d.ts

@@ -4,6 +4,8 @@ import type { SnapshotOpaque } from './snapshot.js';
 import type { EffectEventRequest } from './effectEvent.js';
 import type { CompiledContent } from './dom.js';
 import type { DomMount } from './mount.js';
+import type * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 /** Nominal eligibility for compiled JSX components and compiler primitives. */
 export declare const jsxComponent: unique symbol;
 /** JSX is a compiler input. No renderer library owns its types. */
@@ -16,7 +18,7 @@ export declare namespace JSX {
     export interface ElementArray extends ReadonlyArray<Element>, SnapshotOpaque {
     }
     export type Element = string | number | boolean | null | undefined | CompiledContent | ElementArray;
-    export type EventResult = void | boolean | EffectEventRequest;
+    export type EventResult = void | boolean | EffectEventRequest | Effect.Effect<unknown, unknown, Scope.Scope>;
     export type EventHandler<T, E extends Event> = (event: E & {
         currentTarget: T;
         target: EventTarget & globalThis.Element;

package/dist/keyed-tasks.d.ts

@@ -1,5 +1,6 @@
 import * as Cause from 'effect/Cause';
 import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import { type TaskPolicy } from './program.js';
 import type { DisposableOwner } from './owner.js';
 import { type UiRuntime } from './runtime.js';
@@ -20,8 +21,8 @@ export interface TaskHandle<A, E> {
 export declare function keyedTasks<Key, Input, A, E = never, R = never>(owner: DisposableOwner, definition: {
     readonly name: string;
     readonly policy: TaskPolicy;
-    readonly run: (key: Key, input: Snapshot<Input>) => Effect.Effect<A, E, R>;
-}, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): {
+    readonly run: (key: Key, input: Snapshot<Input>) => Effect.Effect<A, E, R | Scope.Scope>;
+}, ...provided: [Exclude<R, Scope.Scope>] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): {
     submit(key: Key, input: Input | Snapshot<Input>): TaskHandle<A, E>;
     cancel(key: Key): void;
     drain(...selected: [] | [Key]): Effect.Effect<void>;

package/dist/keyed-tasks.js

@@ -66,7 +66,7 @@ export function keyedTasks(owner, definition, ...provided) {
                 if (Exit.isFailure(exit))
                     reportSafely(reportError, exit.cause);
             });
-            const action = Effect.uninterruptibleMask((restore) => restore(Effect.suspend(() => definition.run(key, captured)).pipe(Effect.map((value) => protectSnapshot(value)))).pipe(Effect.exit, Effect.flatMap((exit) => Effect.sync(() => settle(Exit.isSuccess(exit)
+            const action = Effect.uninterruptibleMask((restore) => restore(Effect.scoped(Effect.suspend(() => definition.run(key, captured)).pipe(Effect.map((value) => protectSnapshot(value))))).pipe(Effect.exit, Effect.flatMap((exit) => Effect.sync(() => settle(Exit.isSuccess(exit)
                 ? { _tag: 'Success', value: exit.value }
                 : Cause.hasInterruptsOnly(exit.cause)
                     ? { _tag: 'Cancelled' }
@@ -75,7 +75,7 @@ export function keyedTasks(owner, definition, ...provided) {
                 command: {
                     slot,
                     policy: definition.policy,
-                    action: runtime.provide(action),
+                    action: runtime.provideScoped(action),
                     onDiscard: (_tag) => settle({ _tag }),
                 },
             });

package/dist/lazy.d.ts

@@ -1,5 +1,6 @@
 import * as Cause from 'effect/Cause';
 import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import { type View } from './dom.js';
 import { type UiRuntime } from './runtime.js';
 export interface LazyViewOptions<Model, Message, E> {
@@ -13,7 +14,7 @@ export interface LazyViewOptions<Model, Message, E> {
  * Mount-owned loading with current inputs and a reusable successful definition.
  * Unresolved placements own independent requests; unmount interrupts their work.
  */
-export declare function lazyView<Model, Message = never, E = never, R = never>(load: () => Effect.Effect<View<Model, Message>, E, R>, ...provided: [R] extends [never] ? [
+export declare function lazyView<Model, Message = never, E = never, R = never>(load: () => Effect.Effect<View<Model, Message>, E, R | Scope.Scope>, ...provided: [Exclude<R, Scope.Scope>] extends [never] ? [
     options?: LazyViewOptions<NoInfer<Model>, NoInfer<Message>, NoInfer<E>> & {
         readonly runtime?: UiRuntime<R>;
     }

package/dist/lazy.js

@@ -10,9 +10,10 @@ import { defaultUiRuntime } from './runtime.js';
  */
 export function lazyView(load, ...provided) {
     const options = provided[0];
-    const runtime = options?.runtime ?? defaultUiRuntime;
     let loaded;
     return compiled((scope, parent, before) => {
+        const ownerRuntime = scope.settlement.runtime ?? defaultUiRuntime;
+        const runtime = options?.runtime ?? ownerRuntime;
         const render = viewRegion(scope, parent, before);
         if (loaded) {
             render(loaded);
@@ -29,7 +30,7 @@ export function lazyView(load, ...provided) {
             return;
         const finished = scope.settlement.begin();
         try {
-            fiber = Effect.runFork(runtime.provide(Effect.suspend(load)));
+            fiber = ownerRuntime.runFork(runtime.provideScoped(Effect.suspend(load)));
         }
         catch (error) {
             finished();

package/dist/mount.d.ts

@@ -1,33 +1,39 @@
 import type { Snapshot } from './snapshot.js';
 import { type ReportError } from './errors.js';
 import * as Effect from 'effect/Effect';
+import * as Scope from 'effect/Scope';
+import * as Exit from 'effect/Exit';
 import { type UiRuntime } from './runtime.js';
 export { Portal, type PortalProps } from './dom.js';
 type Work<R = never> = (() => void) | {
     dispose: () => void;
     update?: () => void;
-} | Effect.Effect<never, unknown, R>;
+} | Effect.Effect<unknown, unknown, R | Scope.Scope>;
 export interface DomMount<T extends Element = Element> {
     readonly identity: unknown;
     readonly data: unknown;
     readonly acquire: (element: T, input: () => unknown) => Work;
 }
 /** Element-owned work. Changed acquisition functions replace and interrupt the prior lifetime. */
-export declare function domMount<T extends Element, R = never>(start: (element: T) => Work<R>, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): DomMount<T>;
+export declare function domMount<T extends Element, R = never>(start: (element: T) => Work<R>, ...provided: [Exclude<R, Scope.Scope>] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): DomMount<T>;
 /** A stable DOM lifecycle with fresh immutable inputs, for focus, measurements and native events. */
-export declare function domBinding<T extends Element, A, R = never>(data: A | Snapshot<A>, acquire: (element: T, input: () => Snapshot<A>) => Work<R>, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): DomMount<T>;
+export declare function domBinding<T extends Element, A, R = never>(data: A | Snapshot<A>, acquire: (element: T, input: () => Snapshot<A>) => Work<R>, ...provided: [Exclude<R, Scope.Scope>] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): DomMount<T>;
+/** Describe a DOM acquisition in Effect setup; services are captured once, resources belong to the element. */
+export declare const makeDomMount: <T extends Element, R = never>(start: (element: T) => Work<R>) => Effect.Effect<DomMount<T>, never, R>;
+/** Capture services once and bind changing inputs without replacing the acquisition lifetime. */
+export declare const makeDomBinding: <T extends Element, A, R = never>(acquire: (element: T, input: () => Snapshot<A>) => Work<R>) => Effect.Effect<(data: A | Snapshot<A>) => DomMount<T>, never, R>;
 /** Allocate the lifetime before acquisition so reentrant publications can update or close it. */
-export declare function prepareMount<T extends Element>(element: T, mount: DomMount<T>, report?: ReportError): {
+export declare function prepareMount<T extends Element>(element: T, mount: DomMount<T>, report?: ReportError, runtime?: UiRuntime<never>): {
     closed: Effect.Effect<void, never, never>;
     start(): void;
     close: () => Effect.Effect<void, never, never>;
     update(next: DomMount<T>): boolean;
-    dispose: () => void;
+    dispose: (exit?: Exit.Exit<unknown, unknown>) => void;
 };
-export declare function startMount<T extends Element>(element: T, mount: DomMount<T>, report?: ReportError): {
+export declare function startMount<T extends Element>(element: T, mount: DomMount<T>, report?: ReportError, runtime?: UiRuntime<never>): {
     closed: Effect.Effect<void, never, never>;
     start(): void;
     close: () => Effect.Effect<void, never, never>;
     update(next: DomMount<T>): boolean;
-    dispose: () => void;
+    dispose: (exit?: Exit.Exit<unknown, unknown>) => void;
 };

package/dist/mount.js

@@ -3,17 +3,19 @@ import * as Cause from 'effect/Cause';
 import * as Deferred from 'effect/Deferred';
 import * as Effect from 'effect/Effect';
 import * as Fiber from 'effect/Fiber';
-import { defaultUiRuntime } from './runtime.js';
+import * as Scope from 'effect/Scope';
+import * as Exit from 'effect/Exit';
+import { uiRuntime } from './runtime.js';
 export { Portal } from './dom.js';
 /** Element-owned work. Changed acquisition functions replace and interrupt the prior lifetime. */
 export function domMount(start, ...provided) {
-    const runtime = provided[0] ?? defaultUiRuntime;
+    const runtime = provided[0];
     return {
         identity: start,
         data: undefined,
         acquire: (element) => {
             const work = start(element);
-            return Effect.isEffect(work) ? runtime.provide(work) : work;
+            return Effect.isEffect(work) && runtime ? runtime.provideScoped(work) : work;
         },
     };
 }
@@ -24,29 +26,66 @@ export function domBinding(data, acquire, ...provided) {
         data,
         acquire: (element, input) => {
             const work = acquire(element, input);
-            const runtime = provided[0] ?? defaultUiRuntime;
-            return Effect.isEffect(work) ? runtime.provide(work) : work;
+            const runtime = provided[0];
+            return Effect.isEffect(work) && runtime ? runtime.provideScoped(work) : work;
         },
     };
 }
+/** Describe a DOM acquisition in Effect setup; services are captured once, resources belong to the element. */
+export const makeDomMount = (start) => Effect.map(Effect.context(), (context) => {
+    const runtime = uiRuntime(context);
+    return {
+        identity: start,
+        data: undefined,
+        acquire: (element) => {
+            const work = start(element);
+            return Effect.isEffect(work) ? runtime.provideScoped(work) : work;
+        },
+    };
+});
+/** Capture services once and bind changing inputs without replacing the acquisition lifetime. */
+export const makeDomBinding = (acquire) => Effect.map(Effect.context(), (context) => {
+    const runtime = uiRuntime(context);
+    return (data) => ({
+        identity: acquire,
+        data,
+        acquire: (element, input) => {
+            const work = acquire(element, input);
+            return Effect.isEffect(work) ? runtime.provideScoped(work) : work;
+        },
+    });
+});
 /** Allocate the lifetime before acquisition so reentrant publications can update or close it. */
-export function prepareMount(element, mount, report = reportError) {
+export function prepareMount(element, mount, report = reportError, runtime) {
     let data = mount.data;
     let work;
     let fiber;
+    const resourceScope = Scope.makeUnsafe();
     let started = false;
     let disposed = false;
     let released = false;
+    let closingExit;
     let changedDuringSetup = false;
     const completed = Deferred.makeUnsafe();
     const closed = Deferred.await(completed);
     const finish = () => Deferred.doneUnsafe(completed, Effect.void);
-    const release = () => {
+    const release = (exit = Exit.void) => {
+        closingExit ??= exit;
         if (released || work === undefined || (Effect.isEffect(work) && !fiber))
             return;
         released = true;
-        if (fiber)
-            Effect.runFork(Fiber.interrupt(fiber));
+        if (fiber) {
+            // Acquisition may finish successfully while its resources remain mounted.
+            // Join acquisition before releasing its scope, including async finalizers.
+            Effect.runFork(Effect.gen(function* () {
+                yield* Fiber.interrupt(fiber);
+                yield* Scope.close(resourceScope, closingExit);
+            })).addObserver((exit) => {
+                if (exit._tag === 'Failure')
+                    reportSafely(report, exit.cause);
+                finish();
+            });
+        }
         else {
             try {
                 if (typeof work === 'function')
@@ -59,14 +98,14 @@ export function prepareMount(element, mount, report = reportError) {
             }
         }
     };
-    const dispose = () => {
+    const dispose = (exit = Exit.void) => {
         if (disposed)
             return;
         disposed = true;
         if (!started)
             finish();
         else
-            release();
+            release(exit);
     };
     return {
         closed,
@@ -77,11 +116,18 @@ export function prepareMount(element, mount, report = reportError) {
             try {
                 work = mount.acquire(element, () => data);
                 if (Effect.isEffect(work)) {
-                    fiber = Effect.runFork(work);
+                    const acquisition = Scope.provide(work, resourceScope);
+                    fiber = runtime
+                        ? runtime.runFork(acquisition)
+                        : Effect.runFork(Effect.scoped(acquisition));
                     fiber.addObserver((exit) => {
+                        // User reporting may synchronously unmount; retain the acquisition failure first.
+                        if (exit._tag === 'Failure')
+                            closingExit ??= exit;
                         if (exit._tag === 'Failure' && (!disposed || !Cause.hasInterruptsOnly(exit.cause)))
                             reportSafely(report, exit.cause);
-                        finish();
+                        if (exit._tag === 'Failure')
+                            release(exit);
                     });
                 }
                 if (disposed)
@@ -90,7 +136,7 @@ export function prepareMount(element, mount, report = reportError) {
                     work.update?.();
             }
             catch (error) {
-                dispose();
+                dispose(Exit.die(error));
                 if (work === undefined)
                     finish();
                 throw error;
@@ -113,8 +159,8 @@ export function prepareMount(element, mount, report = reportError) {
         dispose,
     };
 }
-export function startMount(element, mount, report = reportError) {
-    const lifetime = prepareMount(element, mount, report);
+export function startMount(element, mount, report = reportError, runtime) {
+    const lifetime = prepareMount(element, mount, report, runtime);
     lifetime.start();
     return lifetime;
 }

package/dist/owner.d.ts

@@ -1,8 +1,9 @@
 import { type Snapshot } from './snapshot.js';
 import * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import { type Program, type TaskPolicy, type CommandSlot } from './program.js';
 import { type ReportError } from './errors.js';
-import type { UiRuntime } from './runtime.js';
+import { type UiRuntime } from './runtime.js';
 export type { TaskPolicy } from './program.js';
 interface OwnedResource {
     dispose(): void;
@@ -23,7 +24,7 @@ export interface ModelOwner<Model extends object, R = never> extends DisposableO
     readonly edit: <K extends keyof Model>(key: K, change: (value: Snapshot<Model[K]>) => Model[K] | Snapshot<Model[K]>) => void;
     /** Synchronous transaction. Reads see staged changes; a throw discards changes and work. */
     readonly transaction: <A>(work: () => A & (A extends PromiseLike<unknown> ? never : unknown)) => A;
-    readonly run: (slot: CommandSlot, effect: Effect.Effect<unknown, unknown, R>, policy: TaskPolicy) => void;
+    readonly run: (slot: CommandSlot, effect: Effect.Effect<unknown, unknown, R | Scope.Scope>, policy: TaskPolicy) => void;
     readonly cancel: (slot: CommandSlot) => void;
     readonly isRunning: (slot: CommandSlot) => boolean;
     readonly awaitIdle: (slot?: CommandSlot) => Effect.Effect<void>;
@@ -39,3 +40,5 @@ export declare function modelOwner<Model extends object>(initial: Model, options
 export declare function modelOwner<Model extends object, R>(initial: Model, options: Options & {
     runtime: UiRuntime<R>;
 }): ModelOwner<Model, R>;
+/** Construct an owner using the current services and release it with the current Effect scope. */
+export declare const makeModelOwner: <Model extends object, R = never>(initial: Model, options?: Options) => Effect.Effect<ModelOwner<Model, R>, never, R | Scope.Scope>;

package/dist/owner.js

@@ -5,6 +5,7 @@ import * as Exit from 'effect/Exit';
 import { program, } from './program.js';
 import { patchModel } from './state.js';
 import { runAll, reportError } from './errors.js';
+import { makeUiRuntime } from './runtime.js';
 export function modelOwner(initial, options = {}) {
     let disposed = false;
     let staged;
@@ -12,7 +13,15 @@ export function modelOwner(initial, options = {}) {
     let resourcesDisposed = false;
     const source = program({
         initial,
-        ...options,
+        ...(options.name ? { name: options.name } : {}),
+        ...(options.onDefect ? { onDefect: options.onDefect } : {}),
+        ...(options.runtime
+            ? {
+                runtime: {
+                    runFork: (effect) => options.runtime.runFork(effect),
+                },
+            }
+            : {}),
         update(snapshot, operations) {
             let model = snapshot;
             const single = operations.length === 1 ? operations[0] : undefined;
@@ -142,3 +151,8 @@ export function modelOwner(initial, options = {}) {
         dispose,
     };
 }
+/** Construct an owner using the current services and release it with the current Effect scope. */
+export const makeModelOwner = (initial, options = {}) => Effect.gen(function* () {
+    const runtime = yield* makeUiRuntime();
+    return yield* Effect.acquireRelease(Effect.sync(() => modelOwner(initial, { ...options, runtime })), (owner) => owner.close().pipe(Effect.orDie));
+});

package/dist/program.d.ts

@@ -2,6 +2,8 @@ import { type Snapshot } from './snapshot.js';
 import * as Cause from 'effect/Cause';
 import * as Effect from 'effect/Effect';
 import * as Stream from 'effect/Stream';
+import type * as Scope from 'effect/Scope';
+import { type UiRuntime } from './runtime.js';
 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';
@@ -18,15 +20,15 @@ export type Command<Message, R = never> = {
     /** Notification for work that never started. */
     readonly onDiscard?: (reason: 'Cancelled' | 'Superseded' | 'Dropped') => void;
 } & ({
-    readonly effect: Effect.Effect<Message, never, R>;
+    readonly effect: Effect.Effect<Message, never, R | Scope.Scope>;
     readonly stream?: never;
     readonly action?: never;
 } | {
-    readonly stream: Stream.Stream<Message, never, R>;
+    readonly stream: Stream.Stream<Message, never, R | Scope.Scope>;
     readonly effect?: never;
     readonly action?: never;
 } | {
-    readonly action: Effect.Effect<void, unknown, R>;
+    readonly action: Effect.Effect<void, unknown, R | Scope.Scope>;
     readonly effect?: never;
     readonly stream?: never;
 });
@@ -67,5 +69,13 @@ export declare function program<Model, Message>(options: {
     name?: string;
     update: (model: Snapshot<Model>, message: Message) => Transition<Model, Message>;
     onDefect?: (cause: unknown) => void;
+    runtime?: Pick<UiRuntime<never>, 'runFork'>;
 }): RunningProgram<Model, Message>;
+/** Construct a program in the current Effect environment and own it in the current scope. */
+export declare const makeProgram: <Model, Message, R = never>(options: {
+    initial: Model | Snapshot<Model>;
+    name?: string;
+    update: (model: Snapshot<Model>, message: Message) => Transition<Model, Message, R>;
+    onDefect?: (cause: unknown) => void;
+}) => Effect.Effect<RunningProgram<Model, Message>, never, R | Scope.Scope>;
 export {};

package/dist/program.js

@@ -6,13 +6,15 @@ import * as Effect from 'effect/Effect';
 import * as Fiber from 'effect/Fiber';
 import * as Option from 'effect/Option';
 import * as Stream from 'effect/Stream';
+import { makeUiRuntime } from './runtime.js';
 export const commandSlot = (name) => Symbol(name);
 /** A lazy request settles successes, typed failures and defects through one message contract. */
 export function effectCommand(slot, load, handlers) {
     return {
         slot,
         policy: handlers.policy,
-        effect: Effect.suspend(load).pipe(Effect.matchCause(handlers)),
+        // Release the operation with its actual exit before translating it into a message.
+        effect: Effect.scoped(Effect.suspend(load)).pipe(Effect.matchCause(handlers)),
     };
 }
 /** Owned work with no model result. Failures use the program's error reporter. */
@@ -152,7 +154,9 @@ export function program(options) {
                 ? command.action.pipe(Effect.as(Option.none()))
                 : command.effect.pipe(Effect.map(Option.some));
         live.add(task);
-        const fiber = Effect.runFork(effect);
+        const fiber = options.runtime
+            ? options.runtime.runFork(effect)
+            : Effect.runFork(Effect.scoped(effect));
         task.fiber = fiber;
         fiber.addObserver((exit) => {
             live.delete(task);
@@ -320,3 +324,8 @@ export function program(options) {
         dispose,
     };
 }
+/** Construct a program in the current Effect environment and own it in the current scope. */
+export const makeProgram = (options) => Effect.gen(function* () {
+    const runtime = yield* makeUiRuntime();
+    return yield* Effect.acquireRelease(Effect.sync(() => runtime.program(options)), (source) => source.close());
+});

package/dist/query-internals.d.ts

@@ -1,13 +1,15 @@
 import type * as Effect from 'effect/Effect';
+import type * as Scope from 'effect/Scope';
 import type { Snapshot } from './snapshot.js';
-import type { Query, QueryGroup } from './query.js';
+import type { Query, QueryGroup, QueryKey } from './query.js';
 export interface QueryDefinition<Args, A, E, R> {
     readonly name: string;
-    readonly load: (args: Snapshot<Args>, previous?: Snapshot<A>) => Effect.Effect<A, E, R>;
+    readonly load: (args: Snapshot<Args>, previous?: Snapshot<A>) => Effect.Effect<A, E, R | Scope.Scope>;
     readonly groups?: readonly QueryGroup[];
     readonly unused?: 'retain' | 'cancel';
     readonly staleTime: number;
     readonly share?: (previous: Snapshot<A>, next: A | Snapshot<A>) => A | Snapshot<A>;
+    readonly encode?: (args: Snapshot<Args>) => QueryKey;
 }
 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>;