effectweb 0.2.3 → 0.3.1

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/jsx.d.ts

@@ -1,9 +1,21 @@
+import type { HtmlAttributes } from './html-attributes.js';
+import type { SvgAttributes, SvgPresentationAttributes } from './svg-attributes.js';
+import type { SnapshotOpaque } from './snapshot.js';
 import type { EffectEventRequest } from './effectEvent.js';
 import type { CompiledContent } from './dom.js';
 import type { DomMount } from './mount.js';
+/** Nominal eligibility for compiled JSX components and compiler primitives. */
+export declare const jsxComponent: unique symbol;
 /** JSX is a compiler input. No renderer library owns its types. */
 export declare namespace JSX {
-    export type Element = Node | string | number | boolean | null | undefined | CompiledContent | Element[];
+    export interface ComponentType {
+        readonly [jsxComponent]: true;
+    }
+    export type ElementType = keyof IntrinsicElements | (ComponentType & ((props: never) => Element));
+    /** Immutable compiler input; preserve this recursive presentation type through snapshots. */
+    export interface ElementArray extends ReadonlyArray<Element>, SnapshotOpaque {
+    }
+    export type Element = string | number | boolean | null | undefined | CompiledContent | ElementArray;
     export type EventHandler<T, E extends Event> = (event: E & {
         currentTarget: T;
         target: EventTarget & globalThis.Element;
@@ -12,73 +24,193 @@ export declare namespace JSX {
     export type CSSProperties = {
         [property: string]: string | number | undefined | null;
     };
+    /** Standard event payloads not yet declared by the minimum supported TypeScript DOM library. */
+    export interface CommandEvent extends Event {
+        readonly command: string;
+        readonly source: globalThis.Element | null;
+    }
+    export interface SnapEvent extends Event {
+        readonly snapTargetBlock: Node | null;
+        readonly snapTargetInline: Node | null;
+    }
+    export interface TimeEvent extends Event {
+        readonly detail: number;
+        readonly view: Window | null;
+    }
+    /** Native element events; window/document listeners belong in an owned DOM binding. */
     export interface Events<T> {
-        onClick?: EventHandler<T, MouseEvent> | undefined;
+        onAbort?: EventHandler<T, UIEvent> | undefined;
+        onAnimationCancel?: EventHandler<T, AnimationEvent> | undefined;
+        onAnimationEnd?: EventHandler<T, AnimationEvent> | undefined;
+        onAnimationIteration?: EventHandler<T, AnimationEvent> | undefined;
+        onAnimationStart?: EventHandler<T, AnimationEvent> | undefined;
+        onAuxClick?: EventHandler<T, PointerEvent> | undefined;
+        onBeforeInput?: EventHandler<T, InputEvent> | undefined;
+        onBeforeMatch?: EventHandler<T, Event> | undefined;
+        onBeforeToggle?: EventHandler<T, ToggleEvent> | undefined;
+        onBlur?: EventHandler<T, FocusEvent> | undefined;
+        onCancel?: EventHandler<T, Event> | undefined;
+        onCanPlay?: EventHandler<T, Event> | undefined;
+        onCanPlayThrough?: EventHandler<T, Event> | undefined;
+        onChange?: EventHandler<T, Event> | undefined;
+        onClick?: EventHandler<T, PointerEvent> | undefined;
+        onClose?: EventHandler<T, Event> | undefined;
+        onCommand?: EventHandler<T, CommandEvent> | undefined;
+        onCompositionEnd?: EventHandler<T, CompositionEvent> | undefined;
+        onCompositionStart?: EventHandler<T, CompositionEvent> | undefined;
+        onCompositionUpdate?: EventHandler<T, CompositionEvent> | undefined;
+        onContentVisibilityAutoStateChange?: EventHandler<T, ContentVisibilityAutoStateChangeEvent> | undefined;
+        onContextLost?: EventHandler<T, Event> | undefined;
+        onContextMenu?: EventHandler<T, PointerEvent> | undefined;
+        onContextRestored?: EventHandler<T, Event> | undefined;
+        onCopy?: EventHandler<T, ClipboardEvent> | undefined;
+        onCueChange?: EventHandler<T, Event> | undefined;
+        onCut?: EventHandler<T, ClipboardEvent> | undefined;
         onDblClick?: EventHandler<T, MouseEvent> | undefined;
-        onContextMenu?: EventHandler<T, MouseEvent> | undefined;
+        onDrag?: EventHandler<T, DragEvent> | undefined;
+        onDragEnd?: EventHandler<T, DragEvent> | undefined;
+        onDragEnter?: EventHandler<T, DragEvent> | undefined;
+        onDragLeave?: EventHandler<T, DragEvent> | undefined;
+        onDragOver?: EventHandler<T, DragEvent> | undefined;
+        onDragStart?: EventHandler<T, DragEvent> | undefined;
+        onDrop?: EventHandler<T, DragEvent> | undefined;
+        onDurationChange?: EventHandler<T, Event> | undefined;
+        onEmptied?: EventHandler<T, Event> | undefined;
+        onEnded?: EventHandler<T, Event> | undefined;
+        onError?: EventHandler<T, Event> | undefined;
+        onFocus?: EventHandler<T, FocusEvent> | undefined;
+        onFocusIn?: EventHandler<T, FocusEvent> | undefined;
+        onFocusOut?: EventHandler<T, FocusEvent> | undefined;
+        onFormData?: EventHandler<T, FormDataEvent> | undefined;
+        onFullscreenChange?: EventHandler<T, Event> | undefined;
+        onFullscreenError?: EventHandler<T, Event> | undefined;
+        onGotPointerCapture?: EventHandler<T, PointerEvent> | undefined;
         onInput?: EventHandler<T, InputEvent> | undefined;
-        onChange?: EventHandler<T, Event> | undefined;
-        onSubmit?: EventHandler<T, SubmitEvent> | undefined;
+        onInvalid?: EventHandler<T, Event> | undefined;
         onKeyDown?: EventHandler<T, KeyboardEvent> | undefined;
+        /** @deprecated Use onKeyDown or onBeforeInput. */
+        onKeyPress?: EventHandler<T, KeyboardEvent> | undefined;
         onKeyUp?: EventHandler<T, KeyboardEvent> | undefined;
-        onPointerDown?: EventHandler<T, PointerEvent> | undefined;
-        onPointerUp?: EventHandler<T, PointerEvent> | undefined;
-        onPointerMove?: EventHandler<T, PointerEvent> | undefined;
-        onPointerEnter?: EventHandler<T, PointerEvent> | undefined;
-        onPointerLeave?: EventHandler<T, PointerEvent> | undefined;
-        onPointerCancel?: EventHandler<T, PointerEvent> | undefined;
+        onLoad?: EventHandler<T, Event> | undefined;
+        onLoadedData?: EventHandler<T, Event> | undefined;
+        onLoadedMetadata?: EventHandler<T, Event> | undefined;
+        onLoadStart?: EventHandler<T, Event> | undefined;
+        onLostPointerCapture?: EventHandler<T, PointerEvent> | undefined;
         onMouseDown?: EventHandler<T, MouseEvent> | undefined;
         onMouseEnter?: EventHandler<T, MouseEvent> | undefined;
         onMouseLeave?: EventHandler<T, MouseEvent> | undefined;
-        onFocus?: EventHandler<T, FocusEvent> | undefined;
-        onBlur?: EventHandler<T, FocusEvent> | undefined;
+        onMouseMove?: EventHandler<T, MouseEvent> | undefined;
+        onMouseOut?: EventHandler<T, MouseEvent> | undefined;
+        onMouseOver?: EventHandler<T, MouseEvent> | undefined;
+        onMouseUp?: EventHandler<T, MouseEvent> | undefined;
+        onPaste?: EventHandler<T, ClipboardEvent> | undefined;
+        onPause?: EventHandler<T, Event> | undefined;
+        onPlay?: EventHandler<T, Event> | undefined;
+        onPlaying?: EventHandler<T, Event> | undefined;
+        onPointerCancel?: EventHandler<T, PointerEvent> | undefined;
+        onPointerDown?: EventHandler<T, PointerEvent> | undefined;
+        onPointerEnter?: EventHandler<T, PointerEvent> | undefined;
+        onPointerLeave?: EventHandler<T, PointerEvent> | undefined;
+        onPointerMove?: EventHandler<T, PointerEvent> | undefined;
+        onPointerOut?: EventHandler<T, PointerEvent> | undefined;
+        onPointerOver?: EventHandler<T, PointerEvent> | undefined;
+        onPointerRawUpdate?: EventHandler<T, PointerEvent> | undefined;
+        onPointerUp?: EventHandler<T, PointerEvent> | undefined;
+        onProgress?: EventHandler<T, ProgressEvent> | undefined;
+        onRateChange?: EventHandler<T, Event> | undefined;
+        onReset?: EventHandler<T, Event> | undefined;
+        onResize?: EventHandler<T, UIEvent> | undefined;
         onScroll?: EventHandler<T, Event> | undefined;
-        onWheel?: EventHandler<T, WheelEvent> | undefined;
-        onLoad?: EventHandler<T, Event> | undefined;
-        onError?: EventHandler<T, Event> | undefined;
-        onLoadedMetadata?: EventHandler<T, Event> | undefined;
+        onScrollEnd?: EventHandler<T, Event> | undefined;
+        onScrollSnapChange?: EventHandler<T, SnapEvent> | undefined;
+        onScrollSnapChanging?: EventHandler<T, SnapEvent> | undefined;
+        onSecurityPolicyViolation?: EventHandler<T, SecurityPolicyViolationEvent> | undefined;
+        onSeeked?: EventHandler<T, Event> | undefined;
+        onSeeking?: EventHandler<T, Event> | undefined;
+        onSelect?: EventHandler<T, Event> | undefined;
+        onSelectionChange?: EventHandler<T, Event> | undefined;
+        onSelectStart?: EventHandler<T, Event> | undefined;
+        onSlotChange?: EventHandler<T, Event> | undefined;
+        onStalled?: EventHandler<T, Event> | undefined;
+        onSubmit?: EventHandler<T, SubmitEvent> | undefined;
+        onSuspend?: EventHandler<T, Event> | undefined;
         onTimeUpdate?: EventHandler<T, Event> | undefined;
-        onEnded?: EventHandler<T, Event> | undefined;
-        onPlay?: EventHandler<T, Event> | undefined;
-        onPause?: EventHandler<T, Event> | undefined;
-        onPaste?: EventHandler<T, ClipboardEvent> | undefined;
-        onDragOver?: EventHandler<T, DragEvent> | undefined;
-        onDragLeave?: EventHandler<T, DragEvent> | undefined;
-        onDrop?: EventHandler<T, DragEvent> | undefined;
+        onToggle?: EventHandler<T, ToggleEvent> | undefined;
+        onTouchCancel?: EventHandler<T, TouchEvent> | undefined;
+        onTouchEnd?: EventHandler<T, TouchEvent> | undefined;
+        onTouchMove?: EventHandler<T, TouchEvent> | undefined;
+        onTouchStart?: EventHandler<T, TouchEvent> | undefined;
+        onTransitionCancel?: EventHandler<T, TransitionEvent> | undefined;
+        onTransitionEnd?: EventHandler<T, TransitionEvent> | undefined;
+        onTransitionRun?: EventHandler<T, TransitionEvent> | undefined;
+        onTransitionStart?: EventHandler<T, TransitionEvent> | undefined;
+        onVolumeChange?: EventHandler<T, Event> | undefined;
+        onWaiting?: EventHandler<T, Event> | undefined;
+        onWheel?: EventHandler<T, WheelEvent> | undefined;
     }
+    type ElementEvents<T> = Events<T> & (T extends HTMLMediaElement ? {
+        onEncrypted?: EventHandler<T, MediaEncryptedEvent> | undefined;
+        onWaitingForKey?: EventHandler<T, Event> | undefined;
+    } : {}) & (T extends HTMLVideoElement ? {
+        onEnterPictureInPicture?: EventHandler<T, PictureInPictureEvent> | undefined;
+        onLeavePictureInPicture?: EventHandler<T, PictureInPictureEvent> | undefined;
+    } : {}) & (T extends HTMLCanvasElement ? {
+        onWebGLContextCreationError?: EventHandler<T, WebGLContextEvent> | undefined;
+        onWebGLContextLost?: EventHandler<T, WebGLContextEvent> | undefined;
+        onWebGLContextRestored?: EventHandler<T, WebGLContextEvent> | undefined;
+    } : {}) & (T extends SVGAnimationElement ? {
+        onBegin?: EventHandler<T, TimeEvent> | undefined;
+        onEnd?: EventHandler<T, TimeEvent> | undefined;
+        onRepeat?: EventHandler<T, TimeEvent> | undefined;
+    } : {});
     type Scalar = string | number | boolean;
+    type Equal<X, Y> = (<G>() => G extends X ? 1 : 2) extends <G>() => G extends Y ? 1 : 2 ? true : false;
+    type AttributeKey<K extends string> = Lowercase<K> extends keyof HtmlAttributes ? K | Lowercase<K> : K extends 'className' | 'htmlFor' | 'acceptCharset' | 'httpEquiv' ? K | Lowercase<K> : never;
     type DomAttributes<T> = {
-        [K in keyof T as K extends string ? T[K] extends Scalar | null ? K | Lowercase<K> : never : never]?: K extends 'min' | 'max' | 'step' | 'value' ? string | number | undefined : T[K] extends boolean ? boolean | undefined : T[K] extends number ? number | string | undefined : T[K] | undefined;
+        [K in keyof T as K extends string ? Equal<Pick<T, K>, {
+            -readonly [P in K]: T[P];
+        }> extends true ? T[K] extends Scalar | null ? AttributeKey<K> : never : never : never]?: K extends 'min' | 'max' | 'step' | 'value' ? string | number | undefined : T[K] extends boolean ? boolean | undefined : T[K] extends number ? number | string | undefined : T[K] | undefined;
     };
     type CaptureEvents<T> = {
-        [K in keyof Events<T> as `${K}Capture`]?: Events<T>[K];
+        [K in keyof ElementEvents<T> as `${K & string}Capture`]?: ElementEvents<T>[K];
     };
-    export type Attributes<T> = Events<T> & CaptureEvents<T> & DomAttributes<T> & {
+    export type Attributes<T> = ElementEvents<T> & CaptureEvents<T> & Omit<DomAttributes<T>, 'contenteditable' | 'contentEditable' | 'spellcheck' | 'draggable' | 'translate' | 'download'> & {
         children?: Element | undefined;
         class?: string | undefined;
         className?: string | undefined;
         classList?: Record<string, boolean | undefined> | undefined;
         style?: string | CSSProperties | undefined;
-        use?: DomMount | undefined;
+        use?: DomMount<T & globalThis.Element> | undefined;
         role?: string | undefined;
+        nonce?: string | undefined;
         tabindex?: number | undefined;
         loading?: 'lazy' | 'eager' | undefined;
         download?: string | boolean | undefined;
         autocomplete?: string | undefined;
         inputmode?: string | undefined;
-        spellcheck?: boolean | 'true' | 'false' | undefined;
-        contenteditable?: boolean | 'true' | 'false' | undefined;
+        spellcheck?: boolean | 'true' | 'false' | '' | undefined;
+        contenteditable?: boolean | 'true' | 'false' | 'plaintext-only' | 'inherit' | '' | undefined;
+        contentEditable?: boolean | 'true' | 'false' | 'plaintext-only' | 'inherit' | '' | undefined;
+        draggable?: boolean | 'true' | 'false' | undefined;
+        translate?: boolean | 'yes' | 'no' | '' | undefined;
+        part?: string | undefined;
+        exportparts?: string | undefined;
         [data: `data-${string}`]: Scalar | null | undefined;
         [aria: `aria-${string}`]: Scalar | null | undefined;
     };
-    type SvgAttributes = Partial<Record<'viewBox' | 'fill' | 'stroke' | 'stroke-width' | 'stroke-linecap' | 'stroke-linejoin' | 'stroke-dasharray' | 'stroke-dashoffset' | 'stroke-miterlimit' | 'fill-rule' | 'clip-rule' | 'fill-opacity' | 'stroke-opacity' | 'd' | 'points' | 'x' | 'y' | 'x1' | 'x2' | 'y1' | 'y2' | 'cx' | 'cy' | 'r' | 'rx' | 'ry' | 'width' | 'height' | 'xmlns' | 'transform' | 'preserveAspectRatio' | 'offset' | 'stop-color' | 'stop-opacity' | 'clip-path' | 'mask' | 'opacity' | 'pathLength', string | number | undefined>>;
+    type ApplicableAttributes<Tag extends string> = {
+        [Name in keyof HtmlAttributes]: Tag extends keyof HtmlAttributes[Name] ? Name : '*' extends keyof HtmlAttributes[Name] ? Name : never;
+    }[keyof HtmlAttributes];
+    type SharedSvgAttributes<Tag extends string> = Tag extends keyof SVGElementTagNameMap ? SvgPresentationAttributes & (Tag extends 'a' ? Pick<SvgAttributes, 'requiredExtensions' | 'systemLanguage'> : {}) & (Tag extends 'script' ? Pick<SvgAttributes, 'href'> : {}) : {};
     type Html = {
-        [Tag in keyof HTMLElementTagNameMap]: Attributes<HTMLElementTagNameMap[Tag]>;
+        [Tag in keyof HTMLElementTagNameMap]: Attributes<HTMLElementTagNameMap[Tag]> & SharedSvgAttributes<Tag> & Partial<Record<Exclude<ApplicableAttributes<Tag>, keyof Attributes<HTMLElementTagNameMap[Tag]>>, Scalar | null | undefined>>;
     };
     type Svg = {
         [Tag in Exclude<keyof SVGElementTagNameMap, keyof HTMLElementTagNameMap>]: Attributes<SVGElementTagNameMap[Tag]> & SvgAttributes;
     };
-    export type IntrinsicElements = Html & Svg;
+    /** Consumers can explicitly augment custom tags without weakening the built-in contract. */
+    export interface IntrinsicElements extends Html, Svg {
+    }
     export interface ElementChildrenAttribute {
         children: unknown;
     }

package/dist/jsx.js

@@ -1 +1,2 @@
-export {};
+/** Nominal eligibility for compiled JSX components and compiler primitives. */
+export const jsxComponent = Symbol('effectweb.component');

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;
+};