@roku-sdk/solid 0.0.0-stage → 2.19.0

package/EXPORTS.md

@@ -0,0 +1,234 @@
+# @roku-sdk/solid — Export Reference
+
+This document is the single source of truth for the **supported** public API surface of `@roku-sdk/solid`.
+The package uses `export *` for backward compatibility, so additional internal symbols are
+technically accessible — but only the symbols listed in this document are part of the supported API.
+Importing unlisted symbols is unsupported and may break without notice.
+
+## Inclusion Strategy
+
+The package provides two categories of exports:
+
+1. **SolidJS re-exports** — All `solid-js` and `solid-js/store` APIs that are functional within the `solid-js/universal` renderer model. Platform-incompatible features (SSR hydration, lazy dynamic imports, concurrent mode scheduling, internal symbols) are excluded.
+2. **SDK-specific exports** — Renderer initialization and runtime hooks consumed by the JSX transform.
+
+**Always import from `@roku-sdk/solid`, never directly from `solid-js` or `solid-js/store`.**
+
+```ts
+// Correct
+import { createSignal, createStore, mergeProps } from "@roku-sdk/solid";
+
+// Incorrect — bypasses the SDK abstraction layer
+import { createSignal } from "solid-js";
+import { createStore } from "solid-js/store";
+```
+
+## SolidJS Re-exports
+
+### solid-js (core)
+
+#### Functions
+
+| Export | Category | Description |
+|---|---|---|
+| `createSignal` | Reactive primitive | Create a reactive signal (getter + setter) |
+| `createEffect` | Reactive primitive | Run a side effect that tracks reactive dependencies |
+| `createMemo` | Reactive primitive | Create a derived/cached reactive computation |
+| `createResource` | Reactive primitive | Create an async resource tied to a signal source |
+| `createComputed` | Reactive primitive | Eager/synchronous variant of `createEffect` |
+| `batch` | Reactive primitive | Batch multiple signal writes into a single update |
+| `untrack` | Reactive primitive | Read signals without tracking dependencies |
+| `startTransition` | Reactive primitive | Defer signal commits; without `enableScheduling` it falls through to a microtask-deferred batch (no web/scheduler APIs — verified on-device) |
+| `useTransition` | Reactive primitive | Returns `[pending, startTransition]`; thin wrapper over `startTransition` (verified on-device) |
+| `createSelector` | Secondary primitive | Optimized selector for list selection patterns |
+| `createReaction` | Secondary primitive | Create a tracked reaction with explicit tracking/running phases |
+| `createRenderEffect` | Secondary primitive | Like `createEffect` but runs during render |
+| `on` | Dependency helper | Explicit dependency declaration wrapper for effects |
+| `from` | Dependency helper | Create a signal from an observable or producer |
+| `observable` | Dependency helper | Convert a signal to an observable (verified on-device) |
+| `mapArray` | Array helper | Low-level mapped array helper (underlies `<For>`) |
+| `indexArray` | Array helper | Low-level indexed array helper (underlies `<Index>`) |
+| `onMount` | Lifecycle | Register a callback to run once after first render |
+| `onCleanup` | Lifecycle | Register a cleanup callback for the current scope |
+| `catchError` | Error handling | Catch errors within a reactive scope |
+| `resetErrorBoundaries` | Error handling | Programmatically reset `<ErrorBoundary>` state |
+| `createContext` | Context | Create a context for dependency injection |
+| `useContext` | Context | Consume a context value |
+| `getOwner` | Owner management | Get the current reactive owner |
+| `runWithOwner` | Owner management | Run code under a specific owner |
+| `DEV` | Dev-mode API | Solid's dev-mode namespace (hooks/registry); `undefined` in production builds |
+| `mergeProps` | Props utility | Merge multiple props objects with reactive tracking |
+| `splitProps` | Props utility | Split a props object into groups for forwarding |
+| `Show` | Component | Conditional rendering |
+| `For` | Component | Keyed list rendering |
+| `Index` | Component | Indexed (non-keyed) list rendering |
+| `Switch` | Component | Multi-branch conditional rendering |
+| `Match` | Component | Branch for `<Switch>` |
+| `ErrorBoundary` | Component | Catch and recover from errors in children |
+| `Suspense` | Component | Render a fallback while descendant `createResource` reads are loading; context-based loading counter with no DOM/SSR dependency (verified on-device) |
+| `children` | Component | Resolve and track children |
+| `createRoot` | Component | Create a new reactive root |
+| `createUniqueId` | Utility | Generate a stable unique ID per reactive scope |
+
+#### Types
+
+| Export | Description |
+|---|---|
+| `Accessor` | Read-only signal getter type |
+| `AccessorArray` | Tuple of accessors for `on()` |
+| `ChildrenReturn` | Return type of `children()` |
+| `Component` | Standard component type `(props) => JSXElement` |
+| `ComponentProps` | Infer props type from a component or intrinsic element |
+| `Context` | Context object type returned by `createContext` |
+| `ContextProviderComponent` | Provider component type returned inside a `Context` |
+| `EffectFunction` | Callback type for effects |
+| `EffectOptions` | Options for `createEffect` / `createComputed` |
+| `FlowComponent` | Component type for flow control (e.g., `<Show>`) |
+| `FlowProps` | Props type for flow components |
+| `InitializedResource` | Resource type that is guaranteed to have a value |
+| `InitializedResourceOptions` | Options for `createResource` with an initial value |
+| `InitializedResourceReturn` | Return tuple of `createResource` with an initial value |
+| `JSX` | JSX namespace with element/attribute types |
+| `JSXElement` | Union of all valid JSX return types |
+| `MemoOptions` | Options for `createMemo` |
+| `MergeProps` | Inferred return type of `mergeProps()` |
+| `NoInfer` | Utility type to prevent inference |
+| `ObservableObserver` | Observer type for `observable()` |
+| `OnOptions` | Options for `on()` |
+| `Owner` | Reactive owner type |
+| `ParentComponent` | Component type that accepts children |
+| `ParentProps` | Props type that includes `children` |
+| `Ref` | Ref callback or value type for element references |
+| `ResolvedChildren` | Flattened children after resolution |
+| `ResolvedJSXElement` | Single resolved JSX element type |
+| `Resource` | Async resource accessor type |
+| `ResourceActions` | Action methods (`mutate`, `refetch`) for a resource |
+| `ResourceFetcher` | Fetcher function type for `createResource` |
+| `ResourceFetcherInfo` | Info object passed to a resource fetcher |
+| `ResourceOptions` | Options for `createResource` |
+| `ResourceReturn` | Full return tuple type of `createResource` |
+| `ResourceSource` | Source signal type for `createResource` |
+| `Setter` | Signal setter type |
+| `Signal` | Tuple of `[Accessor, Setter]` |
+| `SignalOptions` | Options for `createSignal` |
+| `SplitProps` | Inferred return type of `splitProps()` |
+| `Transition` | Return tuple type of `useTransition()` — `[Accessor<boolean>, (fn: () => void) => Promise<void>]` |
+| `ValidComponent` | Union of all valid component types (intrinsic + functional) |
+| `VoidComponent` | Component type with no props |
+| `VoidProps` | Empty props type |
+
+### solid-js/store
+
+#### Functions
+
+| Export | Description |
+|---|---|
+| `createStore` | Create an immutable reactive store (getter + setter) |
+| `createMutable` | Create a mutable reactive store proxy |
+| `modifyMutable` | Apply batched mutations to a mutable store |
+| `produce` | Immer-style mutation helper for immutable stores |
+| `reconcile` | Diff and patch a store with new data (useful for API responses) |
+| `unwrap` | Retrieve the raw JS object from a store proxy |
+
+#### Types
+
+| Export | Description |
+|---|---|
+| `ArrayFilterFn` | Filter function type for store paths |
+| `DeepMutable` | Recursively mutable version of a type |
+| `DeepReadonly` | Recursively readonly version of a type |
+| `NotWrappable` | Types that cannot be wrapped in a store proxy |
+| `Part` | Store path segment type |
+| `ReconcileOptions` | Options for `reconcile()` |
+| `SetStoreFunction` | Setter function type returned by `createStore` |
+| `SolidStore` | Internal store representation type |
+| `Store` | Store proxy type |
+| `StoreNode` | Base store node type |
+| `StorePathRange` | Range specification for store paths |
+| `StoreSetter` | Store setter value type |
+
+## Excluded Exports
+
+These exist in `solid-js` or `solid-js/store` but are **not** re-exported because they are not functional on the Roku platform or are internal implementation details.
+
+| Export | Source | Reason |
+|---|---|---|
+| `onError` | `solid-js` | Deprecated in solid-js — use `catchError` instead |
+| `SuspenseList` | `solid-js` | Coordination of multiple `<Suspense>` boundaries — depends on the concurrent scheduler (`enableScheduling`), which is unavailable on Roku |
+| `lazy` | `solid-js` | Dynamic `import()` — incompatible with Roku's static module system |
+| `enableHydration` | `solid-js` | SSR hydration, not applicable to Roku |
+| `createDeferred` | `solid-js` | Uses Solid scheduler (`requestCallback`) that requires `MessageChannel`; on current Roku Hermes runtime `MessageChannel` is unavailable (`ReferenceError: Property 'MessageChannel' doesn't exist`) |
+| `enableScheduling` | `solid-js` | Platform-specific scheduler wiring |
+| `enableExternalSource` | `solid-js` | Power-user hook for external reactive libraries (RxJS, MobX) — no current demand |
+| `equalFn` | `solid-js` | Internal default signal equality comparator |
+| `getListener` | `solid-js` | Internal reactive graph introspection |
+| `requestCallback` | `solid-js` | Internal scheduler primitive |
+| `cancelCallback` | `solid-js` | Internal scheduler primitive |
+| `$PROXY` | `solid-js` | Internal symbol, not part of the public API |
+| `$TRACK` | `solid-js` | Internal symbol, not part of the public API |
+| `$DEVCOMP` | `solid-js` | Internal symbol, not part of the public API |
+| `sharedConfig` | `solid-js` | Internal runtime state |
+| `createComponent` | `solid-js` | Internal JSX transform helper, not for direct use |
+| `isWrappable` | `solid-js/store` | Internal utility to check if a value can be wrapped in a store proxy |
+| `setProperty` | `solid-js/store` | Internal low-level store property setter |
+| `updatePath` | `solid-js/store` | Internal low-level store path updater |
+| `$RAW` | `solid-js/store` | Internal symbol, not part of the public API |
+
+## SDK-Specific Exports
+
+These are SDK-owned symbols — not re-exports from `solid-js`. They power the Roku renderer and JSX runtime.
+
+### Renderer Initialization
+
+| Export | Kind | Description |
+|---|---|---|
+| `makeSolidRenderer` | Function | Create and wire the Roku SolidJS renderer. Must be called (via `@roku-sdk/rsg-ts` `setUp()`) before any JSX is rendered. |
+| `Renderer` | Type | Generic renderer interface returned by the universal renderer factory. |
+| `SolidRenderer` | Type | Return type of `makeSolidRenderer` — contains the `renderer` instance and `tmFieldChangeHandlerApi`. |
+
+### Tag Aliases
+
+| Export | Kind | Description |
+|---|---|---|
+| `registerTagAlias` | Function | `registerTagAlias(tag, resolve)` — create the SceneGraph node type `resolve()` returns whenever `tag` is created. Used by `@roku-sdk/runtime` and `@roku-sdk/compat` to choose between a firmware node and its shim; apps do not normally call it. |
+| `hasTagAlias` | Function | `hasTagAlias(tag)` — whether `tag` already has an alias, so a default can be registered without replacing one installed earlier. |
+| `registerSetPropertyObserver` | Function | `registerSetPropertyObserver(observer)` — invoke `observer(node, name, value)` after every `tmTransaction.setProperty`. Used by `__DEV__` diagnostics in `@roku-sdk/components` (Effect gradient validation); apps do not normally call it. Empty-list fast path when nothing is registered. |
+
+### Renderer Runtime Hooks
+
+These mutable bindings are wired when `makeSolidRenderer()` runs. They are consumed by the compiled JSX transform and **must not be called directly by application code**. Calling any of them before renderer initialization throws a descriptive error.
+
+| Export | Description |
+|---|---|
+| `effect` | Schedule a reactive effect (renderer-level) |
+| `memo` | Create a renderer-level memo |
+| `createComponent` | Instantiate a component from the JSX transform (name-collides with the excluded `solid-js` internal — see below) |
+| `createElement` | Create a Roku DOM node for a given tag |
+| `createTextNode` | Create a text node (throws — text nodes are not supported on Roku) |
+| `insertNode` | Insert a child node into a parent |
+| `insert` | Insert a reactive accessor into a parent |
+| `spread` | Spread props onto a node (wraps the underlying renderer to ensure event handlers register before regular props) |
+| `setProp` | Set a single property on a node |
+| `use` | Invoke a `use:` directive on a node |
+
+## Documented Name-Collision Exception
+
+`@roku-sdk/solid` exposes a renderer runtime hook named `createComponent` that collides with the excluded `solid-js` internal of the same name. This is **not** a `solid-js` re-export — it is the SDK's own JSX-transform hook, wired at renderer initialization.
+
+If called before `makeSolidRenderer()` runs, `createComponent` throws:
+
+```
+@roku-sdk/solid internal hook "createComponent" was called before renderer initialization.
+Ensure makeSolidRenderer() runs via @roku-sdk/rsg-ts setUp() before rendering JSX.
+```
+
+## Unsupported Internal Symbols
+
+The following symbols are accessible via `export *` but are **not** part of the supported public API. They are implementation details that may be removed, renamed, or changed without notice in any release. Do not import them in application code.
+
+| Symbol | Source | Reason |
+|---|---|---|
+| `tmTransaction` | `solid.ts` | Internal transaction object — raw renderer plumbing |
+| `cleanUp` | `solid.ts` | Test-only utility that resets internal state |
+| `forgetAnchor` | `focus.ts` | Called by `@roku-sdk/ts-core` when an anchor node is removed, to drop focus state that points into its tree |
+| `MakeRenderer` | `solid.ts` | Internal factory interface used only by `makeRendererFactory` |

