effectweb 0.3.1 → 0.5.0

package/dist/mount.d.ts

@@ -1,24 +1,39 @@
 import type { Snapshot } from './snapshot.js';
 import { type ReportError } from './errors.js';
-import { Effect } from 'effect';
+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 startMount<T extends Element>(element: T, mount: DomMount<T>, report?: ReportError): {
-    closed: Promise<void>;
-    close(): Promise<void>;
+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, 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, runtime?: UiRuntime<never>): {
+    closed: Effect.Effect<void, never, never>;
+    start(): void;
+    close: () => Effect.Effect<void, never, never>;
+    update(next: DomMount<T>): boolean;
+    dispose: (exit?: Exit.Exit<unknown, unknown>) => void;
 };

package/dist/mount.js

@@ -1,16 +1,21 @@
 import { reportError, reportSafely } from './errors.js';
-import { Effect, Fiber } from 'effect';
-import { defaultUiRuntime } from './runtime.js';
+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 * 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;
         },
     };
 }
@@ -21,31 +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;
         },
     };
 }
-export function startMount(element, mount, report = reportError) {
+/** 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, runtime) {
     let data = mount.data;
-    const work = mount.acquire(element, () => data);
-    const fiber = Effect.isEffect(work) ? Effect.runFork(work) : undefined;
+    let work;
+    let fiber;
+    const resourceScope = Scope.makeUnsafe();
+    let started = false;
     let disposed = false;
-    let finish;
-    const closed = new Promise((resolve) => {
-        finish = resolve;
-    });
-    fiber?.addObserver((exit) => {
-        if (exit._tag === 'Failure' && !disposed)
-            reportSafely(report, exit.cause);
-        finish();
-    });
-    const dispose = () => {
-        if (disposed)
+    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 = (exit = Exit.void) => {
+        closingExit ??= exit;
+        if (released || work === undefined || (Effect.isEffect(work) && !fiber))
             return;
-        disposed = true;
-        if (fiber)
-            Effect.runFork(Fiber.interrupt(fiber));
+        released = true;
+        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')
@@ -58,20 +98,69 @@ export function startMount(element, mount, report = reportError) {
             }
         }
     };
+    const dispose = (exit = Exit.void) => {
+        if (disposed)
+            return;
+        disposed = true;
+        if (!started)
+            finish();
+        else
+            release(exit);
+    };
     return {
         closed,
-        close() {
+        start() {
+            if (started || disposed)
+                return;
+            started = true;
+            try {
+                work = mount.acquire(element, () => data);
+                if (Effect.isEffect(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);
+                        if (exit._tag === 'Failure')
+                            release(exit);
+                    });
+                }
+                if (disposed)
+                    release();
+                else if (changedDuringSetup && !fiber && typeof work === 'object' && 'update' in work)
+                    work.update?.();
+            }
+            catch (error) {
+                dispose(Exit.die(error));
+                if (work === undefined)
+                    finish();
+                throw error;
+            }
+        },
+        close: () => Effect.suspend(() => {
             dispose();
             return closed;
-        },
+        }),
         update(next) {
-            if (next.identity !== mount.identity)
+            if (disposed || next.identity !== mount.identity)
                 return false;
             data = next.data;
-            if (!fiber && typeof work === 'object' && 'update' in work)
+            if (started && work === undefined)
+                changedDuringSetup = true;
+            else if (!fiber && typeof work === 'object' && work && 'update' in work)
                 work.update?.();
             return true;
         },
         dispose,
     };
 }
+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,14 +1,17 @@
 import { type Snapshot } from './snapshot.js';
-import { Effect } from 'effect';
+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;
+    close?(): Effect.Effect<void, unknown>;
+}
 export interface DisposableOwner {
     readonly disposed: boolean;
-    readonly own: <A extends {
-        dispose(): void;
-    }>(resource: A) => A;
+    readonly own: <A extends OwnedResource>(resource: A) => A;
 }
 export interface ModelOwner<Model extends object, R = never> extends DisposableOwner {
     readonly source: Program<Model, never>;
@@ -21,12 +24,12 @@ 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) => Promise<void>;
+    readonly awaitIdle: (slot?: CommandSlot) => Effect.Effect<void>;
     /** Interrupt and join work before closing owned dependencies in reverse order. */
-    readonly close: () => Promise<void>;
+    readonly close: () => Effect.Effect<void, AggregateError>;
     readonly dispose: () => void;
 }
 type Options = {
@@ -37,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

@@ -1,16 +1,27 @@
 import { protectSnapshot } from './snapshot.js';
-import { Effect } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+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;
     const cleanups = [];
-    let closing;
+    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;
@@ -57,42 +68,27 @@ export function modelOwner(initial, options = {}) {
             return;
         disposed = true;
         source.dispose();
-        runAll(cleanups
-            .splice(0)
-            .reverse()
-            .map((resource) => () => resource.dispose()), options.onDefect ?? reportError);
+        resourcesDisposed = true;
+        runAll([...cleanups].reverse().map((resource) => () => resource.dispose()), options.onDefect ?? reportError);
     };
-    const close = () => {
-        if (closing)
-            return closing;
+    const closing = Effect.runSync(Effect.cached(Effect.uninterruptible(Effect.gen(function* () {
         disposed = true;
         const resources = cleanups.splice(0).reverse();
-        let finish;
-        let fail;
-        closing = new Promise((resolve, reject) => {
-            finish = resolve;
-            fail = reject;
-        });
-        const closeResources = async () => {
-            await source.close();
-            const errors = [];
-            for (const resource of resources) {
-                try {
-                    if (resource.close)
-                        await resource.close();
-                    else
-                        resource.dispose();
-                }
-                catch (error) {
-                    errors.push(error);
-                }
-            }
-            if (errors.length)
-                throw new AggregateError(errors, 'Owner cleanup failed.');
-        };
-        closeResources().then(finish, fail);
-        return closing;
-    };
+        yield* source.close();
+        const errors = [];
+        for (const resource of resources) {
+            const exit = yield* Effect.exit(Effect.suspend(() => resource.close
+                ? resource.close()
+                : resourcesDisposed
+                    ? Effect.void
+                    : Effect.sync(() => resource.dispose())));
+            if (Exit.isFailure(exit))
+                errors.push(Cause.squash(exit.cause));
+        }
+        if (errors.length)
+            return yield* Effect.fail(new AggregateError(errors, 'Owner cleanup failed.'));
+    }))));
+    const close = () => closing;
     return {
         source: { model: source.model, send: source.send, subscribe: source.subscribe, dispose, close },
         read,
@@ -122,11 +118,6 @@ export function modelOwner(initial, options = {}) {
             staged = batch;
             try {
                 const result = work();
-                if (result &&
-                    (typeof result === 'object' || typeof result === 'function') &&
-                    'then' in result &&
-                    typeof result.then === 'function')
-                    throw new TypeError('Model transactions must be synchronous. Run async work as an owned Effect.');
                 staged = parent;
                 if (!disposed) {
                     if (parent) {
@@ -160,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/pages.d.ts

@@ -1,5 +1,5 @@
 import type { Snapshot } from './snapshot.js';
-import { Cause } from 'effect';
+import * as Cause from 'effect/Cause';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { UiLoad, UiPage } from './load.js';
 import { type Transition, type RunningProgram } from './program.js';

package/dist/pages.js

@@ -1,6 +1,7 @@
 import { commandSlot } from './program.js';
 import { shareData } from './sharing.js';
-import { Cause, Option } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Option from 'effect/Option';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { effectCommand, program, } from './program.js';
 import { defaultUiRuntime } from './runtime.js';

package/dist/program.d.ts

@@ -1,5 +1,9 @@
 import { type Snapshot } from './snapshot.js';
-import { Cause, Effect, Stream } from 'effect';
+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';
@@ -16,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;
 });
@@ -51,19 +55,27 @@ export interface Program<Model, Message> {
     readonly send: Send<Message>;
     readonly subscribe: (listener: (model: Snapshot<Model>) => void) => () => void;
     readonly dispose: () => void;
-    readonly close?: () => Promise<void>;
+    readonly close?: () => Effect.Effect<void, unknown>;
 }
 export interface RunningProgram<Model, Message> extends Program<Model, Message> {
     /** Wait for interrupted work and its finalizers as well as admitted work. */
-    readonly awaitStopped: () => Promise<void>;
-    readonly close: () => Promise<void>;
+    readonly awaitStopped: () => Effect.Effect<void>;
+    readonly close: () => Effect.Effect<void>;
     readonly activeSlots: () => readonly CommandSlot[];
-    readonly awaitIdle: (slot?: CommandSlot) => Promise<void>;
+    readonly awaitIdle: (slot?: CommandSlot) => Effect.Effect<void>;
 }
 export declare function program<Model, Message>(options: {
     initial: Model | Snapshot<Model>;
     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

@@ -1,15 +1,20 @@
 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';
+import * as Cause from 'effect/Cause';
+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);
-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,
         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. */
@@ -68,13 +73,20 @@ export function program(options) {
     const notifyStopped = () => {
         if (live.size || running.size || draining)
             return;
-        for (const done of stopped)
-            done();
+        const completed = [...stopped];
         stopped.clear();
+        for (const done of completed)
+            done();
     };
-    const awaitStopped = () => live.size === 0 && running.size === 0 && !draining
-        ? Promise.resolve()
-        : new Promise((done) => stopped.add(done));
+    const awaitStopped = () => Effect.callback((resume) => {
+        if (live.size === 0 && running.size === 0 && !draining)
+            return resume(Effect.void);
+        const done = () => resume(Effect.void);
+        stopped.add(done);
+        return Effect.sync(() => {
+            stopped.delete(done);
+        });
+    });
     let disposed = false;
     let draining = false;
     const queue = [];
@@ -142,13 +154,18 @@ 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);
-            notifyStopped();
-            if (!valid())
+            if (!valid()) {
+                if (exit._tag === 'Failure' && !Cause.hasInterruptsOnly(exit.cause))
+                    reportSafely(options.onDefect ?? reportError, exit.cause);
+                notifyStopped();
                 return;
+            }
             group.active.delete(task);
             if (!group.active.size && !group.pending.length)
                 running.delete(command.slot);
@@ -198,10 +215,6 @@ export function program(options) {
                 }
                 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);
@@ -276,17 +289,21 @@ export function program(options) {
     };
     return {
         awaitStopped,
-        close: () => {
+        close: () => Effect.suspend(() => {
             dispose();
             return awaitStopped();
-        },
+        }),
         model: () => current,
         activeSlots: () => [...running.keys()],
-        awaitIdle: (slot) => disposed || (!draining && (slot ? !running.has(slot) : running.size === 0))
-            ? Promise.resolve()
-            : new Promise((done) => {
-                waiters.add({ slot, done });
-            }),
+        awaitIdle: (slot) => Effect.callback((resume) => {
+            if (disposed || (!draining && (slot ? !running.has(slot) : running.size === 0)))
+                return resume(Effect.void);
+            const waiter = { slot, done: () => resume(Effect.void) };
+            waiters.add(waiter);
+            return Effect.sync(() => {
+                waiters.delete(waiter);
+            });
+        }),
         send,
         subscribe(listener) {
             if (disposed)
@@ -307,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 { Effect } from 'effect';
+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>;