effectweb 0.3.1 → 0.5.0

package/dist/AsyncContent.d.ts

@@ -1,4 +1,4 @@
-import { Cause } from 'effect';
+import * as Cause from 'effect/Cause';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import { type Slot, type View } from './index.js';
 import type { JSX } from './jsx.js';

package/dist/AsyncContent.js

@@ -1,6 +1,8 @@
 import * as _ew_dom from "./dom.js";
 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 { component } from "./component.js";
 import { view } from "./index.js";
@@ -47,40 +49,21 @@ const implementation = component({
             ...model,
             visible: true
         } }),
-    view: /* @__PURE__ */ _ew_dom.compiled((_ew_scope_1, _ew_parent_2, _ew_before_3) => {
-        const _ew_derived_4 = _ew_scope_1.derive(() => [_ew_scope_1.value?.props], () => {
-            const _ew_capture_6 = _ew_scope_1.value;
-            return _ew_dom.intrinsic(_ew_dom.intrinsic(_ew_capture_6, ["props", "content"], "@slot"), ["props", "failure"], "@slot").props;
-        });
-        const _ew_derived_7 = _ew_scope_1.derive(() => [_ew_derived_4()?.result], () => {
-            const _ew_capture_9 = _ew_derived_4();
-            return AsyncResult.value(_ew_capture_9.result);
-        });
-        const _ew_derived_10 = _ew_scope_1.derive(() => [_ew_derived_4()?.result, _ew_derived_4()?.result?.waiting], () => {
-            const _ew_capture_12 = _ew_derived_4();
-            return AsyncResult.isFailure(_ew_capture_12.result) && !_ew_capture_12.result.waiting ? _ew_capture_12.result : undefined;
-        });
-        _ew_dom.branch(_ew_scope_1, _ew_parent_2, _ew_before_3, () => Option.isSome(_ew_derived_7()), (_ew_scope_1, _ew_parent_13, _ew_before_14) => {
-            _ew_dom.text(_ew_scope_1, _ew_parent_13, _ew_before_14, () => [_ew_derived_4(), _ew_derived_7()?.value], () => _ew_derived_4().content(_ew_derived_7().value));
-            _ew_dom.branch(_ew_scope_1, _ew_parent_13, _ew_before_14, () => _ew_derived_4().result.waiting, (_ew_scope_1, _ew_parent_15, _ew_before_16) => {
-                _ew_dom.text(_ew_scope_1, _ew_parent_15, _ew_before_16, () => [_ew_derived_4()?.refreshing], () => _ew_derived_4().refreshing);
-            }, (_ew_scope_1, _ew_parent_15, _ew_before_16) => { });
-            _ew_dom.branch(_ew_scope_1, _ew_parent_13, _ew_before_14, () => _ew_derived_10() && _ew_derived_4().failure, (_ew_scope_1, _ew_parent_17, _ew_before_18) => {
-                _ew_dom.text(_ew_scope_1, _ew_parent_17, _ew_before_18, () => [_ew_derived_4(), _ew_derived_10()?.cause], () => _ew_derived_4().failure(_ew_derived_10().cause));
-            }, (_ew_scope_1, _ew_parent_17, _ew_before_18) => { });
-        }, (_ew_scope_1, _ew_parent_13, _ew_before_14) => {
-            _ew_dom.branch(_ew_scope_1, _ew_parent_13, _ew_before_14, () => _ew_derived_10() && _ew_derived_4().failure, (_ew_scope_1, _ew_parent_19, _ew_before_20) => {
-                _ew_dom.text(_ew_scope_1, _ew_parent_19, _ew_before_20, () => [_ew_derived_4(), _ew_derived_10()?.cause], () => _ew_derived_4().failure(_ew_derived_10().cause));
-            }, (_ew_scope_1, _ew_parent_19, _ew_before_20) => {
-                _ew_dom.branch(_ew_scope_1, _ew_parent_19, _ew_before_20, () => _ew_scope_1.value.pending, (_ew_scope_1, _ew_parent_21, _ew_before_22) => {
-                    _ew_dom.branch(_ew_scope_1, _ew_parent_21, _ew_before_22, () => _ew_scope_1.value.visible, (_ew_scope_1, _ew_parent_23, _ew_before_24) => {
-                        _ew_dom.text(_ew_scope_1, _ew_parent_23, _ew_before_24, () => [_ew_derived_4()?.pending], () => _ew_derived_4().pending);
-                    }, (_ew_scope_1, _ew_parent_23, _ew_before_24) => { });
-                }, (_ew_scope_1, _ew_parent_21, _ew_before_22) => {
-                    _ew_dom.text(_ew_scope_1, _ew_parent_21, _ew_before_22, () => [_ew_derived_4()?.empty], () => _ew_derived_4().empty);
-                });
-            });
-        });
+    view: view((model, _send) => {
+        const props = model.props;
+        const data = AsyncResult.value(props.result);
+        const failure = AsyncResult.isFailure(props.result) && !props.result.waiting ? props.result : undefined;
+        if (Option.isSome(data))
+            return [
+                props.content(data.value),
+                props.result.waiting ? props.refreshing : null,
+                failure && props.failure ? props.failure(failure.cause) : null
+            ];
+        if (failure && props.failure)
+            return props.failure(failure.cause);
+        if (model.pending)
+            return model.visible ? props.pending : null;
+        return props.empty;
     })
 });
 /** Presentation only: resource owners choose identity, loading, caching and cancellation. */

