solid-tag-runtime 0.0.2 → 0.0.4

package/ARCHITECTURE.md

@@ -195,50 +195,209 @@ This permits ordinary JavaScript and JSX modules to coexist in one graph.
 
 ## 8. HTML/browser adapter
 
-`0.0.2` adds `solid-tag-runtime/html` as an opt-in browser-facing adapter.
+`solid-tag-runtime/html` is an opt-in browser-facing adapter over the core module runtime.
+
+`0.0.3` made the adapter runtime-aware rather than treating document scripts as a single global pool.
 
 Important architectural boundary:
 
 ```text
 DOM / HTML document
       ↓
-solid-tag-runtime/html
+HTML runtime controller
       ↓
 runtime.define(...)
       ↓
 core module graph
 ```
 
-The core runtime remains DOM-independent. It does not scan documents, fetch `<script>` elements, or know about HTML attributes.
+The core runtime remains DOM-independent. It does not scan documents, own HTML elements, run `MutationObserver`, or know about HTML attributes.
 
 ### Public HTML API
 
+The preferred API for non-trivial usage is a persistent controller:
+
+```ts
+const html = createHTMLRuntime(runtime, {
+  scope: "preview",
+  root: document,
+});
+
+await html.register();
+await html.observe({ registerExisting: false });
+```
+
+The controller exposes:
+
+```ts
+html.register(options?);
+html.observe(options?);
+html.flush(options?);
+html.disconnect();
+
+html.defineElement(element, options?);
+html.registerElement(element, options?);
+html.append(element, options?);
+html.addModule(options);
+
+html.owns(element);
+html.getModuleId(element);
+html.getElement(moduleId);
+```
+
+The original convenience functions remain supported and are implemented on top of a cached default controller for each runtime:
+
 ```ts
 await registerHTML(runtime, options?);
 await defineScript(runtime, element, options?);
 const observer = await observeHTML(runtime, options?);
 ```
 
-`registerHTML()` discovers matching script elements, defines the complete discovered graph, and only then executes modules marked `entry` unless `executeEntries: false` is supplied.
+This keeps the simple single-runtime API while giving multi-runtime applications an explicit ownership object.
+
+### Element ownership model
+
+A module-level `WeakMap` is the authoritative in-memory ownership registry for runtime script elements.
+
+Conceptually:
+
+```ts
+WeakMap<HTMLScriptElement, ElementRecord>
+```
+
+An element record stores at least:
+
+```text
+owner controller
+module ID
+format
+entry flag
+source URL
+registration state
+pending registration promise
+result/error
+```
+
+This registry is shared by all HTML runtime controllers created by this package instance.
+
+Important invariants:
+
+1. A runtime script element has at most one HTML-runtime owner.
+2. Ownership is claimed synchronously before asynchronous fetch/compile work.
+3. `append()` claims ownership before inserting the node into the DOM.
+4. Observer discovery, scans, explicit registration, and append/add helpers all use the same ownership record.
+5. Re-registering an element through the same controller is idempotent and waits on the same pending registration work.
+6. A different controller attempting to claim an owned element receives `HTMLModuleOwnershipError`.
+7. The observer must never redefine a module already being handled through `append()` or `registerElement()`.
+8. Distinct HTML elements cannot silently claim the same module ID in one HTML controller.
+9. Existing non-HTML runtime modules are not silently replaced by HTML registration.
+10. DOM removal does not implicitly delete a runtime module.
+
+A `WeakSet` alone is insufficient because the adapter needs to distinguish ownership, pending work, success, and failure. The shared `WeakMap` also avoids retaining detached elements after all external references disappear.
+
+### Controller scope and multiple runtimes
+
+A controller may declare a scope:
+
+```ts
+const previewHTML = createHTMLRuntime(previewRuntime, {
+  scope: "preview",
+});
+```
+
+Owned elements are marked declaratively:
+
+```html
+<script
+  type="solid-jsx"
+  data-solid-runtime="preview"
+  module="/App.jsx">
+</script>
+```
+
+`data-solid-runtime` is useful for declarative selection and DevTools visibility. It is not the authoritative ownership record; the `WeakMap` points to the actual controller object and prevents two controllers with the same string scope from owning the same element.
+
+A scoped controller accepts matching scripts. It may also claim unscoped scripts when `acceptUnscoped` is enabled (default `true`). Setting `acceptUnscoped: false` is recommended when multiple scoped runtimes observe the same DOM root.
+
+An unscoped controller does not silently claim a script carrying `data-solid-runtime` for another runtime.
+
+### User-created script elements
+
+Applications may create the element themselves and explicitly associate it with one runtime:
+
+```ts
+const script = document.createElement("script");
+script.type = "solid-jsx";
+script.setAttribute("module", "/Preview.jsx");
+script.textContent = source;
+
+await previewHTML.append(script);
+```
+
+`append()` performs this ordering:
 
