effectweb 0.3.0 → 0.3.1

package/dist/dom.js

@@ -1,3 +1,4 @@
+import { compiledSlots } from './slotIdentity.js';
 import attributeData from './dom-attributes.json' with { type: 'json' };
 import { validateIdentities } from './collection.js';
 import { runAll, reportError, reportSafely } from './errors.js';
@@ -5,6 +6,7 @@ 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';
 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.
@@ -36,14 +38,16 @@ export class Scope {
     value;
     send;
     report;
+    settlement;
     jobs = [];
     cleanups = [];
     disposed = false;
     revision = 0;
-    constructor(value, send, report = reportError) {
+    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;
@@ -145,10 +149,10 @@ export function compiledSlot(owner, build) {
         placements.clear();
     });
     const definition = {
-        mount(parent, before, value) {
+        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, owner.report);
+            const scope = new Scope(value, owner.send, report, settlement);
             const fragment = buildFragment(parent);
             const range = markers(fragment, null);
             scope.cleanups.push(() => remove(range.start, range.end));
@@ -173,10 +177,12 @@ export function compiledSlot(owner, build) {
             };
         },
     };
-    return Object.assign((value) => new SlotPlacement(definition, value), {
+    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) {
@@ -268,11 +274,18 @@ export function mountView(parent, definition, source, options = {}) {
             remove(start, end);
             throw error;
         }
-        return () => {
+        const dispose = () => {
             if (scope.disposed)
                 return;
             runAll([unsubscribe, () => scope.dispose(), () => remove(start, end)], scope.report);
         };
+        return Object.assign(dispose, {
+            dispose,
+            close: () => {
+                dispose();
+                return scope.settlement.wait();
+            },
+        });
     });
 }
 export function element(parent, before, tag) {
@@ -525,7 +538,7 @@ export function text(scope, parent, before, dependencies, read, source) {
             }
             content = {
                 definition: value.definition,
-                mounted: value.definition.mount(node.parentNode, node, value.value, scope.report),
+                mounted: value.definition.mount(node.parentNode, node, value.value, scope.report, scope.settlement),
             };
             return;
         }
@@ -557,10 +570,10 @@ function validateContent(value, active = new Set()) {
     }
 }
 const arrayContent = {
-    mount: (_parent, before, value, report) => mountArray(report, before, value),
+    mount: (_parent, before, value, report, settlement) => mountArray(report, before, value, settlement),
 };
 /** Runtime content arrays are positional; domain lists retain the explicit collection contract. */
