@continuum-js/dom 0.3.0

package/README.md

@@ -0,0 +1,60 @@
+# @continuum-js/dom
+
+Тонкий fine-grained рендерер поверх [`@continuum-js/frp`](../frp). Отображает
+`Behavior`/`Event` в реальные DOM-узлы с точечными обновлениями; работает с
+обычным JSX через **автоматический рантайм** (`import { h }` не нужен).
+
+```tsx
+import { newBehavior } from "@continuum-js/frp";
+import { mount } from "@continuum-js/dom";
+
+const [name, setName] = newBehavior("world");
+mount(document.body, () => <h1>hello {name}</h1>);
+setName("continuum"); // патчится один текст-узел
+```
+
+- **`h` / `Fragment`** — JSX-фабрика; компонент вызывается один раз. `Behavior`
+  в детях → живой текст-узел; `Behavior` в пропсах → живой атрибут/свойство;
+  `on*` → DOM-слушатель.
+- **`dyn(b, render)`** — условное/переключаемое поддерево.
+- **`each(items, key, render)`** — keyed-список с LIS-диффингом и сохранением
+  фокуса.
+- **Дерево владения** — `root` / `scope` / `onCleanup`: каскадная очистка
+  подписок при сносе динамических регионов.
+- **Контекст** — `createContext` / `provide` / `use` поверх дерева владения.
+- **Хелперы** — `when`, `bindInput`, `portal`, `mount`, `animationFrames`.
+- **SVG** — теги `<svg>`, `<rect>`, `<path>`, `<circle>`, … создаются в SVG-неймспейсе
+  (`createElementNS`); `class` и атрибуты (`viewBox`, `fill`, …) ставятся корректно.
+  HTML внутри `<foreignObject>` остаётся HTML.
+- **Компоненты-обёртки** — JSX над хелперами (в духе Solid):
+
+```tsx
+<Show when={user} fallback={() => <Guest />}>
+  {(u) => <span>{u.name}</span>}
+</Show>
+
+<Each each={items} key={(i) => i.id}>
+  {(item) => <li>{item.name}</li>}
+</Each>
+
+<Dynamic value={route}>{(r) => (r === "home" ? <Home /> : <About />)}</Dynamic>
+
+<Portal mount={document.body}><Modal /></Portal>
+```
+
+### Настройка JSX (автоматический рантайм)
+
+```jsonc
+// tsconfig.json
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "@continuum-js/dom",
+  },
+}
+```
+
+Для Vite/esbuild — `jsx: "automatic"`, `jsxImportSource: "@continuum-js/dom"`.
+Классическая фабрика тоже поддерживается (`h`/`Fragment` экспортируются) — тогда
+`--jsx react --jsxFactory h --jsxFragmentFactory Fragment` и `import { h }` в
+каждом файле с JSX.

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+import { Behavior, Event } from "@continuum-js/frp";
+/** Root owner (a mount point). `fn` receives its dispose handle. */
+export declare function root<T>(fn: (dispose: () => void) => T): T;
+/** Child owner under the current one. Returns its value and dispose handle. */
+export declare function scope<T>(fn: () => T): {
+    value: T;
+    dispose: () => void;
+};
+/** Register a cleanup in the current owner (no-op outside any owner). */
+export declare function onCleanup(fn: () => void): void;
+export type Child = Node | Behavior<unknown> | string | number | boolean | null | undefined | Child[];
+type Props = Record<string, unknown> | null;
+/** Fragment marker for `--jsxFragmentFactory Fragment`. */
+export declare function Fragment(props: {
+    children?: Child;
+}): Node;
+type Component = (props: Record<string, unknown>) => Node;
+/** JSX factory (`--jsxFactory h`). A component function runs exactly once. */
+export declare function h(tag: string | Component | typeof Fragment, props: Props, ...children: Child[]): Node;
+/** Conditional / switching subtree: rebuilds on each change of `b`. */
+export declare function dyn<T>(b: Behavior<T>, render: (v: T) => Child): Node;
+/** Keyed list: reuses rows by key, reorders with minimal moves (LIS). */
+export declare function each<T, K>(items: Behavior<T[]>, key: (item: T) => K, render: (item: T) => Child): Node;
+export interface Context<T> {
+    readonly id: symbol;
+    readonly defaultValue: T;
+}
+export declare function createContext<T>(defaultValue: T): Context<T>;
+/** Write a context value into the current owner. */
+export declare function provide<T>(ctx: Context<T>, value: T): void;
+/** Read the nearest provided value up the owner tree, else the default. */
+export declare function use<T>(ctx: Context<T>): T;
+/** Conditional region driven by a boolean behavior (no rebuild on same value). */
+export declare function when(cond: Behavior<boolean>, thenRender: () => Child, elseRender?: () => Child): Node;
+/** Two-way binding props for a text input. Spread onto an `<input>`. */
+export declare function bindInput(value: Behavior<string>, set: (v: string) => void): {
+    value: Behavior<string>;
+    onInput: (e: globalThis.Event) => void;
+};
+/** Render `child` into another node, cleaning up on dispose. */
+export declare function portal(target: Node, child: Child): Node;
+/** Mount a view under a root owner. Returns an unmount function. */
+export declare function mount(container: Node, view: () => Node): () => void;
+/**
+ * An `Event<number>` of `requestAnimationFrame` timestamps (ms). Drives the
+ * continuous-time combinators (`integral`/`derivative`/`warp` from the core).
+ * Registered against the current owner: it stops automatically on unmount.
+ */
+export declare function animationFrames(): Event<number>;
+/**
+ * Conditional region. Rebuilds only when the truthiness of `when` toggles; the
+ * (narrowed) value is passed to the children render function at build time.
+ *
+ * ```tsx
+ * <Show when={user} fallback={() => <Guest />}>
+ *   {(u) => <span>{u.name}</span>}
+ * </Show>
+ * ```
+ */
+export declare function Show<T>(props: {
+    when: Behavior<T>;
+    children: (value: NonNullable<T>) => Child;
+    fallback?: () => Child;
+}): Node;
+/**
+ * Keyed list. The `by` key selector defaults to identity. (Note: `key` is a
+ * reserved JSX attribute stripped by the compiler, so the prop is named `by`.)
+ *
+ * ```tsx
+ * <Each each={items} by={(i) => i.id}>{(item) => <li>{item.name}</li>}</Each>
+ * ```
+ */
+export declare function Each<T, K = T>(props: {
+    each: Behavior<T[]>;
+    by?: (item: T) => K;
+    children: (item: T) => Child;
+}): Node;
+/**
+ * Switch the subtree on a behavior's value (rebuilds on every change).
+ *
+ * ```tsx
+ * <Dynamic value={route}>{(r) => r === "home" ? <Home /> : <About />}</Dynamic>
+ * ```
+ */
+export declare function Dynamic<T>(props: {
+    value: Behavior<T>;
+    children: (value: T) => Child;
+}): Node;
+/**
+ * Render children into another node (e.g. `document.body`), cleaning up on
+ * unmount. Children are eager here — a portal renders immediately.
+ *
+ * ```tsx
+ * <Portal mount={document.body}><Modal /></Portal>
+ * ```
+ */
+export declare function Portal(props: {
+    mount: Node;
+    children?: Child;
+}): Node;
+export {};