-`observeHTML()` is the live-discovery adapter. It uses `MutationObserver` to discover scripts added after registration. Existing scripts are registered by default; `registerExisting: false` supports the pattern where `registerHTML()` already performed the initial scan.
+```text
+claim element
+    ↓
+stamp data-solid-runtime (when scoped)
+    ↓
+append to DOM
+    ↓
+load/define module directly
+    ↓
+observer later sees mutation and skips duplicate work
+```
 
-Every observer scan preserves the same graph invariant as `registerHTML()`: all newly discovered modules in that batch are defined before any newly discovered entry is executed. The observer tracks element identity so an already-seen element is not repeatedly redefined on unrelated DOM mutations.
+This is deliberately not implemented as “append and wait for MutationObserver”. Explicit APIs are deterministic even when observation is disabled.
 
-The returned controller exposes:
+For an element already in the DOM:
 
 ```ts
-observer.initial;
-observer.connected;
-await observer.flush();
-observer.disconnect();
+await previewHTML.registerElement(script);
 ```
 
-`flush()` waits for queued observer work and performs another scan, making it useful to synchronize application code with asynchronous `src` fetching and module evaluation. Background observer failures may be handled with `onError`.
+### Controller-created script elements
+
+`addModule()` creates and owns the script element for the caller:
 
-Observation in `0.0.2` is intentionally addition-only: changes to attributes/text of an already registered script and removal of that script do not implicitly update or remove its runtime module. Those semantics require explicit runtime updates today and may become a separate future feature.
+```ts
+await previewHTML.addModule({
+  id: "/dynamic/Greeting.jsx",
+  source: `
+    export function Greeting(props) {
+      return <p>Hello {props.name}</p>;
+    }
+  `,
+});
+```
 
-This ordering is an invariant: document order must not require dependencies to appear before entries.
+It uses the same claim-before-append pipeline as `append()`.
+
+### One-shot registration and live observation
+
+`register()` / `registerHTML()` perform one-shot discovery.
+
+`observe()` / `observeHTML()` use `MutationObserver` for newly added scripts. Existing scripts are registered by default; `registerExisting: false` supports the pattern where a one-shot registration already ran.
+
+Every discovered batch preserves the graph invariant:
+
+```text
+discover complete batch
+      ↓
+claim applicable elements
+      ↓
+load all source
+      ↓
+define all modules
+      ↓
+execute newly discovered entries
+```
+
+An entry may therefore import a dependency that appears later in the same discovery batch.
+
+`flush()` waits for queued observer work and scans again, providing a deterministic synchronization point after external DOM mutations.
+
+Observation remains addition-only: changing attributes/text of an already owned script or removing it does not implicitly update/remove the runtime module. Module replacement remains explicit through the core runtime update/invalidation APIs.
 
 ### Supported script declarations
 
@@ -278,9 +437,7 @@ Example:
 
 The source may move without changing imports of `/ui/Button.jsx`.
 
-If a `src` script omits `module`, its resolved source URL becomes the module ID. This allows multiple URL-backed source scripts to use normal relative imports.
-
-Inline non-entry scripts require an explicit `module` identity. Inline entries may omit it and receive an anonymous runtime ID.
+If a `src` script omits `module`, its resolved source URL becomes the module ID. Inline non-entry scripts require an explicit `module` identity. Inline entries may omit it and receive an anonymous runtime ID.
 
 ### Entry execution
 