package/dist/cache-internals.d.ts

@@ -1,3 +1,4 @@
+import type * as Scope from 'effect/Scope';
 import type * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import type * as Atom from 'effect/unstable/reactivity/Atom';
 import type * as AtomRegistry from 'effect/unstable/reactivity/AtomRegistry';
@@ -7,11 +8,11 @@ import type { Snapshot } from './snapshot.js';
 export interface CacheInternals<R> {
     refresh(atom: Atom.Atom<unknown>): void;
     readonly disposed: () => boolean;
-    revision<Args, A, E>(definition: Query<Args, A, E, R>, args: Args | Snapshot<Args>): number | undefined;
+    revision<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, args: Args | Snapshot<Args>): number | undefined;
     retain(atom: Atom.Atom<unknown>): () => void;
     readonly registry: AtomRegistry.AtomRegistry;
     readonly generation: Atom.Writable<number>;
-    query<Args, A, E>(definition: Query<Args, A, E, R>, args: Args | Snapshot<Args>): Atom.Atom<AsyncResult.AsyncResult<Snapshot<A>, E>>;
+    query<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, args: Args | Snapshot<Args>): Atom.Atom<AsyncResult.AsyncResult<Snapshot<A>, E>>;
 }
 export declare function registerCache<R>(cache: QueryCache<R>, internals: CacheInternals<R>): void;
 /** Private implementation access; deliberately absent from package exports. */

package/dist/cache.d.ts

@@ -1,7 +1,8 @@
 import { type Snapshot } from './snapshot.js';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Scope from 'effect/Scope';
 import { type Query, type QueryGroup } from './query.js';
-import type { UiRuntime } from './runtime.js';
+import { type UiRuntime } from './runtime.js';
 export { loadEffect, type UiLoad } from './load.js';
 export { shareValue } from './share.js';
 export interface QueryCacheOptions {
@@ -10,32 +11,34 @@ export interface QueryCacheOptions {
 }
 export declare function makeQueryCache(options?: QueryCacheOptions): QueryCache<never>;
 export declare function makeQueryCache<R>(runtime: UiRuntime<R>, options?: QueryCacheOptions): QueryCache<R>;
+/** Capture application services and clock, and close the cache with the current Effect scope. */
+export declare const scopedQueryCache: <R = never>(options?: QueryCacheOptions) => Effect.Effect<QueryCache<R>, never, R | Scope.Scope>;
 /** A cache owns one registry and the query resources published through it. */
 export interface QueryCache<R = never> {
     batch(work: () => void): void;
-    getQueryData<Args, A, E>(definition: Query<Args, A, E, R>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>): Snapshot<A> | undefined;
-    invalidateWhere<Args, A, E>(definition: Query<Args, A, E, R>, predicate: (args: Snapshot<Args>) => boolean): void;
+    getQueryData<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>): Snapshot<A> | undefined;
+    invalidateWhere<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, predicate: (args: Snapshot<Args>) => boolean): void;
     invalidateGroup(group: QueryGroup): void;
     /** Cancel requests while retaining the last success. Explicit refresh restarts them. */