package/dist/index.js

@@ -0,0 +1,540 @@
+// Continuum — DOM renderer (dom).
+// Fine-grained rendering over the frp core: bindings, dynamic regions,
+// keyed lists, an ownership tree for lifecycle, and context.
+import { Behavior, Event, newEvent } from "@continuum-js/frp";
+let currentOwner = null;
+function createOwner(parent) {
+    const owner = {
+        cleanups: [],
+        children: [],
+        parent,
+        contexts: null,
+        disposed: false,
+    };
+    if (parent)
+        parent.children.push(owner);
+    return owner;
+}
+function disposeOwner(owner) {
+    if (owner.disposed)
+        return;
+    owner.disposed = true;
+    // children first (reverse creation order), then this owner's cleanups.
+    for (let i = owner.children.length - 1; i >= 0; i--) {
+        disposeOwner(owner.children[i]);
+    }
+    owner.children.length = 0;
+    for (let i = owner.cleanups.length - 1; i >= 0; i--) {
+        owner.cleanups[i]();
+    }
+    owner.cleanups.length = 0;
+    // detach from parent
+    if (owner.parent) {
+        const siblings = owner.parent.children;
+        const idx = siblings.indexOf(owner);
+        if (idx >= 0)
+            siblings.splice(idx, 1);
+        owner.parent = null;
+    }
+}
+function runUnder(owner, fn) {
+    const prev = currentOwner;
+    currentOwner = owner;
+    try {
+        return fn();
+    }
+    finally {
+        currentOwner = prev;
+    }
+}
+/** Root owner (a mount point). `fn` receives its dispose handle. */
+export function root(fn) {
+    const owner = createOwner(null);
+    return runUnder(owner, () => fn(() => disposeOwner(owner)));
+}
+/** Child owner under the current one. Returns its value and dispose handle. */
+export function scope(fn) {
+    const owner = createOwner(currentOwner);
+    const value = runUnder(owner, fn);
+    return { value, dispose: () => disposeOwner(owner) };
+}
+/** Register a cleanup in the current owner (no-op outside any owner). */
+export function onCleanup(fn) {
+    if (currentOwner)
+        currentOwner.cleanups.push(fn);
+}
+/** Attach an frp subscription to the current owner's lifecycle. */
+function bind(un) {
+    onCleanup(un);
+}
+// ---------------------------------------------------------------------------
+// JSX factory (§6.4)
+// ---------------------------------------------------------------------------
+const SVG_NS = "http://www.w3.org/2000/svg";
+// SVG-specific tag names. Ambiguous names shared with HTML (a, title, script,
+// style) are treated as HTML; use them inside `foreignObject` for HTML content.
+const SVG_TAGS = new Set([
+    "svg",
+    "g",
+    "defs",
+    "symbol",
+    "use",
+    "image",
+    "switch",
+    "foreignObject",
+    "path",
+    "rect",
+    "circle",
+    "ellipse",
+    "line",
+    "polyline",
+    "polygon",
+    "text",
+    "tspan",
+    "textPath",
+    "marker",
+    "desc",
+    "metadata",
+    "view",
+    "linearGradient",
+    "radialGradient",
+    "stop",
+    "clipPath",
+    "mask",
+    "pattern",
+    "filter",
+    "feGaussianBlur",
+    "feOffset",
+    "feBlend",
+    "feColorMatrix",
+    "feComposite",
+    "feFlood",
+    "feMerge",
+    "feMergeNode",
+    "feImage",
+    "feTile",
+    "feMorphology",
+    "feDisplacementMap",
+    "feTurbulence",
+    "animate",
+    "animateTransform",
+    "animateMotion",
+    "mpath",
+    "set",
+]);
+function createEl(tag) {
+    return SVG_TAGS.has(tag)
+        ? document.createElementNS(SVG_NS, tag)
+        : document.createElement(tag);
+}
+function toText(v) {
+    return v == null ? "" : String(v);
+}
+function appendChild(parent, child) {
+    if (child == null || child === false || child === true)
+        return;
+    if (Array.isArray(child)) {
+        for (const c of child)
+            appendChild(parent, c);
+        return;
+    }
+    if (child instanceof Behavior) {
+        // fine-grained: one text node bound to one behavior
+        const text = document.createTextNode("");
+        bind(child.listen((v) => (text.data = toText(v))));
+        parent.appendChild(text);
+        return;
+    }
+    if (child instanceof Node) {
+        parent.appendChild(child);
+        return;
+    }
+    parent.appendChild(document.createTextNode(String(child)));
+}
+function applyRef(ref, el) {
+    if (typeof ref === "function")
+        ref(el);
+    else if (ref && typeof ref === "object")
+        ref.current = el;
+}
+function setProp(el, key, value) {
+    if (key === "class" || key === "className") {
+        // SVG elements have a read-only `className` (SVGAnimatedString).
+        if (el.namespaceURI === SVG_NS) {
+            if (value == null)
+                el.removeAttribute("class");
+            else
+                el.setAttribute("class", String(value));
+        }
+        else {
+            el.className = value == null ? "" : String(value);
+        }
+        return;
+    }
+    if (key === "style") {
+        if (value && typeof value === "object") {
+            Object.assign(el.style, value);
+        }
+        else {
+            el.setAttribute("style", value == null ? "" : String(value));
+        }
+        return;
+    }
+    if (key === "value" || key === "checked") {
+        el[key] = value;
+        return;
+    }
+    if (typeof value === "boolean") {
+        if (value)
+            el.setAttribute(key, "");
+        else
+            el.removeAttribute(key);
+        return;
+    }
+    if (value == null) {
+        el.removeAttribute(key);
+        return;
+    }
+    el.setAttribute(key, String(value));
+}
+function applyProps(el, props) {
+    for (const key in props) {
+        if (key === "children")
+            continue;
+        const value = props[key];
+        if (key === "ref") {
+            applyRef(value, el);
+            continue;
+        }
+        if (key.length > 2 && key.startsWith("on")) {
+            const evt = key.slice(2).toLowerCase();
+            const handler = value;
+            el.addEventListener(evt, handler);
+            bind(() => el.removeEventListener(evt, handler));
+            continue;
+        }
+        if (value instanceof Behavior) {
+            bind(value.listen((v) => setProp(el, key, v)));
+            continue;
+        }
+        setProp(el, key, value);
+    }
+}
+/** Fragment marker for `--jsxFragmentFactory Fragment`. */
+export function Fragment(props) {
+    const frag = document.createDocumentFragment();
+    appendChild(frag, props?.children ?? null);
+    return frag;
+}
+/** JSX factory (`--jsxFactory h`). A component function runs exactly once. */
+export function h(tag, props, ...children) {
+    if (tag === Fragment) {
+        const frag = document.createDocumentFragment();
+        for (const c of children)
+            appendChild(frag, c);
+        return frag;
+    }
+    if (typeof tag === "function") {
+        return tag({ ...(props || {}), children });
+    }
+    const el = createEl(tag);
+    if (props)
+        applyProps(el, props);
+    for (const c of children)
+        appendChild(el, c);
+    return el;
+}
+// ---------------------------------------------------------------------------
+// Mounting
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Dynamic regions (§7)
+// ---------------------------------------------------------------------------
+// Build `child` into a fragment under a fresh scope of `owner`. Returns the
+// fragment's top-level nodes and the scope's dispose handle.
+function buildScoped(owner, build) {
+    const s = runUnder(owner, () => scope(() => {
+        const built = build();
+        // Fast path: a single element/text node (the common row/component case)
+        // needs no fragment or NodeList copy.
+        if (built instanceof Node &&
+            built.nodeType !== 11 /* DocumentFragment */) {
+            return [built];
+        }
+        const frag = document.createDocumentFragment();
+        appendChild(frag, built);
+        return Array.from(frag.childNodes);
+    }));
+    return { nodes: s.value, dispose: s.dispose };
+}
+/** Conditional / switching subtree: rebuilds on each change of `b`. */
+export function dyn(b, render) {
+    const owner = currentOwner;
+    const start = document.createComment("dyn");
+    const end = document.createComment("/dyn");
+    const frag = document.createDocumentFragment();
+    frag.appendChild(start);
+    frag.appendChild(end);
+    let current = null;
+    const update = (v) => {
+        if (current) {
+            current.dispose();
+            for (const n of current.nodes)
+                if (n.parentNode)
+                    n.parentNode.removeChild(n);
+        }
+        current = buildScoped(owner, () => render(v));
+        const parent = end.parentNode;
+        for (const n of current.nodes)
+            parent.insertBefore(n, end);
+    };
+    bind(b.listen(update));
+    onCleanup(() => current?.dispose());
+    return frag;
+}
+/** Longest strictly-increasing subsequence; returns the set of kept indices. */
+function lisIndices(seq) {
+    const n = seq.length;
+    const piles = [];
+    const prev = new Array(n).fill(-1);
+    for (let i = 0; i < n; i++) {
+        const x = seq[i];
+        if (x < 0)
+            continue; // freshly-created rows are never "stable"
+        let lo = 0;
+        let hi = piles.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (seq[piles[mid]] < x)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        if (lo > 0)
+            prev[i] = piles[lo - 1];
+        piles[lo] = i;
+    }
+    const keep = new Set();
+    let k = piles.length ? piles[piles.length - 1] : -1;
+    while (k >= 0) {
+        keep.add(k);
+        k = prev[k];
+    }
+    return keep;
+}
+/** Keyed list: reuses rows by key, reorders with minimal moves (LIS). */
+export function each(items, key, render) {
+    const owner = currentOwner;
+    const start = document.createComment("each");
+    const end = document.createComment("/each");
+    const frag = document.createDocumentFragment();
+    frag.appendChild(start);
+    frag.appendChild(end);
+    let rows = [];
+    const update = (list) => {
+        const parent = end.parentNode;
+        const oldIndex = new Map();
+        rows.forEach((r, i) => oldIndex.set(r.key, i));
+        const seen = new Set();
+        const next = [];
+        const seq = [];
+        for (const item of list) {
+            const k = key(item);
+            if (seen.has(k))
+                continue; // duplicate keys: keep first
+            seen.add(k);
+            const prevIdx = oldIndex.get(k);
+            if (prevIdx !== undefined) {
+                next.push(rows[prevIdx]); // reuse: no re-render
+                seq.push(prevIdx);
+            }
+            else {
+                const built = buildScoped(owner, () => render(item));
+                next.push({ key: k, nodes: built.nodes, dispose: built.dispose });
+                seq.push(-1);
+            }
+        }
+        // dispose rows whose key disappeared
+        for (const r of rows) {
+            if (!seen.has(r.key)) {
+                r.dispose();
+                for (const n of r.nodes)
+                    if (n.parentNode)
+                        n.parentNode.removeChild(n);
+            }
+        }
+        // reorder with minimal moves; preserve focus across moves
+        const active = (parent.ownerDocument || document).activeElement;
+        const keep = lisIndices(seq);
+        let anchor = end;
+        for (let i = next.length - 1; i >= 0; i--) {
+            const row = next[i];
+            if (!keep.has(i)) {
+                for (const n of row.nodes)
+                    parent.insertBefore(n, anchor);
+            }
+            anchor = row.nodes[0] ?? anchor;
+        }
+        if (active instanceof HTMLElement && active.isConnected)
+            active.focus();
+        rows = next;
+    };
+    bind(items.listen(update));
+    onCleanup(() => {
+        for (const r of rows)
+            r.dispose();
+    });
+    return frag;
+}
+export function createContext(defaultValue) {
+    return { id: Symbol("context"), defaultValue };
+}
+/** Write a context value into the current owner. */
+export function provide(ctx, value) {
+    if (currentOwner) {
+        (currentOwner.contexts ?? (currentOwner.contexts = new Map())).set(ctx.id, value);
+    }
+}
+/** Read the nearest provided value up the owner tree, else the default. */
+export function use(ctx) {
+    let o = currentOwner;
+    while (o) {
+        if (o.contexts && o.contexts.has(ctx.id)) {
+            return o.contexts.get(ctx.id);
+        }
+        o = o.parent;
+    }
+    return ctx.defaultValue;
+}
+// ---------------------------------------------------------------------------
+// Rendering helpers (§14 roadmap #9)
+// ---------------------------------------------------------------------------
+// A behavior that only emits updates when its value actually changes.
+// The dedup memory is seeded with the current value, so re-emitting the
+// initial value does not trigger a rebuild.
+function distinctB(b) {
+    const out = new Event(b.updates.rank + 1);
+    let prev = b.sampleNoTrans();
+    b.updates.listen_(out, (t, a) => {
+        if (!Object.is(prev, a)) {
+            prev = a;
+            out.send_(t, a);
+        }
+    });
+    return new Behavior(() => b.sampleNoTrans(), out);
+}
+/** Conditional region driven by a boolean behavior (no rebuild on same value). */
+export function when(cond, thenRender, elseRender) {
+    return dyn(distinctB(cond), (c) => c ? thenRender() : elseRender ? elseRender() : null);
+}
+/** Two-way binding props for a text input. Spread onto an `<input>`. */
+export function bindInput(value, set) {
+    return {
+        value,
+        onInput: (e) => set(e.target.value),
+    };
+}
+/** Render `child` into another node, cleaning up on dispose. */
+export function portal(target, child) {
+    const built = buildScoped(currentOwner, () => child);
+    for (const n of built.nodes)
+        target.appendChild(n);
+    onCleanup(() => {
+        built.dispose();
+        for (const n of built.nodes)
+            if (n.parentNode)
+                n.parentNode.removeChild(n);
+    });
+    return document.createComment("portal");
+}
+/** Mount a view under a root owner. Returns an unmount function. */
+export function mount(container, view) {
+    return root((dispose) => {
+        const node = view();
+        const nodes = node.nodeType === 11 ? Array.from(node.childNodes) : [node];
+        container.appendChild(node);
+        onCleanup(() => {
+            for (const n of nodes)
+                if (n.parentNode)
+                    n.parentNode.removeChild(n);
+        });
+        return () => dispose();
+    });
+}
+// ---------------------------------------------------------------------------
+// Animation clock (browser) — a discrete tick source for continuous time.
+// ---------------------------------------------------------------------------
+/**
+ * An `Event<number>` of `requestAnimationFrame` timestamps (ms). Drives the
+ * continuous-time combinators (`integral`/`derivative`/`warp` from the core).
+ * Registered against the current owner: it stops automatically on unmount.
+ */
+export function animationFrames() {
+    const [ticks, fire] = newEvent();
+    let raf = requestAnimationFrame(function loop(t) {
+        fire(t);
+        raf = requestAnimationFrame(loop);
+    });
+    onCleanup(() => cancelAnimationFrame(raf));
+    return ticks;
+}
+// ---------------------------------------------------------------------------
+// Control-flow components — JSX wrappers over the rendering helpers.
+// ---------------------------------------------------------------------------
+// JSX always delivers children as the rest array; a single render function
+// arrives as `[fn]`. Normalize to a render callback.
+function asRender(children) {
+    const c = Array.isArray(children) ? children[0] : children;
+    return typeof c === "function"
+        ? c
+        : () => c;
+}
+/**
+ * Conditional region. Rebuilds only when the truthiness of `when` toggles; the
+ * (narrowed) value is passed to the children render function at build time.
+ *
+ * ```tsx
+ * <Show when={user} fallback={() => <Guest />}>
+ *   {(u) => <span>{u.name}</span>}
+ * </Show>
+ * ```
+ */
+export function Show(props) {
+    const render = asRender(props.children);
+    const present = props.when.map((v) => !!v);
+    return when(present, () => render(props.when.sample()), props.fallback);
+}
+/**
+ * Keyed list. The `by` key selector defaults to identity. (Note: `key` is a
+ * reserved JSX attribute stripped by the compiler, so the prop is named `by`.)
+ *
+ * ```tsx
+ * <Each each={items} by={(i) => i.id}>{(item) => <li>{item.name}</li>}</Each>
+ * ```
+ */
+export function Each(props) {
+    const render = asRender(props.children);
+    const key = props.by ?? ((item) => item);
+    return each(props.each, key, render);
+}
+/**
+ * Switch the subtree on a behavior's value (rebuilds on every change).
+ *
+ * ```tsx
+ * <Dynamic value={route}>{(r) => r === "home" ? <Home /> : <About />}</Dynamic>
+ * ```
+ */
+export function Dynamic(props) {
+    return dyn(props.value, asRender(props.children));
+}
+/**
+ * Render children into another node (e.g. `document.body`), cleaning up on
+ * unmount. Children are eager here — a portal renders immediately.
+ *
+ * ```tsx
+ * <Portal mount={document.body}><Modal /></Portal>
+ * ```
+ */
+export function Portal(props) {
+    return portal(props.mount, props.children ?? null);
+}

