@mindees/renderer 0.1.0

package/dist/native-protocol.d.ts

@@ -0,0 +1,141 @@
+//#region src/native-protocol.d.ts
+/**
+ * The **native command protocol** — a small, strongly-typed, *serializable*
+ * description of how to build and mutate a native view tree.
+ *
+ * The Helix reconciler ({@link import('./render').render}) drives a
+ * {@link import('./backend').HostBackend}; the
+ * {@link import('./native-command-backend').NativeCommandBackend} implements that
+ * contract by emitting a stream of {@link NativeCommand}s instead of touching the
+ * DOM. A native host (UIKit on iOS, Android View on Android, or another future
+ * surface) consumes the stream and materializes real views.
+ *
+ * The protocol is deliberately platform-neutral and JSON-serializable: it carries
+ * **no functions**. Event handlers are represented as stable handler-id
+ * *registrations* ({@link RegisterEventCommand}); the host invokes a handler by
+ * id (see {@link import('./native-command-backend').NativeCommandBackend.dispatchEvent}),
+ * so a closure never has to cross a serialization boundary.
+ *
+ * This is the Phase 8A foundation for native rendering. It is **not** itself an
+ * iOS/Android renderer — it is the wire format a real host backend will speak.
+ *
+ * @module
+ */
+/** Identifier for a native node. Stable for the node's lifetime. */
+type NativeNodeId = string | number;
+/**
+ * A value that may be sent as a native prop. Strictly serializable: primitives,
+ * `null`, and (recursively) arrays/plain-objects of the same. Notably **not**
+ * functions, `undefined`, symbols, bigints, or non-finite numbers — those cannot
+ * cross the protocol boundary safely. Event handlers are modeled separately
+ * (see {@link RegisterEventCommand}).
+ */
+type NativePropValue = string | number | boolean | null | readonly NativePropValue[] | {
+  readonly [key: string]: NativePropValue;
+};
+/** Create an element node with a tag (e.g. `"view"`, `"text"`, `"button"`). */
+interface CreateNodeCommand {
+  readonly type: 'createNode';
+  readonly id: NativeNodeId;
+  readonly tag: string;
+}
+/** Create a text node holding `text`. */
+interface CreateTextCommand {
+  readonly type: 'createText';
+  readonly id: NativeNodeId;
+  readonly text: string;
+}
+/** Set (or replace) a serializable prop on a node. */
+interface SetPropCommand {
+  readonly type: 'setProp';
+  readonly id: NativeNodeId;
+  readonly name: string;
+  readonly value: NativePropValue;
+}
+/** Remove a previously-set prop from a node. */
+interface RemovePropCommand {
+  readonly type: 'removeProp';
+  readonly id: NativeNodeId;
+  readonly name: string;
+}
+/** Insert `childId` into `parentId` at `index` (0-based, among current children). */
+interface InsertChildCommand {
+  readonly type: 'insertChild';
+  readonly parentId: NativeNodeId;
+  readonly childId: NativeNodeId;
+  readonly index: number;
+}
+/** Detach `childId` from `parentId` (does not free the node — see {@link DisposeNodeCommand}). */
+interface RemoveChildCommand {
+  readonly type: 'removeChild';
+  readonly parentId: NativeNodeId;
+  readonly childId: NativeNodeId;
+}
+/** Update a text node's content. */
+interface UpdateTextCommand {
+  readonly type: 'updateText';
+  readonly id: NativeNodeId;
+  readonly text: string;
+}
+/**
+ * Free a node's host resources. When a subtree is removed, exactly one
+ * {@link RemoveChildCommand} detaches the subtree's **root**, then a `disposeNode`
+ * is emitted for the root **and every descendant** (deepest-first). Interior nodes
+ * are not individually detached — they are freed in the same batch as their parent
+ * — so a host should treat `disposeNode` as "free this node (and remove it from any
+ * parent it still holds)". No surviving node ever references a freed one.
+ */
+interface DisposeNodeCommand {
+  readonly type: 'disposeNode';
+  readonly id: NativeNodeId;
+}
+/**
+ * Register an event handler on a node under a stable `handlerId`. The host should
+ * call back into the runtime (`dispatchEvent(handlerId, event)`) when the native
+ * event fires. The handler function itself never crosses the protocol.
+ */
+interface RegisterEventCommand {
+  readonly type: 'registerEvent';
+  readonly id: NativeNodeId;
+  /** Normalized event name, e.g. `"press"` for an `onPress` prop. */
+  readonly eventName: string;
+  /** Stable id the host echoes back to invoke the handler. */
+  readonly handlerId: string;
+}
+/** Remove a previously-registered event handler. */
+interface UnregisterEventCommand {
+  readonly type: 'unregisterEvent';
+  readonly id: NativeNodeId;
+  readonly eventName: string;
+  readonly handlerId: string;
+}
+/** A single instruction in the native command stream. */
+type NativeCommand = CreateNodeCommand | CreateTextCommand | SetPropCommand | RemovePropCommand | InsertChildCommand | RemoveChildCommand | UpdateTextCommand | DisposeNodeCommand | RegisterEventCommand | UnregisterEventCommand;
+/**
+ * Type guard: is `value` a valid {@link NativePropValue}? Rejects functions,
+ * `undefined`, symbols, bigints, non-finite numbers, and non-plain objects
+ * (recursively).
+ */
+declare function isNativePropValue(value: unknown): value is NativePropValue;
+/**
+ * Coerce `value` to a {@link NativePropValue}, or `undefined` if it cannot be
+ * represented (signalling the prop should be removed rather than set).
+ *
+ * - Primitives/`null` pass through (non-finite numbers are rejected).
+ * - Arrays are rejected wholesale if **any** element is unrepresentable (so
+ *   element indices are never silently shifted).
+ * - Plain objects keep only their representable entries (an unrepresentable value
+ *   drops that key); non-plain objects (Date, Map, class instances, …) are rejected.
+ */
+declare function normalizeNativeProp(value: unknown): NativePropValue | undefined;
+/** Type guard: is `value` a well-formed {@link NativeCommand}? */
+declare function isNativeCommand(value: unknown): value is NativeCommand;
+/**
+ * Create a generator of unique node ids. Each call returns the next id as
+ * `` `${prefix}${n}` `` with a monotonically increasing `n`. Pass a distinct
+ * `prefix` per backend instance so ids from different backends never collide.
+ */
+declare function createNativeNodeIdFactory(prefix?: string): () => string;
+//#endregion
+export { CreateNodeCommand, CreateTextCommand, DisposeNodeCommand, InsertChildCommand, NativeCommand, NativeNodeId, NativePropValue, RegisterEventCommand, RemoveChildCommand, RemovePropCommand, SetPropCommand, UnregisterEventCommand, UpdateTextCommand, createNativeNodeIdFactory, isNativeCommand, isNativePropValue, normalizeNativeProp };
+//# sourceMappingURL=native-protocol.d.ts.map

