solid-tag-runtime 0.0.11 → 0.0.13

package/docs/html-runtime.md

@@ -0,0 +1,112 @@
+# HTML runtime and ownership
+
+`solid-tag-runtime/html` adapts the core module graph to browser DOM declarations. The core runtime itself does not scan or own DOM.
+
+## Create a controller
+
+```ts
+import { createHTMLRuntime } from "solid-tag-runtime/html";
+
+const html = createHTMLRuntime(runtime, {
+  scope: "main",
+  root: document,
+  acceptUnscoped: false,
+});
+```
+
+## Register existing declarations
+
+```ts
+await html.register();
+```
+
+## Observe later declarations
+
+```ts
+await html.observe({ registerExisting: false });
+
+// after external DOM mutations
+await html.flush();
+```
+
+## Script declarations
+
+```html
+<script
+  type="solid-jsx"
+  data-solid-runtime="main"
+  module="/ui/Button.jsx"
+>
+  export function Button(props) {
+    return <button>{props.children}</button>;
+  }
+</script>
+```
+
+Supported source types include `solid-jsx`, `solid-js`, and `solid-module` (plus `text/...` aliases).
+
+## `src` vs `module`
+
+```html
+<script
+  type="solid-jsx"
+  src="./source/Button.jsx"
+  module="/ui/Button.jsx"
+></script>
+```
+
+- `src` = where source is loaded from
+- `module` = identity in the runtime graph
+
+## Ownership
+
+A physical runtime script element has at most one HTML controller owner.
+
+```ts
+await html.registerElement(script);
+await html.append(script);
+await html.addModule({ id: "/dynamic.js", source, format: "js" });
+
+html.owns(script);
+html.getModuleId(script);
+html.getElement("/dynamic.js");
+```
+
+Ownership is claimed before asynchronous source loading or DOM insertion, preventing observer/manual-registration races.
+
+## Update and remove owned declarations
+
+```ts
+script.textContent = updatedSource;
+await html.updateElement(script);
+
+await html.removeElement(script);
+```
+
+Ordinary DOM removal does not implicitly delete a runtime module. The explicit controller APIs keep DOM ownership and runtime graph lifecycle synchronized.
+
+## Multiple runtimes
+
+```ts
+const main = createHTMLRuntime(mainRuntime, {
+  scope: "main",
+  acceptUnscoped: false,
+});
+
+const preview = createHTMLRuntime(previewRuntime, {
+  scope: "preview",
+  acceptUnscoped: false,
+});
+```
+
+`data-solid-runtime` is declarative routing metadata. In-memory ownership is authoritative.
+
+## Root lifecycle
+
+```ts
+await html.setRoot(nextRoot);
+await html.moveTo(nextRoot);
+html.setAppendTarget(document.head);
+```
+
+`root` controls discovery/observation; `appendTarget` controls where explicit additions are inserted. Reparenting the exact same root node does not require `setRoot()`.

package/docs/lifecycle-events.md

@@ -0,0 +1,77 @@
+# Lifecycle events
+
+Lifecycle subscriptions are observational. They cannot cancel compilation, change resolution, modify source, or stop rendering.
+
+## Core runtime
+
+Catch all events:
+
+```ts
+const leave = runtime.subscribe(event => {
+  console.log(event.type, event);
+});
+```
+
+One event type:
+
+```ts
+const leaveErrors = runtime.subscribe("module-error", event => {
+  console.error(event.phase, event.error);
+});
+```
+
+Several event types:
+
+```ts
+const leaveEvaluation = runtime.subscribe(
+  ["module-evaluating", "module-evaluated"],
+  event => console.log(event.type, event.id),
+);
+```
+
+Each call returns its own disposer.
+
+### Core event groups
+
+Definition/lifecycle:
+
+- `module-defined`
+- `module-updated`
+- `modules-defined`
+- `module-invalidated`
+- `module-removed`
+- `runtime-cleared`
+- `runtime-disposed`
+
+Resolution/link/evaluation:
+
+- `module-resolving`
+- `module-resolved`
+- `module-linking`
+- `module-linked`
+- `module-compiled`
+- `module-evaluating`
+- `module-evaluated`
+- `module-error`
+
+Compile-cache events:
+
+- `compile-cache-hit`
+- `compile-cache-miss`
+- `compile-cache-write`
+- `compile-cache-refresh`
+- `compile-cache-bypass`
+- `compile-cache-error`
+- `compile-cache-evict`
+
+## HTML runtime
+
+```ts
+html.subscribe("element-registered", event => {
+  console.log(event.moduleId);
+});
+```
+
+HTML events cover ownership, observation, roots, entry execution, render mounting/disposal, warnings, and errors.
+
+Listener exceptions are isolated from runtime/HTML operations and are reported to the console rather than aborting the underlying action.