package/dist/jsx-dev-runtime.d.ts

@@ -0,0 +1,2 @@
+export { Fragment, JSX } from "./jsx-runtime.js";
+export declare function jsxDEV(type: unknown, props: Record<string, unknown> | null): Node;

package/dist/jsx-dev-runtime.js

@@ -0,0 +1,8 @@
+// Continuum — automatic JSX runtime (development variant).
+// `jsxDEV` receives extra debug args (key, isStaticChildren, source, self);
+// we ignore them and delegate to the production adapter.
+import { jsx } from "./jsx-runtime.js";
+export { Fragment } from "./jsx-runtime.js";
+export function jsxDEV(type, props) {
+    return jsx(type, props);
+}

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,20 @@
+import { Fragment as Frag } from "./index.js";
+import type { Child } from "./index.js";
+export declare const Fragment: typeof Frag;
+type RuntimeProps = {
+    children?: Child;
+} & Record<string, unknown>;
+/** Single/no static child. */
+export declare function jsx(type: unknown, props: RuntimeProps | null): Node;
+/** Multiple static children (children is an array). */
+export declare function jsxs(type: unknown, props: RuntimeProps | null): Node;
+export declare namespace JSX {
+    type Element = Node;
+    interface ElementChildrenAttribute {
+        children: Record<string, never>;
+    }
+    interface IntrinsicElements {
+        [elem: string]: any;
+    }
+}
+export {};

