effectweb 0.3.0 → 0.4.0

package/dist/resource.js

@@ -1,5 +1,7 @@
 import { commandSlot } from './program.js';
-import { Cause, Effect, Option } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { loadEffect } from './load.js';
 import { component } from './component.js';

package/dist/runtime.d.ts

@@ -1,5 +1,6 @@
 import type { Snapshot } from './snapshot.js';
-import { Context, Effect } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
 import { type Command, type RunningProgram, type Transition } from './program.js';
 /** A binding to application-owned services, not a new scope or service lifetime. */
 export interface UiRuntime<R> {

package/dist/runtime.js

@@ -1,4 +1,6 @@
-import { Context, Effect, Stream } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Stream from 'effect/Stream';
 import { program } from './program.js';
 export function uiRuntime(context) {
     const provide = (effect) => Effect.provideContext(effect, context);

package/dist/session.js

@@ -38,7 +38,10 @@ export function queryResource(context, definition) {
     let revision = 0;
     const initial = AsyncResult.initial();
     const listeners = new Set();
-    const read = () => atom && !disposed && generation === internal.registry.get(internal.generation)
+    const read = () => atom &&
+        !disposed &&
+        !internal.disposed() &&
+        generation === internal.registry.get(internal.generation)
         ? internal.registry.get(atom)
         : initial;
     let published;
@@ -102,7 +105,7 @@ export function queryResource(context, definition) {
     });
     return {
         select(args) {
-            if (disposed)
+            if (disposed || internal.disposed())
                 return;
             const nextGeneration = internal.registry.get(internal.generation);
             const nextKey = args === undefined ? undefined : encodeQueryKey(args);
@@ -118,7 +121,12 @@ export function queryResource(context, definition) {
             atom = nextAtom;
             if (nextAtom) {
                 // Subscription setup itself can execute a synchronous Effect and reenter selection.
-                const release = internal.registry.subscribe(nextAtom, notify);
+                const releaseUse = internal.retain(nextAtom);
+                const unsubscribe = internal.registry.subscribe(nextAtom, notify);
+                const release = () => {
+                    unsubscribe();
+                    releaseUse();
+                };
                 if (disposed || selected !== revision) {
                     release();
                     return;
@@ -139,9 +147,10 @@ export function queryResource(context, definition) {
         refresh: () => {
             if (atom &&
                 !disposed &&
+                !internal.disposed() &&
                 generation === internal.registry.get(internal.generation) &&
                 !internal.registry.get(atom).waiting)
-                internal.registry.refresh(atom);
+                internal.refresh(atom);
         },
         dispose: () => {
             if (disposed)
@@ -183,10 +192,17 @@ export function projectionCache() {
 }
 export function sessionGroup(sessions, changed) {
     const scope = lifetime();
-    for (const session of sessions) {
+    for (const session of sessions)
         scope.add(() => session.dispose());
-        if (session.subscribe)
-            scope.add(session.subscribe(changed));
+    try {
+        for (const session of sessions) {
+            if (session.subscribe)
+                scope.add(session.subscribe(changed));
+        }
+    }
+    catch (error) {
+        scope.dispose();
+        throw error;
     }
     return {
         refresh: () => {

package/dist/settlement.d.ts

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

package/dist/settlement.js

@@ -0,0 +1,32 @@
+/** Internal completion accounting, including reentrant acquisition before a fiber is available. */
+export class Settlement {
+    pending = 0;
+    waiters = new Set();
+    begin() {
+        this.pending++;
+        let finished = false;
+        return () => {
+            if (finished)
+                return;
+            finished = true;
+            if (--this.pending)
+                return;
+            const waiters = [...this.waiters];
+            this.waiters.clear();
+            for (const done of waiters)
+                done();
+        };
+    }
+    wait() {
+        return Effect.callback((resume) => {
+            if (!this.pending)
+                return resume(Effect.void);
+            const done = () => resume(Effect.void);
+            this.waiters.add(done);
+            return Effect.sync(() => {
+                this.waiters.delete(done);
+            });
+        });
+    }
+}
+import * as Effect from 'effect/Effect';

package/dist/sharing.js

@@ -60,28 +60,31 @@ function share(previous, next, fields) {
         oldKeys.some((key) => !Object.hasOwn(Object.getOwnPropertyDescriptor(previous, key), 'value')))
         return next;
     let equal = keys.length === oldKeys.length && (!array || value.length === old.length);
-    let unchangedNext = true;
-    const shared = array ? [] : {};
-    if (array)
-        shared.length = value.length;
+    let changed;
     for (const key of keys) {
         const custom = fields && Object.hasOwn(fields, key) ? fields[key] : undefined;
         const item = custom && Object.hasOwn(old, key)
             ? custom(old[key], value[key])
             : share(Object.hasOwn(old, key) ? old[key] : undefined, value[key], undefined);
-        // Define an own data property, including __proto__, without invoking setters.
-        Object.defineProperty(shared, key, {
-            value: item,
-            writable: true,
-            enumerable: true,
-            configurable: true,
-        });
         if (!Object.hasOwn(old, key) || !Object.is(item, old[key]))
             equal = false;
         if (!Object.is(item, value[key]))
-            unchangedNext = false;
+            (changed ??= new Map()).set(key, item);
+    }
+    let result = equal ? previous : next;
+    if (!equal && changed) {
+        const shared = array ? [] : {};
+        if (array)
+            shared.length = value.length;
+        for (const key of keys)
+            Object.defineProperty(shared, key, {
+                value: changed.has(key) ? changed.get(key) : value[key],
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        result = shared;
     }
-    const result = equal ? previous : unchangedNext ? next : shared;
     if (fields)
         return result;
     if (!pairs) {

package/dist/snapshot.d.ts

@@ -1,4 +1,4 @@
-import type { Effect } from 'effect';
+import type * as Effect from 'effect/Effect';
 import type * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 /** Mark an application service as opaque to snapshot typing; this is a type-only brand. */
 export declare const snapshotOpaque: unique symbol;

package/dist/snapshot.js

@@ -1,30 +1,36 @@
 import { isAsyncResult } from 'effect/unstable/reactivity/AsyncResult';
-const checked = new WeakSet();
+const protectedValues = new WeakSet();
 /** Protect published plain data in every build. Opaque objects keep their own lifecycle. */
 export function protectSnapshot(value) {
-    if (!value || typeof value !== 'object' || checked.has(value))
-        return value;
-    // AsyncResult is an immutable Effect wrapper, but its successful UI data is plain data.
-    if (isAsyncResult(value)) {
-        checked.add(value);
-        if (value._tag === 'Success')
-            protectSnapshot(value.value);
-        else if (value._tag === 'Failure' && value.previousSuccess._tag === 'Some')
-            protectSnapshot(value.previousSuccess.value);
-        return value;
-    }
-    const prototype = Object.getPrototypeOf(value);
-    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null)
-        return value;
-    // Mark before walking to allow cyclic data and reuse already checked shared branches.
-    checked.add(value);
-    const descriptors = Object.getOwnPropertyDescriptors(value);
-    for (const key of Reflect.ownKeys(descriptors)) {
-        const descriptor = Reflect.get(descriptors, key);
-        // Never execute getters or traverse closures, class instances, Effects or DOM objects.
-        if ('value' in descriptor)
-            protectSnapshot(descriptor.value);
-    }
-    Object.freeze(value);
+    const seen = new Set();
+    const plain = [];
+    const visit = (item) => {
+        if (!item || typeof item !== 'object' || protectedValues.has(item) || seen.has(item))
+            return;
+        seen.add(item);
+        // Effect wrappers remain opaque, but their successful UI data is plain data.
+        if (isAsyncResult(item)) {
+            if (item._tag === 'Success')
+                visit(item.value);
+            else if (item._tag === 'Failure' && item.previousSuccess._tag === 'Some')
+                visit(item.previousSuccess.value);
+            return;
+        }
+        const prototype = Object.getPrototypeOf(item);
+        if (!Array.isArray(item) && prototype !== Object.prototype && prototype !== null)
+            return;
+        for (const key of Reflect.ownKeys(item)) {
+            const descriptor = Object.getOwnPropertyDescriptor(item, key);
+            if (Object.hasOwn(descriptor, 'value'))
+                visit(descriptor.value);
+        }
+        plain.push(item);
+    };
+    // Traverse stored data without invoking application getters.
+    visit(value);
+    for (const item of plain)
+        Object.freeze(item);
+    for (const item of seen)
+        protectedValues.add(item);
     return value;
 }

package/dist/task.d.ts

@@ -1,5 +1,5 @@
 import type { Snapshot } from './snapshot.js';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { View } from './dom.js';
 import { type Send, type TaskPolicy } from './program.js';

package/dist/task.js

@@ -1,5 +1,7 @@
 import { commandSlot } from './program.js';
-import { Cause, Effect, Option } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { programView } from './component.js';
 import { effectCommand, } from './program.js';

package/dist/tasks.d.ts

@@ -1,6 +1,6 @@
 import type { Snapshot } from './snapshot.js';
 import type { ModelOwner, TaskPolicy } from './owner.js';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type { View } from './dom.js';
 import { type CommandSlot, type Send, type RunningProgram } from './program.js';

package/dist/tasks.js

@@ -1,4 +1,5 @@
-import { Effect, Option } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { programView } from './component.js';
 import { commandSlot, effectCommand, program, } from './program.js';
@@ -137,6 +138,7 @@ function taskBuilder(definition, runtime) {
                 receive,
                 controls,
                 view: (view) => programView({
+                    ...(definition.identity ? { identity: definition.identity } : {}),
                     create,
                     receive: (source, props) => receive(source, props),
                     view,

package/dist/testing.d.ts

@@ -1,12 +1,13 @@
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import type { CommandSlot, Program, RunningProgram } from './program.js';
 import { type UiRuntime } from './runtime.js';
 /** Program inspection and controlled Effect execution with application-owned services. */
 export interface ProgramDriver<M, Msg, R = never> extends Program<M, Msg> {
+    readonly close: RunningProgram<M, Msg>['close'];
     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>;
+    readonly awaitSlot: (slot: CommandSlot) => Effect.Effect<void>;
+    readonly awaitIdle: () => Effect.Effect<void>;
+    readonly run: <A, E>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E>;
 }
 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>;

package/dist/testing.js

@@ -1,4 +1,5 @@
-import { Cause, Effect } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
 import { defaultUiRuntime } from './runtime.js';
 export function programDriver(source, runtime) {
     return makeDriver(source, runtime ?? defaultUiRuntime);
@@ -9,10 +10,11 @@ function makeDriver(source, runtime) {
         send: source.send,
         subscribe: source.subscribe,
         dispose: source.dispose,
+        close: source.close,
         activeSlots: source.activeSlots,
         awaitSlot: (slot) => source.awaitIdle(slot),
         awaitIdle: () => source.awaitIdle(),
-        run: (effect) => Effect.runPromise(runtime.provide(effect)),
+        run: runtime.provide,
     };
 }
 /** A reusable controlled request, with cancellation visible to tests. No renderer or private messages. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effectweb",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Immutable Effect models and compiled JSX with direct DOM rendering",
   "homepage": "https://github.com/DerpyCrabs/EffectWeb",
   "bugs": {
@@ -127,6 +127,14 @@
     "./http": {
       "types": "./dist/http.d.ts",
       "import": "./dist/http.js"
+    },
+    "./infinite-query": {
+      "types": "./dist/infinite-query.d.ts",
+      "import": "./dist/infinite-query.js"
+    },
+    "./keyed-tasks": {
+      "types": "./dist/keyed-tasks.d.ts",
+      "import": "./dist/keyed-tasks.js"
     }
   },
   "publishConfig": {