@dom-expressions/runtime 0.50.0-next.15

package/CHANGELOG.md

@@ -0,0 +1,348 @@
+# dom-expressions
+
+## 0.50.0-next.15
+
+### Patch Changes
+
+- 42ca328: Awaited renderToStream (`then()`, which renderToStringAsync wraps) now waits out blocking promises and re-pulls pending root holes before completing, matching `pipe()`. Previously a render whose only async was a blocked root hole (e.g. `lazy()` or an async component source with no registered fragment) completed immediately with an unfinished shell.
+- ed01d41: Source server `mergeProps` from rxcore like the client and universal entries instead of shipping a local copy. The local merger resolved function sources for key enumeration only — the per-key getter read values off the raw, un-invoked function — so SSR dropped spread props whose source is a function (`<div {...fn()}>`, `<Dynamic {...props}>`; solidjs/solid#2815). Prop-merge semantics belong to the framework core; renderers must now export `mergeProps` from their server rxcore module (the universal entry already required this).
+- df03fb8: Move all packages under the `@dom-expressions` npm scope with new names:
+  - `dom-expressions` → `@dom-expressions/runtime`
+  - `babel-plugin-jsx-dom-expressions` → `@dom-expressions/babel-plugin-jsx`
+  - `jsx-dom-expressions-compiler` → `@dom-expressions/jsx-compiler`
+  - `hyper-dom-expressions` → `@dom-expressions/hyperscript`
+  - `tagged-jsx-dom-expressions` → `@dom-expressions/tagged-jsx`
+
+  The old unscoped names stop receiving `next` prereleases and remain in use
+  only by the Solid 1.x maintenance line published from `main`.
+
+  `lit-dom-expressions` is dropped from the prerelease line; it has been
+  superseded by `@dom-expressions/tagged-jsx`.
+
+  `@dom-expressions/jsx-compiler` now distributes prebuilt native binaries
+  through per-platform packages (`@dom-expressions/jsx-compiler-darwin-x64`,
+  `-darwin-arm64`, `-linux-x64-gnu`, `-linux-arm64-gnu`, `-win32-x64-msvc`)
+  resolved automatically via `optionalDependencies`, instead of shipping a
+  binary inside the main package.
+
+## 0.50.0-next.14
+
+### Patch Changes
+
+- 910e5fe: Add `host` option to `insert` for portal-style slots. Top-level nodes managed by the slot are tagged with a live `_$host` getter after each update, replacing proxy-based DOM call interception. The mount parent is now a real element so slot-ownership checks (`parentNode` identity) behave correctly — fixes portal content accumulating on swaps (solidjs/solid#2757) — and tagging covers the `replaceChild`, reconcile, and hydration claim paths the proxy missed.
+- 58284f7: Make `ClassValue` recursive so nested arrays type-check. The runtime already
+  flattens arbitrarily nested class arrays (e.g. `class={["a", ["b"]]}`), but the
+  type only allowed a single level. `ClassValue` is now `string | number |
+boolean | null | undefined | Record<string, boolean> | ClassValue[]`.
+- a9357a2: Universal renderer `render()` disposers now remove the top-level host nodes they mounted, matching DOM `render()` cleanup semantics. Custom renderers can provide `cleanupNodes(parent, nodes)` to override the default per-node `removeNode` teardown.
+
+## 0.50.0-next.13
+
+### Patch Changes
+
+- a75a56b: Expose the `ClassValue` type from JSX and lit runtime declarations so consumers can type wrapper props against the supported string, object, and array class forms.
+- 78bb855: Harden DOM-runtime insertion against nodes that have migrated out of their
+  original slot between renders. Resolves the class of bugs reported as
+  solidjs/solid#2030 (a new JSX value that wraps the previous slot's node) and
+  solidjs/solid#2357 (a single node referenced from multiple sibling slots).
+  Previously, `cleanChildren` and `reconcileArrays` could either throw
+  `replaceChild` "new child contains the parent", or silently destroy the
+  migrated node by trusting a stale `current.parentNode === parent` check.
+
+  Every runtime insertion site (`appendNodes`, `insertExpression`'s
+  element-node branch, the replacement path in `cleanChildren`, all four
+  insertion sites in `reconcileArrays`) now tags the inserted node with a
+  per-slot `$$SLOT` Symbol property carrying the slot's marker. Every
+  destructive operation (`remove`, `replaceChild`, `insertBefore` against a
+  sibling anchor) is now gated on parent-and-tag ownership: an untagged node
+  is treated as unclaimed (the slot may manage it), a tagged node is touched
+  only when its tag matches the current slot's marker. Foreign nodes — refs
+  appended by user code, nodes that have migrated to another slot, content
+  inserted by other runtimes — are left alone.
+
+  The `tail.nextSibling` `after` anchor in `reconcileArrays` is also gated:
+  if `a`'s tail has migrated, the `after` falls back to the slot's marker
+  rather than reading a sibling pointer that now points into another slot's
+  region. The symmetric end-swap fast-path (`a[0]===b[n-1] && b[0]===a[n-1]`)
+  gains an anchor-ownership check so it cannot stage moves against a foreign
+  front anchor; mismatched anchors fall through to the map branch which
+  re-gates each destructive op.
+
+  Scope: DOM renderer (`client.js`) only. `universal.js` is intentionally
+  unchanged — universal hosts target older JS environments (Chrome 38+),
+  expando writes on platform nodes can collide with proxy-based node wrappers,
+  and the JSX-DOM-ref migration patterns this fix addresses are not idiomatic
+  on non-DOM platforms. If a real case surfaces on a universal renderer it
+  can be revisited with a host-appropriate storage strategy.
+
+- f1bcd5f: Stop giving special compiler handling to `style:foo` and `class:foo` JSX namespace syntax, and rename the static compiler marker from `@once` to `@static`. `style:foo` and `class:foo` now fall through to literal HTML attributes (e.g. `<div style:border="1px solid black">` emits `style:border` verbatim).
+
+  Internal optimizations still split `style={{...}}` into `setStyleProperty` calls and `class={{...}}` into `classList.toggle` calls.
+
+- f17f7a1: Rename the generated event listener helper from `addEventListener` to `addEvent` so compiled browser bundles no longer introduce a binding that can shadow the native `window.addEventListener` method.
+- a45b224: Dispose the partially-created reactive scope when `render()` (and the universal renderer's `render()`) throws during initial mount. Previously a synchronous throw inside the top-level component would orphan the root and, in the DOM client, leave the delegated-root counter bumped — leaking event-delegation state with no recovery path since the caller never receives the disposer. The throw still propagates; the cleanup just happens before it does. `hydrate()` benefits transitively because it delegates to `render()`.
+
+## 0.50.0-next.12
+
+### Patch Changes
+
+- Port relevant maintenance fixes from the stable branch. Add `omitAttributeSpacing` for strict template attribute spacing, and align `server.js`/`server.d.ts` with the current `client.d.ts` export surface so isomorphic imports continue to resolve on the server.
+- 64e9aee: Delegated events are now owned by render roots instead of the document by default. `render()` installs and disposes its delegated listeners with the root, `delegateEvents()` now only declares event demand, and additional listener containers can be registered explicitly for framework features that render outside the root.
+
+## 0.50.0-next.11
+
+### Patch Changes
+
+- d5cd499: Remove `on:` namespace event support from compiler, runtime, JSX types, and renderer packages.
+
+## 0.50.0-next.10
+
+### Patch Changes
+
+- afbe2ff: Optimize synchronous SSR function holes and plain template array resolution.
+
+## 0.50.0-next.9
+
+### Patch Changes
+
+- d883fad: Schedule `insert()` function-child DOM writes when the parent insert effect is updating an existing slot. This lets async reads inside nested render effects hold the active transition before replacing already-mounted content, and mirrors the fix in the universal renderer.
+
+## 0.50.0-next.8
+
+### Patch Changes
+
+- 858cf13: Fix `ssr()` double-invocation on bail paths.
+
+  A function hole whose return value walked into the bail branch (e.g., an array containing a NotReady-throwing item) was being invoked twice: once by `tryResolveString` for sync probing and again by the fallback `resolveSSRNode(hole, result)`. For closures that read stateful getters such as JSX `props.children` — whose backing component rebuilds an owner subtree on each access — the duplicate invocation produced a second owner tree with a divergent hydration-key prefix that the client could not claim, surfacing as "Hydration completed with N unclaimed server-rendered node(s)" warnings.
+
+  `tryResolveString` now evaluates each function node exactly once and threads the evaluated value through the bail object so `ssr()` can hand it to `resolveSSRNode` without re-invoking the original closure.
+
+## 0.50.0-next.7
+
+### Patch Changes
+
+- 0bd165e: Preserve shared class tokens when diffing object keys that contain multiple class names.
+  Ensure class-method JSX captures `this` before lifted DOM setup statements run.
+- 2fe6310: Speed up DOM and universal reconcile's symmetric end-swap branch on reorder-heavy
+  patterns (e.g. `<For>` reverse / large rotations).
+
+  The trigger condition is unchanged
+  (`a[aStart] === b[bEnd-1] && b[bStart] === a[aEnd-1]`), but the body now
+  walks inward against a single stable front anchor (`a[aStart]`) instead
+  of issuing two cross-anchored `insertBefore` calls per pair. Each move
+  targets the same DOM position so the browser's adjacency cache stays
+  warm and per-call native `insertBefore` cost drops sharply. The inner
+  loop also continues consuming consecutive symmetric swaps without
+  re-entering the outer dispatch.
+
+  Behaviorally equivalent to the previous implementation: same DOM
+  mutation count, same correctness surface, no false-positive widening.
+  Validated against `dom-expressions` reconcile tests, the full Solid
+  test suite, UIBench `tree/[500]/[reverse]`, and `js-framework-benchmark`
+  `05_swap1k`.
+
+- 10f3250: SSR: group contiguous attribute and `textContent` closures into a single
+  `_$ssrGroup(() => […], N)` call per element so the runtime can resolve
+  all `N` hole positions with one closure invocation instead of `N`. The
+  compiler walks each top-level element's `templateValues`, identifies
+  runs of `≥2` groupable entries (inserts/children break a run, preserving
+  child isolation), and replaces them with one grouped declarator repeated
+  `N` times in the `ssr(...)` argument list. `_$ssrGroup` tags the
+  function with `fn.$g = N` so `ssr()` can dispatch through a fast path
+  that's gated at the end of the typeof chain — non-function holes pay
+  nothing for the new branch.
+
+  For the async escalation path (group fn throws `NotReadyError`), every
+  retry slot for the group shares a module-scoped cache keyed on `fn`:
+  slot 0 evaluates and caches `arr` (success) or `err` (still-pending),
+  slots `1..N-1` short-circuit on the cached outcome, and the cache
+  invalidates when slot 0 re-fires next pass. Net retry cost: 1 evaluation
+  per group per pass on either outcome — `N²` → `N` on success, `N²` → `1`
+  on failure — with no per-state bookkeeping.
+
+  Bench: `+15%` on `search-results` (heavy attribute usage), neutral on
+  `color-picker` (no qualifying groups). Hydration ids are unaffected:
+  attribute/textContent expressions never allocate ids, and inserts (which
+  do) stay outside groups by construction.
+
+- 3574228: SSR rendering performance pass.
+
+  **Runtime (`dom-expressions`):**
+  - Inline hole resolution in `ssr()`. Switch from a `(t, ...nodes)` rest
+    parameter to an `arguments` walk, eliminating the per-call holes-array
+    allocation. Inline `string`/`number`/`null`/`boolean` fast paths skip
+    `tryResolveString` for the typical "all-static-after-eval" hole shape; only
+    the heavy path (async escalation) materializes the `{ t, h, p }` result.
+  - Single forward-pass `escape()`. The previous implementation walked the
+    string twice in the hot path (`indexOf(delim)` + `indexOf("&")` upfront
+    then early-exit on the no-hit case). Replaced with a `charCodeAt` loop
+    that bails after one pass for clean strings (the common case), and
+    resumes the slow path from the first hit so the clean prefix isn't
+    re-scanned.
+  - Remove the `ssrRunInScope` public export. The function had been a true
+    pass-through identity (`fn => fn`) since owner-capture moved into
+    `tryResolveString`'s `NotReadyError` handler, and the compiler stopped
+    emitting it. With no internal callers and no behavior, the export was
+    dead surface area. User code that called it can drop the wrap (it was a
+    no-op) or replicate the original deferred-callback owner-capture intent
+    in two lines with `getOwner()` + `runWithOwner()`.
+
+  **Compiler (`babel-plugin-jsx-dom-expressions`):**
+  - IIFE elision in statement-position JSX. When `<jsx/>` is the argument of
+    a `return` or the initializer of a `const` (the overwhelmingly common
+    shapes), the surrounding IIFE is removed and the body lifts to flat
+    statements before the parent. Saves one closure allocation + one
+    function-call frame per render. Applies to `dom`, `ssr`, and `universal`
+    emissions; expression-position JSX (ternary branches, array elements,
+    function args) keeps the IIFE since lifting would change observable
+    evaluation semantics.
+  - SSR templates emit hoisted `var` declarations for dynamic-expression temp
+    vars instead of wrapping the whole thing in an IIFE. In statement
+    position the declarations precede the `ssr(...)` call; in expression
+    position they hoist to the enclosing function scope and the
+    assignment + call become a comma sequence expression.
+  - Drop `ssrRunInScope` emission around dynamic SSR expressions. The
+    temp-var hoist stays — it's a V8 IC-stability tactic (keeps the `ssr()`
+    call site specialized on `Identifier` argument shapes), not an
+    evaluation-order requirement. Ordering is preserved by JS left-to-right
+    semantics.
+  - Drop `createComponent` wrap on SSR component invocations. The SSR
+    runtime's `createComponent` is `Comp(props || {})`; the compiler always
+    emits a real `props` object, so the `|| {}` fallback never fires. Inline
+    to a direct `Comp(props)` call. DOM / dev modes keep the wrapper since
+    it does real work (`untrack`, dev metadata).
+
+  Net effect on representative SSR shapes (color-picker, search-results) is
+  fewer allocations per render and a flatter call graph through the hot path.
+
+## 0.50.0-next.6
+
+### Patch Changes
+
+- f0ca033: Add a build-time JSX declaration customization script for renderer packages.
+
+## 0.50.0-next.5
+
+### Patch Changes
+
+- 4f17771: Fix document-root rendering so lazy memo-owned content remains reactive after `render(..., document)` or `hydrate(..., document)`. Full-document render paths now keep the root JSX tree observed without inserting into `document`, preventing nested content from going stale after later signal updates.
+
+## 0.50.0-next.4
+
+### Patch Changes
+
+- a307ac7: Expose `VoidElements` and `RawTextElements` consistently from every
+  runtime entry that already re-exports the other HTML constants. The
+  runtime added these sets to `client.js` in `0.50.0-next.3`, but
+  `server.js` was missed and the hand-maintained `client.d.ts` /
+  `server.d.ts` declaration files didn't pick them up either. Now both
+  entries (`dom-expressions/client` and `dom-expressions/server`) and
+  their type declarations export the same constant surface, so consumers
+  like `@solidjs/web` no longer need to layer their own explicit
+  re-exports or copy-script workarounds to surface the symbols.
+
+## 0.50.0-next.3
+
+### Patch Changes
+
+- 816870a: Export `VoidElements` and `RawTextElements` from the runtime constants. These are the standard HTML void-element and raw-text-element sets used by HTML parsers, exposed so downstream tagged-template runtimes (e.g. `sld-dom-expressions`) can consume them without redefining the lists.
+- 4dae801: Normalize the `repository` field in every package to the standard npm
+  convention: a `git+https://github.com/ryansolid/dom-expressions.git` URL
+  with a `directory` pointing at the package within the monorepo. Restores
+  "View source" / "Open in repo" links on the npm registry and unblocks
+  tooling that resolves source from package metadata.
+
+## 0.50.0-next.2
+
+### Patch Changes
+
+- d9b571c: Replace the `memo(accessor, true)` wrap in `insert()` with a conditionally
+  nested render-effect pattern. The memo wrap fixed `<Show>` siblings
+  re-rendering but introduced two regressions: stale reads broke at the memo
+  boundary during transitions, and the memo could claim transition ownership
+  and strand later synchronous writes in stashed queues (the Sierpinski hover
+  freeze).
+
+  The outer effect now reads `accessor()` with `doNotUnwrap` so function
+  children are preserved without subscribing to their internals. When
+  function children exist, the outer's compute installs a nested
+  render-effect that owns DOM writes for this slot (signalled via an
+  `INNER_OWNED` sentinel so the outer's write callback no-ops). Every
+  reactive hop on the path is a render-effect with correct stale-value and
+  transition-ownership semantics. Same node count as before for
+  function-children slots, one fewer for primitive slots.
+
+  Mirrored into `universal.js`.
+
+- 39c207c: Fix a SyntaxError when an element has 222+ merged dynamic attributes
+  (solidjs/solid#2682). The internal identifier generator produced `in` at
+  index 221, and since these identifiers are emitted as object shorthand
+  destructuring bindings, the resulting `({ …, in }) => …` could not be parsed.
+  `getNumberedId` now shifts past any natural index that would encode to a JS
+  reserved word, keeping the mapping injective and the output at 2 characters
+  for all practical dynamic counts.
+- 03da8a5: Fix SSR escaping gaps reachable from JSX, and tighten the compiler so
+  redundant runtime `escape` calls drop out of the output.
+
+  Security fixes:
+  - `ssrStyle` and `ssrClassName` now attribute-escape object keys, not
+    just values. Previously a user-controlled key in `<div style={{…}} />`
+    or `<div class={{…}} />` could break out of the surrounding attribute.
+  - Dynamic fragment-child expressions (`<>{state.text}</>`) now compile
+    to `_$memo(() => _$escape(expr))`. Element-child expressions already
+    escaped via `escapeExpression`; fragment children reached SSR through
+    a separate path and were concatenated raw.
+  - Computed-key object styles (`style={{ [k]: v }}`) escape the key at
+    compile time.
+
+  Compiler alignment:
+  - SSR now matches DOM in rejecting fragments placed directly inside an
+    element: `<div><>…</></div>` is a compile error in both renderers.
+    Fragments reached via conditionals (`<div>{cond && <>…</>}</div>`)
+    remain legal.
+
+  Compiler optimizations:
+  - `escapeExpression` drops the outer `_$escape` wrap on a `JSXFragment`
+    when its single significant child is either a dynamic expression
+    (compiles to a memoized accessor function, `escape(fn)` is a no-op)
+    or a native element (compiles to an `_$ssr(…)` SSR node object,
+    `escape(object)` is a no-op). This turns
+    `cond && _$escape(_$memo(() => _$escape(state.text)))` into
+    `cond && _$memo(() => _$escape(state.text))`, and
+    `cond && _$escape(_$ssr(_tmpl$N))` into `cond && _$ssr(_tmpl$N)`.
+
+  SSR fixtures for `components`, `conditionalExpressions`, `fragments`,
+  and `attributeExpressions` regenerate. Each security fix has a JSX
+  round-trip test in `packages/dom-expressions/test/ssr/jsx.spec.jsx`
+  that feeds hostile input through `renderToString`.
+
+- 305d9ce: - SSR: Duplicate attributes in JSX without spreads are now deduplicated —
+  `<div class="a" class="b" />` correctly renders as `<div class="b" />`
+  (last-wins), matching client behavior. Previously the compiler kept both
+  attributes in the output.
+  - Client: `setAttributeNS` / `removeAttributeNS` now use matching names when
+    clearing namespaced attributes (e.g. `xlink:href`). Previously removal could
+    leave the attribute in place because it used the local name while the set
+    used the qualified name.
+  - Expanded test coverage across all four packages; no other behavior changes.
+
+## 0.50.0-next.1
+
+### Patch Changes
+
+- ee365e0: - `insert()` accepts an optional 5th `options` argument that is forwarded to the
+  internal `effect()` call, letting callers (e.g. Solid's `render()`) opt into
+  transition-aware initial mounts without otherwise changing `insert`'s
+  behavior.
+  - SSR: `$dflj(ids)` now materializes every id in the list in a single call
+    instead of stopping after the first successful `$dfl`. Callers pass only the
+    keys they intend to materialize, which simplifies the primitive and composes
+    cleanly for bulk-uncollapse cases (e.g. a group activation revealing several
+    held fallbacks at once).
+  - SSR: Fix cascading async root holes in the streaming shell. When an inner
+    Loading boundary resolved its first chunk while the outer shell was still
+    pending, `flushEnd` could call `serializer.flush()` before `doShell()` had
+    written the root `_assets` module map, causing seroval to silently drop the
+    writes and client hydration to fail with "module was not preloaded". Root
+    asset serialization is now memoized and gated on both paths.
+  - Type formatting cleanup in `jsx-properties.d.ts`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-2019 Ryan Carniato
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# DOM Expressions
+
+[![Build Status](https://github.com/ryansolid/dom-expressions/workflows/DOMExpressions%20CI/badge.svg)](https://github.com/ryansolid/dom-expressions/actions/workflows/main-ci.yml)
+[![Coverage Status](https://img.shields.io/coveralls/github/ryansolid/dom-expressions.svg?style=flat)](https://coveralls.io/github/ryansolid/dom-expressions?branch=main)
+[![NPM Version](https://img.shields.io/npm/v/dom-expressions.svg?style=flat)](https://www.npmjs.com/package/dom-expressions)
+![](https://img.shields.io/bundlephobia/minzip/dom-expressions.svg?style=flat)
+![](https://img.shields.io/npm/dt/dom-expressions.svg?style=flat)
+[![Gitter](https://img.shields.io/gitter/room/dom-expressions/community)](https://gitter.im/dom-expressions/community)
+
+DOM Expressions is a Rendering Runtime for reactive libraries that do fine grained change detection. These libraries rely on concepts like Observables and Signals rather than Lifecycle functions and the Virtual DOM. Standard JSX transformers are not helpful to these libraries as they need to evaluate their expressions in isolation to avoid re-rendering unnecessary parts of the DOM.
+
+This package wraps libraries like KnockoutJS or MobX and use them independent of their current render systems using a small library to render pure DOM expressions. This approach has been proven to be incredibly fast, dominating the highest rankings in the [JS Framework Benchmark](https://github.com/krausest/js-framework-benchmark).
+
+It is designed to be used with a companion render API. Currently there is a JSX Babel Plugin, and Tagged Template Literals, and HyperScript runtime APIs. Most developers will not use this package directly. It is intended to help author your own Reactive Libraries and not to be used directly in projects.
+
+## Example Implementations
+
+- [Solid](https://github.com/ryansolid/solid): A declarative JavaScript library for building user interfaces.
+- [mobx-jsx](https://github.com/ryansolid/mobx-jsx): Ever wondered how much more performant MobX is without React? A lot.
+- [vuerx-jsx](https://github.com/ryansolid/vuerx-jsx): Ever wondered how much more performant Vue is without Vue? ...renderer built on @vue/reactivity
+- [ko-jsx](https://github.com/ryansolid/ko-jsx): Knockout JS with JSX rendering.
+- [s-jsx](https://github.com/ryansolid/s-jsx): Testbed for trying new techniques in the fine grained space.
+
+## Runtime Generator
+
+Dom Expressions is designed to allow you to create a runtime to be tree shakeable. It does that by using "babel-plugin-transform-rename-import" to rename the import to your reactive core file. Setup the babel plugin and then `export * from "dom-expressions/src/runtime"`from your runtime. Be sure to not exclude the dom-expressions node_module.
+
+```js
+{
+  plugins: [
+    [
+      "babel-plugin-transform-rename-import",
+      {
+        original: "rxcore",
+        replacement: "../src/core"
+      }
+    ]
+  ];
+}
+```
+
+What is the reactive core file. It exports an object with the methods required by the runtime.
+Example:
+
+```js
+import { untrack } from "@solidjs/signals";
+
+export const sharedConfig = {};
+
+export function createComponent(Comp, props) {
+  return untrack(() => Comp(props));
+}
+
+export {
+  createRoot as root,
+  createRenderEffect as effect,
+  createMemo as memo,
+  getOwner,
+  untrack,
+  merge as mergeProps
+} from "@solidjs/signals";
+```
+
+## Runtime Renderers
+
+Once you have generated a runtime it can be used with companion render APIs:
+
+### JSX
+
+[Babel Plugin JSX DOM Expressions](https://github.com/ryansolid/dom-expressions/blob/main/packages/babel-plugin-jsx) is by far the best way to use this library. Pre-compilation lends to the best performance since the whole template can be analyzed and optimal compiled into the most performant JavaScript. This allows for not only the most performant code, but the cleanest and the smallest.
+
+### Tagged Template
+
+If precompilation is not an option Tagged Template Literals are the next best thing. [Tagged JSX DOM Expressions](https://github.com/ryansolid/dom-expressions/blob/main/packages/tagged-jsx) provides a similar experience to the JSX, parsing JSX-shaped templates at runtime and caching the compiled result on first run. It keeps most of the performance and syntax of the compiled JSX version with no build step.
+
+### HyperScript
+
+While not as performant as the other options this library provides a mechanism to expose a HyperScript version. [Hyper DOM Expressions](https://github.com/ryansolid/dom-expressions/blob/main/packages/hyperscript) offers the greatest flexibility working with existing tooling for HyperScript and enables pure JS DSLs.
+
+## Work in Progress
+
+This is still a work in progress. My goal here is to better understand and generalize this approach to provide non Virtual DOM alternatives to developing web applications.
+
+## Updating JSX Types
+
+JSX types are located in `packages/runtime/src/jsx-h.d.ts`.
+
+To update JSX types:
+
+1. modify/update `jsx-h.d.ts`
+2. run `npm run jsx-sync-types`
+
+NOTE: The file `jsx.d.ts` is autogenerated taking `jsx-h.d.ts` as source. Changes to `jsx.d.ts` will be discarded!
+
+### Customizing JSX Element Types
+
+Renderer packages that vendor these JSX declarations can customize `JSX.Element` at build time with `dom-expressions-jsx-types`.
+
+```sh
+dom-expressions-jsx-types \
+  --input ./src/jsx.d.ts \
+  --element "SolidElement | Node | ArrayElement" \
+  --import 'import type { Element as SolidElement } from "solid-js";'
+```
+
+The command updates the declaration file in place. Use `--output` to write a separate file. Each `--import` statement is inserted after the local `jsx-properties.js` import and de-duplicated on repeated runs.

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dom-expressions/runtime",
+  "description": "A Fine-Grained Runtime for Performant DOM Rendering",
+  "version": "0.50.0-next.15",
+  "author": "Ryan Carniato",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ryansolid/dom-expressions.git",
+    "directory": "packages/runtime"
+  },
+  "readmeFilename": "README.md",
+  "sideEffects": false,
+  "bin": {
+    "dom-expressions-jsx-types": "./src/jsx-customize.mjs"
+  },
+  "dependencies": {
+    "babel-plugin-transform-rename-import": "^2.3.0"
+  },
+  "peerDependencies": {
+    "csstype": "^3.0",
+    "seroval": "~1.5.0",
+    "seroval-plugins": "~1.5.0"
+  },
+  "devDependencies": {
+    "csstype": "^3.1",
+    "seroval": "~1.5.0",
+    "seroval-plugins": "~1.5.0",
+    "@dom-expressions/babel-plugin-jsx": "0.50.0-next.15"
+  },
+  "scripts": {
+    "test": "jest --no-cache",
+    "test:coverage": "jest --coverage --no-cache",
+    "report:coverage": "cat ./coverage/lcov.info | ../../node_modules/coveralls/bin/coveralls.js && rm -rf ./coverage"
+  }
+}

package/src/client.d.ts

@@ -0,0 +1,117 @@
+import { JSX } from "./jsx.js";
+export const DOMWithState: Record<string, Record<string, 1 | 2>>;
+export const ChildProperties: Set<string>;
+export const DelegatedEvents: Set<string>;
+export const DOMElements: Set<string>;
+export const SVGElements: Set<string>;
+export const MathMLElements: Set<string>;
+export const VoidElements: Set<string>;
+export const RawTextElements: Set<string>;
+export const Namespaces: Record<string, string>;
+
+type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
+export function render(
+  code: () => JSX.Element,
+  element: MountableElement,
+  init?: JSX.Element,
+  options?: { owner?: unknown }
+): () => void;
+/**
+ * @param flag
+ * - `undefined` — clone the template as-is (uses `cloneNode`).
+ * - `1` — use `document.importNode` instead of `cloneNode`.
+ * - `2` — the template html is wrapped; the outer tag is stripped at clone time.
+ */
+export function template(html: string, flag?: 1 | 2): () => Element;
+export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void): void;
+export function memo<T>(fn: () => T, equal: boolean): () => T;
+export function untrack<T>(fn: () => T): T;
+export function insert<T>(
+  parent: MountableElement,
+  accessor: (() => T) | T,
+  marker?: Node | null,
+  init?: JSX.Element,
+  options?: {
+    /**
+     * Live accessor for the slot's logical host in the source tree (portals).
+     * Each top-level node the slot manages is tagged with a `_$host` getter
+     * backed by this accessor so delegated events retarget correctly.
+     */
+    host?: () => Node | null;
+    /** Defer the insert effect to the queue instead of running it inline. */
+    schedule?: boolean;
+  }
+): JSX.Element;
+export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
+export function delegateEvents(eventNames: string[]): void;
+export function registerDelegatedRoot(root: MountableElement): void;
+export function unregisterDelegatedRoot(root: MountableElement): void;
+export function registerDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+export function unregisterDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+export function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
+export function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
+export function assign(
+  node: Element,
+  props: any,
+  skipChildren?: Boolean,
+  prevProps?: any,
+  skipRef?: Boolean
+): void;
+export function setAttribute(node: Element, name: string, value: string): void;
+export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
+export function className(node: Element, value: JSX.ClassValue, prev?: JSX.ClassValue): void;
+export function setProperty(node: Element, name: string, value: any): void;
+export function setStyleProperty(node: Element, name: string, value: any): void;
+export function addEvent(
+  node: Element,
+  name: string,
+  handler: EventListener | EventListenerObject | (EventListenerObject & AddEventListenerOptions),
+  delegate: boolean
+): void;
+export function style(
+  node: Element,
+  value: { [k: string]: string },
+  prev?: { [k: string]: string }
+): void;
+export function getOwner(): unknown;
+export function mergeProps(...sources: unknown[]): unknown;
+export function dynamicProperty(props: unknown, key: string): unknown;
+export function applyRef(
+  r: ((element: Element) => void) | ((element: Element) => void)[],
+  element: Element
+): void;
+export function ref(
+  fn: () => ((element: Element) => void) | ((element: Element) => void)[],
+  element: Element
+): void;
+
+export function hydrate(
+  fn: () => JSX.Element,
+  node: MountableElement,
+  options?: { renderId?: string; owner?: unknown }
+): () => void;
+export function getHydrationKey(): string | undefined;
+export function getNextElement(template?: () => Element): Element;
+export function getNextMatch(start: Node, elementName: string): Element;
+export function getNextMarker(start: Node): [Node, Array<Node>];
+export function useAssets(fn: () => JSX.Element): void;
+export function getAssets(): string;
+export function HydrationScript(props?: { nonce?: string; eventNames?: string[] }): JSX.Element;
+export function generateHydrationScript(options?: {
+  nonce?: string;
+  eventNames?: string[];
+}): string;
+export function Assets(props: { children?: JSX.Element }): JSX.Element;
+export interface RequestEvent {
+  request: Request;
+  locals: Record<string | number | symbol, any>;
+}
+export declare const RequestContext: unique symbol;
+export function getRequestEvent(): RequestEvent | undefined;
+export function runHydrationEvents(): void;