package/docs/modules.md

@@ -0,0 +1,93 @@
+# Runtime modules and resolution
+
+The primary abstraction in `solid-tag-runtime` is a module. Components are ordinary module exports.
+
+## Source modules
+
+```ts
+runtime.define("/math.js", `export const answer = 42;`, {
+  format: "js",
+});
+```
+
+JSX is the default format:
+
+```ts
+runtime.define("/Greeting.jsx", `
+  export default function Greeting() {
+    return <p>Hello</p>;
+  }
+`);
+```
+
+## Host modules
+
+Expose existing JavaScript values by reference:
+
+```ts
+runtime.defineModule("@app/state", {
+  count,
+  setCount,
+});
+```
+
+Dynamic modules import those references normally:
+
+```tsx
+import { count, setCount } from "@app/state";
+```
+
+Host values are not serialized.
+
+## URL modules
+
+```ts
+runtime.defineUrl(
+  "some-library",
+  "https://example.test/library.js",
+);
+```
+
+## Resolution
+
+Resolution is runtime-local. The default rules are:
+
+1. custom `resolve()` callback
+2. exact registered ID
+3. absolute URL
+4. absolute virtual path
+5. relative virtual path
+6. unresolved bare native import when `allowNativeImports:true`
+7. otherwise `ModuleResolutionError`
+
+Virtual paths do not silently become network requests. Missing `/ui/Button.jsx` or `./Button.jsx` is a runtime-resolution error.
+
+```ts
+runtime.resolve("./Button.jsx", "/ui/App.jsx");
+// /ui/Button.jsx
+```
+
+## Batch definition
+
+```ts
+runtime.defineMany([
+  { id: "/dep.js", source: "export const value = 41;", format: "js" },
+  { id: "/main.js", source: 'import { value } from "./dep.js"; export const answer = value + 1;', format: "js" },
+]);
+```
+
+The complete batch is installed before buffered lifecycle events are published.
+
+## Updates and removal
+
+```ts
+runtime.update("/Button.jsx", newSource);
+runtime.remove("/Button.jsx");
+runtime.clear();
+```
+
+Updates/removals invalidate linked/evaluated dependents. Compiler artifacts follow the separate cache rules documented in [Persistent compile cache](./compile-cache.md).
+
+## Current cycle limitation
+
+Circular graphs between runtime-defined source modules are rejected. The current native-module URL backend requires final dependency URLs before an importing URL can be created.

package/docs/rendering.md

@@ -0,0 +1,65 @@
+# Declarative rendering
+
+A runtime script can define a module and mount one component instance.
+
+## Render into a selector
+
+```html
+<div id="app"></div>
+
+<script type="solid-jsx" module="/App.jsx" render="#app">
+  export default function App() {
+    return <h1>Hello</h1>;
+  }
+</script>
+```
+
+Without `component`, rendering selects `module.default`.
+
+## Named export
+
+```html
+<script
+  type="solid-jsx"
+  module="/widgets.jsx"
+  render="#app"
+  component="Counter"
+>
+  export function Counter() {
+    return <button>Counter</button>;
+  }
+</script>
+```
+
+## In-place rendering
+
+Bare `render` means mount at the exact declaration position:
+
+```html
+<p>Before</p>
+
+<script type="solid-jsx" module="/Message.jsx" render>
+  export default function Message() {
+    return <strong>Hello</strong>;
+  }
+</script>
+
+<p>After</p>
+```
+
+The adapter replaces the declaration with an owned marker range. No wrapper is introduced.
+
+## Registration ordering
+
+All matching declarations in a discovered batch are defined before any `entry` or `render` declaration executes. An importer may therefore appear before its dependency in document order.
+
+## `entry` vs `render`
+
+- `entry` = evaluate a module for side effects
+- `render` = evaluate a module because a component export must mount
+
+Combining `entry` and `render` on one declaration is rejected.
+
+## Runtime scope diagnostics
+
+A scoped render declaration is immediate work. If `data-solid-runtime="main"` cannot be handled by any registered controller covering that DOM root, the HTML adapter emits `html-warning` with code `unresolved-runtime-scope` and logs one warning.

package/docs/solid-render.md

