effectweb 0.3.1 → 0.4.0

package/dist/program.js

@@ -1,9 +1,12 @@
 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';
 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 {
@@ -68,13 +71,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 = [];
@@ -146,9 +156,12 @@ export function program(options) {
         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 +211,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 +285,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)

package/dist/query-internals.d.ts

@@ -1,4 +1,4 @@
-import type { Effect } from 'effect';
+import type * as Effect from 'effect/Effect';
 import type { Snapshot } from './snapshot.js';
 import type { Query, QueryGroup } from './query.js';
 export interface QueryDefinition<Args, A, E, R> {

package/dist/query.d.ts

@@ -1,4 +1,4 @@
-import type { Effect } from 'effect';
+import type * as Effect from 'effect/Effect';
 import { type QueryDefinition } from './query-internals.js';
 /** Canonical data identity: plain objects, dense arrays, and finite scalar values. */
 export type QueryKey = string | number | boolean | null | undefined | readonly QueryKey[] | {

package/dist/query.js

@@ -54,8 +54,6 @@ export function encodeQueryKey(key) {
     return encode(key);
 }
 export function query(definition) {
-    if ('key' in definition)
-        throw new TypeError('Query identity includes all arguments. Remove key and provide services through the Effect environment.');
     const staleTime = definition.staleTime ?? Infinity;
     if (Number.isNaN(staleTime) || staleTime < 0)
         throw new RangeError('Query staleTime must be nonnegative.');

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

@@ -192,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

@@ -3,5 +3,6 @@ export declare class Settlement {
     private pending;
     private waiters;
     begin(): () => void;
-    wait(): Promise<void>;
+    wait(): Effect.Effect<void>;
 }
+import * as Effect from 'effect/Effect';

package/dist/settlement.js

@@ -1,7 +1,7 @@
 /** Internal completion accounting, including reentrant acquisition before a fiber is available. */
 export class Settlement {
     pending = 0;
-    waiters = [];
+    waiters = new Set();
     begin() {
         this.pending++;
         let finished = false;
@@ -11,17 +11,22 @@ export class Settlement {
             finished = true;
             if (--this.pending)
                 return;
-            for (const done of this.waiters)
+            const waiters = [...this.waiters];
+            this.waiters.clear();
+            for (const done of waiters)
                 done();
-            this.waiters.length = 0;
         };
     }
     wait() {
-        return new Promise((done) => {
-            if (this.pending)
-                this.waiters.push(done);
-            else
-                done();
+        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/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,19 +1,19 @@
 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) {
     const seen = new Set();
     const plain = [];
-    const validate = (item) => {
-        if (!item || typeof item !== 'object' || checked.has(item) || seen.has(item))
+    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')
-                validate(item.value);
+                visit(item.value);
             else if (item._tag === 'Failure' && item.previousSuccess._tag === 'Some')
-                validate(item.previousSuccess.value);
+                visit(item.previousSuccess.value);
             return;
         }
         const prototype = Object.getPrototypeOf(item);
@@ -21,18 +21,16 @@ export function protectSnapshot(value) {
             return;
         for (const key of Reflect.ownKeys(item)) {
             const descriptor = Object.getOwnPropertyDescriptor(item, key);
-            if (!Object.hasOwn(descriptor, 'value'))
-                throw new Error(`Snapshot data cannot contain an accessor (${String(key)}). Materialize its value before publication; keep services in opaque instances.`);
-            validate(descriptor.value);
+            if (Object.hasOwn(descriptor, 'value'))
+                visit(descriptor.value);
         }
         plain.push(item);
     };
-    // Validate the complete graph before caching any proof. A rejected cyclic graph
-    // must not make a later publication skip validation through a previously seen child.
-    validate(value);
+    // Traverse stored data without invoking application getters.
+    visit(value);
     for (const item of plain)
         Object.freeze(item);
     for (const item of seen)
-        checked.add(item);
+        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';

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.1",
+  "version": "0.4.0",
   "description": "Immutable Effect models and compiled JSX with direct DOM rendering",
   "homepage": "https://github.com/DerpyCrabs/EffectWeb",
   "bugs": {

package/dist/intrinsic.d.ts

@@ -1,2 +0,0 @@
-/** Preserve receiver identity and JavaScript call/optional-chain semantics. */
-export declare function intrinsic<T>(receiver: T, path: readonly (string | null)[], method: string): T;

package/dist/intrinsic.js

@@ -1,120 +0,0 @@
-import { compiledSlots } from './slotIdentity.js';
-// Compiler implementation detail. An untyped receiver's method name is not
-// evidence that it is a standard data operation. Validate its descriptor before
-// invoking it, without running a user getter in the process.
-const prototypes = [
-    Array.prototype,
-    String.prototype,
-    Number.prototype,
-    Boolean.prototype,
-    BigInt.prototype,
-    Function.prototype,
-    Date.prototype,
-    RegExp.prototype,
-    Map.prototype,
-    Set.prototype,
-    URL.prototype,
-    URLSearchParams.prototype,
-    Blob.prototype,
-    File.prototype,
-    Object.getPrototypeOf(Uint8Array.prototype),
-    Intl.DateTimeFormat.prototype,
-    Intl.NumberFormat.prototype,
-    Intl.Collator.prototype,
-    Intl.RelativeTimeFormat.prototype,
-    Intl.PluralRules.prototype,
-    Intl.ListFormat.prototype,
-    Intl.Segmenter.prototype,
-];
-const operations = new Map();
-for (const prototype of prototypes) {
-    for (const [name, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(prototype))) {
-        if (name === 'constructor')
-            continue;
-        const entries = operations.get(name) ?? [];
-        entries.push(descriptor);
-        operations.set(name, entries);
-    }
-}
-/** Preserve receiver identity and JavaScript call/optional-chain semantics. */
-export function intrinsic(receiver, path, method) {
-    checkPath(receiver, path, 0, method);
-    return receiver;
-}
-function checkPath(target, path, index, method) {
-    if (target === null || target === undefined)
-        return;
-    if (index === path.length) {
-        checkIntrinsic(target, method);
-        return;
-    }
-    const field = path[index];
-    if (field === null) {
-        if (Array.isArray(target)) {
-            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(target))) {
-                if (!/^(0|[1-9]\d*)$/u.test(key))
-                    continue;
-                if (!Object.hasOwn(descriptor, 'value'))
-                    throw new Error('EffectWeb render data cannot use an array accessor. Pass immutable values.');
-                checkPath(descriptor.value, path, index + 1, method);
-            }
-        }
-        else if (target instanceof Map) {
-            for (const value of Map.prototype.values.call(target))
-                checkPath(value, path, index + 1, method);
-        }
-        else if (target instanceof Set) {
-            for (const value of Set.prototype.values.call(target))
-                checkPath(value, path, index + 1, method);
-        }
-        return;
-    }
-    let object = Object(target);
-    while (object) {
-        const descriptor = Object.getOwnPropertyDescriptor(object, field);
-        if (descriptor) {
-            if (Object.hasOwn(descriptor, 'value')) {
-                checkPath(descriptor.value, path, index + 1, method);
-            }
-            else if (descriptor.get &&
-                operations.get(field)?.some((operation) => operation.get === descriptor.get)) {
-                // Native getters are checked by identity before execution. File/Blob
-                // metadata and collection sizes expose data through readonly accessors.
-                checkPath(descriptor.get.call(target), path, index + 1, method);
-            }
-            else {
-                throw new Error('EffectWeb render data cannot use an accessor to supply a standard data operation. Pass immutable data or a checked helper.');
-            }
-            return;
-        }
-        object = Object.getPrototypeOf(object);
-    }
-}
-function checkIntrinsic(receiver, method) {
-    if (receiver === null || receiver === undefined)
-        return;
-    if (method === '@slot') {
-        if (typeof receiver !== 'function' || !compiledSlots.has(receiver))
-            throw new Error('EffectWeb render callbacks must be compiled slots. Declare markup with slot(), or use a checked helper with an explicit purity contract.');
-        return;
-    }
-    let object = Object(receiver);
-    while (object) {
-        const descriptor = Object.getOwnPropertyDescriptor(object, method);
-        if (descriptor) {
-            const known = operations
-                .get(method)
-                ?.some((operation) => Object.hasOwn(descriptor, 'value')
-                ? typeof descriptor.value === 'function' && descriptor.value === operation.value
-                : descriptor.get !== undefined &&
-                    descriptor.get === operation.get &&
-                    descriptor.set === undefined);
-            if (!known)
-                throw new Error(`EffectWeb cannot prove .${method} is a standard data operation. Use a checked local helper or an imported helper with a purity contract.`);
-            return;
-        }
-        object = Object.getPrototypeOf(object);
-    }
-    // The original member call retains its own missing/optional-method behavior.
-    return;
-}

package/dist/slotIdentity.d.ts

@@ -1 +0,0 @@
-export declare const compiledSlots: WeakSet<object>;

package/dist/slotIdentity.js

@@ -1,2 +0,0 @@
-// Shared only by compiler runtime helpers; user functions cannot acquire this proof.
-export const compiledSlots = new WeakSet();