-    cancelQuery<Args, A, E>(definition: Query<Args, A, E, R>, ...selected: [] | [NoInfer<Args> | Snapshot<NoInfer<Args>>]): void;
+    cancelQuery<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, ...selected: [] | [NoInfer<Args> | Snapshot<NoInfer<Args>>]): void;
     /** Clear cached data and cancel requests; a subsequent selection or refresh reloads. */
-    removeQuery<Args, A, E>(definition: Query<Args, A, E, R>, ...selected: [] | [NoInfer<Args> | Snapshot<NoInfer<Args>>]): void;
-    prefetch<Args, A, E>(definition: Query<Args, A, E, R>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>, options?: {
+    removeQuery<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, ...selected: [] | [NoInfer<Args> | Snapshot<NoInfer<Args>>]): void;
+    prefetch<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>, options?: {
         readonly refresh?: boolean;
     }): Effect.Effect<Snapshot<A>, E>;
     /** Publish a protected success, including undefined, and supersede any pending load for this key. */
-    setQueryData<Args, A, E>(definition: Query<Args, A, E, R>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>, value: NoInfer<A> | Snapshot<NoInfer<A>>): Snapshot<A>;
+    setQueryData<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>, value: NoInfer<A> | Snapshot<NoInfer<A>>): Snapshot<A>;
     /**
      * Update an existing success, including one retained during refresh or failure, and supersede its load.
      * No success or an undefined updater return skips the write. Use setQueryData to seed or store undefined.
      * Updaters run synchronously on readonly data; a throw leaves the cached value unchanged.
      */
-    updateQueryData<Args, A, E>(definition: Query<Args, A, E, R>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>, update: (previous: Snapshot<A>) => NoInfer<A> | Snapshot<NoInfer<A>> | undefined): Snapshot<A> | undefined;
-    invalidateQuery<Args, A, E>(definition: Query<Args, A, E, R>, ...selected: [] | [NoInfer<Args> | Snapshot<NoInfer<Args>>]): void;
+    updateQueryData<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, args: NoInfer<Args> | Snapshot<NoInfer<Args>>, update: (previous: Snapshot<A>) => NoInfer<A> | Snapshot<NoInfer<A>> | undefined): Snapshot<A> | undefined;
+    invalidateQuery<Args, A, E>(definition: Query<Args, A, E, R | Scope.Scope>, ...selected: [] | [NoInfer<Args> | Snapshot<NoInfer<Args>>]): void;
     /** Observe account resets without exposing registry mutation. */
     onReset(listener: () => void): () => void;
     resetResources(): void;
-    /** Interrupt every request and wait for its finalizers, including previously canceled requests. */
-    close(): Promise<void>;
+    /** Release retained acquisitions and join all load/resource finalizers, including canceled or evicted entries. */
+    close(): Effect.Effect<void>;
     dispose(): void;
 }

package/dist/cache.js

@@ -1,14 +1,20 @@
 import { Settlement } from './settlement.js';
 import { protectSnapshot } from './snapshot.js';
-import { Deferred, Effect, Option } from 'effect';
+import * as Deferred from 'effect/Deferred';
+import * as Effect from 'effect/Effect';
+import * as Scope from 'effect/Scope';
+import * as Exit from 'effect/Exit';
+import * as Option from 'effect/Option';
 import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
 import * as Atom from 'effect/unstable/reactivity/Atom';
 import * as AtomRegistry from 'effect/unstable/reactivity/AtomRegistry';
 import { loadEffect } from './load.js';
 import { shareData } from './sharing.js';
