@atolljs/islands 0.1.12 → 0.1.14

package/dist/ops.d.ts

@@ -0,0 +1,339 @@
+/**
+ * The whole protocol between the two threads.
+ *
+ * The worker runs a real React reconciler whose "host environment" is a set
+ * of records in a Map — every render-phase and mutation-phase host-config
+ * call appends one of these ops to a queue. Task methods (`mount`,
+ * `updateProps`, `dispatch`, `flush`) return the flushed batch, and the main
+ * thread's only job is to replay them against the DOM. Ops ride postMessage —
+ * no shared memory is involved.
+ *
+ * ISLANDS: every island owns an independent op stream — instance ids are only
+ * unique within one worker, so each island's driver keeps its own node map
+ * (see src/island.ts). `emit` is the one op that is NOT a DOM mutation: it is
+ * the island→shell event channel — the driver hands `{name, payload}` to the
+ * shell-registered `onEvent` callback instead of touching the DOM.
+ */
+export type Op = 
+/**
+ * createElement-equivalent — `props` is already wire-serialized. `ns` is
+ * the element's namespace URI when it isn't HTML ('http://www.w3.org/2000/svg',
+ * 'http://www.w3.org/1998/Math/MathML') — the driver calls
+ * `createElementNS(ns, type)`. The reconciler's host context tracks it
+ * (svg/math enter, foreignObject/desc/title return to HTML), so SVG trees
+ * like recharts' arrive correctly namespaced.
+ */
+{
+    t: 'create';
+    id: number;
+    type: string;
+    props: WireProps;
+    ns?: string;
+}
+/** createTextNode-equivalent. */
+ | {
+    t: 'text';
+    id: number;
+    text: string;
+}
+/** `parent.insertBefore(child, before ?? null)` — parent 0 is the root container. */
+ | {
+    t: 'append';
+    parent: number;
+    child: number;
+    before?: number;
+}
+/** Detach `child` from wherever it is mounted. */
+ | {
+    t: 'remove';
+    child: number;
+}
+/** Re-serialized full prop set for `id` (main diffs against its last seen set). */
+ | {
+    t: 'update';
+    id: number;
+    props: WireProps;
+}
+/** New text content for a text instance. Also how the proxy DOM writes
+ *  `element.textContent` — the driver assigns `node.textContent`, which
+ *  replaces the element's children with a single text node. */
+ | {
+    t: 'utext';
+    id: number;
+    text: string;
+}
+/** Clear the root container (React's clearContainer, or an imperative
+ *  instance's rebuild). */
+ | {
+    t: 'clear';
+}
+/**
+ * Set/remove a single attribute — emitted by the worker-side proxy DOM
+ * (`setAttribute`, `id`/`className` setters, `classList`, `dataset`).
+ * `value: null` removes the attribute.
+ */
+ | {
+    t: 'attr';
+    id: number;
+    name: string;
+    value: string | null;
+}
+/**
+ * Merge inline-style changes — the proxy DOM's `style` proxy re-sends only
+ * the changed keys; `''` clears a key (deleteProperty). Two conventions:
+ * keys starting `--` are CSS custom properties (driver routes them to
+ * `style.setProperty`), and a value ending in `!important` applies with
+ * priority (the proxy's `style.setProperty(k, v, 'important')` encodes it
+ * this way — there is no separate priority field).
+ */
+ | {
+    t: 'style';
+    id: number;
+    props: Record<string, string>;
+}
+/**
+ * Attach a DOM listener for a proxy-DOM `addEventListener` — `handler` is
+ * a worker handler-table id (same currency as `__evt` refs); the driver
+ * wires it to `client.dispatch(handler, payload)`. `id: 0` targets the
+ * island's root container — that's where `document`/`window` listeners
+ * land, which makes delegated handlers work. `opts` carries the
+ * once/passive/capture flags through to the real addEventListener.
+ */
+ | {
+    t: 'listen';
+    id: number;
+    type: string;
+    handler: number;
+    opts?: {
+        once?: boolean;
+        passive?: boolean;
+        capture?: boolean;
+    };
+}
+/** Detach the listener a `listen` op attached (type + handler identify it).
+ *  `opts.capture` must match the listen's flag for the detach to apply. */
+ | {
+    t: 'unlisten';
+    id: number;
+    type: string;
+    handler: number;
+    opts?: {
+        once?: boolean;
+        passive?: boolean;
+        capture?: boolean;
+    };
+}
+/**
+ * Island → shell event — worker code calls `emit(name, payload)` inside a
+ * handler (or a commit-phase effect); the driver invokes the island's
+ * `onEvent(name, payload)` instead of mutating the DOM. Payloads must be
+ * structured-cloneable — same rule as props.
+ */
+ | {
+    t: 'emit';
+    name: string;
+    payload?: unknown;
+}
+/**
+ * Request real geometry for `id` — the worker-side proxy DOM emits this
+ * when `doc.observeSize(el, cb)` registers (and once, lazily, when an
+ * unmarked element's geometry is read). The driver measures the real
+ * node, observes it with a ResizeObserver, and pushes rects back through
+ * the `setRects` task. Fire-and-forget: reads keep returning the honest 0
+ * until the first push lands. Older drivers ignore the op; the reads stay
+ * 0 — same degradation as an element that never gets measured.
+ */
+ | {
+    t: 'measure';
+    id: number;
+}
+/**
+ * Cancel a `measure` request — emitted when the last `observeSize`
+ * observer for `id` detaches. Elements auto-requested by a geometry read
+ * stay observed for the element's lifetime (the driver also unobserves
+ * on `remove`/`clear`).
+ */
+ | {
+    t: 'unmeasure';
+    id: number;
+};
+/**
+ * One measured box, pushed main→worker by the `setRects` task. `x`/`y` are
+ * the node's viewport-relative position (getBoundingClientRect), `w`/`h`
+ * its size — worker-side reads derive top/left/right/bottom from these.
+ * Updates fire on element RESIZE (the driver's ResizeObserver); position-only
+ * moves don't retrigger, matching what chart/map libraries actually consume.
+ */
+export interface MeasuredRect {
+    id: number;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/**
+ * Wire-serialized props. Functions named `on*` (onClick, onInput, …) cross as
+ * `{ __evt: handlerId }`; the main thread turns that into a DOM listener that
+ * dispatches back into the worker. `children` never crosses — tree structure
+ * is expressed entirely by append/remove ops.
+ *
+ * One prop is NOT a normal attribute: `data-atoll-slot` marks a transclusion
+ * slot — a leaf element whose box is worker-owned but whose contents the
+ * shell mounts main-thread DOM into (the island's `slots` registry). The
+ * driver routes it to the slot machinery instead of treating it like any
+ * other data attribute.
+ */
+export type WireProps = Record<string, unknown>;
+/** Marker for a prop that was a function — a handle into the worker's handler table. */
+export interface EventRef {
+    __evt: number;
+}
+export declare const isEventRef: (v: unknown) => v is EventRef;
+/**
+ * What the main thread sends back when a DOM event fires. Deliberately NOT a
+ * SyntheticEvent — just a best-effort handful of fields read off the DOM
+ * event and its target. Mouse fields are `undefined` for non-mouse events;
+ * `targetId` is only set when the event target is an op-created node (shell-
+ * owned slot content has no instance id).
+ */
+export interface EventPayload {
+    type: string;
+    value?: string;
+    checked?: boolean;
+    key?: string;
+    clientX?: number;
+    clientY?: number;
+    screenX?: number;
+    screenY?: number;
+    /**
+     * Pointer coords in the LISTENER element's local space:
+     * `clientX/Y − event.currentTarget.getBoundingClientRect()` computed
+     * main-thread where real rects exist. The proxy DOM has no measurement
+     * channel, so worker-side hit-testing libraries cannot derive local
+     * coords themselves: zrender's four-marker getBoundingClientRect
+     * transform degenerates, and e.offsetX is absent anyway. zrender's
+     * normalizeEvent early-returns on `e.zrX != null`, which is why the
+     * fields carry its names — charts (echarts SVG renderer) get working
+     * axis pointers/tooltips, any library can read them the same way.
+     */
+    zrX?: number;
+    zrY?: number;
+    button?: number;
+    /**
+     * UIEvent.which — non-standard but set by every browser (1 = left button,
+     * 2 = middle, 3 = right). Libraries like Leaflet's Draggable gate on it:
+     * `e.which !== 1 && e.button !== 1` must not both hold for a left press.
+     */
+    which?: number;
+    /** Modifier states for the event (KeyboardEvent/MouseEvent share them). */
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+    /** WheelEvent deltas — only set for `wheel` events (deltaMode is always
+     *  0/pixels in practice; reported raw). */
+    deltaX?: number;
+    deltaY?: number;
+    /**
+     * WheelEvent.deltaMode (0 = pixels, 1 = lines, 2 = pages). Libraries like
+     * Leaflet gate on `e.deltaMode === 0` inside getWheelDelta, so the driver
+     * always sends a concrete number — defaulting to 0 when the environment
+     * doesn't expose it but deltas exist.
+     */
+    deltaMode?: number;
+    /** PointerEvent.pointerType ('mouse' | 'touch' | 'pen' | ''). */
+    pointerType?: string;
+    /** `target.scrollTop` when the target is an element. */
+    scrollTop?: number;
+    /** The worker instance id of `event.target`, when it maps to one. */
+    targetId?: number;
+    /**
+     * The worker instance id of `event.relatedTarget` (MouseEvent/FocusEvent),
+     * when it maps to an op-created node. Lets over/out/leave/enter handlers
+     * distinguish "moved to a child" from "actually left the element" —
+     * zrender's mouseout gate (`toElement || relatedTarget` → isLocalEl walk)
+     * is the canonical consumer; without it every child transition looks like
+     * a real leave and charts flicker as tooltips hide/show.
+     */
+    relatedTargetId?: number;
+    /**
+     * The proxy-DOM node for `targetId` — SYNTHESIZED worker-side by the proxy
+     * DOM when it wraps a listener (it never crosses the wire). Lets delegated
+     * handlers written for the real DOM — `e.target.closest('.row')`,
+     * `e.target.dataset` — run unmodified. Only set when the target maps to a
+     * known worker instance; DOM-fidelity only for nodes built through the
+     * same proxy document.
+     */
+    target?: unknown;
+    /**
+     * The proxy-DOM node for `relatedTargetId` — SYNTHESIZED worker-side like
+     * `target` (never crosses the wire). Handler code can walk
+     * `relatedTarget.parentNode` — e.g. zrender's isLocalEl — to test
+     * whether the pointer moved within the listener's subtree.
+     */
+    relatedTarget?: unknown;
+    /**
+     * Synthesized NO-OPS — added worker-side by the proxy DOM when it wraps a
+     * listener's payload (they never cross the wire). They exist so library
+     * code written for real DOM events — `e.preventDefault()`,
+     * `e.stopPropagation()` — doesn't crash. They CANNOT cancel anything: the
+     * real event already dispatched on the main thread before this payload
+     * ever reached the worker. Practical consequence: a `wheel` listener on a
+     * scrolling island can't preventDefault — the page scrolls anyway.
+     */
+    preventDefault?(): void;
+    stopPropagation?(): void;
+    stopImmediatePropagation?(): void;
+}
+/**
+ * The task methods every island worker exposes — what `definePolyWorker`
+ * registers on the worker side and what `connectIslandWorker`'s typed client
+ * calls on the main thread. Every signature leads with the instance key
+ * (`'app'` or `'app@instance'`) — `mountIsland` binds it per island.
+ */
+export type IslandWorkerMethods = {
+    /** Mount the instance's registry app; returns the initial op batch. Async
+     *  because a React app lazily imports the reconciler on first mount. */
+    mount(instance: string, props?: Record<string, unknown>): Op[] | Promise<Op[]>;
+    /** Re-render the instance's root with new serializable props. */
+    updateProps(instance: string, props: Record<string, unknown>): Op[];
+    /** Invoke the worker handler a `__evt` ref or `listen` op points at. */
+    dispatch(handlerId: number, payload: EventPayload): Op[];
+    /**
+     * Push the island container's measured box into the instance — the
+     * always-on geometry channel (per-element rects additionally flow through
+     * `setRects` for elements that requested measurement). The driver observes
+     * the island's `el` with a ResizeObserver and calls this once at mount and
+     * on resizes (throttled ~100ms). The instance stores {w,h}; proxy-DOM
+     * geometry reads on `doc.body`/`documentElement` and on elements marked via
+     * `doc.markContainer(el)` then return it. Handlers registered via
+     * `doc.onResize` re-run on each push; their ops ride back in this method's
+     * return batch.
+     */
+    setSize(instance: string, width: number, height: number): Op[];
+    /**
+     * Push freshly measured element rects — the answer to `measure` ops and
+     * the driver's per-element ResizeObserver ticks. Each rect updates the
+     * instance's per-element store and fires the element's `observeSize`
+     * callbacks inside the instance's scope, so their ops ride back in this
+     * method's return batch like `setSize`'s onResize handlers.
+     */
+    setRects(instance: string, rects: MeasuredRect[]): Op[];
+    /** Drain ops committed outside a task (passive effects, timers). */
+    flush(instance: string): Op[];
+    /**
+     * Tear down one instance — unmounts its tree / disposes its proxy document
+     * and drops the instance, leaving the worker alive for its other mounts.
+     * Returned ops are the detach batch (the driver may skip applying them if
+     * the island element is already gone).
+     */
+    unmount(instance: string): Op[];
+    /** The mounted instance's random id — the island's "worker pid" badge. */
+    whoami(instance: string): string;
+    /**
+     * The instance's renderer tag ('react', 'vue', …) from its adapter; null
+     * for imperative apps. Read by the driver only for devtools, and only
+     * when the mount declared no `framework`.
+     */
+    renderer(instance: string): string | null;
+};

package/dist/worker/defineWorkers.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Two entry points, two topologies:
+ *
+ *   // render.worker.ts — a REGISTRY worker: one script, many apps
+ *   import { definePolyWorker } from '@atolljs/islands/worker';
+ *   export const renderWorker = definePolyWorker({
+ *     apps: { controls: ControlsApp, table: TableApp },
+ *   });
+ *
+ *   // charts.worker.ts — a MONO worker: one script, one app (1:1)
+ *   export const chartsWorker = defineMonoWorker(ChartsApp);
+ *
+ * `definePolyWorker` serves a registry — every island's worker runs the
+ * same script and `mount(instance, props)` picks a component out of `apps`.
+ * `defineMonoWorker` serves exactly one app: the shell mounts it without
+ * naming a registry key (or with any name — a single-registered-app worker
+ * resolves its sole app regardless), and the worker's bundle carries only
+ * that app's dependencies.
+ *
+ * APP REGISTRY is module-level: in a real worker each entry file loads its
+ * own module graph (a instance worker sees exactly its app); under the
+ * in-process test harness several worker entries share one graph, so
+ * registration is a UNION and mounts still resolve — same semantics both
+ * worlds.
+ *
+ * INSTANCE KEYS are `app` or `app@instance` — the part before the last '@'
+ * names the registry app (or 'main' for unnamed instance-worker mounts), the
+ * rest distinguishes instances so the same app can mount more than once —
+ * INCLUDING into one shared worker when two islands share a client
+ * (multi-island-per-worker: one worker, two mounts, two reconcilers).
+ * MountIsland mints a fresh key per island. Wire signatures carry the instance key (`updateProps(instance,
+ * props)`, `flush(instance)`, `whoami(instance)`) so a call routes to its instance —
+ * the main-thread mountIsland helper binds it, so shell code just calls
+ * `island.updateProps(props)`.
+ *
+ * IMPERATIVE INSTANCES: a registry entry can be `{ imperative: (doc, props) }`
+ * instead of a component. Those mounts hold no reconciler at all: mount
+ * hands the app a instance-scoped proxy DOM and its mutations emit ops
+ * directly (updateProps = clear + rebuild, dispatch = runInInstance + drain,
+ * flush = drain only). See worker/proxyDom.ts.
+ *
+ * RENDERED INSTANCES: `{ mount: (ctx) => handle | void }` is the same shape
+ * for EVERY framework renderer, React included — mount(ctx) renders into the
+ * instance's proxy document and returns a handle whose `update(props)` takes
+ * over updateProps (fine-grained patching instead of rebuild), whose
+ * `sync(fn)`/`flush()` let task-ordered renderers (react-reconciler) pin
+ * commits into the task batch, and whose `dispose()` runs before the
+ * document dies. This package ships no renderer: React's lives in
+ * `@atolljs/react-island/worker` — framework-neutral by construction.
+ *
+ * Ops still ride back through the pool's ordinary postMessage channel — the
+ * sharedMemory contract here is only the doorbell (see memory.ts): a commit
+ * counter the main thread observe()s to trigger flush() as a push. Drop it
+ * entirely and the islands still work on the 50ms poll — that's the
+ * message-only mode.
+ */
+import type { SharedMemory, WorkerDefinition } from '@atolljs/core';
+import { type IslandContract } from '../contract.js';
+import { type DoorbellSpec } from '../memory.js';
+import { type ProxyDocument } from './proxyDom.js';
+import type { IslandWorkerMethods } from '../ops.js';
+/**
+ * Registry value shapes:
+ *  - `{ imperative: (doc, props) => void }` — no framework at all. mount()
+ *    hands it a proxy DOM scoped to the instance; its mutations emit ops
+ *    directly.
+ *  - `{ mount: (ctx) => handle | void }` — a framework adapter's output
+ *    (`reactIslandApp`, `vueIslandApp`, …). Bare component functions are NOT
+ *    registry values — wrap them first (defineReactPolyWorker does it).
+ */
+export interface ImperativeIslandApp {
+    imperative: (doc: ProxyDocument, props: Record<string, unknown>) => void;
+    /**
+     * Optional teardown — runs inside the instance's scope BEFORE its proxy
+     * document is disposed (unmount, remount, updateProps rebuild). Cancel
+     * library timers/animation loops/listeners here (e.g. `map.remove()`) so
+     * deferred work can't mutate a dead instance or a foreign ambient document
+     * after teardown.
+     */
+    dispose?: (doc: ProxyDocument) => void;
+}
+/**
+ * What a non-React framework renderer receives at mount: the instance's wire
+ * key (scopes emit() and instance-less ops), a fresh proxy document whose
+ * mutations emit ops, and the serialized props the shell mounted with.
+ */
+export interface RenderContext {
+    instance: string;
+    doc: ProxyDocument;
+    props: Record<string, unknown>;
+}
+export interface RenderedHandle {
+    /**
+     * Fine-grained prop update — the renderer patches its live tree. When
+     * omitted, updateProps falls back to imperative semantics: dispose +
+     * clear + re-mount on a fresh document.
+     */
+    update?(props: Record<string, unknown>): void;
+    /**
+     * Run `fn` inside the renderer's synchronous commit lane (React:
+     * flushSyncFromReconciler + flushSyncWork) so its mutations emit ops
+     * inside the current task batch. Dispatch wraps event-handler invocation
+     * in this when the handle provides one; renderers without a sync lane
+     * simply omit it.
+     */
+    sync?(fn: () => void): void;
+    /**
+     * Drain renderer work scheduled outside tasks — passive effects, async
+     * state updates (React: flushPassiveEffects + flushSyncWork). The worker's
+     * flush() method calls it inside the instance's scope, then drains the
+     * op queue.
+     */
+    flush?(): void;
+    /**
+     * App teardown — runs inside the instance's scope BEFORE its proxy document
+     * is disposed (unmount, remount, updateProps rebuild). Same rules as
+     * ImperativeIslandApp.dispose: cancel framework roots/effects here.
+     */
+    dispose?(): void;
+}
+/**
+ * A renderer-backed app: a framework renderer (React, Vue, Svelte,
+ * Solid, Angular) whose `mount` renders component output into the instance's
+ * proxy document — every proxy mutation already serializes to ops. Package
+ * adapters (e.g. @atolljs/react-island/worker, @atolljs/vue-island/worker)
+ * wrap a component into this shape so it can sit beside imperative apps in
+ * the same `apps` registry.
+ */
+export interface RenderedIslandApp {
+    mount(ctx: RenderContext): RenderedHandle | void;
+    /**
+     * Renderer tag ('react', 'vue', 'svelte', 'solid', 'angular'): set by the
+     * package adapters, reported by the `renderer` task so devtools can mark
+     * an island whose mount declared no `framework`. Hand-written adapters
+     * may set it; imperative apps have none.
+     */
+    renderer?: string;
+}
+/** The apps an island can mount — keyed by the name the shell passes to mount(). */
+export type IslandApp = ImperativeIslandApp | RenderedIslandApp;
+export interface PolyWorkerRegistry {
+    /** Name → island app registry. The shell's `mountIsland({ app: name })`
+     *  picks one per island. */
+    apps: Record<string, IslandApp>;
+    /**
+     * The doorbell contract the worker exposes — defaults to the package's
+     * `renderMemory`. Rarely needed: pass a different doorbell-SPEC instance
+     * if your worker module already defines one (the main side always uses
+     * `makeDoorbell()`, so the spec must match: `opsVersion` number field).
+     */
+    sharedMemory?: SharedMemory<DoorbellSpec>;
+}
+interface InstanceBase {
+    /** The wire key — 'app' or 'app@instance'; op queues route by this. */
+    key: string;
+    /** The registry name — which component this instance renders. */
+    app: string;
+    /** Per-instance random id — shown in the island's badge as proof it's a
+     *  distinct render instance (in production: a distinct worker). Stable across
+     *  remounts of the same instance key. */
+    pid: string;
+    /** The `withContract`-stamped contract — drives props validation at
+     *  mount/updateProps; mirrored into instanceContracts for `emit`. */
+    contract?: IslandContract;
+}
+interface ImperativeInstance extends InstanceBase {
+    rendered?: undefined;
+    imperative: {
+        build: ImperativeIslandApp['imperative'];
+        /** Optional app teardown — run before the instance's doc is disposed. */
+        dispose: ImperativeIslandApp['dispose'];
+        /** The instance's proxy document — replaced on each rebuild. */
+        doc: ProxyDocument;
+        props: Record<string, unknown>;
+    };
+}
+interface RenderedInstance extends InstanceBase {
+    imperative?: undefined;
+    rendered: {
+        app: RenderedIslandApp;
+        /** The mount-returned handle — drives fine-grained updates/teardown. */
+        handle: RenderedHandle | void;
+        props: Record<string, unknown>;
+    };
+}
+/** A mounted instance — one per island worker in production. */
+export type Instance = ImperativeInstance | RenderedInstance;
+/**
+ * PolyWorker — one worker script serving a REGISTRY of islands:
+ * `mountIsland({ app: name })` picks one per island, and every island in
+ * the registry shares the worker's module graph, framework runtimes, and
+ * op pump. This is the bundle-optimization host shape — several islands,
+ * one worker to load and keep warm.
+ */
+export declare function definePolyWorker(registry: PolyWorkerRegistry, options?: {
+    sharedMemory?: SharedMemory<DoorbellSpec>;
+}): WorkerDefinition<DoorbellSpec, IslandWorkerMethods>;
+/**
+ * MonoWorker — one worker script pinned to ONE island app (1:1). The
+ * isolation host shape: own bundle, own failure domain, nothing reachable
+ * outside the single app it serves. `mountIsland` can omit `app` — the
+ * worker resolves its sole app regardless of the supplied name.
+ */
+export declare function defineMonoWorker(app: IslandApp, options?: {
+    sharedMemory?: SharedMemory<DoorbellSpec>;
+}): WorkerDefinition<DoorbellSpec, IslandWorkerMethods>;
+export {};

package/dist/worker/dom/css.d.ts

@@ -0,0 +1,24 @@
+import { ProxyElement } from './element.js';
+/** The small subset of DOMTokenList the proxy implements. */
+export interface ProxyClassList {
+    add(...tokens: string[]): void;
+    remove(...tokens: string[]): void;
+    toggle(token: string, force?: boolean): boolean;
+    contains(token: string): boolean;
+    readonly value: string;
+}
+/** Build (or reuse) a live classList view for the element. */
+export declare function classListFor(el: ProxyElement): ProxyClassList;
+/**
+ * Build (or reuse) a live CSSStyleDeclaration proxy. Writes re-send only the
+ * changed key; `delete style.x`/`style.removeProperty('x')` send '' (the
+ * protocol's "clear this key"). `setProperty`/`getPropertyValue` accept
+ * kebab-case and camelize it, like the real CSSStyleDeclaration.
+ */
+export declare function styleProxyFor(el: ProxyElement): CSSStyleDeclaration;
+/**
+ * Build (or reuse) a live DOMStringMap proxy. camelCase keys map to `data-*`
+ * attribute ops: `el.dataset.foo = 'x'` sets `data-foo`, `delete el.dataset.foo`
+ * removes it.
+ */
+export declare function datasetProxyFor(el: ProxyElement): DOMStringMap;