solid-tag-runtime 0.0.1 → 0.0.3

package/src/html.js

@@ -0,0 +1,832 @@
+import { SolidTagRuntimeError } from "./errors.js";
+
+const DEFAULT_SELECTOR = [
+  'script[type="solid-jsx"]',
+  'script[type="text/solid-jsx"]',
+  'script[type="solid-js"]',
+  'script[type="text/solid-js"]',
+  'script[type="solid-module"]',
+  'script[type="text/solid-module"]',
+].join(",");
+
+const RUNTIME_SCOPE_ATTRIBUTE = "data-solid-runtime";
+const elementOwners = new WeakMap();
+const defaultControllers = new WeakMap();
+let anonymousSequence = 0;
+let controllerSequence = 0;
+
+export class HTMLModuleError extends SolidTagRuntimeError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "HTMLModuleError";
+    this.element = options.element;
+    this.moduleId = options.moduleId;
+    this.sourceUrl = options.sourceUrl;
+  }
+}
+
+export class HTMLModuleOwnershipError extends HTMLModuleError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "HTMLModuleOwnershipError";
+    this.ownerScope = options.ownerScope;
+    this.requestedScope = options.requestedScope;
+  }
+}
+
+/**
+ * Create a persistent DOM/HTML adapter for one solid-tag-runtime instance.
+ *
+ * The controller owns DOM-to-module relationships. All ingestion paths
+ * (scan, observer, registerElement, append, addModule) converge on the same
+ * module-level WeakMap so an element can only be claimed once.
+ */
+export function createHTMLRuntime(runtime, options = {}) {
+  assertRuntime(runtime);
+
+  const controller = {
+    id: `solid-tag-html-${++controllerSequence}`,
+    runtime,
+    scope: normalizeScope(options.scope),
+    root: options.root,
+    selector: options.selector ?? DEFAULT_SELECTOR,
+    acceptUnscoped: options.acceptUnscoped !== false,
+    executeEntries: options.executeEntries !== false,
+    fetch: options.fetch,
+    baseUrl: options.baseUrl,
+    MutationObserver: options.MutationObserver,
+    subtree: options.subtree !== false,
+    createElement: options.createElement,
+    appendTo: options.appendTo,
+    bindings: new Map(),
+    observer: undefined,
+    observerRoot: undefined,
+    ignoredExisting: new WeakSet(),
+    queue: Promise.resolve(),
+    lastError: undefined,
+    connected: false,
+    initial: emptyRegistrationResult(),
+  };
+
+  const api = {
+    get runtime() {
+      return runtime;
+    },
+    get scope() {
+      return controller.scope;
+    },
+    get connected() {
+      return controller.connected;
+    },
+    get initial() {
+      return controller.initial;
+    },
+    register,
+    observe,
+    flush,
+    disconnect,
+    defineElement,
+    registerElement,
+    append,
+    addModule,
+    owns,
+    getModuleId,
+    getElement,
+  };
+
+  controller.api = api;
+  return api;
+
+  /** One-shot scan of matching scripts. */
+  async function register(callOptions = {}) {
+    const root = getRoot(mergeOptions(controller, callOptions), "HTML runtime register");
+    const selector = callOptions.selector ?? controller.selector;
+    const elements = Array.from(root.querySelectorAll(selector)).filter(element =>
+      acceptsDiscoveredElement(controller, element, callOptions),
+    );
+
+    return processElements(controller, elements, {
+      ...callOptions,
+      root,
+      origin: callOptions.origin ?? "initial-scan",
+      executeEntries: callOptions.executeEntries ?? controller.executeEntries,
+    });
+  }
+
+  /**
+   * Start MutationObserver-backed discovery. Existing matching scripts are
+   * registered by default. The controller itself is returned for chaining.
+   */
+  async function observe(callOptions = {}) {
+    if (controller.connected) return api;
+
+    const merged = mergeOptions(controller, callOptions);
+    const root = getRoot(merged, "HTML runtime observe");
+    const MutationObserverImpl = callOptions.MutationObserver ?? controller.MutationObserver ?? globalThis.MutationObserver;
+
+    if (typeof MutationObserverImpl !== "function") {
+      throw new TypeError(
+        "observe() requires MutationObserver support or a MutationObserver option.",
+      );
+    }
+
+    controller.observerRoot = root;
+    controller.connected = true;
+    controller.lastError = undefined;
+    controller.ignoredExisting = new WeakSet();
+
+    if (callOptions.registerExisting === false) {
+      for (const element of Array.from(root.querySelectorAll(callOptions.selector ?? controller.selector))) {
+        if (acceptsDiscoveredElement(controller, element, callOptions)) {
+          controller.ignoredExisting.add(element);
+        }
+      }
+      controller.initial = emptyRegistrationResult();
+    }
+
+    const observer = new MutationObserverImpl(() => {
+      void enqueueObserverScan(controller, callOptions).catch(() => {});
+    });
+
+    controller.observer = observer;
+    observer.observe(root, {
+      childList: true,
+      subtree: callOptions.subtree ?? controller.subtree,
+    });
+
+    try {
+      if (callOptions.registerExisting !== false) {
+        controller.initial = await enqueueObserverScan(controller, {
+          ...callOptions,
+          origin: "observer-initial",
+        });
+      }
+    } catch (error) {
+      disconnect();
+      throw error;
+    }
+
+    return api;
+  }
+
+  /** Wait for observer work, then synchronously scan for newly discoverable scripts. */
+  async function flush(callOptions = {}) {
+    await controller.queue;
+
+    if (controller.lastError) {
+      const error = controller.lastError;
+      controller.lastError = undefined;
+      throw error;
+    }
+
+    if (!controller.connected) return emptyRegistrationResult();
+    return enqueueObserverScan(controller, callOptions);
+  }
+
+  function disconnect() {
+    if (!controller.connected) return;
+    controller.connected = false;
+    controller.observer?.disconnect();
+    controller.observer = undefined;
+    controller.observerRoot = undefined;
+  }
+
+  /** Define one element without automatically executing an entry module. */
+  async function defineElement(element, callOptions = {}) {
+    const result = await processElements(controller, [element], {
+      ...callOptions,
+      origin: callOptions.origin ?? "define-element",
+      explicit: true,
+      executeEntries: false,
+    });
+    return result.modules[0] ?? definitionFromOwnedElement(controller, element);
+  }
+
+  /** Explicitly claim/register an element for this controller. */
+  async function registerElement(element, callOptions = {}) {
+    const result = await processElements(controller, [element], {
+      ...callOptions,
+      origin: callOptions.origin ?? "register-element",
+      explicit: true,
+      executeEntries: callOptions.executeEntries ?? controller.executeEntries,
+    });
+    return result.modules[0] ?? definitionFromOwnedElement(controller, element);
+  }
+
+  /**
+   * Claim a user-created script before DOM insertion, append it to this
+   * controller's target, then register it directly. The observer will see the
+   * mutation later but skip it because ownership was already established.
+   */
+  async function append(element, callOptions = {}) {
+    const claim = claimElement(controller, element, {
+      ...callOptions,
+      origin: callOptions.origin ?? "append",
+      explicit: true,
+    });
+
+    const target = getAppendTarget(controller, callOptions);
+    appendElement(target, element);
+
+    const result = await processClaims(controller, claim.fresh ? [claim.record] : [], {
+      ...callOptions,
+      origin: callOptions.origin ?? "append",
+      executeEntries: callOptions.executeEntries ?? controller.executeEntries,
+    });
+
+    if (!claim.fresh) await claim.record.promise;
+    return result.modules[0] ?? claim.record.definition;
+  }
+
+  /** Create a runtime script element and add it through append(). */
+  async function addModule(moduleOptions = {}) {
+    const format = normalizeFormat(moduleOptions.format ?? inferFormat({
+      explicitFormat: undefined,
+      language: moduleOptions.language,
+      type: moduleOptions.type,
+      moduleId: moduleOptions.id ?? moduleOptions.module,
+      sourceUrl: moduleOptions.src,
+    }));
+
+    const createElement = moduleOptions.createElement
+      ?? controller.createElement
+      ?? getDocumentForCreation(controller, moduleOptions)?.createElement?.bind(getDocumentForCreation(controller, moduleOptions));
+
+    if (typeof createElement !== "function") {
+      throw new TypeError(
+        "addModule() requires document.createElement(), a root ownerDocument, or a createElement option.",
+      );
+    }
+
+    const element = createElement("script");
+    if (!element || typeof element.setAttribute !== "function") {
+      throw new TypeError("addModule() createElement must return a script element-like object with setAttribute().");
+    }
+
+    const type = moduleOptions.type ?? (format === "js" ? "solid-js" : "solid-jsx");
+    element.setAttribute("type", type);
+
+    const id = nonEmpty(moduleOptions.id ?? moduleOptions.module);
+    if (id) element.setAttribute("module", id);
+    if (moduleOptions.src) element.setAttribute("src", String(moduleOptions.src));
+    if (moduleOptions.entry) element.setAttribute("entry", "");
+    if (moduleOptions.language) element.setAttribute("language", String(moduleOptions.language));
+    if (moduleOptions.source != null) element.textContent = String(moduleOptions.source);
+
+    const definition = await append(element, {
+      ...moduleOptions,
+      format,
+      origin: "add-module",
+    });
+
+    return {
+      ...definition,
+      element,
+    };
+  }
+
+  function owns(element) {
+    return elementOwners.get(element)?.owner === controller;
+  }
+
+  function getModuleId(element) {
+    const record = elementOwners.get(element);
+    return record?.owner === controller ? record.moduleId : undefined;
+  }
+
+  function getElement(id) {
+    const normalized = normalizeModuleId(runtime, id);
+    return controller.bindings.get(normalized)?.element;
+  }
+}
+
+/**
+ * Discover runtime module scripts under a Document/Element-like root, define
+ * all of them first, then optionally execute scripts marked with `entry`.
+ *
+ * Backwards-compatible convenience wrapper over the runtime's default HTML
+ * controller.
+ */
+export async function registerHTML(runtime, options = {}) {
+  return getDefaultController(runtime, options).register(options);
+}
+
+/** Backwards-compatible observer convenience wrapper. */
+export async function observeHTML(runtime, options = {}) {
+  const controller = getDefaultController(runtime, options);
+  await controller.observe(options);
+  return controller;
+}
+
+/** Define one <script> element as a runtime module without executing it. */
+export async function defineScript(runtime, element, options = {}) {
+  return getDefaultController(runtime, options).defineElement(element, options);
+}
+
+export const htmlModuleSelector = DEFAULT_SELECTOR;
+export const htmlRuntimeScopeAttribute = RUNTIME_SCOPE_ATTRIBUTE;
+
+async function enqueueObserverScan(controller, callOptions = {}) {
+  const task = controller.queue.then(async () => {
+    if (!controller.connected) return emptyRegistrationResult();
+
+    const root = controller.observerRoot ?? getRoot(mergeOptions(controller, callOptions), "HTML runtime observer");
+    const selector = callOptions.selector ?? controller.selector;
+    const elements = Array.from(root.querySelectorAll(selector)).filter(element => {
+      if (controller.ignoredExisting.has(element)) return false;
+      if (!acceptsDiscoveredElement(controller, element, callOptions)) return false;
+
+      const ownership = elementOwners.get(element);
+      if (!ownership) return true;
+      if (ownership.owner === controller) return false;
+
+      throw ownershipError(controller, element, ownership);
+    });
+
+    return processElements(controller, elements, {
+      ...callOptions,
+      root,
+      origin: callOptions.origin ?? "observer",
+      executeEntries: callOptions.executeEntries ?? controller.executeEntries,
+    });
+  });
+
+  controller.queue = task.then(
+    () => undefined,
+    error => {
+      controller.lastError = error;
+      if (typeof callOptions.onError === "function") {
+        callOptions.onError(error);
+      } else {
+        globalThis.console?.error?.("solid-tag-runtime/html observer error", error);
+      }
+    },
+  );
+
+  return task;
+}
+
+async function processElements(controller, elements, options = {}) {
+  const freshRecords = [];
+  const existingRecords = [];
+
+  // Claim the entire batch synchronously before any asynchronous source loading.
+  // This prevents observer/manual registration races and reserves module IDs.
+  for (const element of elements) {
+    if (!options.explicit && !acceptsDiscoveredElement(controller, element, options)) continue;
+
+    const claim = claimElement(controller, element, options);
+    if (claim.fresh) freshRecords.push(claim.record);
+    else existingRecords.push(claim.record);
+  }
+
+  const result = await processClaims(controller, freshRecords, options);
+
+  // Same-controller repeated registration is idempotent. Await currently pending
+  // registrations, but do not report/re-execute them as newly registered modules.
+  await Promise.all(existingRecords.map(record => record.promise));
+  return result;
+}
+
+async function processClaims(controller, records, options = {}) {
+  if (records.length === 0) return emptyRegistrationResult();
+
+  let prepared;
+  try {
+    prepared = await Promise.all(records.map(record => prepareRecordSource(controller, record, options)));
+  } catch (error) {
+    for (const record of records) rejectRecord(record, error);
+    throw error;
+  }
+
+  const modules = [];
+  try {
+    // Preserve the graph invariant: every module in this discovered batch is
+    // defined before any entry in the batch executes.
+    for (let index = 0; index < records.length; index++) {
+      const record = records[index];
+      const item = prepared[index];
+      controller.runtime.define(record.moduleId, item.source, { format: record.format });
+
+      record.state = "defined";
+      record.definition = definitionFromRecord(record);
+      record.resolve(record.definition);
+      modules.push(record.definition);
+    }
+  } catch (error) {
+    for (const record of records) {
+      if (record.state === "claimed" || record.state === "loading") rejectRecord(record, error);
+    }
+    throw error;
+  }
+
+  const entries = modules.filter(module => module.entry);
+  const executed = [];
+
+  if (options.executeEntries !== false) {
+    for (const entry of entries) {
+      const record = elementOwners.get(entry.element);
+      if (record) record.state = "executing";
+
+      try {
+        const namespace = await controller.runtime.import(entry.id);
+        if (record) record.state = "ready";
+        executed.push({ id: entry.id, namespace });
+      } catch (error) {
+        if (record) {
+          record.state = "error";
+          record.error = error;
+        }
+        throw error;
+      }
+    }
+  }
+
+  return {
+    modules,
+    entries: entries.map(entry => entry.id),
+    executed,
+  };
+}
+
+function claimElement(controller, element, options = {}) {
+  assertElement(element, options.origin ?? "HTML runtime");
+
+  const existing = elementOwners.get(element);
+  if (existing) {
+    if (existing.owner === controller) return { fresh: false, record: existing };
+    throw ownershipError(controller, element, existing);
+  }
+
+  assertExplicitScopeCompatibility(controller, element, options);
+  stampScope(controller, element, options);
+
+  const metadata = inspectElement(controller, element, options);
+  const moduleId = normalizeModuleId(controller.runtime, metadata.id);
+  const binding = controller.bindings.get(moduleId);
+
+  if (binding && binding.element !== element) {
+    throw new HTMLModuleError(
+      `HTML module ${JSON.stringify(moduleId)} is already bound to another script element in this HTML runtime.`,
+      { element, moduleId, sourceUrl: metadata.sourceUrl },
+    );
+  }
+
+  if (!binding && controller.runtime.has(moduleId)) {
+    throw new HTMLModuleError(
+      `Runtime module ${JSON.stringify(moduleId)} already exists and is not owned by this HTML runtime. Use runtime.update() for explicit replacement.`,
+      { element, moduleId, sourceUrl: metadata.sourceUrl },
+    );
+  }
+
+  let resolve;
+  let reject;
+  const promise = new Promise((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  // A failed background observer registration may not have a caller awaiting
+  // this per-element promise. Mark the rejection as observed while preserving
+  // the original promise for explicit callers.
+  void promise.catch(() => {});
+
+  const record = {
+    owner: controller,
+    element,
+    moduleId,
+    format: metadata.format,
+    entry: metadata.entry,
+    sourceUrl: metadata.sourceUrl,
+    inline: !metadata.sourceUrl,
+    state: "claimed",
+    origin: options.origin ?? "unknown",
+    promise,
+    resolve,
+    reject,
+    definition: undefined,
+    error: undefined,
+  };
+
+  elementOwners.set(element, record);
+  controller.bindings.set(moduleId, record);
+  return { fresh: true, record };
+}
+
+async function prepareRecordSource(controller, record, options) {
+  record.state = "loading";
+
+  let source;
+  if (record.sourceUrl) {
+    source = await fetchSource(
+      record.sourceUrl,
+      options.fetch ?? controller.fetch ?? globalThis.fetch,
+      record.element,
+      record.moduleId,
+    );
+  } else {
+    source = record.element.textContent ?? "";
+  }
+
+  return { source };
+}
+
+function inspectElement(controller, element, options = {}) {
+  const type = normalizeType(element.getAttribute("type"));
+  const entry = hasAttribute(element, "entry");
+  const srcAttribute = nonEmpty(element.getAttribute("src"));
+  const explicitId = nonEmpty(element.getAttribute("module"));
+  const baseUrl = options.baseUrl
+    ?? controller.baseUrl
+    ?? element.baseURI
+    ?? options.root?.baseURI
+    ?? controller.root?.baseURI;
+  const sourceUrl = srcAttribute ? resolveSourceUrl(srcAttribute, baseUrl) : undefined;
+
+  const format = inferFormat({
+    explicitFormat: options.format,
+    language: nonEmpty(element.getAttribute("language")),
+    type,
+    moduleId: explicitId,
+    sourceUrl,
+  });
+
+  const id = explicitId ?? sourceUrl ?? (entry ? createAnonymousId(format) : undefined);
+  if (!id) {
+    throw new HTMLModuleError(
+      "Inline solid runtime module scripts require a `module` attribute unless they are marked `entry`.",
+      { element },
+    );
+  }
+
+  return { id, format, entry, sourceUrl };
+}
+
+function definitionFromRecord(record) {
+  return {
+    id: record.moduleId,
+    format: record.format,
+    entry: record.entry,
+    sourceUrl: record.sourceUrl,
+    inline: record.inline,
+    element: record.element,
+  };
+}
+
+function definitionFromOwnedElement(controller, element) {
+  const record = elementOwners.get(element);
+  if (!record || record.owner !== controller) return undefined;
+  return record.definition ?? definitionFromRecord(record);
+}
+
+function rejectRecord(record, error) {
+  if (record.state === "error") return;
+  record.state = "error";
+  record.error = error;
+  record.reject(error);
+}
+
+function acceptsDiscoveredElement(controller, element, options = {}) {
+  const elementScope = nonEmpty(element?.getAttribute?.(RUNTIME_SCOPE_ATTRIBUTE));
+  const scope = normalizeScope(options.scope ?? controller.scope);
+  const acceptUnscoped = options.acceptUnscoped ?? controller.acceptUnscoped;
+
+  if (scope) {
+    if (elementScope) return elementScope === scope;
+    return acceptUnscoped !== false;
+  }
+
+  // An unscoped controller never silently steals a declaratively scoped script.
+  return !elementScope;
+}
+
+function assertExplicitScopeCompatibility(controller, element, options = {}) {
+  const requestedScope = normalizeScope(options.scope ?? controller.scope);
+  const elementScope = nonEmpty(element.getAttribute(RUNTIME_SCOPE_ATTRIBUTE));
+
+  if (elementScope && requestedScope !== elementScope) {
+    throw new HTMLModuleOwnershipError(
+      `Script is scoped to HTML runtime ${JSON.stringify(elementScope)} and cannot be claimed by ${JSON.stringify(requestedScope ?? "(unscoped)")}.`,
+      {
+        element,
+        ownerScope: elementScope,
+        requestedScope,
+      },
+    );
+  }
+}
+
+function stampScope(controller, element, options = {}) {
+  const scope = normalizeScope(options.scope ?? controller.scope);
+  if (!scope) return;
+  if (nonEmpty(element.getAttribute(RUNTIME_SCOPE_ATTRIBUTE))) return;
+
+  if (typeof element.setAttribute !== "function") {
+    throw new TypeError(
+      `Scoped HTML runtimes require script elements with setAttribute() so ${RUNTIME_SCOPE_ATTRIBUTE} can be recorded.`,
+    );
+  }
+
+  element.setAttribute(RUNTIME_SCOPE_ATTRIBUTE, scope);
+}
+
+function ownershipError(controller, element, ownership) {
+  return new HTMLModuleOwnershipError(
+    `Runtime script element is already owned by HTML runtime ${JSON.stringify(ownership.owner.scope ?? ownership.owner.id)} and cannot be claimed by ${JSON.stringify(controller.scope ?? controller.id)}.`,
+    {
+      element,
+      moduleId: ownership.moduleId,
+      sourceUrl: ownership.sourceUrl,
+      ownerScope: ownership.owner.scope,
+      requestedScope: controller.scope,
+    },
+  );
+}
+
+function getDefaultController(runtime, options = {}) {
+  assertRuntime(runtime);
+  let controller = defaultControllers.get(runtime);
+  if (!controller) {
+    controller = createHTMLRuntime(runtime, {
+      root: options.root,
+      selector: options.selector,
+      executeEntries: options.executeEntries,
+      fetch: options.fetch,
+      baseUrl: options.baseUrl,
+      MutationObserver: options.MutationObserver,
+      subtree: options.subtree,
+      createElement: options.createElement,
+      appendTo: options.appendTo,
+      scope: options.scope,
+      acceptUnscoped: options.acceptUnscoped,
+    });
+    defaultControllers.set(runtime, controller);
+  }
+  return controller;
+}
+
+function getAppendTarget(controller, options = {}) {
+  const explicit = options.appendTo ?? controller.appendTo;
+  if (explicit) return explicit;
+
+  const root = options.root ?? controller.root ?? globalThis.document;
+  if (root?.body) return root.body;
+  if (root?.documentElement && root.documentElement !== root) return root.documentElement;
+  return root;
+}
+
+function appendElement(target, element) {
+  if (target && typeof target.append === "function") {
+    target.append(element);
+    return;
+  }
+  if (target && typeof target.appendChild === "function") {
+    target.appendChild(element);
+    return;
+  }
+  throw new TypeError("append() requires an append target with append() or appendChild().");
+}
+
+function getDocumentForCreation(controller, options = {}) {
+  return options.document
+    ?? controller.root?.ownerDocument
+    ?? controller.root
+    ?? globalThis.document;
+}
+
+function mergeOptions(controller, options) {
+  return {
+    root: options.root ?? controller.root,
+    selector: options.selector ?? controller.selector,
+    executeEntries: options.executeEntries ?? controller.executeEntries,
+    fetch: options.fetch ?? controller.fetch,
+    baseUrl: options.baseUrl ?? controller.baseUrl,
+    MutationObserver: options.MutationObserver ?? controller.MutationObserver,
+    subtree: options.subtree ?? controller.subtree,
+    scope: options.scope ?? controller.scope,
+    acceptUnscoped: options.acceptUnscoped ?? controller.acceptUnscoped,
+  };
+}
+
+function emptyRegistrationResult() {
+  return {
+    modules: [],
+    entries: [],
+    executed: [],
+  };
+}
+
+function getRoot(options, caller) {
+  const root = options.root ?? globalThis.document;
+  if (!root || typeof root.querySelectorAll !== "function") {
+    throw new TypeError(`${caller} requires a DOM root with querySelectorAll().`);
+  }
+  return root;
+}
+
+function assertRuntime(runtime) {
+  if (!runtime || typeof runtime.define !== "function" || typeof runtime.import !== "function") {
+    throw new TypeError("Expected a solid-tag-runtime instance.");
+  }
+}
+
+function assertElement(element, caller) {
+  if (!element || typeof element.getAttribute !== "function") {
+    throw new TypeError(`${caller} expects a script element-like object.`);
+  }
+}
+
+function normalizeScope(value) {
+  return nonEmpty(value);
+}
+
+function normalizeModuleId(runtime, id) {
+  return runtime.resolve(String(id));
+}
+
+function normalizeType(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+
+function inferFormat({ explicitFormat, language, type, moduleId, sourceUrl }) {
+  if (explicitFormat != null) return normalizeFormat(explicitFormat);
+  if (language != null) return normalizeFormat(language);
+
+  if (type === "solid-js" || type === "text/solid-js") return "js";
+  if (type === "solid-jsx" || type === "text/solid-jsx") return "jsx";
+
+  const target = moduleId ?? sourceUrl ?? "";
+  const pathname = stripQueryAndHash(target).toLowerCase();
+  if (pathname.endsWith(".js") || pathname.endsWith(".mjs")) return "js";
+  return "jsx";
+}
+
+function normalizeFormat(value) {
+  const format = String(value).trim().toLowerCase();
+  if (format === "js" || format === "javascript") return "js";
+  if (format === "jsx") return "jsx";
+  throw new HTMLModuleError(`Unsupported HTML runtime module format ${JSON.stringify(value)}.`);
+}
+
+async function fetchSource(url, fetchImpl, element, moduleId) {
+  if (typeof fetchImpl !== "function") {
+    throw new HTMLModuleError(
+      `Cannot load ${JSON.stringify(url)} because no fetch implementation is available.`,
+      { element, moduleId, sourceUrl: url },
+    );
+  }
+
+  let response;
+  try {
+    response = await fetchImpl(url);
+  } catch (cause) {
+    throw new HTMLModuleError(
+      `Failed to fetch runtime module ${JSON.stringify(url)}.`,
+      { cause, element, moduleId, sourceUrl: url },
+    );
+  }
+
+  if (!response || response.ok === false) {
+    const status = response?.status ? ` (${response.status}${response.statusText ? ` ${response.statusText}` : ""})` : "";
+    throw new HTMLModuleError(
+      `Failed to fetch runtime module ${JSON.stringify(url)}${status}.`,
+      { element, moduleId, sourceUrl: url },
+    );
+  }
+
+  try {
+    return await response.text();
+  } catch (cause) {
+    throw new HTMLModuleError(
+      `Failed to read runtime module ${JSON.stringify(url)} as text.`,
+      { cause, element, moduleId, sourceUrl: url },
+    );
+  }
+}
+
+function resolveSourceUrl(src, baseUrl) {
+  try {
+    if (baseUrl) return new URL(src, baseUrl).href;
+    return new URL(src).href;
+  } catch {
+    return src;
+  }
+}
+
+function createAnonymousId(format) {
+  const extension = format === "js" ? "js" : "jsx";
+  return `/__solid_tag_runtime__/html-entry-${++anonymousSequence}.${extension}`;
+}
+
+function stripQueryAndHash(value) {
+  return String(value).split(/[?#]/, 1)[0];
+}
+
+function nonEmpty(value) {
+  const text = String(value ?? "").trim();
+  return text || undefined;
+}
+
+function hasAttribute(element, name) {
+  if (typeof element.hasAttribute === "function") return element.hasAttribute(name);
+  return element.getAttribute(name) != null;
+}