-import { encodeQueryKey } from './query.js';
+import { encodeQueryArguments } from './query.js';
 import { registerCache } from './cache-internals.js';
 import { queryDefinition } from './query-internals.js';
+import { defaultUiRuntime, makeUiRuntime } from './runtime.js';
+import { reportError, reportSafely } from './errors.js';
 export { loadEffect } from './load.js';
 export { shareValue } from './share.js';
 export function makeQueryCache(runtimeOrOptions, options = {}) {
@@ -21,6 +27,7 @@ function createQueryCache(runtime, options = {}) {
     if (!Number.isFinite(retention) || retention < 0)
         throw new RangeError('Query retention must be finite and nonnegative.');
     const registry = AtomRegistry.make({ defaultIdleTTL: retention });
+    const clock = (runtime ?? defaultUiRuntime).clock;
     const cancelValue = Symbol('cancel');
     const removeValue = Symbol('remove');
     const generation = Atom.keepAlive(Atom.make(0));
@@ -52,8 +59,28 @@ function createQueryCache(runtime, options = {}) {
                 next.revision = ++nextRevision;
                 next.canceled = false;
                 const revision = next.revision;
+                const scope = Scope.makeUnsafe();
+                const completed = Deferred.makeUnsafe();
+                const finish = settlement.begin();
+                let started = false;
+                let stopping = false;
+                get.addFinalizer(() => {
+                    stopping = true;
+                    // The atom interrupts its load first. Join acquisition and its ensuring
+                    // finalizers before closing resources, including late acquisitions.
+                    Effect.runFork(Effect.uninterruptible(Effect.gen(function* () {
+                        if (started)
+                            yield* Deferred.await(completed);
+                        yield* Scope.close(scope, Exit.void);
+                    })).pipe(Effect.ensuring(Effect.sync(finish)))).addObserver((exit) => {
+                        if (Exit.isFailure(exit))
+                            reportSafely(reportError, exit.cause);
+                    });
+                });
                 return Effect.suspend(() => {
-                    const finish = settlement.begin();
+                    if (stopping)
+                        return Effect.interrupt;
+                    started = true;
                     return loadEffect(() => next.load()).pipe(Effect.map((value) => {
                         const shared = Option.isSome(previous)
                             ? share(previous.value, value)
@@ -62,7 +89,12 @@ function createQueryCache(runtime, options = {}) {
                         if (!disposed && revision === next.revision)
                             remember(next, snapshot);
                         return snapshot;
-                    }), Effect.ensuring(Effect.sync(finish)));
+                    }), Scope.provide(scope), Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void).pipe(Effect.ensuring(Effect.sync(() => {
+                        Deferred.doneUnsafe(completed, Effect.void);
+                        // Successful loads retain their resources with the atom entry.
+                        if (Exit.isFailure(exit))
+                            finish();
+                    })))));
                 });
             });
             const next = {
@@ -110,7 +142,7 @@ function createQueryCache(runtime, options = {}) {
         return { entry, atom: entry.atom };
     };
     const remember = (entry, value) => {
-        entry.loadedAt = Date.now();
+        entry.loadedAt = clock.currentTimeMillisUnsafe();
         const node = registry.getNodes().get(entry.atom);
         if (node)
             values.set(node, { value });
@@ -123,13 +155,15 @@ function createQueryCache(runtime, options = {}) {
         if (disposed)
             throw new Error('Cannot write to a disposed query cache.');
     };
-    const queryKey = (definition, args) => `query:${identity(definition)}:${encodeQueryKey(args)}`;
+    const queryKey = (definition, args) => `query:${identity(definition)}:${encodeQueryArguments(definition, args)}`;
     const acquireQuery = (definition, args) => {
         const config = queryDefinition(definition);
         protectSnapshot(args);
         const { entry, atom } = acquire(queryKey(definition, args), () => {
             const effect = Effect.suspend(() => config.load(args, previousValue(resources.get(queryKey(definition, args)))?.value));
-            return runtime ? runtime.provide(effect) : effect;
+            return runtime
+                ? runtime.provideScoped(effect)
+                : effect;
         }, config.share);
         entry.query = definition;
         entry.args = args;
@@ -147,7 +181,7 @@ function createQueryCache(runtime, options = {}) {
             refresh(entry);
         if (registry.getNodes().has(atom) &&
             entry.loadedAt !== undefined &&
-            Date.now() - entry.loadedAt >= config.staleTime) {
+            clock.currentTimeMillisUnsafe() - entry.loadedAt >= config.staleTime) {
             const current = registry.get(atom);
             if (!current.waiting)
                 refresh(entry);
@@ -292,8 +326,10 @@ function createQueryCache(runtime, options = {}) {
         },
         close() {
             if (!closing) {
-                cache.dispose();
-                closing = settlement.wait();
+                closing = Effect.suspend(() => {
+                    cache.dispose();
+                    return settlement.wait();
+                });
             }
             return closing;
         },
@@ -322,3 +358,8 @@ function createQueryCache(runtime, options = {}) {
     });
     return Object.freeze(cache);
 }
+/** Capture application services and clock, and close the cache with the current Effect scope. */
+export const scopedQueryCache = (options = {}) => Effect.gen(function* () {
+    const runtime = yield* makeUiRuntime();
+    return yield* Effect.acquireRelease(Effect.sync(() => makeQueryCache(runtime, options)), (cache) => cache.close());
+});

package/dist/collection.d.ts

@@ -9,7 +9,7 @@ export interface Rows<A> {
     slice(start?: number, end?: number): Rows<A>;
 }
 /** Validate without retaining values. Positions are zero-based array indices. */
-export declare function validateIdentities<A>(items: readonly A[], identity: (item: A, index: number) => Identity): Identity[];
+export declare function validateIdentities<A, K>(items: readonly A[], identity: (item: A, index: number) => K): K[];
 export interface Collection<A> {
     from(this: void, items: readonly (A | Snapshot<A>)[]): Rows<Snapshot<A>>;
     share<B extends A | Snapshot<A>>(this: void, previous: readonly B[], next: readonly B[]): readonly Snapshot<B>[];

package/dist/collection.js

@@ -2,10 +2,8 @@ import { shareData } from './sharing.js';
 /** Validate without retaining values. Positions are zero-based array indices. */
 export function validateIdentities(items, identity) {
     const seen = new Map();
-    return items.map((item, index) => {
+    return Array.from(items, (item, index) => {
         const key = identity(item, index);
-        if (typeof key !== 'string' && typeof key !== 'number')
-            throw new Error(`Invalid collection identity at index ${index}. Use a string or number domain identity, or sequence(items) for positional identity.`);
         const previous = seen.get(key);
         if (previous !== undefined)
             throw new Error(`Duplicate collection identity at indices ${previous} and ${index}. Identity must be unique within the collection; use a composite domain identity when IDs are only locally unique.`);

package/dist/component.d.ts

@@ -31,7 +31,7 @@ export declare function component<Props, Model extends {
 /** Mount an existing program without introducing a second state owner. */
 export declare function programView<Props, Model, Message>(definition: {
     identity?: (props: Snapshot<Props>) => unknown;
-    create: (props: Snapshot<Props>) => import('./program').Program<Model, Message>;
+    create: (props: Snapshot<Props>, runtime: UiRuntime<never>) => import('./program').Program<Model, Message>;
     receive: (source: import('./program').Program<Model, Message>, props: Snapshot<Props>) => void;
     view: View<Model, Message>;
 }): View<Props, never>;

package/dist/component.js

@@ -1,3 +1,5 @@
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
 import { compiled, Scope, viewRegion } from './dom.js';
 import { mapCommand, program } from './program.js';
 import { patchModel } from './state.js';
@@ -17,8 +19,9 @@ export function localComponent(definition) {
 }
 /** A child model receives immutable parent inputs and owns its own message/command loop. */
 export function component(definition) {
-    const runtime = definition.runtime ?? defaultUiRuntime;
     return identify(compiled((scope, parent, before) => {
+        const ownerRuntime = scope.settlement.runtime ?? defaultUiRuntime;
+        const runtime = definition.runtime ?? ownerRuntime;
         const wrap = (next) => ({
             model: next.model,
             ...(next.cancel ? { cancel: next.cancel } : {}),
@@ -31,6 +34,7 @@ export function component(definition) {
         const source = program({
             initial: definition.init(scope.value),
             onDefect: scope.report,
+            runtime: ownerRuntime,
             update: (model, envelope) => wrap(envelope.type === 'Input'
                 ? (definition.receive?.(model, envelope.props) ?? {
                     model: Object.is(model.props, envelope.props)
@@ -60,7 +64,7 @@ export function component(definition) {
 /** Mount an existing program without introducing a second state owner. */
 export function programView(definition) {
     return identify(compiled((scope, parent, before) => {
-        const source = definition.create(scope.value);
+        const source = definition.create(scope.value, scope.settlement.runtime ?? defaultUiRuntime);
         if (scope.disposed) {
             closeProgram(scope, source);
             return;
@@ -82,9 +86,10 @@ function closeProgram(scope, source) {
     const finish = scope.settlement.begin();
     try {
         if (source.close) {
-            source.close().then(finish, (error) => {
+            Effect.runFork(source.close()).addObserver((exit) => {
                 finish();
-                reportSafely(scope.report, error);
+                if (exit._tag === 'Failure')
+                    reportSafely(scope.report, Cause.squash(exit.cause));
             });
         }
         else {

package/dist/dom.d.ts

@@ -1,12 +1,16 @@
-import type { Snapshot } from './snapshot.js';
+import * as Effect from 'effect/Effect';
+import { type Snapshot } from './snapshot.js';
 import { type ReportError } from './errors.js';
 import { type BindingSource } from './diagnostics.js';
 import type { Rows } from './index.js';
 import { jsxComponent, type JSX } from './jsx.js';
 import type { DomMount } from './mount.js';
 import { Settlement } from './settlement.js';
-import type { Program, Send } from './program.js';
+import type { Send } from './program.js';
+import type { Source } from './source.js';
+import type { UiRuntime } from './runtime.js';
 type Dependencies = () => readonly unknown[];
+type BindingLocation = BindingSource | (() => BindingSource | undefined);
 type Cleanup = () => void;
 type Build<M, E> = (scope: Scope<M, E>, parent: Node, before: Node | null) => void;
 /** Compiler implementation. No implicit tracking, proxies, or per-binding subscriptions. */
@@ -18,10 +22,8 @@ export declare class Scope<M, E> {
     readonly jobs: Cleanup[];
     readonly cleanups: Cleanup[];
     disposed: boolean;
-    private revision;
     constructor(value: M, send: Send<E>, report?: ReportError, settlement?: Settlement);
-    derive<A>(dependencies: Dependencies, compute: () => A, source?: BindingSource): () => A;
-    watch(dependencies: Dependencies, apply: () => void, source?: BindingSource): void;
+    watch(dependencies: Dependencies, apply: () => void, source?: BindingLocation): void;
     set(value: M): void;
     dispose(): void;
 }
@@ -29,8 +31,8 @@ export interface View<M, E> extends JSX.ComponentType {
     (this: never, props: [E] extends [never] ? M | Snapshot<M> : never): JSX.Element;
     readonly build: Build<M, E>;
 }
-/** Compiler marker for mounting a view with an explicit model and message dispatcher. */
-export declare const ViewBinding: (<M, E>(this: never, _props: {
+/** Mount a view with an explicit model and message dispatcher. */
+export declare const ViewBinding: (<M, E>(this: never, props: {
     view: View<M, E>;
     model: NoInfer<M> | Snapshot<NoInfer<M>>;
     send: Send<NoInfer<E>>;
@@ -38,51 +40,82 @@ export declare const ViewBinding: (<M, E>(this: never, _props: {
     [jsxComponent]: true;
 };
 /** Untyped callers get an actionable failure instead of silently losing child messages. */
-export declare function unboundSend(_message: never): never;
+export declare function unboundSend(_message: unknown): never;
 declare const contentBrand: unique symbol;
 /** Owned markup accepted wherever JSX can render content. */
 export interface CompiledContent {
     readonly [contentBrand]: true;
 }
-/** A compiled template with a typed placement value, captured in its declaring view. */
+/** An ordinary render callback with a typed input. Invoke it to produce content. */
 export interface Slot<A = void> {
     (value: A | Snapshot<A>): JSX.Element;
-    readonly [contentBrand]: [A] extends [void] ? true : false;
 }
-/** Compiler marker: declare inside view(), or directly in a compiled component prop. */
-export declare function slot<A = void>(_render: (value: Snapshot<A>) => JSX.Element): Slot<A>;
-/** Compiler output. Captures follow their declaring scope; placements own independent scopes. */
-export declare function compiledSlot<M, E, A>(owner: Scope<M, E>, build: Build<A, E>): Slot<A>;
-/** This declaration is a compiler marker, never a component setup callback. */
-export declare function view<M, E = never>(_render: (model: Snapshot<M>, send: Send<E>) => JSX.Element): View<M, E>;
+export declare function slot<A = void>(render: (value: Snapshot<A>) => JSX.Element): Slot<A>;
+/** Evaluate ordinary synchronous JavaScript for each immutable model publication. */
+export declare function view<M, E = never>(render: (model: Snapshot<M>, send: Send<E>) => JSX.Element): View<M, E>;
 export declare function compiled<M, E>(build: Build<M, E>): View<M, E>;
+/** Skip a view only under the caller's explicit equality contract. */
+export declare function memoView<M, E>(definition: View<M, E>, equals: (previous: Snapshot<M>, next: Snapshot<M>) => boolean): View<M, E>;
+type MarkupProps = Readonly<Record<string, unknown>> & {
+    readonly children?: JSX.Element;
+};
+/** JSX factories preserve host identity by element type; source locations are metadata only. */
+export declare function markup(tag: string, sources?: Readonly<Record<string, BindingSource>>): (props: MarkupProps) => JSX.Element;
+export declare function renderComponent(component: (props: never) => JSX.Element, props: Readonly<Record<string, unknown>>): JSX.Element;
+/** Preserve collection identity (or array reference identity) while rendering rows. */
+export declare function list<A>(rows: Rows<A> | readonly A[], render: (item: A, index: number) => JSX.Element): JSX.Element;
+/**
+ * Define keyed row projection once. Every dependency is passed as an explicit input;
+ * only changed projected props enter the row view's renderer.
+ */
+export declare function listView<A, Input, Props, Message = never>(options: {
+    readonly project: (item: A, index: number, input: Input) => Props | Snapshot<Props>;
+    readonly view: View<Props, Message>;
+    readonly equals?: (previous: Snapshot<Props>, next: Snapshot<Props>) => boolean;
+}): (rows: Rows<A> | readonly A[], input: Input, ...dispatch: [Message] extends [never] ? [send?: Send<Message>] : [send: Send<Message>]) => JSX.Element;
+/** Render a declared source in its own subscribed region. No dependencies are inferred. */
+export declare function observe<A>(source: Source<A>, render: (value: Snapshot<A>) => JSX.Element): JSX.Element;
 export interface PortalProps {
     readonly children?: JSX.Element;
     readonly mount?: Element | undefined;
 }
 /** Owned content in an element target, defaulting to the document body. */
 export declare const Portal: View<PortalProps, never>;
-export declare function mountView<M, E>(parent: Node, definition: View<M, E>, source: Program<M, E>, options?: {
-    onError?: ReportError;
-}): (() => void) & {
-    dispose: () => void;
-    close: () => Promise<void>;
-};
+export interface MountOptions {
+    readonly onError?: ReportError;
+    readonly runtime?: UiRuntime<never>;
+}
+export interface Mounted {
+    (): void;
+    readonly dispose: () => void;
+    readonly close: () => Effect.Effect<void>;
+}
+export declare function mountView<M, E>(parent: Node, definition: View<M, E>, source: Source<M> & {
+    readonly send: Send<E>;
+}, options?: MountOptions): Mounted;
+export declare function mountView<M>(parent: Node, definition: View<M, never>, source: Source<M>, options?: MountOptions): Mounted;
+export declare function mountView<M, E>(parent: Node, definition: View<M, E>, source: Source<M>, options: MountOptions & {
+    readonly send: Send<E>;
+}): Mounted;
+/** Internal mounting boundary. Its owner retains completion accounting if construction fails. */
+export declare function mountViewWithSettlement<M, E>(parent: Node, definition: View<M, E>, source: Source<M>, options: {
+    readonly send: Send<E>;
+    readonly onError?: ReportError;
+}, settlement: Settlement): Mounted;
 export declare function element(parent: Node, before: Node | null, tag: string): Element;
 export declare function attribute(element: Element, name: string, value: unknown): void;
 /** Compiler output for attributes whose unchanged value needs no DOM refresh. */
-export declare function bindAttribute<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown, source?: BindingSource): void;
+export declare function bindAttribute<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown, source?: BindingLocation): void;
 /** Handled edits can change a control even when dispatch publishes no new model. */
-export declare function bindControl<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown, source?: BindingSource): void;
-export declare function text<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, dependencies: Dependencies, read: () => unknown, source?: BindingSource): void;
-export declare function event<M, E>(scope: Scope<M, E>, element: Element, name: string, handler: (event: Event) => unknown): void;
-/** One handler identity owns its requests, regardless of the JSX attribute spelling. */
-export declare function bindEvent<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown): void;
+export declare function bindControl<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown, source?: BindingLocation): void;
+export declare function text<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, dependencies: Dependencies, read: () => JSX.Element, source?: BindingLocation): void;
+export declare function event<M, E>(scope: Scope<M, E>, element: Element, name: string, handler: (event: Event) => JSX.EventResult): void;
+/** The event binding owns its requests; snapshot renders may replace its callback. */
+export declare function bindEvent<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => ((event: Event) => JSX.EventResult) | undefined): void;
 /** Reconcile merged JSX attributes. Each host, event and control owns its cleanup. */
-export declare function bindAttributes<M, E>(scope: Scope<M, E>, element: Element, dependencies: Dependencies, read: () => Readonly<Record<string, unknown>>): void;
+export declare function bindAttributes<M, E>(scope: Scope<M, E>, element: Element, dependencies: Dependencies, read: () => Readonly<Record<string, unknown>>, sources?: () => Readonly<Record<string, BindingSource>> | undefined): void;
 export declare function branch<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, choose: () => boolean, yes: Build<M, E>, no: Build<M, E>): void;
 export declare function each<M, E, A>(scope: Scope<M, E>, parent: Node, before: Node | null, read: () => Rows<A> | readonly A[], outer: Dependencies, indexUsed: boolean, build: Build<readonly [A, number], E>): void;
-export declare function invoke<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, dependencies: Dependencies, read: () => readonly unknown[], build: Build<readonly unknown[], E>): void;
 export declare function child<M, E, C, F>(scope: Scope<M, E>, parent: Node, before: Node | null, definition: View<C, F>, dependencies: Dependencies, model: () => C, send: Send<F>): void;
 /** A late-bound compiled definition owns one replaceable DOM region. */
 export declare function viewRegion<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, options?: {
@@ -94,4 +127,4 @@ export declare function portal<M, E>(scope: Scope<M, E>, build: Build<M, E>, mou
 /** Build static markup once per document/namespace, then clone native nodes at each use. */
 export declare function template(build: string | ((parent: Node, before: Node | null) => void), depth?: number): (parent: Node, before: Node | null) => Node;
 export declare function literal(parent: Node, before: Node | null, value: string): void;
-export { intrinsic } from './intrinsic.js';
+export {};