-function mountArray(report, before, initial) {
+function mountArray(report, before, initial, settlement) {
     const cells = [];
     const disposeCell = (cell) => {
         cell.scope.dispose();
@@ -578,7 +591,7 @@ function mountArray(report, before, initial) {
                     cell.scope.set(values[index]);
                 continue;
             }
-            const scope = new Scope(values[index], unboundSend, report);
+            const scope = new Scope(values[index], unboundSend, report, settlement);
             const fragment = buildFragment(before.parentNode);
             const range = markers(fragment, null);
             try {
@@ -617,7 +630,7 @@ export function event(scope, element, name, handler) {
             try {
                 const result = handler(event);
                 if (result !== null && typeof result === 'object' && !scope.disposed) {
-                    effects ??= eventEffects(scope.report);
+                    effects ??= eventEffects(scope.report, scope.settlement);
                     effects.accept(result);
                 }
             }
@@ -655,7 +668,7 @@ export function bindEvent(scope, element, name, dependencies, read) {
         current = next;
         if (typeof next === 'function') {
             const handler = next;
-            owned = new Scope(next, scope.send, scope.report);
+            owned = new Scope(next, scope.send, scope.report, scope.settlement);
             event(owned, element, name, handler);
         }
     });
@@ -699,7 +712,7 @@ export function bindAttributes(scope, element, dependencies, read) {
                 binding.set(value);
                 continue;
             }
-            const owned = new Scope(value, scope.send, scope.report);
+            const owned = new Scope(value, scope.send, scope.report, scope.settlement);
             bindings.set(name, owned);
             if (name === 'use')
                 attach(owned, element, () => [owned.value], () => owned.value);
@@ -726,7 +739,7 @@ export function branch(scope, parent, before, choose, yes, no) {
         if (active !== next) {
             child?.dispose();
             clear(start, end);
-            child = new Scope(scope.value, scope.send, scope.report);
+            child = new Scope(scope.value, scope.send, scope.report, scope.settlement);
             const fragment = buildFragment(end.parentNode);
             try {
                 (next ? yes : no)(child, fragment, null);
@@ -804,7 +817,7 @@ export function each(scope, parent, before, read, outer, indexUsed, build) {
             if (!row) {
                 const fragment = buildFragment(target);
                 const range = markers(fragment, null);
-                const child = new Scope([item, index], scope.send, scope.report);
+                const child = new Scope([item, index], scope.send, scope.report, scope.settlement);
                 try {
                     build(child, fragment, range.end);
                 }
@@ -880,7 +893,7 @@ 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);
+    const child = new Scope(read(), scope.send, scope.report, scope.settlement);
     scope.cleanups.push(() => child.dispose());
     build(child, parent, before);
     scope.watch(dependencies, () => {
@@ -890,7 +903,7 @@ export function invoke(scope, parent, before, dependencies, read, build) {
     });
 }
 export function child(scope, parent, before, definition, dependencies, model, send) {
-    const child = new Scope(model(), send, scope.report);
+    const child = new Scope(model(), send, scope.report, scope.settlement);
     scope.cleanups.push(() => child.dispose());
     definition.build(child, parent, before);
     scope.watch(dependencies, () => {
@@ -900,11 +913,12 @@ export function child(scope, parent, before, definition, dependencies, model, se
     });
 }
 /** A late-bound compiled definition owns one replaceable DOM region. */
-export function viewRegion(scope, parent, before) {
+export function viewRegion(scope, parent, before, options = {}) {
     const { start, end } = markers(parent, before);
     let active;
     let definition;
-    scope.jobs.push(() => active?.set(scope.value));
+    if (!options.manual)
+        scope.jobs.push(() => active?.set(scope.value));
     scope.cleanups.push(() => {
         active?.dispose();
         remove(start, end);
@@ -925,7 +939,7 @@ export function viewRegion(scope, parent, before) {
         clear(start, end);
         if (!next)
             return;
-        const child = new Scope(scope.value, scope.send, scope.report);
+        const child = new Scope(scope.value, scope.send, options.report ?? scope.report, scope.settlement);
         const fragment = buildFragment(end.parentNode);
         active = child;
         definition = next;
@@ -965,14 +979,17 @@ export function attach(scope, element, dependencies, read) {
             return;
         queueMicrotask(() => {
             if (!scope.disposed && token === generation) {
+                const finished = scope.settlement.begin();
                 try {
                     const acquired = startMount(element, mount, scope.report);
+                    acquired.closed.then(finished, finished);
                     if (scope.disposed || token !== generation)
                         acquired.dispose();
                     else
                         active = acquired;
                 }
                 catch (error) {
+                    finished();
                     reportSafely(scope.report, error);
                 }
             }
@@ -998,7 +1015,7 @@ export function portal(scope, build, mount = () => undefined) {
                 ? target.ownerDocument.createElementNS(svgNamespace, 'g')
                 : target.ownerDocument.createElement('div');
             host.style.display = 'contents';
-            child = new Scope(scope.value, scope.send, scope.report);
+            child = new Scope(scope.value, scope.send, scope.report, scope.settlement);
             target.appendChild(host);
             build(child, host, null);
             return;
@@ -1089,3 +1106,4 @@ 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,5 +1,6 @@
 import { Effect } from 'effect';
 import { type ReportError } from './errors.js';
+import type { Settlement } from './settlement.js';
 import { type UiRuntime } from './runtime.js';
 declare const tag: unique symbol;
 export interface EffectEventRequest {
@@ -11,7 +12,7 @@ export interface EffectEventRequest {
 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. */
-export declare function eventEffects(report: ReportError): {
+export declare function eventEffects(report: ReportError, settlement?: Settlement): {
     accept(value: unknown): void;
     dispose(): void;
 };

package/dist/effectEvent.js

@@ -7,7 +7,7 @@ export function effectEvent(policy, load, runtime) {
     return (event) => ({ [tag]: true, policy, effect: owner.provide(load(event)) });
 }
 /** Internal listener owner, allocated only when an event returns a value needing inspection. */
-export function eventEffects(report) {
+export function eventEffects(report, settlement) {
     let active;
     let disposed = false;
     const stop = () => {
@@ -27,8 +27,10 @@ export function eventEffects(report) {
                 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));
@@ -43,6 +45,7 @@ export function eventEffects(report) {
                     });
                 }
                 catch (error) {
+                    finished?.();
                     if (active === token)
                         active = undefined;
                     reportSafely(report, error);

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { lazyView, type LazyViewOptions } from './lazy.js';
 export type { JSX } from './jsx.js';
 export { Portal, domBinding, domMount, type DomMount, type PortalProps } from './mount.js';
 export { pages, type PagesMessage, type PagesRequest, type PagesModel, type PagesProgram, type Pagination, } from './pages.js';
-export { program, actionCommand, effectCommand, commandSlot, type CommandSlot, type Command, type Program, type Send, type Transition, } from './program.js';
+export { program, mapTransition, actionCommand, effectCommand, commandSlot, type CommandSlot, type Command, type Program, type Send, type Transition, } from './program.js';
 export { available, resourceComponent, resourceError, type ResourceMessage, type ResourceModel, } from './resource.js';
 export { fromPromise, type UiLoad, type UiPage } from './load.js';
 export { observeBindings, inspectBindings, mountBindingInspector, type BindingInspector, type BindingInspection, observePrograms, type BindingUpdate, type ProgramUpdate, } from './diagnostics.js';
@@ -20,7 +20,10 @@ export { slot, type Slot, type CompiledContent } from './dom.js';
 export { AsyncContent, type AsyncContentProps } from './AsyncContent.js';
 export { defineTasks, type TaskDefinition, type TasksModel, type TasksMessage, type TaskResults, } from './tasks.js';
 export { uiRuntime, type UiRuntime } from './runtime.js';
-export { query, type Query, type QueryKey } from './query.js';
-export { makeQueryCache, type QueryCache } from './cache.js';
+export { query, queryGroup, type Query, type QueryKey, type QueryGroup } from './query.js';
+export { makeQueryCache, type QueryCache, type QueryCacheOptions } from './cache.js';
 export { queryResource, type QueryResource, observeQuery, lifetime, projectionCache, sessionGroup, type SessionContext, type Read, } from './session.js';
 export { httpJson } from './http.js';
+export { infiniteQuery, infiniteResource, type InfiniteData, type InfiniteQuery, type InfiniteResource, } from './infinite-query.js';
+export { keyedTasks, type TaskHandle, type TaskOutcome } from './keyed-tasks.js';
+export { errorBoundary } from './boundary.js';

package/dist/index.js

@@ -9,7 +9,7 @@ export { mountView, view, ViewBinding } from './dom.js';
 export { lazyView } from './lazy.js';
 export { Portal, domBinding, domMount } from './mount.js';
 export { pages, } from './pages.js';
-export { program, actionCommand, effectCommand, commandSlot, } from './program.js';
+export { program, mapTransition, actionCommand, effectCommand, commandSlot, } from './program.js';
 export { available, resourceComponent, resourceError, } from './resource.js';
 export { fromPromise } from './load.js';
 export { observeBindings, inspectBindings, mountBindingInspector, observePrograms, } from './diagnostics.js';
@@ -18,7 +18,10 @@ export { slot } from './dom.js';
 export { AsyncContent } from './AsyncContent.js';
 export { defineTasks, } from './tasks.js';
 export { uiRuntime } from './runtime.js';
-export { query } from './query.js';
+export { query, queryGroup } from './query.js';
 export { makeQueryCache } from './cache.js';
 export { queryResource, observeQuery, lifetime, projectionCache, sessionGroup, } from './session.js';
 export { httpJson } from './http.js';
+export { infiniteQuery, infiniteResource, } from './infinite-query.js';
+export { keyedTasks } from './keyed-tasks.js';
+export { errorBoundary } from './boundary.js';

package/dist/infinite-query.d.ts

@@ -0,0 +1,42 @@
+import { Effect } from 'effect';
+import { type Query, type QueryArgs, type QueryGroup } from './query.js';
+import type { QueryCache } from './cache.js';
+import { type QueryResource } from './session.js';
+import { type Snapshot } from './snapshot.js';
+export interface InfiniteData<A, Param> {
+    readonly pages: readonly {
+        readonly param: Param;
+        readonly value: A;
+    }[];
+    readonly next: Param | undefined;
+}
+export interface InfiniteQuery<Args, A, Param, E = never, R = never> {
+    readonly query: Query<Args, InfiniteData<A, Param>, E, R>;
+    readonly page: Query<{
+        args: Args;
+        param: Param;
+    }, A, E, R>;
+    readonly maxPages: number;
+    readonly next: (value: Snapshot<A>, param: Snapshot<Param>) => Param | undefined;
+}
+/** Shared pages with explicit cursor identity. Refresh preserves retained page parameters by default. */
+export declare function infiniteQuery<Args, A, Param, E = never, R = never>(definition: {
+    readonly name: string;
+    readonly initial: Param;
+    readonly load: (args: Snapshot<Args>, param: Snapshot<Param>) => Effect.Effect<A, E, R>;
+    readonly next: (value: Snapshot<A>, param: Snapshot<Param>) => Param | undefined;
+    readonly maxPages?: number;
+    readonly refresh?: 'retained' | 'first';
+    readonly groups?: readonly QueryGroup[];
+} & (Args extends QueryArgs<Args> ? unknown : {
+    readonly nonSerializableQueryArguments: never;
+}) & (Param extends QueryArgs<Param> ? unknown : {
+    readonly nonSerializablePageParameters: never;
+})): InfiniteQuery<Args, A, Param, E, R>;
+export interface InfiniteResource<Args, A, Param, E = never> extends QueryResource<Args, InfiniteData<A, Param>, E> {
+    loadNext(): Effect.Effect<Snapshot<InfiniteData<A, Param>>, E>;
+    retryPage(param: Param | Snapshot<Param>): Effect.Effect<Snapshot<InfiniteData<A, Param>>, E>;
+    seed(args: Args | Snapshot<Args>, data: InfiniteData<A, Param> | Snapshot<InfiniteData<A, Param>>): Snapshot<InfiniteData<A, Param>>;
+}
+/** Cache-owned results, observer-owned subscriptions. Operations return typed Effects for task composition. */
+export declare function infiniteResource<Args, A, Param, E, R>(cache: QueryCache<R>, definition: InfiniteQuery<Args, A, Param, E, NoInfer<R>>): InfiniteResource<Args, A, Param, E>;

package/dist/infinite-query.js

@@ -0,0 +1,150 @@
+import { Effect } from 'effect';
+import { query, encodeQueryKey, } from './query.js';
+import { cacheInternals } from './cache-internals.js';
+import { queryResource } from './session.js';
+import { protectSnapshot } from './snapshot.js';
+/** Shared pages with explicit cursor identity. Refresh preserves retained page parameters by default. */
+export function infiniteQuery(definition) {
+    const config = Object.freeze({ ...definition });
+    const maxPages = config.maxPages ?? Infinity;
+    if (maxPages !== Infinity && (!Number.isInteger(maxPages) || maxPages < 1))
+        throw new RangeError('maxPages must be a positive integer.');
+    encodeQueryKey(config.initial);
+    const initial = protectSnapshot(config.initial);
+    const next = (value, param) => {
+        const result = config.next(value, param);
+        encodeQueryKey(result);
+        return result;
+    };
+    const page = query({
+        name: `${config.name}:page`,
+        load: ({ args, param }) => config.load(args, param),
+    });
+    const root = query({
+        name: config.name,
+        ...(config.groups ? { groups: config.groups } : {}),
+        load: (args, previous) => {
+            const params = config.refresh !== 'first' && previous?.pages.length
+                ? previous.pages.map((page) => page.param)
+                : [initial];
+            return Effect.forEach(params, (param) => config.load(args, param).pipe(Effect.map((value) => ({ param: param, value })))).pipe(Effect.map((pages) => {
+                const last = pages[pages.length - 1];
+                return {
+                    pages,
+                    next: next(protectSnapshot(last.value), last.param),
+                };
+            }));
+        },
+    });
+    return Object.freeze({ query: root, page, maxPages, next });
+}
+const operations = new WeakMap();
+function operationBook(cache, definition) {
+    let definitions = operations.get(cache);
+    if (!definitions) {
+        definitions = new WeakMap();
+        operations.set(cache, definitions);
+    }
+    let book = definitions.get(definition);
+    if (!book) {
+        book = new Map();
+        definitions.set(definition, book);
+    }
+    return book;
+}
+/** Cache-owned results, observer-owned subscriptions. Operations return typed Effects for task composition. */
+export function infiniteResource(cache, definition) {
+    const resource = queryResource({ cache }, definition.query);
+    const internal = cacheInternals(cache);
+    let selected;
+    let disposed = false;
+    const stopReset = cache.onReset(() => {
+        selected = undefined;
+    });
+    const book = operationBook(cache, definition.query);
+    const updatePage = (retry) => Effect.gen(function* () {
+        if (disposed || selected === undefined)
+            return yield* Effect.interrupt;
+        const args = selected;
+        const current = yield* cache.prefetch(definition.query, args);
+        const param = retry ? retry.param : current.next;
+        if (param === undefined)
+            return current;
+        const pageKey = encodeQueryKey(param);
+        const retained = current.pages.some((page) => encodeQueryKey(page.param) === pageKey);
+        if (retry && !retained && encodeQueryKey(current.next) !== pageKey)
+            return yield* Effect.die(new RangeError('Retry a retained page or the next page parameter.'));
+        const key = encodeQueryKey(args);
+        const revision = internal.revision(definition.query, args);
+        let operation = book.get(key);
+        if (!operation || operation.revision !== revision) {
+            operation = { revision, active: 0 };
+            book.set(key, operation);
+        }
+        const state = operation;
+        state.active++;
+        return yield* Effect.gen(function* () {
+            const pageArgs = { args, param };
+            const value = yield* cache.prefetch(definition.page, pageArgs, { refresh: true });
+            let result;
+            cache.batch(() => {
+                const latest = cache.getQueryData(definition.query, args);
+                result = latest;
+                // Other page operations can merge. External refresh, writes and reset own a new revision.
+                if (!latest ||
+                    book.get(key) !== state ||
+                    state.revision !== internal.revision(definition.query, args))
+                    return;
+                const index = latest.pages.findIndex((page) => encodeQueryKey(page.param) === pageKey);
+                if (index < 0 && (retained || encodeQueryKey(latest.next) !== pageKey))
+                    return;
+                if (index >= 0 && latest.pages[index].value === value)
+                    return;
+                const pages = [...latest.pages];
+                const page = { param, value };
+                if (index >= 0)
+                    pages[index] = page;
+                else
+                    pages.push(page);
+                const kept = pages.slice(-definition.maxPages);
+                const last = kept[kept.length - 1];
+                result = cache.setQueryData(definition.query, args, {
+                    pages: kept,
+                    next: definition.next(last.value, last.param),
+                });
+                state.revision = internal.revision(definition.query, args);
+            });
+            return result ?? (yield* Effect.interrupt);
+        }).pipe(Effect.ensuring(Effect.sync(() => {
+            state.active--;
+            if (state.active === 0 && book.get(key) === state)
+                book.delete(key);
+        })));
+    });
+    return {
+        read: resource.read,
+        subscribe: resource.subscribe,
+        select(args) {
+            selected = args;
+            resource.select(args);
+        },
+        refresh: resource.refresh,
+        loadNext: () => updatePage(),
+        retryPage: (param) => updatePage({ param }),
+        seed(args, data) {
+            if (!data.pages.length || data.pages.length > definition.maxPages)
+                throw new RangeError('Seed pages must fit the retained page range.');
+            encodeQueryKey(data.next);
+            const keys = data.pages.map((page) => encodeQueryKey(page.param));
+            if (new Set(keys).size !== keys.length)
+                throw new TypeError('Seed page parameters must be unique.');
+            return cache.setQueryData(definition.query, args, data);
+        },
+        dispose() {
+            disposed = true;
+            selected = undefined;
+            stopReset();
+            resource.dispose();
+        },
+    };
+}

package/dist/intrinsic.d.ts

@@ -0,0 +1,2 @@
+/** 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

@@ -0,0 +1,120 @@
+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/keyed-tasks.d.ts

@@ -0,0 +1,29 @@
+import { Cause, Effect } from 'effect';
+import { type TaskPolicy } from './program.js';
+import type { DisposableOwner } from './owner.js';
+import { type UiRuntime } from './runtime.js';
+import { type Snapshot } from './snapshot.js';
+export type TaskOutcome<A, E> = {
+    readonly _tag: 'Success';
+    readonly value: Snapshot<A>;
+} | {
+    readonly _tag: 'Failure';
+    readonly cause: Cause.Cause<E>;
+} | {
+    readonly _tag: 'Cancelled' | 'Superseded' | 'Dropped';
+};
+export interface TaskHandle<A, E> {
+    readonly outcome: Promise<TaskOutcome<A, E>>;
+}
+/** Per-entity serialization. Inputs are captured now; run reads services when work starts. */
+export declare function keyedTasks<Key, Input, A, E = never, R = never>(owner: DisposableOwner, definition: {
+    readonly name: string;
+    readonly policy: TaskPolicy;
+    readonly run: (key: Key, input: Snapshot<Input>) => Effect.Effect<A, E, R>;
+}, ...provided: [R] extends [never] ? [runtime?: UiRuntime<R>] : [runtime: UiRuntime<R>]): {
+    submit(key: Key, input: Input | Snapshot<Input>): TaskHandle<A, E>;
+    cancel(key: Key): void;
+    drain(...selected: [] | [Key]): Promise<void>;
+    close: () => Promise<void>;
+    dispose: () => void;
+};