@@ -0,0 +1,111 @@
+# `<solid-render>`
+
+`<solid-render>` references an already-defined runtime module and mounts a component instance into its own light DOM.
+
+```html
+<script type="solid-jsx" module="/Counter.jsx">
+  export default function Counter() {
+    return <button>Counter</button>;
+  }
+</script>
+
+<solid-render module="/Counter.jsx"></solid-render>
+```
+
+## Important HTML syntax rule
+
+**Always use an explicit closing tag in HTML.**
+
+Correct:
+
+```html
+<solid-render module="/Counter.jsx"></solid-render>
+```
+
+Do not write:
+
+```html
+<solid-render module="/Counter.jsx" />
+```
+
+Custom elements are not HTML void elements. The HTML parser ignores the XML-style self-closing slash, so following siblings may become children of `<solid-render>`. Because initial child content is captured as `props.children`, this can make later page content appear to disappear.
+
+## Named component
+
+```html
+<solid-render
+  module="/widgets.jsx"
+  component="Counter"
+></solid-render>
+```
+
+## Runtime selection
+
+```html
+<solid-render
+  data-solid-runtime="main"
+  module="/Counter.jsx"
+></solid-render>
+```
+
+The selected controller must match scope rules and contain the element within its configured root.
+
+## Declarative props
+
+```html
+<solid-render
+  module="/UserCard.jsx"
+  prop:name="Alice"
+  prop:user-id="42"
+  prop:compact
+></solid-render>
+```
+
+Rules:
+
+- `prop:user-id` becomes `userId`
+- a present empty prop becomes `true`
+- other attribute values remain strings
+- renderer configuration (`module`, `component`, `data-solid-runtime`) is not forwarded
+- `prop:module` is a normal component prop and does not collide with renderer `module`
+
+## Programmatic props
+
+```ts
+const element = document.querySelector("solid-render");
+
+element.props = {
+  user,
+  onSave,
+  service,
+};
+```
+
+Programmatic values may contain arbitrary JavaScript references and override declarative `prop:*` values.
+
+## Reactive updates
+
+Changing `prop:*` or `.props` updates the existing component instance without remounting.
+
+Changing `module`, `component`, or `data-solid-runtime` changes render identity and therefore disposes/remounts.
+
+## Children
+
+Initial child DOM becomes `props.children`:
+
+```html
+<solid-render module="/Card.jsx">
+  <p>Hello from HTML.</p>
+</solid-render>
+```
+
+Initial children are captured once. Named slots and dynamic child recapture are not part of the current API.
+
+## Multiple instances
+
+```html
+<solid-render module="/Counter.jsx"></solid-render>
+<solid-render module="/Counter.jsx"></solid-render>
+```
+
+The evaluated module namespace is shared, while each element owns an independent Solid component/root lifecycle.

package/examples/basic.js

@@ -0,0 +1,41 @@
+import { createRuntime } from "solid-tag-runtime";
+import * as Solid from "solid-js";
+import * as SolidWeb from "@solidjs/web";
+import html from "@solidjs/html";
+
+const runtime = createRuntime({
+  modules: {
+    "solid-js": Solid,
+    "@solidjs/web": SolidWeb,
+    "@solidjs/html": { default: html },
+  },
+});
+
+runtime.define(
+  "/Button.jsx",
+  `
+    export function Button(props) {
+      return <button onClick={props.onClick}>{props.children}</button>;
+    }
+  `,
+);
+
+runtime.define(
+  "/Counter.jsx",
+  `
+    import { createSignal } from "solid-js";
+    import { Button } from "./Button.jsx";
+
+    export function Counter() {
+      const [count, setCount] = createSignal(0);
+      return (
+        <Button onClick={() => setCount(value => value + 1)}>
+          Count: {count()}
+        </Button>
+      );
+    }
+  `,
+);
+
+const { Counter } = await runtime.import("/Counter.jsx");
+console.log(Counter);

package/examples/compile-cache.js

@@ -0,0 +1,35 @@
+import {
+  createRuntime,
+  createIndexedDBCompileCache,
+} from "solid-tag-runtime";
+
+const store = createIndexedDBCompileCache({
+  database: "my-app-runtime",
+});
+
+function createAppRuntime() {
+  return createRuntime({
+    compileCache: {
+      store,
+      namespace: "main",
+      version: "1",
+      maxEntries: 500,
+      maxBytes: 50 * 1024 * 1024,
+    },
+  });
+}
+
+// First runtime: compile miss + persistent write.
+const first = createAppRuntime();
+first.define("/config.js", `export const value = 42;`, { format: "js" });
+await first.import("/config.js");
+console.log("first", first.getModuleInfo("/config.js")?.compileCache);
+first.dispose();
+
+// New runtime, same source and cache namespace/version: compile hit.
+// Linking, module URL creation, and native evaluation are still fresh.
+const second = createAppRuntime();
+second.define("/config.js", `export const value = 42;`, { format: "js" });
+await second.import("/config.js");
+console.log("second", second.getModuleInfo("/config.js")?.compileCache);
+second.dispose();