@@ -290,13 +447,7 @@ Inline non-entry scripts require an explicit `module` identity. Inline entries m
 <script type="solid-jsx" module="/App.jsx" entry>...</script>
 ```
 
-After all discovered modules are defined, the adapter performs:
-
-```ts
-await runtime.import("/App.jsx");
-```
-
-The entry module is expected to perform whatever side effect starts the application, such as calling `render()`.
+After all newly discovered modules in the batch are defined, the adapter imports each entry unless `executeEntries: false` is supplied.
 
 ### Explicitly not HTML-as-JSX
 
@@ -737,3 +888,31 @@ Decision: add `observeHTML()` to the existing `solid-tag-runtime/html` subpath i
 
 Reason: applications that dynamically insert runtime modules should not need to manually rescan the document, while keeping DOM observation separate from the core runtime module engine. Addition-only semantics avoid silently redefining modules because of text/attribute churn or trying to infer deletion semantics before the runtime has an explicit module-removal API.
 
+### 2026-10-02 — Persistent HTML runtime controllers own DOM/module bindings
+
+Decision: `0.0.3` added `createHTMLRuntime(runtime, options)` as the preferred advanced HTML API while keeping `registerHTML()`, `observeHTML()`, and `defineScript()` as compatibility conveniences.
+
+Reason: once multiple runtimes, explicit append/register helpers, and observers coexist, ownership must be represented by a persistent object instead of implicit document-wide behavior.
+
+### 2026-10-02 — Runtime script ownership is coordinated through a shared WeakMap
+
+Decision: all HTML ingestion paths use one module-level `WeakMap` from script element to ownership/registration record. Per-controller module-ID maps supplement element ownership.
+
+Reason: a simple observer-local `WeakSet` cannot prevent races between manual registration and MutationObserver, distinguish different owners, retain a pending registration promise, or reject cross-runtime claims deterministically.
+
+### 2026-10-02 — Explicit append claims before DOM insertion
+
+Decision: `html.append(element)` and `html.addModule()` claim ownership before mutating the DOM and register directly rather than relying on the observer callback.
+
+Reason: ownership-before-insertion guarantees the observer can only observe already-owned work, eliminating duplicate compilation and making explicit APIs deterministic even when no observer is active.
+
+### 2026-10-02 — HTML runtime scope is declarative metadata, not ownership authority
+
+Decision: scoped controllers stamp/use `data-solid-runtime="<scope>"` for discovery and debugging, while the in-memory WeakMap remains authoritative.
+
+Reason: attributes are useful across declarative HTML and DevTools but cannot uniquely identify a controller instance or safely coordinate concurrent registration work.
+
+
+### 0.0.4 — typing/test/documentation hardening
+
+Decision: publish the next package as `0.0.4` because `0.0.3` has already been published. `0.0.4` preserves the `0.0.3` runtime/HTML semantics while shipping the DOM-compatible HTML adapter declaration fixes, broader regression coverage, and updated feature documentation. No module-resolution, ownership, execution-backend, or cache-invalidation semantics change in this release.

package/README.md

@@ -100,18 +100,48 @@ The runtime compiles and links the dependency graph automatically.
 
 ## Declarative HTML modules
 
-`0.0.2` adds a browser adapter at `solid-tag-runtime/html`. The core runtime remains DOM-independent; the HTML adapter only discovers source modules and feeds them into the same runtime module graph.
+`solid-tag-runtime/html` is the browser/DOM adapter. The core runtime remains DOM-independent.
+
+For simple single-runtime use, the original helpers remain available:
 
 ```ts
-import { registerHTML, observeHTML } from "solid-tag-runtime/html";
+import {
+  registerHTML,
+  observeHTML,
+} from "solid-tag-runtime/html";
 
 await registerHTML(runtime);
 ```
 
-The adapter recognizes runtime script modules such as:
+For applications that may have multiple runtimes or that create runtime scripts programmatically, `0.0.3` added a persistent HTML runtime controller:
+
+```ts
+import { createHTMLRuntime } from "solid-tag-runtime/html";
+
+const html = createHTMLRuntime(runtime, {
+  scope: "main",
+  root: document,
+});
+
+await html.register();
+await html.observe({ registerExisting: false });
+```
+
+A scope is written to owned script elements as:
+
+```html
+<script data-solid-runtime="main" ...></script>
+```
+
+When multiple runtimes observe the same document, give each one a unique scope and normally set `acceptUnscoped: false`.
+
+### Declarative modules
 
 ```html