package/LICENSE

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

package/README.md

@@ -1,3 +1,23 @@
-# Temporary Holding Version
+# `@roku-sdk/solid`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+SolidJS for RSG SDK apps. It re-exports the parts of `solid-js` and `solid-js/store` that work with the SDK's SceneGraph renderer, together with the renderer hooks the JSX transform calls. Apps import every Solid primitive from this package and never from `solid-js` directly, so that the app and the SDK share one reactive runtime.
+
+## Install
+
+```sh
+pnpm add @roku-sdk/solid
+```
+
+## Usage
+
+```tsx
+import { createSignal, createStore, mergeProps } from "@roku-sdk/solid";
+```
+
+Some Solid features are left out on purpose, such as SSR hydration and lazy dynamic imports. [`EXPORTS.md`](EXPORTS.md) lists what is supported and what is excluded.
+
+## Documentation
+
+- [`EXPORTS.md`](EXPORTS.md) — the supported export list
+- [SolidJS idiosyncrasies on Roku](../../documentation/knowledge-base/solid-idiosyncrasies.md)
+- [Full SDK documentation](../../documentation/README.md)

package/eslint.config.mjs

@@ -0,0 +1,3 @@
+import rokuSdkToolsLinterConfig from "@roku-sdk/dev-tools/linter-config/eslint.config.mjs";
+
+export default rokuSdkToolsLinterConfig;

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@roku-sdk/solid",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "2.19.0",
+  "description": "Roku SceneGraph modules",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": {
+      "development": {
+        "import": "./src/index.dev.ts"
+      },
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./src/dom-node": "./src/dom-node.ts",
+    "./jsx-runtime": "./src/jsx-runtime.ts"
+  },
+  "files": [
+    "src/",
+    "dist/",
+    "eslint.config.mjs",
+    "tsconfig.json",
+    "README.md",
+    "EXPORTS.md"
+  ],
+  "engines": {
+    "npm": ">=8.5.0",
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "solid-js": "^1.9.17",
+    "@roku-sdk/common": "2.19.0",
+    "@roku-sdk/interfaces": "2.19.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@roku-sdk/dev-tools": "2.19.0"
+  },
+  "author": "Roku Inc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/rokudev/rsg-sdk.git",
+    "directory": "packages/solid"
+  },
+  "homepage": "https://gitlab.com/rokudev/rsg-sdk/-/tree/main/packages/solid#readme",
+  "bugs": {
+    "url": "https://gitlab.com/rokudev/rsg-sdk/-/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "type-check": "tsc --noEmit --project tsconfig.typecheck.json",
+    "test": "pnpm run type-check && jest --passWithNoTests",
+    "coverage": "jest --coverage --runInBand --passWithNoTests --testTimeout=60000 --forceExit",
+    "clean": "rm -rf dist",
+    "lint": "eslint --no-error-on-unmatched-pattern \"src/**/*.{ts,tsx,mjs,cjs,js}\""
+  }
 }

