@mindees/renderer 0.1.0

package/LICENSE

@@ -0,0 +1,31 @@
+# License
+
+MindeesNative is dual-licensed under either of:
+
+- **Apache License, Version 2.0** ([LICENSE-APACHE](./LICENSE-APACHE) or
+  <https://www.apache.org/licenses/LICENSE-2.0>)
+- **MIT license** ([LICENSE-MIT](./LICENSE-MIT) or
+  <https://opensource.org/licenses/MIT>)
+
+at your option.
+
+This `MIT OR Apache-2.0` dual-license is the same model used by the Rust
+ecosystem and many modern open-source projects. It gives downstream users
+maximum flexibility: the MIT option is short and permissive, while the Apache
+option adds an explicit patent grant.
+
+## SPDX identifier
+
+```
+SPDX-License-Identifier: MIT OR Apache-2.0
+```
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally
+submitted for inclusion in the work by you, as defined in the Apache-2.0
+license, shall be dual-licensed as above, without any additional terms or
+conditions.
+
+Contributions are accepted under the **Developer Certificate of Origin (DCO)**.
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for details on signing off your commits.

package/README.md

@@ -0,0 +1,129 @@
+# @mindees/renderer
+
+**Helix** — MindeesNative's renderer. It turns the `@mindees/core` element tree
+into host nodes through a swappable **host backend**, with **fine-grained
+reactive bindings**: a changing signal patches exactly the affected
+attribute/text/region — no virtual-DOM diffing.
+
+> **Status: 🧪 Experimental.** Implemented and tested: the reconciler, the
+> **web/DOM backend**, **SSR + hydration**, a **headless** test backend, a
+> **native command backend** (`createNativeCommandBackend()`), a strict reference
+> host (`createReferenceHost()`), and iOS/Android host projects that compile and
+> render the command stream into native view trees in CI. A full end-to-end native
+> app bridge/embedded JS engine and GPU canvas remain **research tracks**; the
+> direct `createNativeBackend()` and `createCanvasBackend()` seams throw
+> `NotImplementedError`. APIs may change before `1.0`.
+
+## Why Helix
+
+- **Fine-grained updates** — built on `@mindees/core` signals: updates are
+  O(what-changed), not O(tree). A reactive text node is patched in place; a
+  reactive prop sets exactly one attribute.
+- **Real SSR + SEO** — `renderToString` emits crawlable HTML (`view`→`div`,
+  `text`→`span`, …), unlike canvas-based web renderers. `hydrate` attaches
+  reactivity on the client.
+- **Backend-agnostic** — the reconciler speaks only the `HostBackend` contract,
+  so a new platform is "implement `HostBackend<N>`." DOM, headless, native command
+  stream, and reference-host validation ship today.
+
+## Quick start
+
+```ts
+import { signal, createElement as h } from '@mindees/core'
+import { createDomBackend, render } from '@mindees/renderer'
+
+function Counter() {
+  const n = signal(0)
+  return h('button', { onClick: () => n.set(n() + 1) }, () => `count: ${n()}`)
+}
+
+const backend = createDomBackend() // uses the global document in a browser
+const app = render(Counter, {}, backend, document.getElementById('app'))
+// app.dispose() unmounts and tears down every reactive binding (no leaks)
+```
+
+### Server-side rendering
+
+```ts
+import { renderToString, hydrate } from '@mindees/renderer'
+
+const html = renderToString(Counter, {}) // '<button>count: 0</button>'
+// …send `html` in your server response, then on the client:
+hydrate(document.getElementById('app'), Counter, {})
+```
+
+### Native command backend (Phase 8A)
+
+The same reconciler can target a native host. `createNativeCommandBackend()`
+implements the `HostBackend` contract but, instead of touching a DOM, records a
+stream of serializable [`NativeCommand`](./src/native-protocol.ts)s
+(`createNode`, `insertChild`, `setProp`, `updateText`, `disposeNode`, …) that a
+native host (UIKit and Android View today; other surfaces later) can replay. It
+runs in Node — no DOM — so the whole native path is testable.
+
+```ts
+import { createNativeCommandBackend, render } from '@mindees/renderer'
+
+const backend = createNativeCommandBackend()
+const app = render(Counter, {}, backend, backend.root)
+const commands = backend.flushCommands() // ship this batch to a native host
+// Event handlers cross as stable ids, never as functions; the host calls back:
+// backend.dispatchEvent(handlerId, event)
+```
+
+> This is the **foundation** for native rendering — it produces the command
+> stream, and the host projects in
+> [`examples/native-hosts/`](https://github.com/mindees/mindees/tree/main/examples/native-hosts)
+> replay/render that stream in CI. You cannot build a native mobile app
+> end-to-end yet because Phase 8F still needs an embedded JS engine plus a
+> JS↔native bridge running the reactive app on-device.
+
+### Reference host + conformance contract (Phase 8B)
+
+`createReferenceHost()` is the **inverse** of the command backend: it consumes a
+`NativeCommand` stream, reconstructs the view tree, and **strictly validates** it
+(throws `NativeHostError` on any malformed/leaking sequence). It is the executable
+**contract** a real native host implements (in Swift/Kotlin against platform
+views). Piping the backend through it proves the stream is valid and non-leaking
+end to end:
+
+```ts
+import { createNativeCommandBackend, createReferenceHost, render } from '@mindees/renderer'
+
+const host = createReferenceHost()
+const backend = createNativeCommandBackend({ rootId: host.rootId, onCommand: (c) => host.apply(c) })
+const app = render(Counter, {}, backend, backend.root)
+host.serialize()      // the reconstructed tree, e.g. '<button>count: 0</button>'
+host.liveNodeCount()  // 0 after app.dispose() — no orphaned/leaked nodes
+```
+
+## API
+
+| Export | Kind | Description |
+| --- | --- | --- |
+| `render(node\|component, [props,] backend, container)` | fn | Mount a tree; returns `Mounted` with `dispose()`. |
+| `renderToString(node\|component, [props])` | fn | SSR → crawlable HTML string. |
+| `hydrate(container, node\|component, [props,] opts?)` | fn | Attach reactivity to server HTML (developer preview). |
+| `createDomBackend(doc?)` | fn | Web/DOM `HostBackend`. |
+| `createHeadlessBackend()` / `createHeadlessRoot()` | fn | In-memory backend (tests, snapshots, SSR). |
+| `domTagFor(tag)` | fn | Map a semantic tag to its HTML tag. |
+| `HostBackend` / `SerializableBackend` | type | The platform seam. |
+| `createNativeCommandBackend(opts?)` | fn | Native `HostBackend` that emits a serializable `NativeCommand` stream (Phase 8A). |
+| `createReferenceHost(rootId?)` | fn | Strict reference host: replays + validates a `NativeCommand` stream (Phase 8B). |
+| `NativeCommand` + `isNativeCommand` / `isNativePropValue` / `normalizeNativeProp` / `createNativeNodeIdFactory` | type/fn | The native command protocol + helpers. |
+| `createNativeBackend` / `createCanvasBackend` | fn | 🔬 research tracks (direct runtime native backend + GPU canvas) — throw `NotImplementedError`. |
+
+### Reactive bindings
+
+Pass a **function** as a child or prop value to make it reactive:
+
+```ts
+h('view', { class: () => theme() }, () => label())
+//          ^ reactive prop           ^ reactive child region
+```
+
+Static values (`h('view', { id: 'x' }, 'hello')`) are applied once.
+
+## License
+
+`MIT OR Apache-2.0`

package/dist/backend.d.ts

@@ -0,0 +1,68 @@
+//#region src/backend.d.ts
+/**
+ * Helix host-backend contract.
+ *
+ * A {@link HostBackend} is the seam between the renderer and a concrete target
+ * (DOM today; native iOS/Android and a GPU canvas are research tracks). The
+ * reconciler ({@link import('./render').render}) speaks only this interface, so
+ * a new platform is "implement `HostBackend<N>`" — nothing in the reconciler
+ * changes.
+ *
+ * `N` is the opaque host-node type (a real DOM `Node`, a headless record, a
+ * native view handle, …). The backend never interprets MindeesNative elements;
+ * it just creates, mutates, and arranges host nodes on command.
+ *
+ * @module
+ */
+/**
+ * A platform target. Implementations create/mutate/arrange host nodes of type
+ * `N`. All methods are synchronous and side-effecting on the host tree.
+ */
+interface HostBackend<N> {
+  /** Create an element host node for `type` (e.g. `"view"`, `"text"`). */
+  createElement(type: string): N;
+  /** Create a text host node holding `value`. */
+  createText(value: string): N;
+  /**
+   * Apply a single prop/attribute. `prev` is the previously-applied value (or
+   * `undefined` on first apply) so the backend can diff/cleanup if needed
+   * (e.g. removing an old event listener). Event props are `onX` (capitalized).
+   */
+  setProp(node: N, key: string, value: unknown, prev: unknown): void;
+  /** Update a text host node's value. */
+  setText(node: N, value: string): void;
+  /**
+   * Insert `node` into `parent` immediately before `anchor`, or append when
+   * `anchor` is `null`.
+   */
+  insert(parent: N, node: N, anchor: N | null): void;
+  /** Remove `node` from `parent`. */
+  remove(parent: N, node: N): void;
+  /** The parent of `node`, or `null` if it has none (detached / root). */
+  parentOf(node: N): N | null;
+  /** The next sibling of `node`, or `null`. Used to compute insertion anchors. */
+  nextSibling(node: N): N | null;
+  /** True if `node` is a text host node (vs an element). */
+  isText(node: N): boolean;
+}
+/** Options controlling {@link SerializableBackend.serialize}. */
+interface SerializeOptions {
+  /**
+   * Map a MindeesNative element tag to the tag actually emitted (e.g. the web
+   * target maps `view`→`div`, `text`→`span`). Defaults to identity.
+   */
+  mapTag?: (type: string) => string;
+}
+/**
+ * Optional capability: serialize a host subtree to an HTML string. Backends
+ * that support server-side rendering implement this; the headless backend does.
+ */
+interface SerializableBackend<N> extends HostBackend<N> {
+  /** Serialize `node` (and its subtree) to an HTML string. */
+  serialize(node: N, options?: SerializeOptions): string;
+}
+/** Type guard: does `backend` support {@link SerializableBackend.serialize}? */
+declare function isSerializable<N>(backend: HostBackend<N>): backend is SerializableBackend<N>;
+//#endregion
+export { HostBackend, SerializableBackend, isSerializable };
+//# sourceMappingURL=backend.d.ts.map

package/dist/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","names":[],"sources":["../src/backend.ts"],"mappings":";;AAoBA;;;;;;;;;;;;;;;;;;UAAiB,WAAA;EAAY;EAE3B,aAAA,CAAc,IAAA,WAAe,CAAA;EAAf;EAEd,UAAA,CAAW,KAAA,WAAgB,CAAA;EAA3B;;;;;EAMA,OAAA,CAAQ,IAAA,EAAM,CAAA,EAAG,GAAA,UAAa,KAAA,WAAgB,IAAA;EAA7B;EAEjB,OAAA,CAAQ,IAAA,EAAM,CAAA,EAAG,KAAA;EAF6B;;;;EAO9C,MAAA,CAAO,MAAA,EAAQ,CAAA,EAAG,IAAA,EAAM,CAAA,EAAG,MAAA,EAAQ,CAAA;EAAnC;EAEA,MAAA,CAAO,MAAA,EAAQ,CAAA,EAAG,IAAA,EAAM,CAAA;EAFjB;EAIP,QAAA,CAAS,IAAA,EAAM,CAAA,GAAI,CAAA;EAJD;EAMlB,WAAA,CAAY,IAAA,EAAM,CAAA,GAAI,CAAA;EANK;EAQ3B,MAAA,CAAO,IAAA,EAAM,CAAA;AAAA;;UAIE,gBAAA;EAVG;;;;EAelB,MAAA,IAAU,IAAY;AAAA;;;;;UAOP,mBAAA,YAA+B,WAAA,CAAY,CAAA;EAhBnD;EAkBP,SAAA,CAAU,IAAA,EAAM,CAAA,EAAG,OAAA,GAAU,gBAAA;AAAA;AAd/B;AAAA,iBAkBgB,cAAA,IAAkB,OAAA,EAAS,WAAA,CAAY,CAAA,IAAK,OAAA,IAAW,mBAAA,CAAoB,CAAA"}

package/dist/backend.js

@@ -0,0 +1,9 @@
+//#region src/backend.ts
+/** Type guard: does `backend` support {@link SerializableBackend.serialize}? */
+function isSerializable(backend) {
+	return typeof backend.serialize === "function";
+}
+//#endregion
+export { isSerializable };
+
+//# sourceMappingURL=backend.js.map

package/dist/backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.js","names":[],"sources":["../src/backend.ts"],"sourcesContent":["/**\n * Helix host-backend contract.\n *\n * A {@link HostBackend} is the seam between the renderer and a concrete target\n * (DOM today; native iOS/Android and a GPU canvas are research tracks). The\n * reconciler ({@link import('./render').render}) speaks only this interface, so\n * a new platform is \"implement `HostBackend<N>`\" — nothing in the reconciler\n * changes.\n *\n * `N` is the opaque host-node type (a real DOM `Node`, a headless record, a\n * native view handle, …). The backend never interprets MindeesNative elements;\n * it just creates, mutates, and arranges host nodes on command.\n *\n * @module\n */\n\n/**\n * A platform target. Implementations create/mutate/arrange host nodes of type\n * `N`. All methods are synchronous and side-effecting on the host tree.\n */\nexport interface HostBackend<N> {\n  /** Create an element host node for `type` (e.g. `\"view\"`, `\"text\"`). */\n  createElement(type: string): N\n  /** Create a text host node holding `value`. */\n  createText(value: string): N\n  /**\n   * Apply a single prop/attribute. `prev` is the previously-applied value (or\n   * `undefined` on first apply) so the backend can diff/cleanup if needed\n   * (e.g. removing an old event listener). Event props are `onX` (capitalized).\n   */\n  setProp(node: N, key: string, value: unknown, prev: unknown): void\n  /** Update a text host node's value. */\n  setText(node: N, value: string): void\n  /**\n   * Insert `node` into `parent` immediately before `anchor`, or append when\n   * `anchor` is `null`.\n   */\n  insert(parent: N, node: N, anchor: N | null): void\n  /** Remove `node` from `parent`. */\n  remove(parent: N, node: N): void\n  /** The parent of `node`, or `null` if it has none (detached / root). */\n  parentOf(node: N): N | null\n  /** The next sibling of `node`, or `null`. Used to compute insertion anchors. */\n  nextSibling(node: N): N | null\n  /** True if `node` is a text host node (vs an element). */\n  isText(node: N): boolean\n}\n\n/** Options controlling {@link SerializableBackend.serialize}. */\nexport interface SerializeOptions {\n  /**\n   * Map a MindeesNative element tag to the tag actually emitted (e.g. the web\n   * target maps `view`→`div`, `text`→`span`). Defaults to identity.\n   */\n  mapTag?: (type: string) => string\n}\n\n/**\n * Optional capability: serialize a host subtree to an HTML string. Backends\n * that support server-side rendering implement this; the headless backend does.\n */\nexport interface SerializableBackend<N> extends HostBackend<N> {\n  /** Serialize `node` (and its subtree) to an HTML string. */\n  serialize(node: N, options?: SerializeOptions): string\n}\n\n/** Type guard: does `backend` support {@link SerializableBackend.serialize}? */\nexport function isSerializable<N>(backend: HostBackend<N>): backend is SerializableBackend<N> {\n  return typeof (backend as Partial<SerializableBackend<N>>).serialize === 'function'\n}\n"],"mappings":";;AAmEA,SAAgB,eAAkB,SAA4D;CAC5F,OAAO,OAAQ,QAA4C,cAAc;AAC3E"}

package/dist/dom.d.ts

@@ -0,0 +1,39 @@
+import { HostBackend } from "./backend.js";
+
+//#region src/dom.d.ts
+/** A minimal structural view of the DOM we use (so types don't require `lib.dom`). */
+interface DomDocument {
+  createElement(tag: string): DomElement;
+  createTextNode(data: string): DomText;
+}
+interface DomNode {
+  parentNode: DomNode | null;
+  nextSibling: DomNode | null;
+  nodeType: number;
+  removeChild(child: DomNode): DomNode;
+  insertBefore(node: DomNode, ref: DomNode | null): DomNode;
+}
+interface DomElement extends DomNode {
+  setAttribute(name: string, value: string): void;
+  removeAttribute(name: string): void;
+  addEventListener(type: string, listener: (e: unknown) => void): void;
+  removeEventListener(type: string, listener: (e: unknown) => void): void;
+  style: Record<string, string> & {
+    cssText: string;
+  };
+}
+interface DomText extends DomNode {
+  data: string;
+}
+/** Map a MindeesNative tag to its DOM tag. Unknown tags pass through. */
+declare function domTagFor(type: string): string;
+/**
+ * Create a {@link HostBackend} that renders to real DOM nodes.
+ *
+ * @param doc - The document to create nodes with. Defaults to the global
+ *   `document`; pass a happy-dom/jsdom document for headless tests.
+ */
+declare function createDomBackend(doc?: DomDocument): HostBackend<DomNode>;
+//#endregion
+export { type DomDocument, type DomElement, type DomNode, type DomText, createDomBackend, domTagFor };
+//# sourceMappingURL=dom.d.ts.map

package/dist/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","names":[],"sources":["../src/dom.ts"],"mappings":";;;;UAeU,WAAA;EACR,aAAA,CAAc,GAAA,WAAc,UAAA;EAC5B,cAAA,CAAe,IAAA,WAAe,OAAO;AAAA;AAAA,UAE7B,OAAA;EACR,UAAA,EAAY,OAAA;EACZ,WAAA,EAAa,OAAA;EACb,QAAA;EACA,WAAA,CAAY,KAAA,EAAO,OAAA,GAAU,OAAA;EAC7B,YAAA,CAAa,IAAA,EAAM,OAAA,EAAS,GAAA,EAAK,OAAA,UAAiB,OAAA;AAAA;AAAA,UAE1C,UAAA,SAAmB,OAAO;EAClC,YAAA,CAAa,IAAA,UAAc,KAAA;EAC3B,eAAA,CAAgB,IAAA;EAChB,gBAAA,CAAiB,IAAA,UAAc,QAAA,GAAW,CAAA;EAC1C,mBAAA,CAAoB,IAAA,UAAc,QAAA,GAAW,CAAA;EAC7C,KAAA,EAAO,MAAA;IAA2B,OAAA;EAAA;AAAA;AAAA,UAE1B,OAAA,SAAgB,OAAO;EAC/B,IAAI;AAAA;;iBAgBU,SAAA,CAAU,IAAY;;;;;;AA1BqB;iBAmF3C,gBAAA,CAAiB,GAAA,GAAM,WAAA,GAAc,WAAA,CAAY,OAAA"}

package/dist/dom.js

@@ -0,0 +1,125 @@
+//#region src/dom.ts
+const TEXT_NODE = 3;
+/** Tag aliases: MindeesNative semantic tags → HTML elements on the web target. */
+const TAG_ALIASES = {
+	view: "div",
+	text: "span",
+	image: "img",
+	scrollview: "div",
+	textinput: "input",
+	button: "button"
+};
+/** Map a MindeesNative tag to its DOM tag. Unknown tags pass through. */
+function domTagFor(type) {
+	return TAG_ALIASES[type] ?? type;
+}
+function isEventProp(key) {
+	return key.length > 2 && key[0] === "o" && key[1] === "n" && key[2] === (key[2] ?? "").toUpperCase();
+}
+/**
+* CSS properties whose numeric value is unitless (no `px`). Mirrors React DOM's
+* `isUnitlessNumber` set — everything else gets `px` appended to a bare number, so a
+* platform-agnostic `{ width: 12 }` renders as `12px` on web (and stays `12` on native).
+*/
+const UNITLESS_STYLE_PROPS = new Set([
+	"opacity",
+	"flex",
+	"flexGrow",
+	"flexShrink",
+	"order",
+	"zIndex",
+	"fontWeight",
+	"lineHeight",
+	"aspectRatio"
+]);
+/** Stringify a style value, appending `px` to a finite number on a non-unitless property. */
+function styleValue(prop, value) {
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) return "";
+		return UNITLESS_STYLE_PROPS.has(prop) ? String(value) : `${value}px`;
+	}
+	return String(value);
+}
+/**
+* Form-control props that must be written as the live DOM **property** (not an attribute). The
+* `value`/`checked` *attribute* only seeds the DEFAULT; once the user edits, the property and
+* attribute diverge, so a controlled update must set the property to change what's shown.
+*/
+const FORM_PROPERTIES = new Set([
+	"value",
+	"checked",
+	"selected",
+	"indeterminate"
+]);
+/** `onClick` → `click`, `onPointerDown` → `pointerdown`. */
+function eventNameFor(key) {
+	return key.slice(2).toLowerCase();
+}
+/** Listeners we've attached, so reactive updates can swap them cleanly. */
+const listeners = /* @__PURE__ */ new WeakMap();
+/**
+* Create a {@link HostBackend} that renders to real DOM nodes.
+*
+* @param doc - The document to create nodes with. Defaults to the global
+*   `document`; pass a happy-dom/jsdom document for headless tests.
+*/
+function createDomBackend(doc) {
+	const documentRef = doc ?? globalThis.document;
+	if (!documentRef) throw new Error("createDomBackend: no document available (pass one explicitly outside a browser)");
+	const document = documentRef;
+	return {
+		createElement: (type) => document.createElement(domTagFor(type)),
+		createText: (value) => document.createTextNode(value),
+		setProp(node, key, value, prev) {
+			const el = node;
+			if (isEventProp(key)) {
+				const event = eventNameFor(key);
+				let map = listeners.get(el);
+				if (!map) {
+					map = /* @__PURE__ */ new Map();
+					listeners.set(el, map);
+				}
+				const old = map.get(event);
+				if (old) el.removeEventListener(event, old);
+				if (typeof value === "function") {
+					const fn = value;
+					el.addEventListener(event, fn);
+					map.set(event, fn);
+				} else map.delete(event);
+				return;
+			}
+			if (key === "style") {
+				const style = el.style;
+				const next = value && typeof value === "object" ? value : null;
+				const prevObj = prev && typeof prev === "object" ? prev : null;
+				if (prevObj) {
+					for (const prop of Object.keys(prevObj)) if (!next || !(prop in next)) style[prop] = "";
+				}
+				if (next) for (const [prop, v] of Object.entries(next)) style[prop] = v === null || v === void 0 ? "" : styleValue(prop, v);
+				return;
+			}
+			if (FORM_PROPERTIES.has(key)) {
+				el[key] = value === null || value === void 0 ? "" : value;
+				return;
+			}
+			if (value === false || value === null || value === void 0) el.removeAttribute(key);
+			else el.setAttribute(key, value === true ? "" : String(value));
+		},
+		setText(node, value) {
+			node.data = value;
+		},
+		insert(parent, node, anchor) {
+			parent.insertBefore(node, anchor);
+		},
+		remove(parent, node) {
+			parent.removeChild(node);
+		},
+		parentOf: (node) => node.parentNode,
+		nextSibling: (node) => node.nextSibling,
+		isText: (node) => node.nodeType === TEXT_NODE
+	};
+}
+//#endregion
+export { createDomBackend, domTagFor };
+
+//# sourceMappingURL=dom.js.map

package/dist/dom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.js","names":[],"sources":["../src/dom.ts"],"sourcesContent":["/**\n * DOM host backend — renders to real `Node`s in a browser (or any DOM, such as\n * happy-dom/jsdom in tests).\n *\n * MindeesNative element tags map to DOM via a small alias table so the same app\n * tree (`view`, `text`, …) renders to sensible HTML; unknown tags pass through\n * as custom elements. Props become attributes, except `onX` event props (added\n * as listeners) and `style` objects (applied to `style`).\n *\n * @module\n */\n\nimport type { HostBackend } from './backend'\n\n/** A minimal structural view of the DOM we use (so types don't require `lib.dom`). */\ninterface DomDocument {\n  createElement(tag: string): DomElement\n  createTextNode(data: string): DomText\n}\ninterface DomNode {\n  parentNode: DomNode | null\n  nextSibling: DomNode | null\n  nodeType: number\n  removeChild(child: DomNode): DomNode\n  insertBefore(node: DomNode, ref: DomNode | null): DomNode\n}\ninterface DomElement extends DomNode {\n  setAttribute(name: string, value: string): void\n  removeAttribute(name: string): void\n  addEventListener(type: string, listener: (e: unknown) => void): void\n  removeEventListener(type: string, listener: (e: unknown) => void): void\n  style: Record<string, string> & { cssText: string }\n}\ninterface DomText extends DomNode {\n  data: string\n}\n\nconst TEXT_NODE = 3\n\n/** Tag aliases: MindeesNative semantic tags → HTML elements on the web target. */\nconst TAG_ALIASES: Record<string, string> = {\n  view: 'div',\n  text: 'span',\n  image: 'img',\n  scrollview: 'div',\n  textinput: 'input',\n  button: 'button',\n}\n\n/** Map a MindeesNative tag to its DOM tag. Unknown tags pass through. */\nexport function domTagFor(type: string): string {\n  return TAG_ALIASES[type] ?? type\n}\n\nfunction isEventProp(key: string): boolean {\n  return (\n    key.length > 2 && key[0] === 'o' && key[1] === 'n' && key[2] === (key[2] ?? '').toUpperCase()\n  )\n}\n\n/**\n * CSS properties whose numeric value is unitless (no `px`). Mirrors React DOM's\n * `isUnitlessNumber` set — everything else gets `px` appended to a bare number, so a\n * platform-agnostic `{ width: 12 }` renders as `12px` on web (and stays `12` on native).\n */\nconst UNITLESS_STYLE_PROPS = new Set([\n  'opacity',\n  'flex',\n  'flexGrow',\n  'flexShrink',\n  'order',\n  'zIndex',\n  'fontWeight',\n  'lineHeight',\n  'aspectRatio',\n])\n\n/** Stringify a style value, appending `px` to a finite number on a non-unitless property. */\nfunction styleValue(prop: string, value: unknown): string {\n  if (typeof value === 'number') {\n    if (!Number.isFinite(value)) return '' // NaN/Infinity → unset, never the literal \"NaN\"\n    return UNITLESS_STYLE_PROPS.has(prop) ? String(value) : `${value}px`\n  }\n  return String(value)\n}\n\n/**\n * Form-control props that must be written as the live DOM **property** (not an attribute). The\n * `value`/`checked` *attribute* only seeds the DEFAULT; once the user edits, the property and\n * attribute diverge, so a controlled update must set the property to change what's shown.\n */\nconst FORM_PROPERTIES = new Set(['value', 'checked', 'selected', 'indeterminate'])\n\n/** `onClick` → `click`, `onPointerDown` → `pointerdown`. */\nfunction eventNameFor(key: string): string {\n  return key.slice(2).toLowerCase()\n}\n\n/** Listeners we've attached, so reactive updates can swap them cleanly. */\nconst listeners = new WeakMap<object, Map<string, (e: unknown) => void>>()\n\n/**\n * Create a {@link HostBackend} that renders to real DOM nodes.\n *\n * @param doc - The document to create nodes with. Defaults to the global\n *   `document`; pass a happy-dom/jsdom document for headless tests.\n */\nexport function createDomBackend(doc?: DomDocument): HostBackend<DomNode> {\n  const documentRef = doc ?? (globalThis as unknown as { document?: DomDocument }).document\n  if (!documentRef) {\n    throw new Error(\n      'createDomBackend: no document available (pass one explicitly outside a browser)',\n    )\n  }\n  const document = documentRef\n\n  return {\n    createElement: (type) => document.createElement(domTagFor(type)),\n    createText: (value) => document.createTextNode(value),\n\n    setProp(node, key, value, prev): void {\n      const el = node as DomElement\n      if (isEventProp(key)) {\n        const event = eventNameFor(key)\n        let map = listeners.get(el)\n        if (!map) {\n          map = new Map()\n          listeners.set(el, map)\n        }\n        const old = map.get(event)\n        if (old) el.removeEventListener(event, old)\n        if (typeof value === 'function') {\n          const fn = value as (e: unknown) => void\n          el.addEventListener(event, fn)\n          map.set(event, fn)\n        } else {\n          map.delete(event)\n        }\n        return\n      }\n      if (key === 'style') {\n        const style = el.style\n        const next = value && typeof value === 'object' ? (value as Record<string, unknown>) : null\n        const prevObj = prev && typeof prev === 'object' ? (prev as Record<string, unknown>) : null\n        // Clear keys present in the previous style object but absent from the\n        // new one, so stale inline styles don't persist across reactive updates.\n        if (prevObj) {\n          for (const prop of Object.keys(prevObj)) {\n            if (!next || !(prop in next)) style[prop] = ''\n          }\n        }\n        if (next) {\n          for (const [prop, v] of Object.entries(next)) {\n            // Nullish → unset (don't write the literal \"undefined\"/\"null\").\n            style[prop] = v === null || v === undefined ? '' : styleValue(prop, v)\n          }\n        }\n        return\n      }\n      if (FORM_PROPERTIES.has(key)) {\n        // Live property, so a controlled `value`/`checked` updates what the user sees.\n        ;(el as unknown as Record<string, unknown>)[key] =\n          value === null || value === undefined ? '' : value\n        return\n      }\n      if (value === false || value === null || value === undefined) {\n        el.removeAttribute(key)\n      } else {\n        el.setAttribute(key, value === true ? '' : String(value))\n      }\n      void prev\n    },\n\n    setText(node, value): void {\n      ;(node as DomText).data = value\n    },\n\n    insert(parent, node, anchor): void {\n      ;(parent as DomNode).insertBefore(node, anchor)\n    },\n\n    remove(parent, node): void {\n      ;(parent as DomNode).removeChild(node)\n    },\n\n    parentOf: (node) => node.parentNode,\n    nextSibling: (node) => node.nextSibling,\n    isText: (node) => node.nodeType === TEXT_NODE,\n  }\n}\n\nexport type { DomDocument, DomElement, DomNode, DomText }\n"],"mappings":"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"}

package/dist/headless.d.ts

@@ -0,0 +1,25 @@
+import { SerializableBackend } from "./backend.js";
+
+//#region src/headless.d.ts
+/** A headless host node: an element (with tag/props/children) or a text node. */
+interface HeadlessNode {
+  /** `"#text"` for text nodes, otherwise the element tag. */
+  type: string;
+  /** Applied props (elements only). */
+  props: Record<string, unknown>;
+  /** Text content (text nodes only). */
+  text: string;
+  /** Child nodes (elements only). */
+  children: HeadlessNode[];
+  /** Back-pointer to the parent, or `null` when detached. */
+  parent: HeadlessNode | null;
+}
+/** Create a {@link SerializableBackend} backed by an in-memory tree. */
+declare function createHeadlessBackend(): SerializableBackend<HeadlessNode>;
+/** Whether a prop key is an event handler (`onClick`, `onPress`, …). */
+declare function isEventProp(key: string): boolean;
+/** Convenience: create a detached headless root element (default tag `"root"`). */
+declare function createHeadlessRoot(type?: string): HeadlessNode;
+//#endregion
+export { HeadlessNode, createHeadlessBackend, createHeadlessRoot, isEventProp };
+//# sourceMappingURL=headless.d.ts.map

package/dist/headless.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless.d.ts","names":[],"sources":["../src/headless.ts"],"mappings":";;;;UAaiB,YAAA;EAIf;EAFA,IAAA;EAIA;EAFA,KAAA,EAAO,MAAA;EAIG;EAFV,IAAA;EAIQ;EAFR,QAAA,EAAU,YAAA;EAEU;EAApB,MAAA,EAAQ,YAAA;AAAA;;iBAiEM,qBAAA,IAAyB,mBAAmB,CAAC,YAAA;AAAY;AAAA,iBAkEzD,WAAA,CAAY,GAAW;;iBAOvB,kBAAA,CAAmB,IAAA,YAAgB,YAAY"}

package/dist/headless.js

@@ -0,0 +1,116 @@
+//#region src/headless.ts
+const TEXT = "#text";
+function escapeAttr(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function escapeText(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** Render an attribute value: a `style` object becomes a CSS string. */
+function serializeAttrValue(value) {
+	if (value && typeof value === "object") return Object.entries(value).map(([prop, v]) => `${prop}:${String(v)}`).join(";");
+	return String(value);
+}
+/**
+* Whether `key` is a safe HTML attribute name. Attribute NAMES are interpolated
+* into markup unescaped, so a name containing `>`, whitespace, quotes, `=`, `/`,
+* etc. could break out of the tag and inject markup (stored XSS when props are
+* built from user/server data). We emit only names that match the HTML name
+* grammar — matching what the DOM's `setAttribute` would accept — and drop the
+* rest, exactly as an invalid name would never reach the DOM either.
+*/
+function isValidAttrName(key) {
+	return /^[A-Za-z_:][\w:.-]*$/.test(key);
+}
+/**
+* Serialize a headless node (and subtree) to HTML. A standalone function, not an
+* object method: the public {@link SerializableBackend.serialize} is typed as a
+* plain function member, so a consumer may legally detach it
+* (`const { serialize } = backend`). Recursing through this lexical helper rather
+* than `this.serialize` keeps it binding-independent.
+*/
+function serializeHeadless(node, options) {
+	if (node.type === TEXT) return escapeText(node.text);
+	const tag = (options?.mapTag ?? ((t) => t))(node.type);
+	if (!isValidAttrName(tag)) throw new Error(`refusing to serialize unsafe element tag: ${JSON.stringify(tag)}`);
+	return `<${tag}${Object.entries(node.props).filter(([key]) => !isEventProp(key) && isValidAttrName(key)).map(([key, value]) => value === true ? ` ${key}=""` : ` ${key}="${escapeAttr(serializeAttrValue(value))}"`).join("")}>${node.children.map((c) => serializeHeadless(c, options)).join("")}</${tag}>`;
+}
+/** Create a {@link SerializableBackend} backed by an in-memory tree. */
+function createHeadlessBackend() {
+	return {
+		createElement(type) {
+			return {
+				type,
+				props: {},
+				text: "",
+				children: [],
+				parent: null
+			};
+		},
+		createText(value) {
+			return {
+				type: TEXT,
+				props: {},
+				text: value,
+				children: [],
+				parent: null
+			};
+		},
+		setProp(node, key, value) {
+			if (value === void 0 || value === null || value === false) delete node.props[key];
+			else node.props[key] = value;
+		},
+		setText(node, value) {
+			node.text = value;
+		},
+		insert(parent, node, anchor) {
+			if (node.parent) {
+				const prevSiblings = node.parent.children;
+				const at = prevSiblings.indexOf(node);
+				if (at >= 0) prevSiblings.splice(at, 1);
+			}
+			node.parent = parent;
+			if (anchor === null) parent.children.push(node);
+			else {
+				const idx = parent.children.indexOf(anchor);
+				parent.children.splice(idx < 0 ? parent.children.length : idx, 0, node);
+			}
+		},
+		remove(parent, node) {
+			const idx = parent.children.indexOf(node);
+			if (idx >= 0) parent.children.splice(idx, 1);
+			node.parent = null;
+		},
+		parentOf(node) {
+			return node.parent;
+		},
+		nextSibling(node) {
+			const parent = node.parent;
+			if (!parent) return null;
+			const idx = parent.children.indexOf(node);
+			return idx >= 0 && idx + 1 < parent.children.length ? parent.children[idx + 1] ?? null : null;
+		},
+		isText(node) {
+			return node.type === TEXT;
+		},
+		serialize: serializeHeadless
+	};
+}
+/** Whether a prop key is an event handler (`onClick`, `onPress`, …). */
+function isEventProp(key) {
+	return key.length > 2 && key[0] === "o" && key[1] === "n" && key[2] === (key[2] ?? "").toUpperCase();
+}
+/** Convenience: create a detached headless root element (default tag `"root"`). */
+function createHeadlessRoot(type = "root") {
+	return {
+		type,
+		props: {},
+		text: "",
+		children: [],
+		parent: null
+	};
+}
+//#endregion
+export { createHeadlessBackend, createHeadlessRoot, isEventProp };
+
+//# sourceMappingURL=headless.js.map

package/dist/headless.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless.js","names":[],"sources":["../src/headless.ts"],"sourcesContent":["/**\n * Headless host backend — an in-memory host tree, no browser required.\n *\n * This is the **reference backend**: it implements the full {@link HostBackend}\n * (plus {@link SerializableBackend}) so the entire reconciler can be exercised\n * in CI without a DOM. It's also handy for snapshot-testing rendered output.\n *\n * @module\n */\n\nimport type { SerializableBackend, SerializeOptions } from './backend'\n\n/** A headless host node: an element (with tag/props/children) or a text node. */\nexport interface HeadlessNode {\n  /** `\"#text\"` for text nodes, otherwise the element tag. */\n  type: string\n  /** Applied props (elements only). */\n  props: Record<string, unknown>\n  /** Text content (text nodes only). */\n  text: string\n  /** Child nodes (elements only). */\n  children: HeadlessNode[]\n  /** Back-pointer to the parent, or `null` when detached. */\n  parent: HeadlessNode | null\n}\n\nconst TEXT = '#text'\n\nfunction escapeAttr(value: string): string {\n  return value.replace(/&/g, '&amp;').replace(/\"/g, '&quot;').replace(/</g, '&lt;')\n}\n\nfunction escapeText(value: string): string {\n  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')\n}\n\n/** Render an attribute value: a `style` object becomes a CSS string. */\nfunction serializeAttrValue(value: unknown): string {\n  if (value && typeof value === 'object') {\n    return Object.entries(value as Record<string, unknown>)\n      .map(([prop, v]) => `${prop}:${String(v)}`)\n      .join(';')\n  }\n  return String(value)\n}\n\n/**\n * Whether `key` is a safe HTML attribute name. Attribute NAMES are interpolated\n * into markup unescaped, so a name containing `>`, whitespace, quotes, `=`, `/`,\n * etc. could break out of the tag and inject markup (stored XSS when props are\n * built from user/server data). We emit only names that match the HTML name\n * grammar — matching what the DOM's `setAttribute` would accept — and drop the\n * rest, exactly as an invalid name would never reach the DOM either.\n */\nfunction isValidAttrName(key: string): boolean {\n  return /^[A-Za-z_:][\\w:.-]*$/.test(key)\n}\n\n/**\n * Serialize a headless node (and subtree) to HTML. A standalone function, not an\n * object method: the public {@link SerializableBackend.serialize} is typed as a\n * plain function member, so a consumer may legally detach it\n * (`const { serialize } = backend`). Recursing through this lexical helper rather\n * than `this.serialize` keeps it binding-independent.\n */\nfunction serializeHeadless(node: HeadlessNode, options?: SerializeOptions): string {\n  if (node.type === TEXT) return escapeText(node.text)\n  const mapTag = options?.mapTag ?? ((t: string) => t)\n  const tag = mapTag(node.type)\n  // The tag is interpolated into `<tag>`/`</tag>` unescaped, so a tag containing `>`,\n  // whitespace, etc. would break out of the element and inject markup. Reject any tag\n  // that isn't a valid name (same grammar as attribute names) — fail closed.\n  if (!isValidAttrName(tag)) {\n    throw new Error(`refusing to serialize unsafe element tag: ${JSON.stringify(tag)}`)\n  }\n  const attrs = Object.entries(node.props)\n    .filter(([key]) => !isEventProp(key) && isValidAttrName(key))\n    .map(([key, value]) =>\n      // Boolean `true` → a valueless attribute (`disabled=\"\"`), matching the DOM\n      // backend (dom.ts) so SSR markup equals hydrated markup.\n      value === true ? ` ${key}=\"\"` : ` ${key}=\"${escapeAttr(serializeAttrValue(value))}\"`,\n    )\n    .join('')\n  const inner = node.children.map((c) => serializeHeadless(c, options)).join('')\n  return `<${tag}${attrs}>${inner}</${tag}>`\n}\n\n/** Create a {@link SerializableBackend} backed by an in-memory tree. */\nexport function createHeadlessBackend(): SerializableBackend<HeadlessNode> {\n  return {\n    createElement(type: string): HeadlessNode {\n      return { type, props: {}, text: '', children: [], parent: null }\n    },\n\n    createText(value: string): HeadlessNode {\n      return { type: TEXT, props: {}, text: value, children: [], parent: null }\n    },\n\n    setProp(node, key, value): void {\n      // Event handlers and falsy values are tracked but not serialized as attrs.\n      if (value === undefined || value === null || value === false) {\n        delete node.props[key]\n      } else {\n        node.props[key] = value\n      }\n    },\n\n    setText(node, value): void {\n      node.text = value\n    },\n\n    insert(parent, node, anchor): void {\n      if (node.parent) {\n        const prevSiblings = node.parent.children\n        const at = prevSiblings.indexOf(node)\n        if (at >= 0) prevSiblings.splice(at, 1)\n      }\n      node.parent = parent\n      if (anchor === null) {\n        parent.children.push(node)\n      } else {\n        const idx = parent.children.indexOf(anchor)\n        parent.children.splice(idx < 0 ? parent.children.length : idx, 0, node)\n      }\n    },\n\n    remove(parent, node): void {\n      const idx = parent.children.indexOf(node)\n      if (idx >= 0) parent.children.splice(idx, 1)\n      node.parent = null\n    },\n\n    parentOf(node): HeadlessNode | null {\n      return node.parent\n    },\n\n    nextSibling(node): HeadlessNode | null {\n      const parent = node.parent\n      if (!parent) return null\n      const idx = parent.children.indexOf(node)\n      return idx >= 0 && idx + 1 < parent.children.length\n        ? (parent.children[idx + 1] ?? null)\n        : null\n    },\n\n    isText(node): boolean {\n      return node.type === TEXT\n    },\n\n    serialize: serializeHeadless,\n  }\n}\n\n/** Whether a prop key is an event handler (`onClick`, `onPress`, …). */\nexport function isEventProp(key: string): boolean {\n  return (\n    key.length > 2 && key[0] === 'o' && key[1] === 'n' && key[2] === (key[2] ?? '').toUpperCase()\n  )\n}\n\n/** Convenience: create a detached headless root element (default tag `\"root\"`). */\nexport function createHeadlessRoot(type = 'root'): HeadlessNode {\n  return { type, props: {}, text: '', children: [], parent: null }\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { HostBackend, SerializableBackend, isSerializable } from "./backend.js";
+import { DomDocument, DomElement, DomNode, DomText, createDomBackend, domTagFor } from "./dom.js";
+import { HeadlessNode, createHeadlessBackend, createHeadlessRoot, isEventProp } from "./headless.js";
+import { CreateNodeCommand, CreateTextCommand, DisposeNodeCommand, InsertChildCommand, NativeCommand, NativeNodeId, NativePropValue, RegisterEventCommand, RemoveChildCommand, RemovePropCommand, SetPropCommand, UnregisterEventCommand, UpdateTextCommand, createNativeNodeIdFactory, isNativeCommand, isNativePropValue, normalizeNativeProp } from "./native-protocol.js";
+import { NativeCommandBackend, NativeCommandBackendOptions, NativeCommandNode, createNativeCommandBackend } from "./native-command-backend.js";
+import { CanvasBackend, NativeBackend, createCanvasBackend, createNativeBackend } from "./native.js";
+import { NativeHostError, ReferenceHost, ReferenceHostNode, createReferenceHost } from "./native-host.js";
+import { Mounted, render } from "./render.js";
+import { hydrate, renderToString } from "./ssr.js";
+import { Maturity, NotImplementedError, PackageInfo, notImplemented } from "@mindees/core";
+
+//#region src/index.d.ts
+/** The npm package name. */
+declare const name = "@mindees/renderer";
+/** The package version. All `@mindees/*` packages share one locked version line. */
+declare const VERSION = "0.1.0";
+/**
+ * Current maturity. The Helix **web/DOM** renderer (reconciler, DOM backend,
+ * headless backend, SSR + hydration) is implemented and tested. Native
+ * (iOS/Android) and the GPU canvas are research tracks (throw
+ * `NotImplementedError`). See the repository `STATUS.md`.
+ */
+declare const maturity: Maturity;
+/**
+ * Static identity + maturity metadata for this package. Frozen so the
+ * self-reported identity tooling introspects cannot be mutated at runtime,
+ * matching the `readonly` fields of {@link PackageInfo}.
+ */
+declare const info: PackageInfo;
+//#endregion
+export { type CanvasBackend, type CreateNodeCommand, type CreateTextCommand, type DisposeNodeCommand, type DomDocument, type DomElement, type DomNode, type DomText, type HeadlessNode, type HostBackend, type InsertChildCommand, type Maturity, type Mounted, type NativeBackend, type NativeCommand, type NativeCommandBackend, type NativeCommandBackendOptions, type NativeCommandNode, NativeHostError, type NativeNodeId, type NativePropValue, NotImplementedError, type PackageInfo, type ReferenceHost, type ReferenceHostNode, type RegisterEventCommand, type RemoveChildCommand, type RemovePropCommand, type SerializableBackend, type SetPropCommand, type UnregisterEventCommand, type UpdateTextCommand, VERSION, createCanvasBackend, createDomBackend, createHeadlessBackend, createHeadlessRoot, createNativeBackend, createNativeCommandBackend, createNativeNodeIdFactory, createReferenceHost, domTagFor, hydrate, info, isEventProp, isNativeCommand, isNativePropValue, isSerializable, maturity, name, normalizeNativeProp, notImplemented, render, renderToString };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;cA4Ea,IAAA;AAkBb;AAAA,cAfa,OAAA;;;AAeuE;;;;cAPvE,QAAA,EAAU,QAAyB;;;;;;cAOnC,IAAA,EAAM,WAAiE"}