-<script type="solid-jsx" module="/ui/Button.jsx">
+<script
+  type="solid-jsx"
+  data-solid-runtime="main"
+  module="/ui/Button.jsx">
   export function Button(props) {
     return (
       <button onClick={props.onClick}>
@@ -120,126 +150,133 @@ The adapter recognizes runtime script modules such as:
     );
   }
 </script>
+```
 
-<script type="solid-jsx" module="/App.jsx" entry>
-  import { render } from "@solidjs/web";
-  import { Button } from "./ui/Button.jsx";
-
-  function App() {
-    return <Button>Hello from runtime JSX</Button>;
-  }
+Runtime modules import one another normally:
 
-  render(() => <App />, document.getElementById("app"));
-</script>
+```tsx
+import { Button } from "./ui/Button.jsx";
 ```
 
-All matching scripts are **defined before any `entry` module is executed**. This means an entry may import a module that appears later in the HTML document.
+All newly discovered scripts in one batch are defined before any newly discovered `entry` module executes, so HTML document order does not require dependencies to appear first.
 
-External source is supported as well:
+### External source
 
 ```html
 <script
   type="solid-jsx"
+  data-solid-runtime="main"
   module="/ui/Button.jsx"
   src="./components/Button.jsx">
 </script>
-
-<script
-  type="solid-jsx"
-  module="/App.jsx"
-  src="./App.jsx"
-  entry>
-</script>
 ```
 
-`src` answers **where the source is fetched from** while `module` answers **what its identity is in the runtime graph**. They are intentionally separate.
+`src` answers **where source is loaded from**. `module` answers **what identity the source has in the runtime graph**.
 
-If `module` is omitted for a `src` script, the resolved source URL becomes the module ID. This makes relative imports between externally loaded modules work naturally. Inline non-entry scripts require a `module` attribute; an inline `entry` may omit it and receives an anonymous runtime module ID.
+### User-created script elements
 
-### HTML script formats
+If application code creates a script itself, use the controller to associate it with the correct runtime:
 
-Explicit script types:
+```ts
+const script = document.createElement("script");
+script.type = "solid-jsx";
+script.setAttribute("module", "/dynamic/Greeting.jsx");
+script.textContent = `
+  export function Greeting(props) {
+    return <p>Hello {props.name}</p>;
+  }
+`;
 
-```text
-solid-jsx / text/solid-jsx  → JSX transformation
-solid-js  / text/solid-js   → plain JavaScript module
-solid-module                → infer from module/src extension
+await html.append(script);
 ```
 
-For `solid-module`, `.js`/`.mjs` are treated as JavaScript and other extensions currently default to JSX. A `language="js"` or `language="jsx"` attribute can override inference.
+`append()` claims the element **before** inserting it in the DOM, stamps the controller scope, then registers it directly. If a `MutationObserver` is active, the later mutation callback sees that the element is already owned and does not compile it twice.
 
-### Register without executing entries
+For an element that is already in the DOM:
 
 ```ts
-const registration = await registerHTML(runtime, {
-  executeEntries: false,
-});
-
-console.log(registration.modules);
-console.log(registration.entries);
-
-await runtime.import(registration.entries[0]);
+await html.registerElement(script);
 ```
 
-### Register one script manually
+Same-controller repeated registration is idempotent. Trying to register an element already owned by another HTML controller throws `HTMLModuleOwnershipError`.
 
-```ts
-import { defineScript } from "solid-tag-runtime/html";
+### Let the controller create the script
 
-const definition = await defineScript(
-  runtime,
-  document.querySelector("#runtime-component"),
-);
-
-const namespace = await runtime.import(definition.id);
+```ts
+await html.addModule({
+  id: "/dynamic/Badge.jsx",
+  source: `
+    export function Badge(props) {
+      return <span>{props.children}</span>;
+    }
+  `,
+});
 ```
 
-### Observe scripts added later
+`addModule()` creates the `<script>` element, associates it with the controller, appends it, and registers it.
 
-`observeHTML()` uses `MutationObserver` to register runtime module scripts added after startup. It performs an initial scan by default and preserves the same batch invariant as `registerHTML()`: all newly discovered modules are defined before any newly discovered `entry` executes.
+### Observe scripts added by other code
 
 ```ts