package/src/dev-wrappers.ts

@@ -0,0 +1,108 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+import {
+    type Accessor,
+    createEffect as _createEffect,
+    createMemo as _createMemo,
+    createSignal as _createSignal,
+    type EffectFunction,
+    type EffectOptions,
+    type MemoOptions,
+    type NoInfer,
+    type Signal,
+    type SignalOptions
+} from "solid-js";
+
+// `perfetto` was moved under the global `roku` namespace.
+declare const roku: {
+    perfetto: {
+        beginEvent: (label: string, args?: Record<string, string>) => void;
+        endEvent: () => void;
+        instantEvent: (label: string, args?: Record<string, string>) => void;
+    };
+};
+declare const HermesInternal: {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    getFunctionLocation: (fn: Function) => { lineNumber: number; columnNumber: number };
+    getCallStack: () => string;
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const perfScope = function (label: string, value: string | undefined, fn: () => any) {
+    try {
+        if (value) {
+            roku.perfetto?.beginEvent(label, { value: value ?? "" });
+        } else {
+            roku.perfetto?.beginEvent(label);
+        }
+        return fn();
+    } finally {
+        roku.perfetto?.endEvent();
+    }
+};
+
+export function createSignal<T>(): Signal<T | undefined>;
+export function createSignal<T>(value: T, options?: SignalOptions<T | undefined>): Signal<T>;
+export function createSignal<T>(value?: T, options?: SignalOptions<T>): Signal<T | undefined> {
+    const name = (options as { name?: string } | undefined)?.name ?? "unnamed";
+    const [get, set] = _createSignal(value as T, options as SignalOptions<T | undefined>);
+    const src = HermesInternal.getCallStack().split("\n")[2];
+
+    const wrappedGet: typeof get = () => {
+        return perfScope(`readSignal:${name}`, src, get);
+    };
+
+    const wrappedSet: typeof set = (...args) => {
+        return perfScope(`writeSignal:${name}`, src, () => set(...(args as Parameters<typeof set>)));
+    };
+
+    return [wrappedGet, wrappedSet] as Signal<T | undefined>;
+}
+
+export function createMemo<Next extends Prev, Prev = Next>(
+    fn: EffectFunction<Prev | Next, Next>,
+    value?: undefined,
+    options?: MemoOptions<Next>
+): Accessor<Next>;
+export function createMemo<Next extends Prev, Init = Next, Prev = Next>(
+    fn: EffectFunction<Init | Prev | Next, Next>,
+    value: Init,
+    options?: MemoOptions<Next>
+): Accessor<Next>;
+
+export function createMemo(
+    fn: EffectFunction<unknown, unknown>,
+    value?: unknown,
+    options?: MemoOptions<unknown>
+): Accessor<unknown> {
+    const name = options?.name ?? "";
+    const info = HermesInternal.getFunctionLocation(fn);
+
+    let resolvedStr: string | undefined;
+    const fnWrapper = (prev: unknown) => {
+        if (resolvedStr === undefined) {
+            resolvedStr = `${info.lineNumber}:${info.columnNumber}`;
+        }
+        return perfScope(`memo:${name}`, resolvedStr, () => fn(prev));
+    };
+    return _createMemo(fnWrapper, value, options);
+}
+
+export function createEffect<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
+export function createEffect<Next, Init = Next>(
+    fn: EffectFunction<Init | Next, Next>,
+    value: Init,
+    options?: EffectOptions
+): void;
+
+export function createEffect(fn: EffectFunction<unknown, unknown>, value?: unknown, options?: EffectOptions): void {
+    const name = (options as { name?: string } | undefined)?.name ?? "";
+    const info = HermesInternal.getFunctionLocation(fn);
+    let resolvedStr: string | undefined;
+    const fnWrapper = (prev: unknown) => {
+        if (resolvedStr === undefined) {
+            resolvedStr = `${info.lineNumber}:${info.columnNumber}`;
+        }
+        return perfScope(`effect:${name}`, resolvedStr, () => fn(prev));
+    };
+    _createEffect(fnWrapper, value, options);
+}

package/src/dom-node.ts

@@ -0,0 +1,150 @@
+// Copyright (c) 2026 Roku, Inc.
+// SPDX-License-Identifier: MIT
+
+import { DomNode, domNodeSymbol, TmNodeRef, TmValue } from "@roku-sdk/interfaces";
+
+type SetPropertyHandler = (node: DomNode, name: string, value: TmValue) => void;
+
+const defaultProto = { _s: domNodeSymbol };
+const tagProtoMap = new Map<string, object>();
+const imperativeMethodsRegistry = new Map<string, PropertyDescriptorMap>();
+let focusHandler: ((focusNode: DomNode) => void) | undefined;
+let blurHandler: ((blurNode: DomNode) => void) | undefined;
+let setPropertyHandler: SetPropertyHandler | undefined;
+
+function setPropertyValue(node: DomNode, name: string, value: TmValue) {
+    setPropertyHandler?.(node, name, value);
+}
+
+/**
+ * Creates a data PropertyDescriptor for an imperative method that sets a property on the node.
+ * The returned descriptor is always a non-writable, non-enumerable, non-configurable data descriptor.
+ *
+ * @param propName - The property name to set on the underlying SceneGraph node.
+ * @param fixedValue - If provided, the method takes no arguments and always sets this value.
+ *                     If omitted, the method takes one argument and sets it as the value.
+ * @returns A data PropertyDescriptor whose `value` is the imperative method function.
+ *
+ * @example
+ * // Zero-arg method: sets control = "play"
+ * setPropMethod("control", "play")
+ *
+ * // One-arg method: sets seek = <user-provided value>
+ * setPropMethod("seek")
+ */
+export function setPropMethod(propName: string, fixedValue?: TmValue): PropertyDescriptor {
+    if (fixedValue !== undefined) {
+        return {
+            value: function (this: DomNode) {
+                setPropertyValue(this, propName, fixedValue);
+            },
+            writable: false,
+            enumerable: false,
+            configurable: false
+        };
+    }
+    return {
+        value: function (this: DomNode, value: TmValue) {
+            setPropertyValue(this, propName, value);
+        },
+        writable: false,
+        enumerable: false,
+        configurable: false
+    };
+}
+
+/**
+ * Registers imperative methods for a given tag. Methods are attached to the node prototype
+ * when the first node of that tag is created.
+ *
+ * Must be called before any node of the given tag is created (i.e., at module load time
+ * in the component file that defines the tag). Late registration has no effect on
+ * already-created prototypes because `getOrCreatePrototype` caches in `tagProtoMap`.
+ */
+export function registerImperativeMethods(tag: string, methods: PropertyDescriptorMap): void {
+    if (imperativeMethodsRegistry.has(tag)) {
+        console.warn(`[solid] Duplicate imperative methods registration for tag "${tag}"`);
+    }
+    if (tagProtoMap.has(tag)) {
+        console.warn(
+            `[solid] Late imperative methods registration for tag "${tag}": nodes already created with this tag will not receive the new methods`
+        );
+    }
+    imperativeMethodsRegistry.set(tag, methods);
+}
+
+function addImperativeMethods(tag: string, proto: object): void {
+    const methods = imperativeMethodsRegistry.get(tag);
+    if (methods) {
+        Object.defineProperties(proto, methods);
+    }
+}
+
+export function createDomNode(tag: string, nodeRef: TmNodeRef): DomNode {
+    if (!tagProtoMap.has(tag)) {
+        const objByTag = Object.create(defaultProto, {
+            t: {
+                // Not storing interned string ref since this object is never sent to other domain.
+                // Hermes does intern all string literals.
+                // Do use tagRef if we use js engine that does not support string interning.
+                value: tag,
+                writable: false,
+                enumerable: true,
+                configurable: false
+            },
+            focus: {
+                value: function () {
+                    focusHandler?.(this);
+                },
+                writable: false,
+                enumerable: false,
+                configurable: false
+            },
+            blur: {
+                value: function () {
+                    blurHandler?.(this);
+                },
+                writable: false,
+                enumerable: false,
+                configurable: false
+            }
+        });
+
+        addImperativeMethods(tag, objByTag);
+
+        tagProtoMap.set(tag, objByTag);
+    }
+
+    const node: DomNode = Object.create(tagProtoMap.get(tag)!, {
+        r: {
+            value: nodeRef,
+            writable: false,
+            enumerable: true,
+            configurable: false
+        },
+        parent: {
+            value: undefined,
+            writable: true,
+            enumerable: false,
+            configurable: false
+        }
+    });
+
+    return node;
+}
+
+export function isDomNode(node: DomNode): node is DomNode {
+    return node?._s === domNodeSymbol;
+}
+
+export function setFocusHandler(handler: (focusNode: DomNode) => void): void {
+    focusHandler = handler;
+}
+
+export function setBlurHandler(handler: (blurNode: DomNode) => void): void {
+    blurHandler = handler;
+}
+
+export function setSetPropertyHandler(handler: SetPropertyHandler): void {
+    setPropertyHandler = handler;
+}