package/dist/native-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-protocol.d.ts","names":[],"sources":["../src/native-protocol.ts"],"mappings":";;AAwBA;;;;AAAwB;AASxB;;;;;;;;AAM6C;AAG7C;;;;;;;;KAlBY,YAAA;AAqBE;AAId;;;;;;AAJc,KAZF,eAAA,+CAKC,eAAA;EAAA,UACG,GAAA,WAAc,eAAe;AAAA;AAa9B;AAAA,UAVE,iBAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA,EAAI,YAAY;EAAA,SAChB,GAAA;AAAA;;UAIM,iBAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA,EAAI,YAAY;EAAA,SAChB,IAAA;AAAA;AAQsB;AAAA,UAJhB,cAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA,EAAI,YAAA;EAAA,SACJ,IAAA;EAAA,SACA,KAAA,EAAO,eAAe;AAAA;;UAIhB,iBAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA,EAAI,YAAY;EAAA,SAChB,IAAA;AAAA;;UAIM,kBAAA;EAAA,SACN,IAAA;EAAA,SACA,QAAA,EAAU,YAAA;EAAA,SACV,OAAA,EAAS,YAAY;EAAA,SACrB,KAAA;AAAA;;UAIM,kBAAA;EAAA,SACN,IAAA;EAAA,SACA,QAAA,EAAU,YAAA;EAAA,SACV,OAAA,EAAS,YAAY;AAAA;;UAIf,iBAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA,EAAI,YAAY;EAAA,SAChB,IAAA;AAAA;;AAPqB;AAIhC;;;;;;UAciB,kBAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA,EAAI,YAAY;AAAA;AAF3B;;;;;AAAA,UAUiB,oBAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA,EAAI,YAAY;EAVA;EAAA,SAYhB,SAAA;EAJ0B;EAAA,SAM1B,SAAA;AAAA;;UAIM,sBAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA,EAAI,YAAY;EAAA,SAChB,SAAA;EAAA,SACA,SAAA;AAAA;AAJX;AAAA,KAQY,aAAA,GACR,iBAAA,GACA,iBAAA,GACA,cAAA,GACA,iBAAA,GACA,kBAAA,GACA,kBAAA,GACA,iBAAA,GACA,kBAAA,GACA,oBAAA,GACA,sBAAA;;;;;;iBAmCY,iBAAA,CAAkB,KAAA,YAAiB,KAAA,IAAS,eAAe;;;AAjDvD;AAIpB;;;;;;;iBA2FgB,mBAAA,CAAoB,KAAA,YAAiB,eAAe;;iBA8CpD,eAAA,CAAgB,KAAA,YAAiB,KAAA,IAAS,aAAa;;;;;;iBAyCvD,yBAAA,CAA0B,MAAY"}

package/dist/native-protocol.js