-import { observeHTML } from "solid-tag-runtime/html";
-
-const observer = await observeHTML(runtime, {
+await html.observe({
+  registerExisting: false,
   onError(error) {
-    console.error("runtime module registration failed", error);
+    console.error(error);
   },
 });
 
-// Later, code may append a new runtime module script.
+// Some unrelated code mutates the DOM directly.
 const script = document.createElement("script");
 script.type = "solid-jsx";
-script.setAttribute("module", "/dynamic/Greeting.jsx");
-script.textContent = `
-  export function Greeting(props) {
-    return <p>Hello {props.name}</p>;
-  }
-`;
+script.setAttribute("data-solid-runtime", "main");
+script.setAttribute("module", "/observed/Thing.jsx");
+script.textContent = `export const value = 42;`;
 document.body.append(script);
 
-// Normally MutationObserver handles this automatically. flush() is useful when
-// code needs to wait until queued observation work has completed.
-await observer.flush();
+await html.flush();
+const module = await runtime.import("/observed/Thing.jsx");
+```
 
-const { Greeting } = await runtime.import("/dynamic/Greeting.jsx");
+The observer is for DOM changes that happen **outside** the controller API. Prefer `html.append()` / `html.addModule()` when your code controls insertion because those operations are deterministic and do not depend on observer timing.
 
-observer.disconnect();
-```
+### Ownership and deduplication
+
+All HTML controllers share an internal `WeakMap` of script element → ownership/registration record.
+
+That controller model gives these guarantees:
 
-If existing scripts were already registered separately, start observation without re-registering them:
+- one script element has at most one HTML-runtime owner;
+- manual registration and observer registration cannot compile the same element twice;
+- the same controller can register the same element repeatedly without redefining it;
+- two distinct elements cannot silently define the same HTML-owned module ID;
+- an HTML script cannot silently replace a module already defined outside that HTML controller;
+- `data-solid-runtime` is declarative metadata while the in-memory owner record is authoritative.
+
+The controller also exposes lightweight introspection:
 
 ```ts
-await registerHTML(runtime);
+html.owns(script);
+html.getModuleId(script);
+html.getElement("/dynamic/Greeting.jsx");
+```
 
-const observer = await observeHTML(runtime, {
-  registerExisting: false,
-});
+### Script formats
+
+```text
+solid-jsx / text/solid-jsx  → JSX transformation
+solid-js  / text/solid-js   → plain JavaScript module
+solid-module                → infer from module/src extension
 ```
 
-In `0.0.2`, observation is intentionally **addition-only**. Editing attributes/text of an already registered script or removing that script does not automatically update/remove the corresponding runtime module. Use `runtime.update()` / `runtime.invalidate()` explicitly when needed.
+`language="js"` or `language="jsx"` may override inference.
+
+### Addition-only observation
+
+Observation remains addition-only in `0.0.4`.
+
+Changing the source/attributes of an already owned script or removing it from the DOM does not implicitly update/delete the corresponding runtime module. Use `runtime.update()` / `runtime.invalidate()` for explicit module lifecycle changes.
 
-The HTML adapter does **not** reinterpret ordinary document HTML as JSX and does not currently add `<template>` component semantics. JSX remains source-code syntax inside runtime modules.
+The HTML adapter does **not** reinterpret arbitrary document HTML as JSX and does not currently assign component semantics to `<template>`.
 
 ## `toModule()`
 

package/html.d.ts

@@ -4,12 +4,28 @@ import type { ModuleFormat, ModuleNamespaceLike, SolidTagRuntime } from "./index
 export interface HTMLModuleScriptElement {
   textContent?: string | null;
   baseURI?: string;
+  ownerDocument?: HTMLDocumentLike | null;
   getAttribute(name: string): string | null;
   hasAttribute?(name: string): boolean;
+  setAttribute?(name: string, value: string): void;
+}
+
+export interface HTMLAppendTarget {
+  append?(...nodes: any[]): void;
+  appendChild?(element: any): unknown;
+}
+
+export interface HTMLDocumentLike extends HTMLModuleRoot, HTMLAppendTarget {
+  body?: HTMLAppendTarget;
+  documentElement?: HTMLAppendTarget;
+  createElement?(tagName: string): any;
 }
 
 export interface HTMLModuleRoot {
   baseURI?: string;
+  ownerDocument?: HTMLDocumentLike | null;
+  body?: HTMLAppendTarget;
+  documentElement?: HTMLAppendTarget;
   querySelectorAll(selector: string): Iterable<HTMLModuleScriptElement> | ArrayLike<HTMLModuleScriptElement>;
 }
 
@@ -44,6 +60,10 @@ export interface DefineScriptOptions {
   baseUrl?: string;
   format?: ModuleFormat | "javascript";
   fetch?: HTMLFetch;
+  /** Declarative ownership scope stored in data-solid-runtime. */
+  scope?: string;
+  /** Whether an HTML runtime may claim scripts without data-solid-runtime. Default: true. */
+  acceptUnscoped?: boolean;
 }
 
 export interface HTMLModuleDefinition {
@@ -80,22 +100,89 @@ export interface ObserveHTMLOptions extends RegisterHTMLOptions {
   onError?: (error: unknown) => void;
 }
 
-export interface HTMLObserverController {
-  /** Result of the initial scan. Empty when registerExisting is false. */
-  initial: RegisterHTMLResult;
+export interface AddHTMLModuleOptions extends DefineScriptOptions {
+  id?: string;
+  module?: string;
+  source?: string;
+  src?: string;
+  entry?: boolean;
+  type?: string;
+  language?: string;
+  executeEntries?: boolean;
+  appendTo?: HTMLAppendTarget;
+  document?: HTMLDocumentLike;
+  createElement?: (tagName: string) => HTMLModuleScriptElement;
+}
+
+export interface HTMLRuntimeOptions extends ObserveHTMLOptions {
+  appendTo?: HTMLAppendTarget;
+  createElement?: (tagName: string) => HTMLModuleScriptElement;
+}
+
+export interface HTMLRuntimeController {
+  readonly runtime: SolidTagRuntime;
+  readonly scope?: string;
   readonly connected: boolean;
-  /** Wait for queued observer work and synchronously scan for any unseen scripts. */
-  flush(): Promise<RegisterHTMLResult>;
+  /** Result of the observer's initial scan. */
+  readonly initial: RegisterHTMLResult;
+
+  /** One-shot scan of matching scripts under the configured/root override. */
+  register(options?: RegisterHTMLOptions): Promise<RegisterHTMLResult>;
+
+  /** Start live addition observation. Returns this controller. */
+  observe(options?: ObserveHTMLOptions): Promise<HTMLRuntimeController>;
+
+  /** Wait for queued observer work and scan for newly discoverable scripts. */
+  flush(options?: RegisterHTMLOptions): Promise<RegisterHTMLResult>;
   disconnect(): void;
+
+  /** Define one element without auto-running an entry. */
+  defineElement(
+    element: HTMLModuleScriptElement,
+    options?: DefineScriptOptions,
+  ): Promise<HTMLModuleDefinition>;
+
+  /** Explicitly claim/register an existing element for this runtime. */
+  registerElement(
+    element: HTMLModuleScriptElement,
+    options?: RegisterHTMLOptions,
+  ): Promise<HTMLModuleDefinition>;
+
+  /** Claim first, append a user-created element, then register it directly. */
+  append(
+    element: HTMLModuleScriptElement,
+    options?: RegisterHTMLOptions & { appendTo?: HTMLAppendTarget },
+  ): Promise<HTMLModuleDefinition>;
+
+  /** Create a runtime script element and add it through the controller. */
+  addModule(options: AddHTMLModuleOptions): Promise<HTMLModuleDefinition>;
+
+  owns(element: HTMLModuleScriptElement): boolean;
+  getModuleId(element: HTMLModuleScriptElement): string | undefined;
+  getElement(id: string): HTMLModuleScriptElement | undefined;
 }
 
+/** Legacy observer shape is now the full HTML runtime controller. */
+export type HTMLObserverController = HTMLRuntimeController;
+
 export declare class HTMLModuleError extends SolidTagRuntimeError {
   element?: HTMLModuleScriptElement;
   moduleId?: string;
   sourceUrl?: string;
 }
 
+export declare class HTMLModuleOwnershipError extends HTMLModuleError {
+  ownerScope?: string;
+  requestedScope?: string;
+}
+
 export declare const htmlModuleSelector: string;
+export declare const htmlRuntimeScopeAttribute: "data-solid-runtime";
+
+export declare function createHTMLRuntime(
+  runtime: SolidTagRuntime,
+  options?: HTMLRuntimeOptions,
+): HTMLRuntimeController;
 
 export declare function defineScript(
   runtime: SolidTagRuntime,