effectweb 0.3.1 → 0.4.0

package/dist/dom.js

@@ -1,13 +1,13 @@
-import { compiledSlots } from './slotIdentity.js';
 import attributeData from './dom-attributes.json' with { type: 'json' };
+import * as Effect from 'effect/Effect';
 import { validateIdentities } from './collection.js';
 import { runAll, reportError, reportSafely } from './errors.js';
 import { eventEffects } from './effectEvent.js';
 import { traceBinding } from './diagnostics.js';
-import { shareData } from './sharing.js';
 import { jsxComponent } from './jsx.js';
 import { Settlement } from './settlement.js';
-import { startMount } from './mount.js';
+import { prepareMount } from './mount.js';
+const bindingLocation = (source) => typeof source === 'function' ? source() : source;
 const equal = (a, b) => a.length === b.length && a.every((value, index) => Object.is(value, b[index]));
 // A model publication reconciles DOM first and controlled dependent properties second.
 // Nested child scopes join the same synchronous commit; there is no reactive graph.
@@ -42,41 +42,23 @@ export class Scope {
     jobs = [];
     cleanups = [];
     disposed = false;
-    revision = 0;
     constructor(value, send, report = reportError, settlement = new Settlement()) {
         this.value = value;
         this.send = send;
         this.report = report;
         this.settlement = settlement;
     }
-    derive(dependencies, compute, source) {
-        let previous;
-        let value;
-        let revision = -1;
-        return () => {
-            if (revision === this.revision)
-                return value;
-            const next = dependencies();
-            if (!previous || !equal(previous, next)) {
-                value = previous ? shareData(value, compute()) : compute();
-                traceBinding(source, previous, next, 'derive');
-                previous = next;
-            }
-            revision = this.revision;
-            return value;
-        };
-    }
     watch(dependencies, apply, source) {
         let previous = dependencies();
         apply();
-        traceBinding(source, undefined, previous, 'binding');
+        traceBinding(bindingLocation(source), undefined, previous, 'binding');
         if (!previous.length)
             return;
         const run = () => {
             const next = dependencies();
             if (!equal(previous, next)) {
                 apply();
-                traceBinding(source, previous, next, 'binding');
+                traceBinding(bindingLocation(source), previous, next, 'binding');
                 previous = next;
             }
         };
@@ -87,7 +69,6 @@ export class Scope {
             return;
         commitDom(() => {
             this.value = value;
-            this.revision++;
             for (const job of this.jobs) {
                 if (this.disposed)
                     break;
@@ -108,18 +89,18 @@ export class Scope {
         runAll(this.cleanups.splice(0).reverse(), this.report);
     }
 }
-/** Compiler marker for mounting a view with an explicit model and message dispatcher. */
-export const ViewBinding = /* @__PURE__ */ Object.assign(function ViewBinding(_props) {
-    throw new Error('ViewBinding reached runtime without the EffectWeb JSX compiler');
+/** Mount a view with an explicit model and message dispatcher. */
+export const ViewBinding = /* @__PURE__ */ Object.assign(function ViewBinding(props) {
+    return new SlotPlacement(viewContent(props.view), { model: props.model, send: props.send });
 }, { [jsxComponent]: true });
 /** Untyped callers get an actionable failure instead of silently losing child messages. */
 export function unboundSend(_message) {
     throw new Error('This view needs a dispatcher. Mount it through ViewBinding with model and send.');
 }
 const contentBrand = Symbol('compiled content');
-/** Compiler marker: declare inside view(), or directly in a compiled component prop. */
-export function slot(_render) {
-    throw new Error('EffectWeb slot reached runtime without the EffectWeb JSX compiler');
+/* @__NO_SIDE_EFFECTS__ */
+export function slot(render) {
+    return render;
 }
 // Placement values are opaque to structural sharing, which only traverses plain data.
 class SlotPlacement {
@@ -136,62 +117,83 @@ function isContent(value) {
         (typeof value === 'object' || typeof value === 'function') &&
         contentBrand in value);
 }
-/** Compiler output. Captures follow their declaring scope; placements own independent scopes. */
-export function compiledSlot(owner, build) {
-    const placements = new Set();
-    owner.jobs.push(() => {
-        for (const scope of placements)
-            scope.set(scope.value);
-    });
-    owner.cleanups.push(() => {
-        for (const scope of placements)
-            scope.dispose();
-        placements.clear();
+/** Evaluate ordinary synchronous JavaScript for each immutable model publication. */
+/* @__NO_SIDE_EFFECTS__ */
+export function view(render) {
+    return compiled((scope, parent, before) => {
+        const read = () => render(scope.value, scope.send);
+        text(scope, parent, before, () => [scope.value], read);
     });
-    const definition = {
+}
+/* @__NO_SIDE_EFFECTS__ */
+export function compiled(build) {
+    const definition = Object.assign((props) => new SlotPlacement(viewContent(definition), { model: props, send: unboundSend }), { build, [jsxComponent]: true });
+    return definition;
+}
+const viewDefinitions = new WeakMap();
+function viewContent(definition) {
+    let content = viewDefinitions.get(definition);
+    if (!content) {
+        content = contentDefinition((scope, parent, before) => {
+            const childScope = new Scope(scope.value.model, (message) => scope.value.send(message), scope.report, scope.settlement);
+            scope.cleanups.push(() => childScope.dispose());
+            definition.build(childScope, parent, before);
+            scope.jobs.push(() => childScope.set(scope.value.model));
+        });
+        viewDefinitions.set(definition, content);
+    }
+    return content;
+}
+function contentDefinition(build) {
+    return {
         mount(parent, before, value, report, settlement) {
-            if (owner.disposed)
-                throw new Error('Cannot mount content after its declaring view disposed');
-            const scope = new Scope(value, owner.send, report, settlement);
+            const scope = new Scope(value, unboundSend, report, settlement);
             const fragment = buildFragment(parent);
             const range = markers(fragment, null);
             scope.cleanups.push(() => remove(range.start, range.end));
             try {
                 build(scope, fragment, range.end);
-                parent.insertBefore(fragment, before);
-                placements.add(scope);
+                if (!scope.disposed)
+                    parent.insertBefore(fragment, before);
             }
             catch (error) {
                 scope.dispose();
                 throw error;
             }
-            return {
-                set(value) {
-                    if (!Object.is(scope.value, value))
-                        scope.set(value);
-                },
-                dispose() {
-                    placements.delete(scope);
-                    scope.dispose();
-                },
-            };
+            return { set: (value) => scope.set(value), dispose: () => scope.dispose() };
         },
     };
-    const slot = Object.assign((value) => new SlotPlacement(definition, value), {
-        [contentBrand]: true,
-        definition,
-    });
-    compiledSlots.add(slot);
-    return slot;
 }
-/** This declaration is a compiler marker, never a component setup callback. */
-export function view(_render) {
-    throw new Error('EffectWeb view reached runtime without the EffectWeb JSX compiler');
+const markupDefinitions = new Map();
+/** JSX factories preserve host identity by element type; source locations are metadata only. */
+export function markup(tag, sources) {
+    let definition = markupDefinitions.get(tag);
+    if (!definition) {
+        definition = contentDefinition((scope, parent, before) => {
+            const node = element(parent, before, tag);
+            bindAttributes(scope, node, () => [scope.value.props], () => {
+                const { children: _children, ...attributes } = scope.value.props;
+                return attributes;
+            }, () => scope.value.sources);
+            text(scope, node, null, () => [scope.value.props.children], () => scope.value.props.children, () => scope.value.sources?.children);
+        });
+        markupDefinitions.set(tag, definition);
+    }
+    return (props) => new SlotPlacement(definition, { props, sources });
+}
+export function renderComponent(component, props) {
+    return component(props);
 }
-export function compiled(build) {
-    return Object.assign(() => {
-        throw new Error('Mount compiled views with mountView or inside another compiled view');
-    }, { build, [jsxComponent]: true });
+const listDefinition = contentDefinition((scope, parent, before) => {
+    each(scope, parent, before, () => scope.value.rows, () => [scope.value.render], true, (row, parent, before) => {
+        // The explicit list operation owns callback evaluation and keyed row lifetimes.
+        const update = () => scope.value.render(row.value[0], row.value[1]);
+        text(row, parent, before, () => [row.value, scope.value.render], update);
+    });
+});
+/** Preserve collection identity (or array reference identity) while rendering rows. */
+export function list(rows, render) {
+    return new SlotPlacement(listDefinition, { rows, render });
 }
 /** Owned content in an element target, defaulting to the document body. */
 export const Portal = /* @__PURE__ */ compiled((scope) => {
@@ -263,15 +265,23 @@ export function mountView(parent, definition, source, options = {}) {
         const { start, end } = markers(parent, null);
         const scope = new Scope(source.model(), source.send, options.onError);
         let unsubscribe = () => { };
+        let ready = false;
+        let latest = scope.value;
         try {
+            unsubscribe = source.subscribe((model) => {
+                latest = model;
+                if (ready)
+                    scope.set(model);
+            });
             const fragment = buildFragment(parent);
             definition.build(scope, fragment, null);
             parent.insertBefore(fragment, end);
-            unsubscribe = source.subscribe((model) => scope.set(model));
+            ready = true;
+            if (!Object.is(latest, scope.value))
+                scope.set(latest);
         }
         catch (error) {
-            scope.dispose();
-            remove(start, end);
+            runAll([unsubscribe, () => scope.dispose(), () => remove(start, end)], scope.report);
             throw error;
         }
         const dispose = () => {
@@ -282,8 +292,10 @@ export function mountView(parent, definition, source, options = {}) {
         return Object.assign(dispose, {
             dispose,
             close: () => {
-                dispose();
-                return scope.settlement.wait();
+                return Effect.suspend(() => {
+                    dispose();
+                    return scope.settlement.wait();
+                });
             },
         });
     });
@@ -385,7 +397,7 @@ export function bindAttribute(scope, element, name, dependencies, read, source)
     let previous = dependencies();
     let value = read();
     attribute(element, name, value);
-    traceBinding(source, undefined, previous, 'binding');
+    traceBinding(bindingLocation(source), undefined, previous, 'binding');
     if (!previous.length)
         return;
     // Keep the value cache in the dependency job itself, without an extra closure
@@ -399,7 +411,7 @@ export function bindAttribute(scope, element, name, dependencies, read, source)
             attribute(element, name, nextValue);
             value = nextValue;
         }
-        traceBinding(source, previous, next, 'binding');
+        traceBinding(bindingLocation(source), previous, next, 'binding');
         previous = next;
     });
 }
@@ -519,16 +531,20 @@ export function text(scope, parent, before, dependencies, read, source) {
         let value = read();
         if (Array.isArray(value)) {
             validateContent(value);
-            value = { [contentBrand]: true, definition: arrayContent, value };
+            value = new SlotPlacement(arrayContent, value);
         }
         if (isContent(value)) {
-            node.data = '';
+            if (node.data !== '')
+                node.data = '';
             if (content?.definition === value.definition) {
                 content.mounted.set(value.value);
                 return;
             }
-            content?.mounted.dispose();
+            const previous = content;
             content = undefined;
+            previous?.mounted.dispose();
+            if (scope.disposed)
+                return;
             if (start)
                 clear(start, node);
             else {
@@ -536,10 +552,11 @@ export function text(scope, parent, before, dependencies, read, source) {
                 scope.cleanups.push(() => content?.mounted.dispose());
                 node.parentNode.insertBefore(start, node);
             }
-            content = {
-                definition: value.definition,
-                mounted: value.definition.mount(node.parentNode, node, value.value, scope.report, scope.settlement),
-            };
+            const mounted = value.definition.mount(node.parentNode, node, value.value, scope.report, scope.settlement);
+            if (scope.disposed)
+                mounted.dispose();
+            else
+                content = { definition: value.definition, mounted };
             return;
         }
         if (value != null && typeof value === 'object')
@@ -575,20 +592,28 @@ const arrayContent = {
 /** Runtime content arrays are positional; domain lists retain the explicit collection contract. */
 function mountArray(report, before, initial, settlement) {
     const cells = [];
+    let disposed = false;
     const disposeCell = (cell) => {
         cell.scope.dispose();
         remove(cell.start, cell.end);
     };
     const set = (input) => {
+        if (disposed)
+            return;
         const values = input;
         validateContent(values);
-        while (cells.length > values.length)
+        while (cells.length > values.length) {
             disposeCell(cells.pop());
+            if (disposed)
+                return;
+        }
         for (let index = 0; index < values.length; index++) {
             const cell = cells[index];
             if (cell) {
                 if (!Object.is(cell.scope.value, values[index]))
                     cell.scope.set(values[index]);
+                if (disposed)
+                    return;
                 continue;
             }
             const scope = new Scope(values[index], unboundSend, report, settlement);
@@ -596,6 +621,10 @@ function mountArray(report, before, initial, settlement) {
             const range = markers(fragment, null);
             try {
                 text(scope, fragment, range.end, () => [scope.value], () => scope.value);
+                if (disposed) {
+                    scope.dispose();
+                    return;
+                }
                 before.parentNode.insertBefore(fragment, before);
                 cells.push({ scope, ...range });
             }
@@ -606,6 +635,9 @@ function mountArray(report, before, initial, settlement) {
         }
     };
     const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
         for (const cell of cells.splice(0))
             disposeCell(cell);
     };
@@ -652,29 +684,28 @@ export function event(scope, element, name, handler) {
         effects?.dispose();
     });
 }
-/** One handler identity owns its requests, regardless of the JSX attribute spelling. */
+/** The event binding owns its requests; snapshot renders may replace its callback. */
 export function bindEvent(scope, element, name, dependencies, read) {
     let current;
     let owned;
     scope.cleanups.push(() => owned?.dispose());
     scope.watch(dependencies, () => {
         const next = read();
-        if (next != null && typeof next !== 'function')
-            throw new TypeError(`Event ${name} must be a synchronous handler.`);
         if (Object.is(current, next))
             return;
-        owned?.dispose();
-        owned = undefined;
         current = next;
-        if (typeof next === 'function') {
-            const handler = next;
+        if (!next) {
+            owned?.dispose();
+            owned = undefined;
+        }
+        else if (!owned) {
             owned = new Scope(next, scope.send, scope.report, scope.settlement);
-            event(owned, element, name, handler);
+            event(owned, element, name, (event) => current?.(event));
         }
     });
 }
 /** Reconcile merged JSX attributes. Each host, event and control owns its cleanup. */
-export function bindAttributes(scope, element, dependencies, read) {
+export function bindAttributes(scope, element, dependencies, read, sources) {
     const bindings = new Map();
     let previous = {};
     const isEvent = (name) => /^on[A-Z]/u.test(name);
@@ -689,8 +720,6 @@ export function bindAttributes(scope, element, dependencies, read) {
         for (const name of Object.keys(next)) {
             if (['key', 'ref', 'innerHTML', 'children'].includes(name))
                 throw new Error(`Spread attribute ${name} is unsupported. Use collections, DOM hosts, or JSX children.`);
-            if (isEvent(name) && next[name] != null && typeof next[name] !== 'function')
-                throw new Error(`Spread event ${name} must be a synchronous handler.`);
         }
         for (const name of Object.keys(previous)) {
             if (Object.hasOwn(next, name))
@@ -701,8 +730,11 @@ export function bindAttributes(scope, element, dependencies, read) {
                 attribute(element, name, undefined);
         }
         for (const [name, value] of Object.entries(next)) {
+            if (!Object.hasOwn(previous, name) || !Object.is(previous[name], value))
+                traceBinding(sources?.()?.[name], Object.hasOwn(previous, name) ? [previous[name]] : undefined, [value], 'binding');
             if (name !== 'use' && !isEvent(name) && !isControl(name)) {
-                attribute(element, name, value);
+                if (!Object.hasOwn(previous, name) || !Object.is(previous[name], value))
+                    attribute(element, name, value);
                 continue;
             }
             let binding = bindings.get(name);
@@ -767,6 +799,8 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
     let previousOuter = [];
     let previousIdentities = [];
     const update = () => {
+        if (scope.disposed)
+            return;
         const target = end.parentNode;
         const next = read();
         const nextOuter = outer();
@@ -787,8 +821,11 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
             target instanceof Element &&
             target.firstChild === rows.get(previousIdentities[0])?.start &&
             target.lastChild === end) {
-            for (const row of rows.values())
+            for (const row of rows.values()) {
                 row.scope.dispose();
+                if (scope.disposed)
+                    return;
+            }
             target.replaceChildren(end);
             rows.clear();
             previousList = next;
@@ -796,24 +833,21 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
             previousIdentities = [];
             return;
         }
-        const identities = validateIdentities(items, (item, index) => {
-            const key = collection ? collection.identity(item, index) : item;
-            if (typeof key !== 'string' && typeof key !== 'number')
-                throw new Error('Object lists need domain identity. Declare collection(identity) once; do not add JSX keys.');
-            return key;
-        });
+        const identities = validateIdentities(items, (item, index) => collection ? collection.identity(item, index) : item);
         const keep = new Set(identities);
         for (const [key, row] of rows) {
             if (keep.has(key))
                 continue;
             row.scope.dispose();
+            if (scope.disposed)
+                return;
             remove(row.start, row.end);
             rows.delete(key);
         }
         for (let index = 0; index < items.length; index++) {
             const key = identities[index];
             const row = rows.get(key);
-            const item = row ? shareData(row.scope.value[0], items[index]) : items[index];
+            const item = items[index];
             if (!row) {
                 const fragment = buildFragment(target);
                 const range = markers(fragment, null);
@@ -825,6 +859,10 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
                     child.dispose();
                     throw error;
                 }
+                if (scope.disposed) {
+                    child.dispose();
+                    return;
+                }
                 // A single element is its own stable range. Keep markers for dynamic/multiple roots.
                 const root = range.start.nextSibling;
                 const single = root instanceof Element && root.nextSibling === range.end;
@@ -843,6 +881,8 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
                 row.scope.value[0] !== item ||
                 (indexUsed && row.scope.value[1] !== index)) {
                 row.scope.set([item, index]);
+                if (scope.disposed)
+                    return;
             }
         }
         // Retained prefixes are already ordered. New tail rows were appended above and
@@ -892,16 +932,6 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
     });
     update();
 }
-export function invoke(scope, parent, before, dependencies, read, build) {
-    const child = new Scope(read(), scope.send, scope.report, scope.settlement);
-    scope.cleanups.push(() => child.dispose());
-    build(child, parent, before);
-    scope.watch(dependencies, () => {
-        const next = read();
-        if (!equal(child.value, next))
-            child.set(next);
-    });
-}
 export function child(scope, parent, before, definition, dependencies, model, send) {
     const child = new Scope(model(), send, scope.report, scope.settlement);
     scope.cleanups.push(() => child.dispose());
@@ -981,12 +1011,14 @@ export function attach(scope, element, dependencies, read) {
             if (!scope.disposed && token === generation) {
                 const finished = scope.settlement.begin();
                 try {
-                    const acquired = startMount(element, mount, scope.report);
-                    acquired.closed.then(finished, finished);
+                    const acquired = prepareMount(element, mount, scope.report);
+                    Effect.runFork(acquired.closed).addObserver(finished);
                     if (scope.disposed || token !== generation)
                         acquired.dispose();
-                    else
+                    else {
                         active = acquired;
+                        acquired.start();
+                    }
                 }
                 catch (error) {
                     finished();
@@ -1106,4 +1138,3 @@ export function template(build, depth = 0) {
 export function literal(parent, before, value) {
     parent.insertBefore((parent.ownerDocument ?? document).createTextNode(value), before);
 }
-export { intrinsic } from './intrinsic.js';

package/dist/effectEvent.d.ts

@@ -1,4 +1,4 @@
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import { type ReportError } from './errors.js';
 import type { Settlement } from './settlement.js';
 import { type UiRuntime } from './runtime.js';
@@ -11,9 +11,9 @@ export interface EffectEventRequest {
 /** Capture/prevent native events on every call; the policy gates only Effect execution. */
 export declare function effectEvent<EventType extends Event, E>(policy: 'drop' | 'replace', load: (event: EventType) => Effect.Effect<unknown, E>): (event: EventType) => EffectEventRequest;
 export declare function effectEvent<EventType extends Event, E, R>(policy: 'drop' | 'replace', load: (event: EventType) => Effect.Effect<unknown, E, R>, runtime: UiRuntime<R>): (event: EventType) => EffectEventRequest;
-/** Internal listener owner, allocated only when an event returns a value needing inspection. */
+/** Internal listener owner, allocated only when an event returns an owned request. */
 export declare function eventEffects(report: ReportError, settlement?: Settlement): {
-    accept(value: unknown): void;
+    accept(request: EffectEventRequest): void;
     dispose(): void;
 };
 export {};

package/dist/effectEvent.js

@@ -1,4 +1,6 @@
-import { Effect, Fiber } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
 import { reportSafely } from './errors.js';
 import { defaultUiRuntime } from './runtime.js';
 const tag = Symbol('Effect event');
@@ -6,7 +8,7 @@ export function effectEvent(policy, load, runtime) {
     const owner = runtime ?? defaultUiRuntime;
     return (event) => ({ [tag]: true, policy, effect: owner.provide(load(event)) });
 }
-/** Internal listener owner, allocated only when an event returns a value needing inspection. */
+/** Internal listener owner, allocated only when an event returns an owned request. */
 export function eventEffects(report, settlement) {
     let active;
     let disposed = false;
@@ -17,49 +19,35 @@ export function eventEffects(report, settlement) {
             Effect.runFork(Fiber.interrupt(previous.fiber));
     };
     return {
-        accept(value) {
+        accept(request) {
             if (disposed)
                 return;
-            if (value && typeof value === 'object' && tag in value) {
-                const request = value;
-                if (request.policy === 'drop' && active)
-                    return;
-                stop();
-                const token = {};
-                active = token;
-                const finished = settlement?.begin();
-                try {
-                    const fiber = Effect.runFork(request.effect);
-                    fiber.addObserver(() => finished?.());
-                    token.fiber = fiber;
-                    if (disposed || active !== token) {
-                        Effect.runFork(Fiber.interrupt(fiber));
-                        return;
-                    }
-                    fiber.addObserver((exit) => {
-                        if (disposed || active !== token)
-                            return;
+            if (request.policy === 'drop' && active)
+                return;
+            stop();
+            const token = {};
+            active = token;
+            const finished = settlement?.begin();
+            try {
+                const fiber = Effect.runFork(request.effect);
+                token.fiber = fiber;
+                fiber.addObserver((exit) => {
+                    const current = !disposed && active === token;
+                    if (current)
                         active = undefined;
-                        if (exit._tag === 'Failure')
-                            reportSafely(report, exit.cause);
-                    });
-                }
-                catch (error) {
+                    if (exit._tag === 'Failure' && (current || !Cause.hasInterruptsOnly(exit.cause)))
+                        reportSafely(report, exit.cause);
                     finished?.();
-                    if (active === token)
-                        active = undefined;
-                    reportSafely(report, error);
+                });
+                if (disposed || active !== token) {
+                    Effect.runFork(Fiber.interrupt(fiber));
                 }
             }
-            else if (Effect.isEffect(value)) {
-                reportSafely(report, new Error('Event returned an unowned Effect. Use effectEvent(policy, factory) or dispatch a command.'));
-            }
-            else if (value &&
-                typeof value === 'object' &&
-                'then' in value &&
-                typeof value.then === 'function') {
-                void Promise.resolve(value).catch((error) => reportSafely(report, error));
-                reportSafely(report, new Error('Event returned an unowned Promise. Adapt it with fromPromise inside effectEvent or a command.'));
+            catch (error) {
+                finished?.();
+                if (active === token)
+                    active = undefined;
+                reportSafely(report, error);
             }
         },
         dispose() {

package/dist/form.d.ts

@@ -1,4 +1,5 @@
-import type { Cause, Effect } from 'effect';
+import type * as Cause from 'effect/Cause';
+import type * as Effect from 'effect/Effect';
 import { type Transition } from './program.js';
 import type { Snapshot } from './snapshot.js';
 import type { EffectEventRequest } from './effectEvent.js';

package/dist/http.d.ts

@@ -1,4 +1,5 @@
-import { Effect, type Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import type * as Schema from 'effect/Schema';
 import * as HttpClient from 'effect/unstable/http/HttpClient';
 import type * as HttpClientRequest from 'effect/unstable/http/HttpClientRequest';
 /** Decode successful JSON through a schema, retaining transport, decoding and service types. */

package/dist/http.js

@@ -1,4 +1,4 @@
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 import * as HttpClient from 'effect/unstable/http/HttpClient';
 import * as HttpClientResponse from 'effect/unstable/http/HttpClientResponse';
 /** Decode successful JSON through a schema, retaining transport, decoding and service types. */