package/dist/jsx-runtime.js

@@ -0,0 +1,24 @@
+// Continuum — automatic JSX runtime.
+// With `"jsx": "react-jsx"` + `"jsxImportSource": "@continuum-js/dom"`, the
+// compiler auto-imports these, so components no longer need `import { h }`.
+// They are thin adapters over `h`: the automatic runtime delivers children in
+// `props.children`, whereas `h` takes them as rest arguments.
+import { h, Fragment as Frag } from "./index.js";
+export const Fragment = Frag;
+function build(type, props) {
+    const { children, ...rest } = props ?? {};
+    const kids = children === undefined
+        ? []
+        : Array.isArray(children)
+            ? children
+            : [children];
+    return h(type, rest, ...kids);
+}
+/** Single/no static child. */
+export function jsx(type, props) {
+    return build(type, props);
+}
+/** Multiple static children (children is an array). */
+export function jsxs(type, props) {
+    return build(type, props);
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@continuum-js/dom",
+  "version": "0.3.0",
+  "description": "Continuum DOM renderer — fine-grained bindings, dynamic regions, ownership, context",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/denislibs/continuum.git",
+    "directory": "packages/dom"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx-runtime.d.ts",
+      "import": "./dist/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx-dev-runtime.d.ts",
+      "import": "./dist/jsx-dev-runtime.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@continuum-js/frp": "0.3.0"
+  }
+}