solid-tag-runtime 0.0.3 → 0.0.5

package/ARCHITECTURE.md

@@ -197,7 +197,7 @@ This permits ordinary JavaScript and JSX modules to coexist in one graph.
 
 `solid-tag-runtime/html` is an opt-in browser-facing adapter over the core module runtime.
 
-`0.0.3` makes the adapter runtime-aware rather than treating document scripts as a single global pool.
+`0.0.3` made the adapter runtime-aware rather than treating document scripts as a single global pool.
 
 Important architectural boundary:
 
@@ -397,7 +397,7 @@ An entry may therefore import a dependency that appears later in the same discov
 
 `flush()` waits for queued observer work and scans again, providing a deterministic synchronization point after external DOM mutations.
 
-Observation in `0.0.3` 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.
+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
 
@@ -890,7 +890,7 @@ Reason: applications that dynamically insert runtime modules should not need to
 
 ### 2026-10-02 — Persistent HTML runtime controllers own DOM/module bindings
 
-Decision: `0.0.3` adds `createHTMLRuntime(runtime, options)` as the preferred advanced HTML API while keeping `registerHTML()`, `observeHTML()`, and `defineScript()` as compatibility conveniences.
+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.
 
@@ -912,3 +912,17 @@ Decision: scoped controllers stamp/use `data-solid-runtime="<scope>"` for discov
 
 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.
+### 0.0.5 — fresh module identity after invalidation
+
+Decision: every execution-backend `create(code)` call must produce a fresh native ESM module identity, even when the generated source text is byte-for-byte identical to an earlier version. The `data:` backend now appends a monotonically increasing fragment to each generated URL. This matches the naturally unique URLs returned by `URL.createObjectURL()` and prevents the browser/Node ESM cache from returning a previously evaluated module after `invalidate()`, `update()`, or `defineModule()` replacement.
+
+Reason: replacing a host namespace correctly invalidated its dependents in the runtime graph, but a deterministic `data:` URL could recreate the exact same URL for the host bridge and dependent source. Native ESM caches by URL, so the old evaluation was reused and dependents continued to observe stale host exports.
+
+Invariant: invalidation must result in a fresh executable module identity on the next compile/import. Cache invalidation is not complete if the execution backend can recreate an already-evaluated URL.
+
+Regression coverage: host-module replacement must update already-imported dependents, and explicit `runtime.invalidate()` must cause a side-effecting module to evaluate again on the next import.
+

package/README.md

@@ -113,7 +113,7 @@ import {
 await registerHTML(runtime);
 ```
 
-For applications that may have multiple runtimes or that create runtime scripts programmatically, `0.0.3` adds a persistent HTML runtime controller:
+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";
@@ -243,7 +243,7 @@ The observer is for DOM changes that happen **outside** the controller API. Pref
 
 All HTML controllers share an internal `WeakMap` of script element → ownership/registration record.
 
-That gives `0.0.3` these guarantees:
+That controller model gives these guarantees:
 
 - one script element has at most one HTML-runtime owner;
 - manual registration and observer registration cannot compile the same element twice;
@@ -272,7 +272,7 @@ solid-module                → infer from module/src extension
 
 ### Addition-only observation
 
-Observation remains addition-only in `0.0.3`.
+Observation remains addition-only in `0.0.5`.
 
 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.
 

package/html.d.ts

@@ -4,26 +4,26 @@ import type { ModuleFormat, ModuleNamespaceLike, SolidTagRuntime } from "./index
 export interface HTMLModuleScriptElement {
   textContent?: string | null;
   baseURI?: string;
-  ownerDocument?: HTMLDocumentLike;
+  ownerDocument?: HTMLDocumentLike | null;
   getAttribute(name: string): string | null;
   hasAttribute?(name: string): boolean;
   setAttribute?(name: string, value: string): void;
 }
 
 export interface HTMLAppendTarget {
-  append?(element: HTMLModuleScriptElement): void;
-  appendChild?(element: HTMLModuleScriptElement): unknown;
+  append?(...nodes: any[]): void;
+  appendChild?(element: any): unknown;
 }
 
 export interface HTMLDocumentLike extends HTMLModuleRoot, HTMLAppendTarget {
   body?: HTMLAppendTarget;
   documentElement?: HTMLAppendTarget;
-  createElement?(tagName: string): HTMLModuleScriptElement;
+  createElement?(tagName: string): any;
 }
 
 export interface HTMLModuleRoot {
   baseURI?: string;
-  ownerDocument?: HTMLDocumentLike;
+  ownerDocument?: HTMLDocumentLike | null;
   body?: HTMLAppendTarget;
   documentElement?: HTMLAppendTarget;
   querySelectorAll(selector: string): Iterable<HTMLModuleScriptElement> | ArrayLike<HTMLModuleScriptElement>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid-tag-runtime",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Runtime module system for JSX modules compiled with solid-tag and executed through @solidjs/html",
   "type": "module",
   "exports": {

package/src/url-backend.js

@@ -23,10 +23,17 @@ export function createBlobModuleUrlBackend() {
 }
 
 export function createDataModuleUrlBackend() {
+  let sequence = 0;
+
   return {
     kind: "data",
     create(code) {
-      return `data:text/javascript;charset=utf-8,${encodeURIComponent(code)}`;
+      // Native ESM caches modules by URL. Recreating the same data: URL after
+      // invalidation would otherwise return the previously evaluated module.
+      // Give every backend create() call a fresh module identity, matching the
+      // naturally unique identity of URL.createObjectURL() in the blob backend.
+      const identity = ++sequence;
+      return `data:text/javascript;charset=utf-8,${encodeURIComponent(code)}#solid-tag-runtime-${identity}`;
     },
     revoke() {},
   };