@@ -0,0 +1,135 @@
+//#region src/native-protocol.ts
+const COMMAND_TYPES = new Set([
+	"createNode",
+	"createText",
+	"setProp",
+	"removeProp",
+	"insertChild",
+	"removeChild",
+	"updateText",
+	"disposeNode",
+	"registerEvent",
+	"unregisterEvent"
+]);
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function isPlainObject(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function isId(value) {
+	return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+/**
+* Type guard: is `value` a valid {@link NativePropValue}? Rejects functions,
+* `undefined`, symbols, bigints, non-finite numbers, and non-plain objects
+* (recursively).
+*/
+function isNativePropValue(value) {
+	return isPropValue(value, /* @__PURE__ */ new WeakSet());
+}
+function isPropValue(value, seen) {
+	switch (typeof value) {
+		case "string":
+		case "boolean": return true;
+		case "number": return Number.isFinite(value);
+		case "object":
+			if (value === null) return true;
+			if (seen.has(value)) return false;
+			seen.add(value);
+			try {
+				if (Array.isArray(value)) {
+					for (const item of value) if (!isPropValue(item, seen)) return false;
+					return true;
+				}
+				if (isPlainObject(value)) {
+					for (const v of Object.values(value)) if (!isPropValue(v, seen)) return false;
+					return true;
+				}
+				return false;
+			} finally {
+				seen.delete(value);
+			}
+		default: return false;
+	}
+}
+/**
+* Coerce `value` to a {@link NativePropValue}, or `undefined` if it cannot be
+* represented (signalling the prop should be removed rather than set).
+*
+* - Primitives/`null` pass through (non-finite numbers are rejected).
+* - Arrays are rejected wholesale if **any** element is unrepresentable (so
+*   element indices are never silently shifted).
+* - Plain objects keep only their representable entries (an unrepresentable value
+*   drops that key); non-plain objects (Date, Map, class instances, …) are rejected.
+*/
+function normalizeNativeProp(value) {
+	return normalizeProp(value, /* @__PURE__ */ new WeakSet());
+}
+function normalizeProp(value, seen) {
+	switch (typeof value) {
+		case "string":
+		case "boolean": return value;
+		case "number": return Number.isFinite(value) ? value : void 0;
+		case "object":
+			if (value === null) return null;
+			if (seen.has(value)) return void 0;
+			seen.add(value);
+			try {
+				if (Array.isArray(value)) {
+					const out = [];
+					for (const item of value) {
+						const n = normalizeProp(item, seen);
+						if (n === void 0) return void 0;
+						out.push(n);
+					}
+					return out;
+				}
+				if (isPlainObject(value)) {
+					const out = Object.create(null);
+					for (const [k, v] of Object.entries(value)) {
+						const n = normalizeProp(v, seen);
+						if (n !== void 0) out[k] = n;
+					}
+					return out;
+				}
+				return;
+			} finally {
+				seen.delete(value);
+			}
+		default: return;
+	}
+}
+/** Type guard: is `value` a well-formed {@link NativeCommand}? */
+function isNativeCommand(value) {
+	if (!isObject(value)) return false;
+	const type = value.type;
+	if (typeof type !== "string" || !COMMAND_TYPES.has(type)) return false;
+	switch (type) {
+		case "createNode": return isId(value.id) && typeof value.tag === "string";
+		case "createText":
+		case "updateText": return isId(value.id) && typeof value.text === "string";
+		case "setProp": return isId(value.id) && typeof value.name === "string" && isNativePropValue(value.value);
+		case "removeProp": return isId(value.id) && typeof value.name === "string";
+		case "insertChild": return isId(value.parentId) && isId(value.childId) && typeof value.index === "number" && Number.isInteger(value.index) && value.index >= 0;
+		case "removeChild": return isId(value.parentId) && isId(value.childId);
+		case "disposeNode": return isId(value.id);
+		case "registerEvent":
+		case "unregisterEvent": return isId(value.id) && typeof value.eventName === "string" && typeof value.handlerId === "string";
+		default: return false;
+	}
+}
+/**
+* Create a generator of unique node ids. Each call returns the next id as
+* `` `${prefix}${n}` `` with a monotonically increasing `n`. Pass a distinct
+* `prefix` per backend instance so ids from different backends never collide.
+*/
+function createNativeNodeIdFactory(prefix = "n") {
+	let n = 0;
+	return () => `${prefix}${++n}`;
+}
+//#endregion
+export { createNativeNodeIdFactory, isNativeCommand, isNativePropValue, normalizeNativeProp };
+
+//# sourceMappingURL=native-protocol.js.map

package/dist/native-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-protocol.js","names":[],"sources":["../src/native-protocol.ts"],"sourcesContent":["/**\n * The **native command protocol** — a small, strongly-typed, *serializable*\n * description of how to build and mutate a native view tree.\n *\n * The Helix reconciler ({@link import('./render').render}) drives a\n * {@link import('./backend').HostBackend}; the\n * {@link import('./native-command-backend').NativeCommandBackend} implements that\n * contract by emitting a stream of {@link NativeCommand}s instead of touching the\n * DOM. A native host (UIKit on iOS, Android View on Android, or another future\n * surface) consumes the stream and materializes real views.\n *\n * The protocol is deliberately platform-neutral and JSON-serializable: it carries\n * **no functions**. Event handlers are represented as stable handler-id\n * *registrations* ({@link RegisterEventCommand}); the host invokes a handler by\n * id (see {@link import('./native-command-backend').NativeCommandBackend.dispatchEvent}),\n * so a closure never has to cross a serialization boundary.\n *\n * This is the Phase 8A foundation for native rendering. It is **not** itself an\n * iOS/Android renderer — it is the wire format a real host backend will speak.\n *\n * @module\n */\n\n/** Identifier for a native node. Stable for the node's lifetime. */\nexport type NativeNodeId = string | number\n\n/**\n * A value that may be sent as a native prop. Strictly serializable: primitives,\n * `null`, and (recursively) arrays/plain-objects of the same. Notably **not**\n * functions, `undefined`, symbols, bigints, or non-finite numbers — those cannot\n * cross the protocol boundary safely. Event handlers are modeled separately\n * (see {@link RegisterEventCommand}).\n */\nexport type NativePropValue =\n  | string\n  | number\n  | boolean\n  | null\n  | readonly NativePropValue[]\n  | { readonly [key: string]: NativePropValue }\n\n/** Create an element node with a tag (e.g. `\"view\"`, `\"text\"`, `\"button\"`). */\nexport interface CreateNodeCommand {\n  readonly type: 'createNode'\n  readonly id: NativeNodeId\n  readonly tag: string\n}\n\n/** Create a text node holding `text`. */\nexport interface CreateTextCommand {\n  readonly type: 'createText'\n  readonly id: NativeNodeId\n  readonly text: string\n}\n\n/** Set (or replace) a serializable prop on a node. */\nexport interface SetPropCommand {\n  readonly type: 'setProp'\n  readonly id: NativeNodeId\n  readonly name: string\n  readonly value: NativePropValue\n}\n\n/** Remove a previously-set prop from a node. */\nexport interface RemovePropCommand {\n  readonly type: 'removeProp'\n  readonly id: NativeNodeId\n  readonly name: string\n}\n\n/** Insert `childId` into `parentId` at `index` (0-based, among current children). */\nexport interface InsertChildCommand {\n  readonly type: 'insertChild'\n  readonly parentId: NativeNodeId\n  readonly childId: NativeNodeId\n  readonly index: number\n}\n\n/** Detach `childId` from `parentId` (does not free the node — see {@link DisposeNodeCommand}). */\nexport interface RemoveChildCommand {\n  readonly type: 'removeChild'\n  readonly parentId: NativeNodeId\n  readonly childId: NativeNodeId\n}\n\n/** Update a text node's content. */\nexport interface UpdateTextCommand {\n  readonly type: 'updateText'\n  readonly id: NativeNodeId\n  readonly text: string\n}\n\n/**\n * Free a node's host resources. When a subtree is removed, exactly one\n * {@link RemoveChildCommand} detaches the subtree's **root**, then a `disposeNode`\n * is emitted for the root **and every descendant** (deepest-first). Interior nodes\n * are not individually detached — they are freed in the same batch as their parent\n * — so a host should treat `disposeNode` as \"free this node (and remove it from any\n * parent it still holds)\". No surviving node ever references a freed one.\n */\nexport interface DisposeNodeCommand {\n  readonly type: 'disposeNode'\n  readonly id: NativeNodeId\n}\n\n/**\n * Register an event handler on a node under a stable `handlerId`. The host should\n * call back into the runtime (`dispatchEvent(handlerId, event)`) when the native\n * event fires. The handler function itself never crosses the protocol.\n */\nexport interface RegisterEventCommand {\n  readonly type: 'registerEvent'\n  readonly id: NativeNodeId\n  /** Normalized event name, e.g. `\"press\"` for an `onPress` prop. */\n  readonly eventName: string\n  /** Stable id the host echoes back to invoke the handler. */\n  readonly handlerId: string\n}\n\n/** Remove a previously-registered event handler. */\nexport interface UnregisterEventCommand {\n  readonly type: 'unregisterEvent'\n  readonly id: NativeNodeId\n  readonly eventName: string\n  readonly handlerId: string\n}\n\n/** A single instruction in the native command stream. */\nexport type NativeCommand =\n  | CreateNodeCommand\n  | CreateTextCommand\n  | SetPropCommand\n  | RemovePropCommand\n  | InsertChildCommand\n  | RemoveChildCommand\n  | UpdateTextCommand\n  | DisposeNodeCommand\n  | RegisterEventCommand\n  | UnregisterEventCommand\n\nconst COMMAND_TYPES = new Set<NativeCommand['type']>([\n  'createNode',\n  'createText',\n  'setProp',\n  'removeProp',\n  'insertChild',\n  'removeChild',\n  'updateText',\n  'disposeNode',\n  'registerEvent',\n  'unregisterEvent',\n])\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null\n}\n\nfunction isPlainObject(value: object): boolean {\n  const proto = Object.getPrototypeOf(value)\n  return proto === Object.prototype || proto === null\n}\n\nfunction isId(value: unknown): value is NativeNodeId {\n  // Reject NaN/Infinity: they don't round-trip through JSON (→ null), which would\n  // corrupt the most identity-critical field on the wire.\n  return typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value))\n}\n\n/**\n * Type guard: is `value` a valid {@link NativePropValue}? Rejects functions,\n * `undefined`, symbols, bigints, non-finite numbers, and non-plain objects\n * (recursively).\n */\nexport function isNativePropValue(value: unknown): value is NativePropValue {\n  return isPropValue(value, new WeakSet())\n}\n\nfunction isPropValue(value: unknown, seen: WeakSet<object>): boolean {\n  switch (typeof value) {\n    case 'string':\n    case 'boolean':\n      return true\n    case 'number':\n      return Number.isFinite(value)\n    case 'object': {\n      if (value === null) return true\n      if (seen.has(value)) return false // a cycle is not serializable\n      seen.add(value)\n      try {\n        // for…of yields `undefined` for array holes, so sparse arrays are rejected\n        // (matching normalizeNativeProp — the two stay a consistent accept/coerce pair).\n        if (Array.isArray(value)) {\n          for (const item of value) if (!isPropValue(item, seen)) return false\n          return true\n        }\n        if (isPlainObject(value)) {\n          for (const v of Object.values(value)) if (!isPropValue(v, seen)) return false\n          return true\n        }\n        return false\n      } finally {\n        seen.delete(value) // shared (diamond) references are fine — only true cycles fail\n      }\n    }\n    default:\n      return false\n  }\n}\n\n/**\n * Coerce `value` to a {@link NativePropValue}, or `undefined` if it cannot be\n * represented (signalling the prop should be removed rather than set).\n *\n * - Primitives/`null` pass through (non-finite numbers are rejected).\n * - Arrays are rejected wholesale if **any** element is unrepresentable (so\n *   element indices are never silently shifted).\n * - Plain objects keep only their representable entries (an unrepresentable value\n *   drops that key); non-plain objects (Date, Map, class instances, …) are rejected.\n */\nexport function normalizeNativeProp(value: unknown): NativePropValue | undefined {\n  return normalizeProp(value, new WeakSet())\n}\n\nfunction normalizeProp(value: unknown, seen: WeakSet<object>): NativePropValue | undefined {\n  switch (typeof value) {\n    case 'string':\n    case 'boolean':\n      return value\n    case 'number':\n      return Number.isFinite(value) ? value : undefined\n    case 'object': {\n      if (value === null) return null\n      if (seen.has(value)) return undefined // a cycle can't be represented — drop it\n      seen.add(value)\n      try {\n        if (Array.isArray(value)) {\n          const out: NativePropValue[] = []\n          for (const item of value) {\n            const n = normalizeProp(item, seen)\n            if (n === undefined) return undefined\n            out.push(n)\n          }\n          return out\n        }\n        if (isPlainObject(value)) {\n          // Null-prototype accumulator so an own `__proto__` key (e.g. from\n          // JSON.parse) becomes a real data key instead of mutating the prototype.\n          const out: Record<string, NativePropValue> = Object.create(null)\n          for (const [k, v] of Object.entries(value)) {\n            const n = normalizeProp(v, seen)\n            if (n !== undefined) out[k] = n\n          }\n          return out\n        }\n        return undefined\n      } finally {\n        seen.delete(value)\n      }\n    }\n    default:\n      return undefined\n  }\n}\n\n/** Type guard: is `value` a well-formed {@link NativeCommand}? */\nexport function isNativeCommand(value: unknown): value is NativeCommand {\n  if (!isObject(value)) return false\n  const type = value.type\n  if (typeof type !== 'string' || !COMMAND_TYPES.has(type as NativeCommand['type'])) return false\n  switch (type as NativeCommand['type']) {\n    case 'createNode':\n      return isId(value.id) && typeof value.tag === 'string'\n    case 'createText':\n    case 'updateText':\n      return isId(value.id) && typeof value.text === 'string'\n    case 'setProp':\n      return isId(value.id) && typeof value.name === 'string' && isNativePropValue(value.value)\n    case 'removeProp':\n      return isId(value.id) && typeof value.name === 'string'\n    case 'insertChild':\n      return (\n        isId(value.parentId) &&\n        isId(value.childId) &&\n        typeof value.index === 'number' &&\n        Number.isInteger(value.index) &&\n        value.index >= 0\n      )\n    case 'removeChild':\n      return isId(value.parentId) && isId(value.childId)\n    case 'disposeNode':\n      return isId(value.id)\n    case 'registerEvent':\n    case 'unregisterEvent':\n      return (\n        isId(value.id) && typeof value.eventName === 'string' && typeof value.handlerId === 'string'\n      )\n    default:\n      return false\n  }\n}\n\n/**\n * Create a generator of unique node ids. Each call returns the next id as\n * `` `${prefix}${n}` `` with a monotonically increasing `n`. Pass a distinct\n * `prefix` per backend instance so ids from different backends never collide.\n */\nexport function createNativeNodeIdFactory(prefix = 'n'): () => string {\n  let n = 0\n  return () => `${prefix}${++n}`\n}\n"],"mappings":"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"}

package/dist/native.d.ts

@@ -0,0 +1,42 @@
+import { HostBackend } from "./backend.js";
+import { NativeCommandBackend, NativeCommandBackendOptions, NativeCommandNode, createNativeCommandBackend } from "./native-command-backend.js";
+
+//#region src/native.d.ts
+/**
+ * 🔬 Research track. The native (iOS/Android) host backend. Extends the same
+ * {@link HostBackend} contract the reconciler already speaks, so when it lands,
+ * `render()` works against native views with no reconciler changes.
+ */
+interface NativeBackend<N> extends HostBackend<N> {
+  /** The target platform this backend drives. */
+  readonly platform: 'ios' | 'android';
+}
+/**
+ * 🔬 Research track. A GPU-canvas backend (wgpu/WebGPU) for pixel-perfect custom
+ * UI. Composes with the native strand: a canvas subtree renders to a GPU surface
+ * embedded among native host nodes.
+ */
+interface CanvasBackend<N> extends HostBackend<N> {
+  /** Marks this backend as drawing to a GPU canvas surface. */
+  readonly surface: 'gpu-canvas';
+}
+/**
+ * 🔬 Research track — a direct iOS/Android runtime backend that draws platform views.
+ * **Not implemented**: throws {@link NotImplementedError}.
+ *
+ * Today, drive {@link createNativeCommandBackend} to produce the native command
+ * stream consumed by the verified host projects in `examples/native-hosts/`, or
+ * {@link createDomBackend} for the web.
+ *
+ * @experimental
+ */
+declare function createNativeBackend(_platform: 'ios' | 'android'): never;
+/**
+ * 🔬 Research track — not implemented. Throws {@link NotImplementedError}.
+ *
+ * @experimental
+ */
+declare function createCanvasBackend(): never;
+//#endregion
+export { CanvasBackend, NativeBackend, createCanvasBackend, createNativeBackend };
+//# sourceMappingURL=native.d.ts.map

package/dist/native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","names":[],"sources":["../src/native.ts"],"mappings":";;;;;AA0EmC;;;;UAlClB,aAAA,YAAyB,WAAW,CAAC,CAAA;;WAE3C,QAAA;AAAA;;;;;;UAQM,aAAA,YAAyB,WAAW,CAAC,CAAA;;WAE3C,OAAA;AAAA;;;;;;;;;;;iBAaK,mBAAA,CAAoB,SAA4B;;;;;;iBAShD,mBAAA"}

package/dist/native.js

@@ -0,0 +1,59 @@
+import "./native-command-backend.js";
+import { NotImplementedError } from "@mindees/core";
+//#region src/native.ts
+/**
+* Native rendering backends.
+*
+* Two layers live here, at different maturities:
+*
+* - ✅ **Native command backend** ({@link createNativeCommandBackend},
+*   re-exported below) — **implemented today**. It turns the Helix element tree +
+*   fine-grained reactive updates into a serializable {@link NativeCommand}
+*   stream that a native host can replay. This is the Phase 8A foundation for
+*   native rendering; it does not itself draw to the screen.
+* - 🔬 **Direct runtime backends** ({@link createNativeBackend},
+*   {@link createCanvasBackend}) — **research tracks**. They define the contracts
+*   so the Helix architecture is real and the public API is honest, but they are
+*   **not implemented**: the constructors throw {@link NotImplementedError}.
+*
+* The web/DOM backend ({@link createDomBackend}), the headless backend, the native
+* command backend, and the strict reference host are the fully working render targets
+* and protocol validation path today. The iOS/UIKit and Android View host projects in
+* `examples/native-hosts/` compile and render the command stream in CI.
+*
+* - **Native strand** (`NativeBackend`): a direct runtime backend that will connect
+*   a running JS app to real platform views. The command protocol and reference host
+*   projects exist today; the full app bridge/embedded JS engine remains future work.
+* - **GPU canvas strand** (`CanvasBackend`): a wgpu/WebGPU surface with
+*   build-time-precompiled shaders, for pixel-perfect custom UI composited next
+*   to native nodes.
+*
+* See ROADMAP.md and STATUS.md for the honest maturity breakdown.
+*
+* @module
+*/
+/**
+* 🔬 Research track — a direct iOS/Android runtime backend that draws platform views.
+* **Not implemented**: throws {@link NotImplementedError}.
+*
+* Today, drive {@link createNativeCommandBackend} to produce the native command
+* stream consumed by the verified host projects in `examples/native-hosts/`, or
+* {@link createDomBackend} for the web.
+*
+* @experimental
+*/
+function createNativeBackend(_platform) {
+	throw new NotImplementedError("Native (iOS/Android) platform host backend");
+}
+/**
+* 🔬 Research track — not implemented. Throws {@link NotImplementedError}.
+*
+* @experimental
+*/
+function createCanvasBackend() {
+	throw new NotImplementedError("GPU canvas renderer backend (wgpu/WebGPU)");
+}
+//#endregion
+export { createCanvasBackend, createNativeBackend };
+
+//# sourceMappingURL=native.js.map

package/dist/native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.js","names":[],"sources":["../src/native.ts"],"sourcesContent":["/**\n * Native rendering backends.\n *\n * Two layers live here, at different maturities:\n *\n * - ✅ **Native command backend** ({@link createNativeCommandBackend},\n *   re-exported below) — **implemented today**. It turns the Helix element tree +\n *   fine-grained reactive updates into a serializable {@link NativeCommand}\n *   stream that a native host can replay. This is the Phase 8A foundation for\n *   native rendering; it does not itself draw to the screen.\n * - 🔬 **Direct runtime backends** ({@link createNativeBackend},\n *   {@link createCanvasBackend}) — **research tracks**. They define the contracts\n *   so the Helix architecture is real and the public API is honest, but they are\n *   **not implemented**: the constructors throw {@link NotImplementedError}.\n *\n * The web/DOM backend ({@link createDomBackend}), the headless backend, the native\n * command backend, and the strict reference host are the fully working render targets\n * and protocol validation path today. The iOS/UIKit and Android View host projects in\n * `examples/native-hosts/` compile and render the command stream in CI.\n *\n * - **Native strand** (`NativeBackend`): a direct runtime backend that will connect\n *   a running JS app to real platform views. The command protocol and reference host\n *   projects exist today; the full app bridge/embedded JS engine remains future work.\n * - **GPU canvas strand** (`CanvasBackend`): a wgpu/WebGPU surface with\n *   build-time-precompiled shaders, for pixel-perfect custom UI composited next\n *   to native nodes.\n *\n * See ROADMAP.md and STATUS.md for the honest maturity breakdown.\n *\n * @module\n */\n\nimport { NotImplementedError } from '@mindees/core'\nimport type { HostBackend } from './backend'\n\n/**\n * 🔬 Research track. The native (iOS/Android) host backend. Extends the same\n * {@link HostBackend} contract the reconciler already speaks, so when it lands,\n * `render()` works against native views with no reconciler changes.\n */\nexport interface NativeBackend<N> extends HostBackend<N> {\n  /** The target platform this backend drives. */\n  readonly platform: 'ios' | 'android'\n}\n\n/**\n * 🔬 Research track. A GPU-canvas backend (wgpu/WebGPU) for pixel-perfect custom\n * UI. Composes with the native strand: a canvas subtree renders to a GPU surface\n * embedded among native host nodes.\n */\nexport interface CanvasBackend<N> extends HostBackend<N> {\n  /** Marks this backend as drawing to a GPU canvas surface. */\n  readonly surface: 'gpu-canvas'\n}\n\n/**\n * 🔬 Research track — a direct iOS/Android runtime backend that draws platform views.\n * **Not implemented**: throws {@link NotImplementedError}.\n *\n * Today, drive {@link createNativeCommandBackend} to produce the native command\n * stream consumed by the verified host projects in `examples/native-hosts/`, or\n * {@link createDomBackend} for the web.\n *\n * @experimental\n */\nexport function createNativeBackend(_platform: 'ios' | 'android'): never {\n  throw new NotImplementedError('Native (iOS/Android) platform host backend')\n}\n\n/**\n * 🔬 Research track — not implemented. Throws {@link NotImplementedError}.\n *\n * @experimental\n */\nexport function createCanvasBackend(): never {\n  throw new NotImplementedError('GPU canvas renderer backend (wgpu/WebGPU)')\n}\n\n/**\n * ✅ The implemented native MVP: a backend that emits a serializable\n * {@link NativeCommand} stream for a native host to replay. See\n * {@link import('./native-command-backend').createNativeCommandBackend}.\n */\nexport {\n  createNativeCommandBackend,\n  type NativeCommandBackend,\n  type NativeCommandBackendOptions,\n  type NativeCommandNode,\n} from './native-command-backend'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA,SAAgB,oBAAoB,WAAqC;CACvE,MAAM,IAAI,oBAAoB,4CAA4C;AAC5E;;;;;;AAOA,SAAgB,sBAA6B;CAC3C,MAAM,IAAI,oBAAoB,2CAA2C;AAC3E"}

package/dist/render.d.ts

@@ -0,0 +1,28 @@
+import { HostBackend } from "./backend.js";
+import { Component, MindeesNode } from "@mindees/core";
+
+//#region src/render.d.ts
+/** A mounted subtree: its host nodes plus a disposer that unmounts + cleans up. */
+interface Mounted<N> {
+  /** The top-level host nodes produced (a fragment can yield several). */
+  readonly nodes: N[];
+  /** Unmount: remove host nodes and dispose all reactive bindings. */
+  dispose(): void;
+}
+/**
+ * Render `node` into `container` using `backend`. Returns a {@link Mounted}
+ * handle whose `dispose()` removes the produced nodes and tears down every
+ * reactive binding created during the render.
+ *
+ * @example
+ * const backend = createHeadlessBackend()
+ * const root = createHeadlessRoot()
+ * const app = render(MyComponent, {}, backend, root) // component form
+ * const m = render(element, backend, root)           // element form
+ * m.dispose()
+ */
+declare function render<N>(node: MindeesNode, backend: HostBackend<N>, container: N): Mounted<N>;
+declare function render<N, P>(component: Component<P>, props: P, backend: HostBackend<N>, container: N): Mounted<N>;
+//#endregion
+export { Mounted, render };
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","names":[],"sources":["../src/render.ts"],"mappings":";;;;;UAgDiB,OAAA;EAmB2E;EAAA,SAjBjF,KAAA,EAAO,CAAC;EAiBI;EAfrB,OAAA;AAAA;;;;;;;;;AAe4F;AAC9F;;;iBADgB,MAAA,IAAU,IAAA,EAAM,WAAA,EAAa,OAAA,EAAS,WAAA,CAAY,CAAA,GAAI,SAAA,EAAW,CAAA,GAAI,OAAA,CAAQ,CAAA;AAAA,iBAC7E,MAAA,OACd,SAAA,EAAW,SAAA,CAAU,CAAA,GACrB,KAAA,EAAO,CAAA,EACP,OAAA,EAAS,WAAA,CAAY,CAAA,GACrB,SAAA,EAAW,CAAA,GACV,OAAA,CAAQ,CAAA"}

package/dist/render.js

@@ -0,0 +1,145 @@
+import { ELEMENT_TYPE, createRoot, effect, onCleanup, untrack } from "@mindees/core";
+//#region src/render.ts
+/**
+* Helix reconciler — turns a MindeesNative element tree into host nodes via a
+* {@link HostBackend}, with **fine-grained reactive bindings**.
+*
+* There is no virtual-DOM diff. Instead:
+* - A dynamic prop (a function value) becomes an `effect` that patches exactly
+*   that one attribute when its signals change.
+* - A dynamic child (a function returning nodes) becomes an `effect` that
+*   replaces exactly that region of the host tree.
+* - Everything created during render is owned by a reactive scope, so unmounting
+*   disposes every binding — no leaks.
+*
+* This is the Phase 1/2 reactivity paying off: updates are O(what-changed), not
+* O(tree).
+*
+* @module
+*/
+function isElementLike(value) {
+	return typeof value === "object" && value !== null && value.$$typeof === ELEMENT_TYPE;
+}
+function isEventProp(key) {
+	return key.length > 2 && key[0] === "o" && key[1] === "n" && key[2] === (key[2] ?? "").toUpperCase();
+}
+function render(a, b, c, d) {
+	const isComponentForm = d !== void 0;
+	const backend = isComponentForm ? c : b;
+	const container = isComponentForm ? d : c;
+	let nodes = [];
+	let dispose;
+	try {
+		createRoot((d) => {
+			dispose = d;
+			nodes = mountNode(isComponentForm ? a(b) : a, backend, container, null);
+		});
+	} catch (err) {
+		dispose?.();
+		throw err;
+	}
+	return {
+		nodes,
+		dispose() {
+			for (const n of nodes) {
+				const parent = backend.parentOf(n);
+				if (parent) backend.remove(parent, n);
+			}
+			dispose();
+		}
+	};
+}
+/**
+* Mount a node into `parent` before `anchor`. Returns the top-level host nodes
+* created (for fragments / arrays this can be more than one).
+*/
+function mountNode(node, backend, parent, anchor) {
+	if (node === null || node === void 0 || typeof node === "boolean") return [];
+	if (typeof node === "function") return bindReactiveChild(node, backend, parent, anchor);
+	if (typeof node === "string" || typeof node === "number") {
+		const text = backend.createText(String(node));
+		backend.insert(parent, text, anchor);
+		return [text];
+	}
+	if (Array.isArray(node)) {
+		const out = [];
+		for (const child of node) out.push(...mountNode(child, backend, parent, anchor));
+		return out;
+	}
+	if (isElementLike(node)) {
+		const { type } = node;
+		if (typeof type === "function") return mountNode(type({
+			...node.props,
+			children: node.children
+		}), backend, parent, anchor);
+		const el = backend.createElement(type);
+		for (const [key, value] of Object.entries(node.props)) bindProp(backend, el, key, value);
+		mountChildren(node.children, backend, el);
+		backend.insert(parent, el, anchor);
+		return [el];
+	}
+	return [];
+}
+/** Mount a list of children into `parent`, appending in order. */
+function mountChildren(children, backend, parent) {
+	for (const child of children) mountNode(child, backend, parent, null);
+}
+/**
+* Apply a prop. A function value is a **reactive binding**: an effect re-applies
+* exactly this attribute when its dependencies change. Event props (`onX`) are
+* applied once (the handler itself can close over signals).
+*/
+function bindProp(backend, el, key, value) {
+	if (key === "children") return;
+	if (isEventProp(key)) {
+		backend.setProp(el, key, value, void 0);
+		onCleanup(() => backend.setProp(el, key, void 0, value));
+		return;
+	}
+	if (typeof value === "function") {
+		let prev;
+		effect(() => {
+			const next = value();
+			backend.setProp(el, key, next, prev);
+			prev = next;
+		});
+		return;
+	}
+	backend.setProp(el, key, value, void 0);
+}
+/**
+* Bind a reactive child region: an effect that, when the accessor changes,
+* unmounts the previous nodes and mounts the new ones at the same position. A
+* stable text-only fast path patches the text node in place.
+*
+* The effect runs synchronously on creation, so `current` is populated before
+* we return it — letting the caller report the region's initial host nodes.
+*/
+function bindReactiveChild(accessor, backend, parent, initialAnchor) {
+	const marker = backend.createText("");
+	backend.insert(parent, marker, initialAnchor);
+	const nodes = [marker];
+	let content = [];
+	onCleanup(() => {
+		for (const n of content) if (backend.parentOf(n)) backend.remove(parent, n);
+		if (backend.parentOf(marker)) backend.remove(parent, marker);
+	});
+	effect(() => {
+		const value = accessor();
+		untrack(() => {
+			if (content.length === 1 && content[0] !== void 0 && backend.isText(content[0]) && (typeof value === "string" || typeof value === "number")) {
+				backend.setText(content[0], String(value));
+				return;
+			}
+			for (const n of content) if (backend.parentOf(n)) backend.remove(parent, n);
+			content = mountNode(value, backend, parent, marker);
+			nodes.length = 0;
+			nodes.push(...content, marker);
+		});
+	});
+	return nodes;
+}
+//#endregion
+export { render };
+
+//# sourceMappingURL=render.js.map

package/dist/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","names":["component"],"sources":["../src/render.ts"],"sourcesContent":["/**\n * Helix reconciler — turns a MindeesNative element tree into host nodes via a\n * {@link HostBackend}, with **fine-grained reactive bindings**.\n *\n * There is no virtual-DOM diff. Instead:\n * - A dynamic prop (a function value) becomes an `effect` that patches exactly\n *   that one attribute when its signals change.\n * - A dynamic child (a function returning nodes) becomes an `effect` that\n *   replaces exactly that region of the host tree.\n * - Everything created during render is owned by a reactive scope, so unmounting\n *   disposes every binding — no leaks.\n *\n * This is the Phase 1/2 reactivity paying off: updates are O(what-changed), not\n * O(tree).\n *\n * @module\n */\n\nimport {\n  type Component,\n  createRoot,\n  ELEMENT_TYPE,\n  effect,\n  type MindeesElement,\n  type MindeesNode,\n  onCleanup,\n  untrack,\n} from '@mindees/core'\nimport type { HostBackend } from './backend'\n\n/** A dynamic value: pass a function and the binding reacts to its signals. */\ntype MaybeReactive<T> = T | (() => T)\n\nfunction isElementLike(value: unknown): value is MindeesElement {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { $$typeof?: unknown }).$$typeof === ELEMENT_TYPE\n  )\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/** A mounted subtree: its host nodes plus a disposer that unmounts + cleans up. */\nexport interface Mounted<N> {\n  /** The top-level host nodes produced (a fragment can yield several). */\n  readonly nodes: N[]\n  /** Unmount: remove host nodes and dispose all reactive bindings. */\n  dispose(): void\n}\n\n/**\n * Render `node` into `container` using `backend`. Returns a {@link Mounted}\n * handle whose `dispose()` removes the produced nodes and tears down every\n * reactive binding created during the render.\n *\n * @example\n * const backend = createHeadlessBackend()\n * const root = createHeadlessRoot()\n * const app = render(MyComponent, {}, backend, root) // component form\n * const m = render(element, backend, root)           // element form\n * m.dispose()\n */\nexport function render<N>(node: MindeesNode, backend: HostBackend<N>, container: N): Mounted<N>\nexport function render<N, P>(\n  component: Component<P>,\n  props: P,\n  backend: HostBackend<N>,\n  container: N,\n): Mounted<N>\nexport function render<N, P>(\n  a: MindeesNode | Component<P>,\n  b: HostBackend<N> | P,\n  c?: HostBackend<N> | N,\n  d?: N,\n): Mounted<N> {\n  // Disambiguate by ARITY, not `typeof a`: `MindeesNode` now includes the\n  // accessor form `() => MindeesNode`, so a function `a` may be either a\n  // component (4-arg form) or a reactive node (3-arg form). The component form\n  // is the only one with a 4th argument (`container = d`).\n  const isComponentForm = d !== undefined\n  const backend = (isComponentForm ? c : b) as HostBackend<N>\n  const container = (isComponentForm ? d : c) as N\n\n  let nodes: N[] = []\n  // Capture the disposer eagerly — createRoot passes it to the callback\n  // synchronously, BEFORE the body runs. If the component or mountNode throws\n  // part-way, effects/regions created before the throw are already adopted on\n  // this root; createRoot does NOT auto-dispose on a throw, so without this they\n  // would leak (stay subscribed forever) and the caller would get no disposer.\n  // Dispose the partial scope, then rethrow — restoring the \"no leaks\" guarantee.\n  let dispose!: () => void\n  try {\n    createRoot((d) => {\n      dispose = d\n      // Evaluate the component INSIDE the root scope so its effects/memos are\n      // owned here and disposed with us. A non-component node is mounted as-is\n      // (an accessor node becomes a reactive region during mount).\n      const node: MindeesNode = isComponentForm ? (a as Component<P>)(b as P) : (a as MindeesNode)\n      nodes = mountNode(node, backend, container, null)\n    })\n  } catch (err) {\n    dispose?.()\n    throw err\n  }\n\n  return {\n    nodes,\n    dispose() {\n      for (const n of nodes) {\n        const parent = backend.parentOf(n)\n        if (parent) backend.remove(parent, n)\n      }\n      dispose()\n    },\n  }\n}\n\n/**\n * Mount a node into `parent` before `anchor`. Returns the top-level host nodes\n * created (for fragments / arrays this can be more than one).\n */\nfunction mountNode<N>(\n  node: MindeesNode,\n  backend: HostBackend<N>,\n  parent: N,\n  anchor: N | null,\n): N[] {\n  // Null-ish / boolean → nothing.\n  if (node === null || node === undefined || typeof node === 'boolean') return []\n\n  // Function node → a reactive region (an accessor `() => MindeesNode`). Handled\n  // uniformly here so it works at the top level and as a child.\n  if (typeof node === 'function') {\n    return bindReactiveChild(node as () => MindeesNode, backend, parent, anchor)\n  }\n\n  // Text-like primitives.\n  if (typeof node === 'string' || typeof node === 'number') {\n    const text = backend.createText(String(node))\n    backend.insert(parent, text, anchor)\n    return [text]\n  }\n\n  // Arrays / fragments → mount each child in order.\n  if (Array.isArray(node)) {\n    const out: N[] = []\n    for (const child of node) out.push(...mountNode(child, backend, parent, anchor))\n    return out\n  }\n\n  if (isElementLike(node)) {\n    const { type } = node\n    // Function component: invoked directly. We are already inside render()'s\n    // createRoot owner scope, so any effects/memos the component creates are\n    // owned here and disposed on unmount. `children` is passed through props.\n    if (typeof type === 'function') {\n      const component = type as Component<Record<string, unknown>>\n      const rendered = component({ ...node.props, children: node.children })\n      return mountNode(rendered, backend, parent, anchor)\n    }\n\n    // Host element.\n    const el = backend.createElement(type)\n    for (const [key, value] of Object.entries(node.props)) {\n      bindProp(backend, el, key, value)\n    }\n    mountChildren(node.children, backend, el)\n    backend.insert(parent, el, anchor)\n    return [el]\n  }\n\n  return []\n}\n\n/** Mount a list of children into `parent`, appending in order. */\nfunction mountChildren<N>(\n  children: readonly MindeesNode[],\n  backend: HostBackend<N>,\n  parent: N,\n): void {\n  // mountNode handles every node kind uniformly, including function children\n  // (reactive regions) via the function-node branch.\n  for (const child of children) {\n    mountNode(child, backend, parent, null)\n  }\n}\n\n/**\n * Apply a prop. A function value is a **reactive binding**: an effect re-applies\n * exactly this attribute when its dependencies change. Event props (`onX`) are\n * applied once (the handler itself can close over signals).\n */\nfunction bindProp<N>(backend: HostBackend<N>, el: N, key: string, value: unknown): void {\n  if (key === 'children') return\n  if (isEventProp(key)) {\n    backend.setProp(el, key, value, undefined)\n    // Symmetric teardown: remove the listener when this scope is disposed (unmount\n    // or an enclosing region re-run), so a backend's addEventListener always has a\n    // matching removal — not left to GC. Passing `undefined` drives the backend's\n    // own listener-removal path (e.g. the DOM backend's removeEventListener).\n    onCleanup(() => backend.setProp(el, key, undefined, value))\n    return\n  }\n  if (typeof value === 'function') {\n    let prev: unknown\n    effect(() => {\n      const next = (value as () => unknown)()\n      backend.setProp(el, key, next, prev)\n      prev = next\n    })\n    return\n  }\n  backend.setProp(el, key, value, undefined)\n}\n\n/**\n * Bind a reactive child region: an effect that, when the accessor changes,\n * unmounts the previous nodes and mounts the new ones at the same position. A\n * stable text-only fast path patches the text node in place.\n *\n * The effect runs synchronously on creation, so `current` is populated before\n * we return it — letting the caller report the region's initial host nodes.\n */\nfunction bindReactiveChild<N>(\n  accessor: () => MindeesNode,\n  backend: HostBackend<N>,\n  parent: N,\n  initialAnchor: N | null,\n): N[] {\n  // Pin the region's slot with a persistent, invisible empty-text marker, and\n  // always (re)mount content immediately BEFORE it. This keeps the region's\n  // exact position across empty↔content transitions (an empty region previously\n  // collapsed — its content reappeared at the parent's end, breaking the\n  // `() => cond() ? <X/> : null` pattern when the region had following siblings)\n  // and keeps adjacent regions in order. The marker serializes to '' so it is\n  // invisible in output.\n  const marker = backend.createText('')\n  backend.insert(parent, marker, initialAnchor)\n\n  // `nodes` is a STABLE, live array — the region's current content followed by\n  // the slot marker — mutated in place on every run. Returning the same array\n  // reference (not a one-time snapshot) means a caller that captures it once\n  // (e.g. render()'s root disposer) always removes the CURRENT content, not the\n  // first-run nodes.\n  const nodes: N[] = [marker]\n  let content: N[] = []\n\n  // Authoritative unmount for the region. Reading the LIVE `content`/`marker` at\n  // teardown means it removes whatever is mounted NOW, regardless of how the\n  // region was composed. This is required for correctness: when the region is a\n  // child of a top-level array/fragment, render()'s disposer only captured a\n  // flattened ONE-TIME snapshot of the host nodes (the array branch in mountNode\n  // spreads `nodes` into a fresh array), so after a content swap it can no longer\n  // remove the current content — that node would leak. This owner-scoped cleanup\n  // closes that gap. It is owned by whoever mounted the region: render()'s root\n  // (fires once, on final dispose) or an enclosing region effect (fires on each\n  // re-run, tearing the nested region down). Guarded by parentOf so it is a safe\n  // no-op for nodes already detached by render()'s disposer or a swap.\n  onCleanup(() => {\n    for (const n of content) {\n      if (backend.parentOf(n)) backend.remove(parent, n)\n    }\n    if (backend.parentOf(marker)) backend.remove(parent, marker)\n  })\n\n  effect(() => {\n    const value = accessor()\n    untrack(() => {\n      // Fast path: single existing text node + new text-like value → patch.\n      if (\n        content.length === 1 &&\n        content[0] !== undefined &&\n        backend.isText(content[0]) &&\n        (typeof value === 'string' || typeof value === 'number')\n      ) {\n        backend.setText(content[0], String(value))\n        return\n      }\n      // Guarded: when this region is nested in another region, the parent's\n      // re-run fires this region's onCleanup first (detaching `content`), so a\n      // second removal here would hit an already-detached node — the DOM\n      // backend's removeChild throws on a non-child.\n      for (const n of content) {\n        if (backend.parentOf(n)) backend.remove(parent, n)\n      }\n      content = mountNode(value, backend, parent, marker)\n      nodes.length = 0\n      nodes.push(...content, marker)\n    })\n  })\n  return nodes\n}\n\nexport type { MaybeReactive }\n"],"mappings":"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"}