@async/framework 0.5.0 → 0.6.0

package/framework.umd.js

@@ -0,0 +1,4158 @@
+// Generated by scripts/build-framework-bundle.js. Do not edit by hand.
+// Bundled UMD entry for script-tag and CommonJS-style consumers.
+(function (root, factory) {
+  const namespace = factory();
+  if (typeof define === "function" && define.amd) {
+    define([], function () { return namespace; });
+  } else if (typeof module === "object" && module.exports) {
+    module.exports = namespace;
+  } else {
+    root.AsyncFramework = namespace;
+    root.Async = namespace;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function () {
+  "use strict";
+  const __asyncSignalModule = (() => {
+    const asyncSignalKind = Symbol.for("@async/framework.asyncSignal");
+
+    function asyncSignal(id, fn) {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new TypeError("asyncSignal(id, fn) requires a non-empty string id.");
+      }
+      if (typeof fn !== "function") {
+        throw new TypeError("asyncSignal(id, fn) requires a function.");
+      }
+
+      let value;
+      let loading = false;
+      let error = null;
+      let status = "idle";
+      let version = 0;
+      let registry;
+      let registeredId = id;
+      let activeController;
+      let activeAbort;
+      const subscribers = new Set();
+      const dependencyCleanups = new Set();
+
+      const state = {
+        [asyncSignalKind]: true,
+        kind: "async-signal",
+
+        get id() {
+          return registeredId;
+        },
+
+        get value() {
+          return value;
+        },
+
+        get loading() {
+          return loading;
+        },
+
+        get error() {
+          return error;
+        },
+
+        get status() {
+          return status;
+        },
+
+        get version() {
+          return version;
+        },
+
+        set(nextValue) {
+          value = nextValue;
+          loading = false;
+          error = null;
+          status = "ready";
+          notify();
+          return value;
+        },
+
+        refresh() {
+          if (!registry) {
+            throw new Error(`Async signal "${registeredId}" is not registered.`);
+          }
+
+          if (activeAbort && !activeAbort.aborted) {
+            activeAbort.cancel(new Error(`Async signal "${registeredId}" refreshed.`));
+          }
+
+          const runVersion = version + 1;
+          version = runVersion;
+          loading = true;
+          error = null;
+          status = "loading";
+
+          const controller = new AbortController();
+          activeController = controller;
+          activeAbort = controller.signal;
+          attachCancel(activeAbort, controller);
+          notify();
+
+          const context = {
+            signals: registry,
+            id: registeredId,
+            get server() {
+              const context = registry._context?.() ?? {};
+              const server = context.server;
+              if (typeof server?._withContext === "function") {
+                return server._withContext({
+                  signals: registry,
+                  router: context.router,
+                  loader: context.loader,
+                  cache: context.cache,
+                  abort: activeAbort
+                });
+              }
+              return server;
+            },
+            get router() {
+              return registry._context?.().router;
+            },
+            get loader() {
+              return registry._context?.().loader;
+            },
+            get cache() {
+              return registry._context?.().cache;
+            },
+            get version() {
+              return runVersion;
+            },
+            get abort() {
+              return activeAbort;
+            },
+            refresh() {
+              return state.refresh();
+            }
+          };
+
+          let outcome;
+          try {
+            outcome = registry._collectDependencies(() => fn.call(context));
+          } catch (cause) {
+            finishError(runVersion, cause);
+            return Promise.reject(cause);
+          }
+
+          syncDependencies(outcome.dependencies);
+
+          return Promise.resolve(outcome.value).then(
+            (nextValue) => {
+              if (!isCurrent(runVersion)) {
+                return value;
+              }
+              value = nextValue;
+              loading = false;
+              error = null;
+              status = "ready";
+              notify();
+              return value;
+            },
+            (cause) => {
+              if (!isCurrent(runVersion)) {
+                return value;
+              }
+              if (activeAbort?.aborted) {
+                loading = false;
+                status = value === undefined ? "idle" : "ready";
+                notify();
+                return value;
+              }
+              finishError(runVersion, cause);
+              return value;
+            }
+          );
+        },
+
+        cancel(reason) {
+          if (activeAbort && !activeAbort.aborted) {
+            activeAbort.cancel(reason);
+          }
+        },
+
+        subscribe(fn) {
+          if (typeof fn !== "function") {
+            throw new TypeError("subscribe(fn) requires a function.");
+          }
+          subscribers.add(fn);
+          return () => subscribers.delete(fn);
+        },
+
+        snapshot() {
+          return {
+            value,
+            loading,
+            error,
+            status,
+            version
+          };
+        },
+
+        _bindRegistry(nextRegistry, nextId) {
+          registry = nextRegistry;
+          registeredId = nextId;
+          queueMicrotask(() => {
+            if (registry === nextRegistry && status === "idle") {
+              state.refresh();
+            }
+          });
+        },
+
+        _dispose() {
+          state.cancel(new Error(`Async signal "${registeredId}" disposed.`));
+          for (const cleanup of dependencyCleanups) {
+            cleanup();
+          }
+          dependencyCleanups.clear();
+          subscribers.clear();
+        }
+      };
+
+      function finishError(runVersion, cause) {
+        if (!isCurrent(runVersion)) {
+          return;
+        }
+        loading = false;
+        error = cause;
+        status = "error";
+        notify();
+      }
+
+      function isCurrent(runVersion) {
+        return runVersion === version && activeController?.signal === activeAbort;
+      }
+
+      function syncDependencies(dependencies) {
+        for (const cleanup of dependencyCleanups) {
+          cleanup();
+        }
+        dependencyCleanups.clear();
+
+        for (const dependency of dependencies) {
+          const dependencyId = String(dependency).split(".")[0];
+          if (dependencyId && dependencyId !== registeredId) {
+            dependencyCleanups.add(registry.subscribe(dependency, () => state.refresh()));
+          }
+        }
+      }
+
+      function notify() {
+        for (const subscriber of [...subscribers]) {
+          subscriber(state);
+        }
+      }
+
+      return state;
+    }
+
+    function isAsyncSignal(value) {
+      return Boolean(value?.[asyncSignalKind]);
+    }
+
+    function attachCancel(signal, controller) {
+      Object.defineProperty(signal, "cancel", {
+        configurable: true,
+        enumerable: false,
+        value(reason) {
+          controller.abort(reason);
+        }
+      });
+    }
+    return { asyncSignal, isAsyncSignal };
+  })();
+
+  const __registryStoreModule = (() => {
+    const declarationTypes = new Set(["signal", "handler", "server", "partial", "route", "component"]);
+    const cacheTypes = new Set(["cache.browser", "cache.server"]);
+    const cacheEntryTypes = new Set(["cache.browser.entries", "cache.server.entries"]);
+    const allTypes = new Set([...declarationTypes, ...cacheTypes, ...cacheEntryTypes]);
+
+    function createRegistryStore(initial = {}, options = {}) {
+      const backing = options.backing ?? createBacking();
+      const target = options.target ?? "server";
+
+      const registry = {
+        target,
+
+        register(type, id, value) {
+          const map = registry._map(type);
+          assertId(type, id);
+          if (map.has(id)) {
+            throw new Error(`${type} "${id}" is already registered.`);
+          }
+          map.set(id, value);
+          return id;
+        },
+
+        registerMany(type, map = {}) {
+          for (const [id, value] of Object.entries(map ?? {})) {
+            registry.register(type, id, value);
+          }
+          return registry;
+        },
+
+        set(type, id, value) {
+          const map = registry._map(type);
+          assertId(type, id);
+          map.set(id, value);
+          return value;
+        },
+
+        unregister(type, id) {
+          return registry.delete(type, id);
+        },
+
+        delete(type, id) {
+          return registry._map(type).delete(id);
+        },
+
+        keys(type) {
+          if (isHiddenInBrowser(type, target)) {
+            return [];
+          }
+          return [...registry._map(type).keys()];
+        },
+
+        entries(type, entryOptions = {}) {
+          const normalized = normalizeType(type);
+          if (isHiddenInBrowser(normalized, entryOptions.target ?? target)) {
+            return [];
+          }
+          return [...registry._map(normalized)].map(([id, value]) => [
+            id,
+            publicValue(normalized, id, value, { target, ...entryOptions })
+          ]);
+        },
+
+        has(type, id) {
+          assertId(type, id);
+          if (isHiddenInBrowser(type, target)) {
+            return false;
+          }
+          return registry._map(type).has(id);
+        },
+
+        get(type, id, getOptions = {}) {
+          assertId(type, id);
+          const normalized = normalizeType(type);
+          if (isHiddenInBrowser(normalized, getOptions.target ?? target)) {
+            return undefined;
+          }
+          const value = registry._map(normalized).get(id);
+          if (value === undefined) {
+            return undefined;
+          }
+          return publicValue(normalized, id, value, { target, ...getOptions });
+        },
+
+        snapshot(snapshotOptions = {}) {
+          const snapshotTarget = snapshotOptions.target ?? target;
+          return {
+            signal: snapshotSignals(backing.signal),
+            handler: snapshotDescriptors(backing.handler, "handler"),
+            server: snapshotDescriptors(backing.server, "server"),
+            partial: snapshotDescriptors(backing.partial, "partial"),
+            route: snapshotPlain(backing.route),
+            component: snapshotDescriptors(backing.component, "component"),
+            cache: {
+              browser: snapshotPlain(backing.cache.browser),
+              server: snapshotPlain(backing.cache.server)
+            },
+            entries: {
+              browser: snapshotCacheEntries(backing.cacheEntries.browser),
+              server: snapshotTarget === "browser" ? {} : snapshotCacheEntries(backing.cacheEntries.server)
+            }
+          };
+        },
+
+        rawSnapshot() {
+          return {
+            signal: Object.fromEntries(backing.signal),
+            handler: Object.fromEntries(backing.handler),
+            server: Object.fromEntries(backing.server),
+            partial: Object.fromEntries(backing.partial),
+            route: Object.fromEntries(backing.route),
+            component: Object.fromEntries(backing.component),
+            cache: {
+              browser: Object.fromEntries(backing.cache.browser),
+              server: Object.fromEntries(backing.cache.server)
+            }
+          };
+        },
+
+        view(viewOptions = {}) {
+          return createRegistryStore(undefined, {
+            backing,
+            target: viewOptions.target ?? target
+          });
+        },
+
+        _map(type) {
+          const normalized = normalizeType(type);
+          if (declarationTypes.has(normalized)) {
+            return backing[normalized];
+          }
+          if (normalized === "cache.browser") {
+            return backing.cache.browser;
+          }
+          if (normalized === "cache.server") {
+            return backing.cache.server;
+          }
+          if (normalized === "cache.browser.entries") {
+            return backing.cacheEntries.browser;
+          }
+          if (normalized === "cache.server.entries") {
+            return backing.cacheEntries.server;
+          }
+          throw new Error(`Unknown Async registry type "${type}".`);
+        }
+      };
+
+      applyInitial(registry, initial);
+      return registry;
+    }
+
+    function attachRegistryInspection(target, registry, type) {
+      Object.defineProperty(target, "registry", {
+        configurable: true,
+        enumerable: true,
+        value: registry
+      });
+      target.keys = () => registry.keys(type);
+      target.entries = () => registry.entries(type);
+      target.inspect = () => registry.entries(type);
+      return target;
+    }
+
+    function createBacking() {
+      return {
+        signal: new Map(),
+        handler: new Map(),
+        server: new Map(),
+        partial: new Map(),
+        route: new Map(),
+        component: new Map(),
+        cache: {
+          browser: new Map(),
+          server: new Map()
+        },
+        cacheEntries: {
+          browser: new Map(),
+          server: new Map()
+        }
+      };
+    }
+
+    function applyInitial(registry, initial = {}) {
+      registry.registerMany("signal", initial.signal);
+      registry.registerMany("handler", initial.handler);
+      registry.registerMany("server", initial.server);
+      registry.registerMany("partial", initial.partial);
+      registry.registerMany("route", initial.route);
+      registry.registerMany("component", initial.component);
+      registry.registerMany("cache.browser", initial.cache?.browser);
+      registry.registerMany("cache.server", initial.cache?.server);
+
+      const entries = initial.entries ?? {};
+      for (const [key, value] of Object.entries(entries.browser ?? {})) {
+        registry.set("cache.browser.entries", key, cacheEntry(value));
+      }
+      for (const [key, value] of Object.entries(entries.server ?? {})) {
+        registry.set("cache.server.entries", key, cacheEntry(value));
+      }
+    }
+
+    function normalizeType(type) {
+      if (!allTypes.has(type)) {
+        throw new Error(`Unknown Async registry type "${type}".`);
+      }
+      return type;
+    }
+
+    function assertId(type, id) {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new TypeError(`${type} id must be a non-empty string.`);
+      }
+    }
+
+    function publicValue(type, id, value, options) {
+      if (type === "server" && options.target === "browser") {
+        return { id, kind: "server" };
+      }
+      if (cacheEntryTypes.has(type)) {
+        return value?.value;
+      }
+      return value;
+    }
+
+    function isHiddenInBrowser(type, target) {
+      return type === "cache.server.entries" && target === "browser";
+    }
+
+    function snapshotSignals(map) {
+      const snapshot = {};
+      for (const [id, entry] of map) {
+        snapshot[id] = typeof entry?.snapshot === "function" ? entry.snapshot() : entry?.value ?? entry;
+      }
+      return snapshot;
+    }
+
+    function snapshotDescriptors(map, kind) {
+      const snapshot = {};
+      for (const id of map.keys()) {
+        snapshot[id] = { id, kind };
+      }
+      return snapshot;
+    }
+
+    function snapshotPlain(map) {
+      return Object.fromEntries(map);
+    }
+
+    function snapshotCacheEntries(map) {
+      const snapshot = {};
+      for (const [id, entry] of map) {
+        snapshot[id] = entry?.value;
+      }
+      return snapshot;
+    }
+
+    function cacheEntry(value) {
+      if (value && typeof value === "object" && Object.hasOwn(value, "value")) {
+        return value;
+      }
+      return { value };
+    }
+    return { createRegistryStore, attachRegistryInspection };
+  })();
+
+  const __cacheModule = (() => {
+    const { attachRegistryInspection, createRegistryStore } = __registryStoreModule;
+    const cacheDefinitionKind = Symbol.for("@async/framework.cacheDefinition");
+
+    function defineCache(options = {}) {
+      return {
+        [cacheDefinitionKind]: true,
+        kind: "cache-definition",
+        store: options.store ?? "memory",
+        ttl: options.ttl
+      };
+    }
+
+    function createCacheRegistry(initialMap = {}, { now = () => Date.now(), registry, type = "cache.browser" } = {}) {
+      const registryStore = registry ?? createRegistryStore();
+      const definitions = registryStore._map(type);
+      const entries = registryStore._map(`${type}.entries`);
+
+      const registryApi = attachRegistryInspection({
+        register(id, definition = defineCache()) {
+          assertId(id);
+          const normalized = normalizeDefinition(definition);
+          if (definitions.has(id)) {
+            throw new Error(`Cache "${id}" is already registered.`);
+          }
+          definitions.set(id, normalized);
+          return id;
+        },
+
+        registerMany(map) {
+          for (const [id, definition] of Object.entries(map ?? {})) {
+            registryApi.register(id, definition);
+          }
+          return registryApi;
+        },
+
+        unregister(id) {
+          assertId(id);
+          return definitions.delete(id);
+        },
+
+        resolve(id) {
+          assertId(id);
+          return definitions.get(id);
+        },
+
+        get(key) {
+          assertKey(key);
+          const entry = entries.get(key);
+          if (!entry) {
+            return undefined;
+          }
+          if (entry.expiresAt !== undefined && entry.expiresAt <= now()) {
+            entries.delete(key);
+            return undefined;
+          }
+          return entry.value;
+        },
+
+        set(key, value, options = {}) {
+          assertKey(key);
+          const ttl = options.ttl ?? resolvePolicy(key, options.cache)?.ttl;
+          entries.set(key, {
+            value,
+            expiresAt: ttl === undefined ? undefined : now() + ttl
+          });
+          return value;
+        },
+
+        async getOrSet(key, fn, options = {}) {
+          assertKey(key);
+          if (typeof fn !== "function") {
+            throw new TypeError("cache.getOrSet(key, fn) requires a function.");
+          }
+          const cached = registryApi.get(key);
+          if (cached !== undefined) {
+            return cached;
+          }
+          const value = await fn();
+          registryApi.set(key, value, options);
+          return value;
+        },
+
+        delete(key) {
+          assertKey(key);
+          return entries.delete(key);
+        },
+
+        clear(prefix) {
+          if (prefix === undefined) {
+            entries.clear();
+            return registryApi;
+          }
+          for (const key of [...entries.keys()]) {
+            if (key.startsWith(prefix)) {
+              entries.delete(key);
+            }
+          }
+          return registryApi;
+        },
+
+        snapshot() {
+          const snapshot = {};
+          for (const [key] of entries) {
+            const value = registryApi.get(key);
+            if (value !== undefined) {
+              snapshot[key] = value;
+            }
+          }
+          return snapshot;
+        },
+
+        restore(snapshot = {}) {
+          for (const [key, value] of Object.entries(snapshot ?? {})) {
+            registryApi.set(key, value);
+          }
+          return registryApi;
+        },
+
+        entryKeys() {
+          return [...entries.keys()];
+        },
+
+        entryEntries() {
+          return registryStore.entries(`${type}.entries`);
+        },
+
+        _adoptMany() {
+          return registryApi;
+        }
+      }, registryStore, type);
+
+      registryApi.registerMany(initialMap);
+      return registryApi;
+
+      function resolvePolicy(key, explicitId) {
+        if (explicitId !== undefined) {
+          return definitions.get(explicitId);
+        }
+        if (definitions.has(key)) {
+          return definitions.get(key);
+        }
+        const prefix = key.split(":")[0];
+        return definitions.get(prefix);
+      }
+    }
+
+    function normalizeDefinition(definition) {
+      if (definition?.[cacheDefinitionKind]) {
+        return definition;
+      }
+      return defineCache(definition);
+    }
+
+    function assertId(id) {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new TypeError("Cache id must be a non-empty string.");
+      }
+    }
+
+    function assertKey(key) {
+      if (typeof key !== "string" || key.length === 0) {
+        throw new TypeError("Cache key must be a non-empty string.");
+      }
+    }
+    return { defineCache, createCacheRegistry };
+  })();
+
+  const __attributesModule = (() => {
+    const defaultPrefixes = Object.freeze({
+      async: ["async:"],
+      class: ["class:"],
+      signal: ["signal:"],
+      on: ["on:"]
+    });
+
+    function defineAttributeConfig(config = {}) {
+      return normalizeAttributeConfig(config);
+    }
+
+    function normalizeAttributeConfig(config = {}) {
+      return {
+        async: normalizePrefixes(config.async, defaultPrefixes.async),
+        class: normalizePrefixes(config.class, defaultPrefixes.class),
+        signal: normalizePrefixes(config.signal, defaultPrefixes.signal),
+        on: normalizePrefixes(config.on, defaultPrefixes.on)
+      };
+    }
+
+    function attributeName(attributes, type, name) {
+      return normalizeAttributeConfig(attributes)[type][0] + name;
+    }
+
+    function readAttribute(element, attributes, type, name) {
+      for (const prefix of normalizeAttributeConfig(attributes)[type]) {
+        const attr = `${prefix}${name}`;
+        if (element.hasAttribute?.(attr)) {
+          return element.getAttribute(attr);
+        }
+      }
+      return null;
+    }
+
+    function matchAttribute(name, attributes, type) {
+      for (const prefix of normalizeAttributeConfig(attributes)[type]) {
+        if (name.startsWith(prefix)) {
+          return name.slice(prefix.length);
+        }
+      }
+      return null;
+    }
+
+    function normalizePrefixes(value, fallback) {
+      const prefixes = value == null ? fallback : Array.isArray(value) ? value : [value];
+      return prefixes.map((prefix) => {
+        if (typeof prefix !== "string" || prefix.length === 0) {
+          throw new TypeError("Attribute prefixes must be non-empty strings.");
+        }
+        return prefix;
+      });
+    }
+    return { defineAttributeConfig, normalizeAttributeConfig, attributeName, readAttribute, matchAttribute };
+  })();
+
+  const __signalsModule = (() => {
+    const { asyncSignal: createAsyncSignal, isAsyncSignal } = __asyncSignalModule;
+    const { attachRegistryInspection, createRegistryStore } = __registryStoreModule;
+    const signalKind = Symbol.for("@async/framework.signal");
+    const computedKind = Symbol.for("@async/framework.computed");
+    const effectKind = Symbol.for("@async/framework.effect");
+    const refKind = Symbol.for("@async/framework.signalRef");
+    const dependencyFrames = [];
+
+    function createSignal(initial) {
+      let value = initial;
+      const subscribers = new Set();
+
+      return {
+        [signalKind]: true,
+        kind: "signal",
+
+        get value() {
+          return value;
+        },
+
+        set value(nextValue) {
+          this.set(nextValue);
+        },
+
+        set(nextValue) {
+          if (Object.is(value, nextValue)) {
+            return value;
+          }
+          value = nextValue;
+          notify();
+          return value;
+        },
+
+        update(fn) {
+          return this.set(fn(value));
+        },
+
+        subscribe(fn) {
+          if (typeof fn !== "function") {
+            throw new TypeError("subscribe(fn) requires a function.");
+          }
+          subscribers.add(fn);
+          return () => subscribers.delete(fn);
+        },
+
+        snapshot() {
+          return value;
+        }
+      };
+
+      function notify() {
+        for (const subscriber of [...subscribers]) {
+          subscriber(value);
+        }
+      }
+    }
+
+    const signal = createSignal;
+
+    function computed(fn) {
+      if (typeof fn !== "function") {
+        throw new TypeError("computed(fn) requires a function.");
+      }
+      const backing = createSignal(undefined);
+
+      return {
+        [computedKind]: true,
+        kind: "computed",
+
+        get value() {
+          return backing.value;
+        },
+
+        set(nextValue) {
+          return backing.set(nextValue);
+        },
+
+        update(fn) {
+          return backing.update(fn);
+        },
+
+        subscribe(fn) {
+          return backing.subscribe(fn);
+        },
+
+        snapshot() {
+          return backing.snapshot();
+        },
+
+        _bindRegistry(registry, id) {
+          return registry.effect(() => {
+            backing.set(fn.call({
+              signals: registry,
+              id,
+              server: registry._context?.().server,
+              router: registry._context?.().router,
+              loader: registry._context?.().loader,
+              cache: registry._context?.().cache
+            }));
+          });
+        }
+      };
+    }
+
+    function effect(fn) {
+      if (typeof fn !== "function") {
+        throw new TypeError("effect(fn) requires a function.");
+      }
+      return {
+        [effectKind]: true,
+        kind: "effect",
+        fn,
+        _bindRegistry(registry) {
+          return registry.effect(fn);
+        }
+      };
+    }
+
+    function createSignalRegistry(initialMap = {}, options = {}) {
+      const registryStore = options.registry ?? createRegistryStore();
+      const type = options.type ?? "signal";
+      const entries = registryStore._map(type);
+      const registryCleanups = new Map();
+      const runtimeContext = {};
+      const boundEntries = new Set();
+
+      const registry = attachRegistryInspection({
+        register(id, signalLike) {
+          assertId(id);
+          if (entries.has(id)) {
+            throw new Error(`Signal "${id}" is already registered.`);
+          }
+          const entry = normalizeSignal(signalLike);
+          entries.set(id, entry);
+          bindEntry(id, entry);
+          return registry.ref(id);
+        },
+
+        registerMany(map) {
+          for (const [id, signalLike] of Object.entries(map ?? {})) {
+            registry.register(id, signalLike);
+          }
+          return registry;
+        },
+
+        unregister(id) {
+          assertId(id);
+          if (!entries.has(id)) {
+            return false;
+          }
+          registryCleanups.get(id)?.();
+          registryCleanups.delete(id);
+          entries.get(id)?._dispose?.();
+          entries.delete(id);
+          boundEntries.delete(id);
+          return true;
+        },
+
+        ensure(id, initial) {
+          assertId(id);
+          if (!entries.has(id)) {
+            registry.register(id, createSignal(initial));
+          }
+          return registry.ref(id);
+        },
+
+        has(id) {
+          return entries.has(id);
+        },
+
+        get(path) {
+          const parsed = parsePath(path, entries);
+          track(parsed.path);
+          const entry = requireEntry(entries, parsed.id);
+          return readEntry(entry, parsed.parts);
+        },
+
+        set(path, value) {
+          const parsed = parsePath(path, entries);
+          const entry = requireEntry(entries, parsed.id);
+          if (parsed.parts.length === 0) {
+            return entry.set(value);
+          }
+          const nextValue = setPath(entry.value, parsed.parts, value);
+          entry.set(nextValue);
+          return value;
+        },
+
+        update(path, fn) {
+          if (typeof fn !== "function") {
+            throw new TypeError("update(path, fn) requires a function.");
+          }
+          return registry.set(path, fn(registry.get(path)));
+        },
+
+        ref(id) {
+          assertId(id);
+          return createRef(registry, id);
+        },
+
+        subscribe(path, fn) {
+          if (typeof fn !== "function") {
+            throw new TypeError("subscribe(path, fn) requires a function.");
+          }
+          const parsed = parsePath(path, entries);
+          const entry = requireEntry(entries, parsed.id);
+          return entry.subscribe(() => {
+            fn(registry.get(parsed.path), {
+              id: parsed.id,
+              path: parsed.path,
+              signal: entry
+            });
+          });
+        },
+
+        snapshot() {
+          const snapshot = {};
+          for (const [id, entry] of entries) {
+            snapshot[id] = typeof entry.snapshot === "function" ? entry.snapshot() : entry.value;
+          }
+          return snapshot;
+        },
+
+        asyncSignal(id, fn) {
+          registry.register(id, createAsyncSignal(id, fn));
+          return registry.ref(id);
+        },
+
+        effect(fn) {
+          let cleanup;
+          let dependencyCleanups = [];
+          let stopped = false;
+
+          const run = () => {
+            if (stopped) {
+              return;
+            }
+            if (typeof cleanup === "function") {
+              cleanup();
+            }
+            for (const stop of dependencyCleanups) {
+              stop();
+            }
+            dependencyCleanups = [];
+
+            const outcome = registry._collectDependencies(() => fn.call({
+              signals: registry,
+              server: runtimeContext.server,
+              router: runtimeContext.router,
+              loader: runtimeContext.loader,
+              cache: runtimeContext.cache
+            }));
+            cleanup = outcome.value;
+            dependencyCleanups = outcome.dependencies.map((dependency) => registry.subscribe(dependency, run));
+          };
+
+          run();
+
+          return () => {
+            stopped = true;
+            if (typeof cleanup === "function") {
+              cleanup();
+            }
+            for (const stop of dependencyCleanups) {
+              stop();
+            }
+          };
+        },
+
+        destroy() {
+          for (const cleanup of registryCleanups.values()) {
+            cleanup();
+          }
+          registryCleanups.clear();
+          for (const entry of entries.values()) {
+            entry._dispose?.();
+          }
+          entries.clear();
+        },
+
+        _collectDependencies(fn) {
+          const frame = new Set();
+          dependencyFrames.push(frame);
+          try {
+            const value = fn();
+            return { value, dependencies: [...frame] };
+          } finally {
+            dependencyFrames.pop();
+          }
+        },
+
+        _entry(id) {
+          return requireEntry(entries, id);
+        },
+
+        _setContext(context = {}) {
+          Object.assign(runtimeContext, context);
+          return registry;
+        },
+
+        _context() {
+          return runtimeContext;
+        },
+
+        _adoptMany(map = {}) {
+          for (const id of Object.keys(map ?? {})) {
+            if (entries.has(id)) {
+              bindEntry(id, entries.get(id));
+            }
+          }
+          return registry;
+        }
+      }, registryStore, type);
+
+      for (const [id, entry] of entries) {
+        bindEntry(id, entry);
+      }
+      registry.registerMany(initialMap);
+      return registry;
+
+      function bindEntry(id, entry) {
+        if (boundEntries.has(id) || typeof entry?._bindRegistry !== "function") {
+          return;
+        }
+        boundEntries.add(id);
+        const cleanup = entry._bindRegistry(registry, id);
+        if (typeof cleanup === "function") {
+          registryCleanups.set(id, cleanup);
+        }
+      }
+    }
+
+    function normalizeSignal(signalLike) {
+      if (isSignalLike(signalLike)) {
+        return signalLike;
+      }
+      return createSignal(signalLike);
+    }
+
+    function isSignalLike(value) {
+      return Boolean(value && typeof value === "object" && typeof value.subscribe === "function");
+    }
+
+    function createRef(registry, id) {
+      return {
+        [refKind]: true,
+        kind: "signal-ref",
+        id,
+
+        get value() {
+          return registry.get(id);
+        },
+
+        set value(nextValue) {
+          registry.set(id, nextValue);
+        },
+
+        get loading() {
+          return registry._entry(id).loading ?? false;
+        },
+
+        get error() {
+          return registry._entry(id).error ?? null;
+        },
+
+        get status() {
+          return registry._entry(id).status ?? "ready";
+        },
+
+        get version() {
+          return registry._entry(id).version ?? 0;
+        },
+
+        get() {
+          return registry.get(id);
+        },
+
+        set(nextValue) {
+          return registry.set(id, nextValue);
+        },
+
+        update(fn) {
+          return registry.update(id, fn);
+        },
+
+        subscribe(fn) {
+          return registry.subscribe(id, fn);
+        },
+
+        refresh() {
+          const entry = registry._entry(id);
+          if (typeof entry.refresh !== "function") {
+            throw new Error(`Signal "${id}" cannot refresh.`);
+          }
+          return entry.refresh();
+        },
+
+        cancel(reason) {
+          const entry = registry._entry(id);
+          if (typeof entry.cancel !== "function") {
+            throw new Error(`Signal "${id}" cannot cancel.`);
+          }
+          return entry.cancel(reason);
+        },
+
+        toString() {
+          return id;
+        },
+
+        [Symbol.toPrimitive]() {
+          return id;
+        }
+      };
+    }
+
+    function isSignalRef(value) {
+      return Boolean(value?.[refKind]);
+    }
+
+    function parsePath(path, entries) {
+      if (typeof path !== "string" || path.length === 0) {
+        throw new TypeError("Signal path must be a non-empty string.");
+      }
+      const segments = path.split(".");
+      for (let end = segments.length; end > 0; end -= 1) {
+        const id = segments.slice(0, end).join(".");
+        if (entries.has(id)) {
+          return { id, parts: segments.slice(end), path };
+        }
+      }
+      const [id, ...parts] = segments;
+      return { id, parts, path };
+    }
+
+    function readEntry(entry, parts) {
+      if (isAsyncSignal(entry) && parts[0]?.startsWith("$")) {
+        const metadata = readAsyncMetadata(entry, parts[0]);
+        return readPath(metadata, parts.slice(1));
+      }
+      return readPath(entry.value, parts);
+    }
+
+    function readAsyncMetadata(entry, part) {
+      switch (part) {
+        case "$value":
+          return entry.value;
+        case "$loading":
+          return entry.loading;
+        case "$error":
+          return entry.error;
+        case "$status":
+          return entry.status;
+        case "$version":
+          return entry.version;
+        default:
+          return undefined;
+      }
+    }
+
+    function readPath(value, parts) {
+      let cursor = value;
+      for (const part of parts) {
+        if (cursor == null) {
+          return undefined;
+        }
+        cursor = cursor[part];
+      }
+      return cursor;
+    }
+
+    function setPath(value, parts, nextValue) {
+      const root = cloneContainer(value, parts[0]);
+      let cursor = root;
+      for (let index = 0; index < parts.length - 1; index += 1) {
+        const part = parts[index];
+        const nextPart = parts[index + 1];
+        cursor[part] = cloneContainer(cursor[part], nextPart);
+        cursor = cursor[part];
+      }
+      cursor[parts.at(-1)] = nextValue;
+      return root;
+    }
+
+    function cloneContainer(value, nextPart) {
+      if (Array.isArray(value)) {
+        return [...value];
+      }
+      if (value && typeof value === "object") {
+        return { ...value };
+      }
+      return isArrayIndex(nextPart) ? [] : {};
+    }
+
+    function isArrayIndex(part) {
+      return String(Number(part)) === String(part);
+    }
+
+    function requireEntry(entries, id) {
+      const entry = entries.get(id);
+      if (!entry) {
+        throw new Error(`Signal "${id}" is not registered.`);
+      }
+      return entry;
+    }
+
+    function assertId(id) {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new TypeError("Signal id must be a non-empty string.");
+      }
+    }
+
+    function track(path) {
+      const frame = dependencyFrames.at(-1);
+      if (frame) {
+        frame.add(path);
+      }
+    }
+    return { createSignal, computed, effect, createSignalRegistry, isSignalRef, signal };
+  })();
+
+  const __htmlModule = (() => {
+    const { isSignalRef } = __signalsModule;
+    const { attributeName, matchAttribute, normalizeAttributeConfig } = __attributesModule;
+    const templateKind = Symbol.for("@async/framework.template");
+    const rawKind = Symbol.for("@async/framework.rawHtml");
+
+    function html(strings, ...values) {
+      return {
+        [templateKind]: true,
+        strings,
+        values
+      };
+    }
+
+    function isTemplateResult(value) {
+      return Boolean(value?.[templateKind]);
+    }
+
+    function rawHtml(value) {
+      return {
+        [rawKind]: true,
+        html: String(value ?? "")
+      };
+    }
+
+    function renderTemplate(value, options = {}) {
+      if (isTemplateResult(value)) {
+        const context = createRenderContext(options);
+        let output = "";
+        for (let index = 0; index < value.strings.length; index += 1) {
+          output += value.strings[index];
+          if (index < value.values.length) {
+            output += renderValue(value.values[index], {
+              ...context,
+              attribute: readAttributeContext(value.strings[index])
+            });
+          }
+        }
+        return output;
+      }
+      return renderValue(value, createRenderContext(options));
+    }
+
+    function renderValue(value, context = createRenderContext()) {
+      if (value?.[rawKind]) {
+        return value.html;
+      }
+      if (isTemplateResult(value)) {
+        return renderTemplate(value, context);
+      }
+      if (context.attribute) {
+        return renderAttributeValue(value, context);
+      }
+      if (Array.isArray(value)) {
+        return value.map((item) => renderValue(item, context)).join("");
+      }
+      if (isSignalRef(value)) {
+        return escapeHtml(value.value);
+      }
+      if (value == null || value === false) {
+        return "";
+      }
+      return escapeHtml(value);
+    }
+
+    function renderAttributeValue(value, context) {
+      const signalName = matchAttribute(context.attribute.name, context.attributes, "signal");
+      const className = matchAttribute(context.attribute.name, context.attributes, "class");
+      const signalPath = signalPathFor(value, context);
+
+      if (context.attribute.name === "value" && signalPath) {
+        const currentValue = readSignalValue(value, context);
+        const signalValueAttribute = attributeName(context.attributes, "signal", "value");
+        return `${escapeHtml(currentValue)}${context.attribute.quote} ${signalValueAttribute}=${context.attribute.quote}${escapeHtml(signalPath)}`;
+      }
+
+      if (signalName != null || className != null) {
+        if (signalPath) {
+          return escapeHtml(signalPath);
+        }
+        if (isInlineBindingValue(value)) {
+          return escapeHtml(registerInlineBinding(value, context));
+        }
+      }
+
+      return renderValueAsAttributeLiteral(value, context);
+    }
+
+    function renderValueAsAttributeLiteral(value, context) {
+      if (Array.isArray(value)) {
+        return value.map((item) => renderValueAsAttributeLiteral(item, context)).join("");
+      }
+      if (isSignalRef(value)) {
+        return escapeHtml(value.value);
+      }
+      if (value == null || value === false) {
+        return "";
+      }
+      return escapeHtml(value);
+    }
+
+    function createRenderContext(options = {}) {
+      return {
+        ...options,
+        attributes: normalizeAttributeConfig(options.attributes)
+      };
+    }
+
+    function readAttributeContext(source) {
+      const match = source.match(/(?:^|[\s<])([^\s"'=<>`]+)\s*=\s*(["'])$/);
+      if (!match) {
+        return null;
+      }
+      return {
+        name: match[1],
+        quote: match[2]
+      };
+    }
+
+    function signalPathFor(value, context) {
+      if (isSignalRef(value)) {
+        return value.id;
+      }
+      if (typeof value === "string" && context.signals?.has?.(value)) {
+        return value;
+      }
+      return null;
+    }
+
+    function readSignalValue(value, context) {
+      if (isSignalRef(value)) {
+        return value.value;
+      }
+      if (typeof value === "string" && context.signals?.has?.(value)) {
+        return context.signals.get(value);
+      }
+      return value;
+    }
+
+    function isInlineBindingValue(value) {
+      return Boolean(value && typeof value === "object");
+    }
+
+    function registerInlineBinding(value, context) {
+      if (typeof context.bind !== "function") {
+        return value;
+      }
+      return context.bind(value);
+    }
+
+    function escapeHtml(value) {
+      return String(value)
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+    }
+    return { html, isTemplateResult, rawHtml, renderTemplate, escapeHtml };
+  })();
+
+  const __componentModule = (() => {
+    const { attributeName } = __attributesModule;
+    const { escapeHtml, rawHtml, renderTemplate } = __htmlModule;
+    const { attachRegistryInspection, createRegistryStore } = __registryStoreModule;
+    const componentKind = Symbol.for("@async/framework.component");
+    let componentCounter = 0;
+
+    function defineComponent(fn) {
+      if (typeof fn !== "function") {
+        throw new TypeError("defineComponent(fn) requires a function.");
+      }
+      Object.defineProperty(fn, componentKind, {
+        configurable: true,
+        value: true
+      });
+      return fn;
+    }
+
+    const component = defineComponent;
+
+    function createComponentRegistry(initialMap = {}, options = {}) {
+      const registryStore = options.registry ?? createRegistryStore();
+      const type = options.type ?? "component";
+      const entries = registryStore._map(type);
+
+      const registry = attachRegistryInspection({
+        register(id, Component) {
+          if (typeof id !== "string" || id.length === 0) {
+            throw new TypeError("Component id must be a non-empty string.");
+          }
+          if (!isComponent(Component) && typeof Component !== "function") {
+            throw new TypeError(`Component "${id}" must be a component function.`);
+          }
+          if (entries.has(id)) {
+            throw new Error(`Component "${id}" is already registered.`);
+          }
+          entries.set(id, Component);
+          return id;
+        },
+
+        registerMany(map) {
+          for (const [id, Component] of Object.entries(map ?? {})) {
+            registry.register(id, Component);
+          }
+          return registry;
+        },
+
+        unregister(id) {
+          if (typeof id !== "string" || id.length === 0) {
+            throw new TypeError("Component id must be a non-empty string.");
+          }
+          return entries.delete(id);
+        },
+
+        resolve(id) {
+          if (typeof id !== "string" || id.length === 0) {
+            throw new TypeError("Component id must be a non-empty string.");
+          }
+          return entries.get(id);
+        },
+
+        _adoptMany() {
+          return registry;
+        }
+      }, registryStore, type);
+
+      registry.registerMany(initialMap);
+      return registry;
+    }
+
+    function isComponent(value) {
+      return Boolean(value?.[componentKind]);
+    }
+
+    function renderComponent(Component, props = {}, runtime, parentScope = "component") {
+      if (!isComponent(Component) && typeof Component !== "function") {
+        throw new TypeError("renderComponent(Component) requires a component function.");
+      }
+
+      const scope = `${parentScope}.${componentName(Component)}.${++componentCounter}`;
+      const cleanups = [];
+      const attachHooks = [];
+      const visibleHooks = [];
+      const destroyHooks = [];
+      const bindingIds = [];
+      const templateOptions = {
+        attributes: runtime.attributes,
+        signals: runtime.signals,
+        bind(value) {
+          const id = runtime.loader?._registerBinding?.(value);
+          if (!id) {
+            throw new Error("Inline template bindings require a Loader.");
+          }
+          bindingIds.push(id);
+          return id;
+        }
+      };
+      const renderScopedTemplate = (value) => renderTemplate(value, templateOptions);
+      const context = createComponentContext({
+        runtime,
+        scope,
+        cleanups,
+        attachHooks,
+        visibleHooks,
+        destroyHooks,
+        renderScopedTemplate
+      });
+
+      const output = Component.call(context, props);
+      const html = renderScopedTemplate(output);
+
+      return {
+        html,
+        attach(target) {
+          for (const hook of attachHooks) {
+            const cleanup = hook(target);
+            if (typeof cleanup === "function") {
+              cleanups.push(cleanup);
+            }
+          }
+        },
+        mount(target) {
+          this.attach(target);
+        },
+        visible(target, observeVisible) {
+          for (const hook of visibleHooks) {
+            const cleanup = observeVisible(target, hook);
+            if (typeof cleanup === "function") {
+              cleanups.push(cleanup);
+            }
+          }
+        },
+        cleanup() {
+          while (destroyHooks.length > 0) {
+            destroyHooks.pop()?.();
+          }
+          while (cleanups.length > 0) {
+            cleanups.pop()?.();
+          }
+          while (bindingIds.length > 0) {
+            runtime.loader?._releaseBinding?.(bindingIds.pop());
+          }
+        }
+      };
+    }
+
+    function createComponentContext({ runtime, scope, cleanups, attachHooks, visibleHooks, destroyHooks, renderScopedTemplate }) {
+      const { signals, handlers, loader, server, router, cache } = runtime;
+      const generatedHandlers = new WeakMap();
+      let generatedHandlerCounter = 0;
+      let generatedSignalCounter = 0;
+      const context = {
+        scope,
+        signals,
+        handlers,
+        loader,
+        server,
+        router,
+        cache,
+
+        signal(name, initial) {
+          if (arguments.length === 1) {
+            const id = scoped(scope, `signal.${++generatedSignalCounter}`);
+            const ref = signals.ensure(id, name);
+            cleanups.push(() => signals.unregister?.(id));
+            return ref;
+          }
+          const id = scoped(scope, name);
+          const created = !signals.has(id);
+          const ref = signals.ensure(id, initial);
+          if (created) {
+            cleanups.push(() => signals.unregister?.(id));
+          }
+          return ref;
+        },
+
+        computed(name, fn) {
+          const id = scoped(scope, name);
+          const created = !signals.has(id);
+          const ref = signals.ensure(id, undefined);
+          if (created) {
+            cleanups.push(() => signals.unregister?.(id));
+          }
+          const cleanup = signals.effect(() => {
+            signals.set(id, fn.call(context));
+          });
+          cleanups.push(cleanup);
+          return ref;
+        },
+
+        asyncSignal(name, fn) {
+          const id = scoped(scope, name);
+          const created = !signals.has(id);
+          if (!signals.has(id)) {
+            signals.asyncSignal(id, fn);
+          }
+          if (created) {
+            cleanups.push(() => signals.unregister?.(id));
+          }
+          return signals.ref(id);
+        },
+
+        effect(fn) {
+          const cleanup = signals.effect(() => fn.call(context));
+          cleanups.push(cleanup);
+          return cleanup;
+        },
+
+        handler(name, fn) {
+          if (typeof name === "function" && fn === undefined) {
+            const inlineFn = name;
+            if (generatedHandlers.has(inlineFn)) {
+              return generatedHandlers.get(inlineFn);
+            }
+            const id = registerScopedHandler(`handler.${++generatedHandlerCounter}`, inlineFn);
+            generatedHandlers.set(inlineFn, id);
+            return id;
+          }
+          if (typeof fn !== "function") {
+            throw new TypeError("this.handler(name, fn) or this.handler(fn) requires a function.");
+          }
+          return registerScopedHandler(name, fn);
+        },
+
+        render(Child, childProps = {}) {
+          const child = renderComponent(Child, childProps, runtime, scope);
+          cleanups.push(child.cleanup);
+          attachHooks.push((target) => child.attach(target));
+          visibleHooks.push((target) => child.visible(target, loader._observeVisible));
+          return rawHtml(child.html);
+        },
+
+        suspense(signalRef, views) {
+          const id = signalRef?.id;
+          if (!id) {
+            throw new TypeError("this.suspense(signalRef, views) requires a signal ref.");
+          }
+
+          const normalized = normalizeSuspenseViews(views);
+          const chunks = [];
+          for (const state of ["loading", "ready", "error"]) {
+            const view = normalized[state];
+            if (!view) {
+              continue;
+            }
+            const attr = attributeName(runtime.attributes, "async", state);
+            const body = renderScopedTemplate(view.call(context, signalRef));
+            chunks.push(`<template ${attr}="${escapeHtml(id)}">${body}</template>`);
+          }
+          return rawHtml(chunks.join(""));
+        },
+
+        on(eventName, fn) {
+          if (typeof eventName !== "string" || eventName.length === 0) {
+            throw new TypeError("Component lifecycle event must be a non-empty string.");
+          }
+          if (typeof fn !== "function") {
+            throw new TypeError(`Component lifecycle "${eventName}" requires a function.`);
+          }
+          const event = eventName === "mount" ? "attach" : eventName;
+          if (event === "attach") {
+            attachHooks.push((target) => fn.call(context, target));
+            return;
+          }
+          if (event === "visible") {
+            visibleHooks.push((target) => fn.call(context, target));
+            return;
+          }
+          if (event === "destroy") {
+            destroyHooks.push(() => fn.call(context));
+            return;
+          }
+          throw new Error(`Unsupported component lifecycle event "${eventName}".`);
+        },
+
+        onMount(fn) {
+          context.on("attach", fn);
+        },
+
+        onVisible(fn) {
+          context.on("visible", fn);
+        }
+      };
+
+      return context;
+
+      function registerScopedHandler(name, fn) {
+        const id = scoped(scope, name);
+        handlers.register(id, function runComponentHandler(handlerContext) {
+          return fn.call({ ...context, ...handlerContext }, handlerContext);
+        });
+        cleanups.push(() => handlers.unregister?.(id));
+        return id;
+      }
+    }
+
+    function scoped(scope, name) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new TypeError("Scoped signal or handler name must be a non-empty string.");
+      }
+      return `${scope}.${name}`;
+    }
+
+    function normalizeSuspenseViews(views) {
+      const normalized = typeof views === "function" ? { ready: views } : views;
+      if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
+        throw new TypeError("this.suspense(signalRef, views) requires views to be a function or object.");
+      }
+
+      for (const state of ["loading", "ready", "error"]) {
+        if (Object.hasOwn(normalized, state) && normalized[state] !== undefined && typeof normalized[state] !== "function") {
+          throw new TypeError(`this.suspense(signalRef, views) view "${state}" must be a function.`);
+        }
+      }
+
+      return normalized;
+    }
+
+    function componentName(Component) {
+      return Component.displayName || Component.name || "anonymous";
+    }
+    return { defineComponent, createComponentRegistry, isComponent, renderComponent, component };
+  })();
+
+  const __serverModule = (() => {
+    const { attachRegistryInspection, createRegistryStore } = __registryStoreModule;
+    const serverEnvelopeKeys = new Set(["value", "signals", "boundary", "html", "redirect", "error"]);
+
+    function createServerRegistry(initialMap = {}, options = {}) {
+      const registryStore = options.registry ?? createRegistryStore();
+      const type = options.type ?? "server";
+      const entries = registryStore._map(type);
+      const defaults = {};
+
+      const registry = attachRegistryInspection({
+        register(id, fn) {
+          assertServerId(id);
+          if (typeof fn !== "function") {
+            throw new TypeError(`Server function "${id}" must be a function.`);
+          }
+          if (entries.has(id)) {
+            throw new Error(`Server function "${id}" is already registered.`);
+          }
+          entries.set(id, fn);
+          return id;
+        },
+
+        registerMany(map) {
+          for (const [id, fn] of Object.entries(map ?? {})) {
+            registry.register(id, fn);
+          }
+          return registry;
+        },
+
+        unregister(id) {
+          assertServerId(id);
+          return entries.delete(id);
+        },
+
+        resolve(id) {
+          assertServerId(id);
+          return entries.get(id);
+        },
+
+        async run(id, args = [], context = {}) {
+          assertServerId(id);
+          const fn = registry.resolve(id);
+          if (!fn) {
+            throw new Error(`Server function "${id}" is not registered.`);
+          }
+
+          let runContext;
+          const server = createServerNamespace((childId, childArgs, childContext = {}) => {
+            return registry.run(childId, childArgs, { ...runContext, ...childContext });
+          }, {}, () => runContext);
+
+          const mergedContext = {
+            ...defaults,
+            ...context,
+            cache: defaults.cache ?? context.cache
+          };
+
+          runContext = {
+            ...mergedContext,
+            id,
+            args,
+            input: mergedContext.input,
+            signals: createSignalReader(mergedContext.signals),
+            abort: mergedContext.abort,
+            cache: mergedContext.cache,
+            server
+          };
+
+          return fn.call(runContext, ...args);
+        },
+
+        _setContext(context = {}) {
+          Object.assign(defaults, context);
+          return registry;
+        },
+
+        _adoptMany() {
+          return registry;
+        }
+      }, registryStore, type);
+
+      registry.registerMany(initialMap);
+      return createServerNamespace((id, args, context) => registry.run(id, args, context), registry, () => defaults);
+    }
+
+    function createServerProxy({
+      endpoint = "/__async/server",
+      fetch: fetchImpl = globalThis.fetch?.bind(globalThis),
+      signals,
+      loader,
+      router,
+      cache,
+      headers = {}
+    } = {}) {
+      if (typeof fetchImpl !== "function") {
+        throw new TypeError("createServerProxy(...) requires fetch to be available.");
+      }
+
+      const defaults = { signals, loader, router, cache };
+
+      async function run(id, args = [], context = {}) {
+        assertServerId(id);
+        const runContext = { ...defaults, ...context };
+        const body = {
+          args,
+          input: context.input ?? defaultInput(runContext),
+          signals: context.signalValues ?? snapshotSignalPaths(context.signalPaths, runContext.signals)
+        };
+
+        const response = await fetchImpl(joinEndpoint(endpoint, id), {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...headers
+          },
+          body: JSON.stringify(body),
+          signal: context.abort
+        });
+
+        if (!response.ok) {
+          throw new Error(`Server function "${id}" failed with ${response.status}.`);
+        }
+
+        const result = await readServerResponse(response);
+        await applyServerResult(result, runContext);
+        return unwrapServerResult(result);
+      }
+
+      return createServerNamespace(run, {
+        run,
+        _setContext(context = {}) {
+          Object.assign(defaults, context);
+        }
+      }, () => defaults);
+    }
+
+    function resolveServerCommandArguments(args, context = {}) {
+      const resolved = [];
+      const signalValues = {};
+      const signalPaths = [];
+
+      for (const arg of args) {
+        if (arg.type === "local") {
+          resolved.push(resolveLocal(arg.name, context, { forServer: true }));
+          continue;
+        }
+
+        const value = readSignal(context.signals, arg.path);
+        resolved.push(value);
+        signalValues[arg.path] = value;
+        signalPaths.push(arg.path);
+      }
+
+      return { args: resolved, signalValues, signalPaths };
+    }
+
+    async function applyServerResult(result, context = {}) {
+      if (!isServerEnvelope(result)) {
+        return result;
+      }
+
+      if (result.signals && context.signals) {
+        for (const [path, value] of Object.entries(result.signals)) {
+          context.signals.set?.(path, value);
+        }
+      }
+
+      if (result.cache?.browser && context.cache?.restore) {
+        context.cache.restore(result.cache.browser);
+      }
+
+      if (result.boundary && Object.hasOwn(result, "html")) {
+        context.loader?.swap?.(result.boundary, result.html);
+      }
+
+      if (result.redirect) {
+        await context.router?.navigate?.(result.redirect);
+      }
+
+      if (result.error) {
+        throw toError(result.error);
+      }
+
+      return result;
+    }
+
+    function unwrapServerResult(result) {
+      if (isServerEnvelope(result) && Object.hasOwn(result, "value")) {
+        return result.value;
+      }
+      return result;
+    }
+
+    function defaultInput(context = {}) {
+      const form = findForm(context);
+      if (form) {
+        return formDataToObject(new form.ownerDocument.defaultView.FormData(form));
+      }
+
+      const element = context.element ?? context.el ?? context.event?.target;
+      if (!element) {
+        return {};
+      }
+
+      return {
+        value: "value" in element ? element.value : undefined,
+        checked: "checked" in element ? element.checked : undefined,
+        dataset: element.dataset ? { ...element.dataset } : {}
+      };
+    }
+
+    function createServerNamespace(run, root = {}, contextProvider = () => ({})) {
+      const cache = new Map();
+
+      function namespace(parts) {
+        const cacheKey = parts.join(".");
+        if (cache.has(cacheKey)) {
+          return cache.get(cacheKey);
+        }
+
+        const callable = async (...args) => {
+          if (parts.length === 0) {
+            throw new Error("Server namespace is not directly callable.");
+          }
+          const context = contextProvider() ?? {};
+          const result = await run(parts.join("."), args, context);
+          await applyServerResult(result, context);
+          return unwrapServerResult(result);
+        };
+
+        const proxy = new Proxy(callable, {
+          get(_target, prop) {
+            if (prop === "then") {
+              return undefined;
+            }
+            if (prop in _target) {
+              return _target[prop];
+            }
+            if (parts.length === 0 && prop === "_withContext") {
+              return (context = {}) => createServerNamespace(run, root, () => ({
+                ...(contextProvider() ?? {}),
+                ...context
+              }));
+            }
+            if (parts.length === 0 && prop === "run" && typeof root.run === "function") {
+              return (id, args = [], context = {}) => root.run(id, args, {
+                ...(contextProvider() ?? {}),
+                ...context
+              });
+            }
+            if (parts.length === 0 && Object.hasOwn(root, prop)) {
+              return root[prop];
+            }
+            if (prop === Symbol.toStringTag) {
+              return "AsyncServerNamespace";
+            }
+            if (prop === "toString") {
+              return () => parts.length === 0 ? "server" : `server.${parts.join(".")}`;
+            }
+            return namespace([...parts, String(prop)]);
+          }
+        });
+
+        cache.set(cacheKey, proxy);
+        return proxy;
+      }
+
+      return namespace([]);
+    }
+
+    async function readServerResponse(response) {
+      const type = response.headers.get("content-type") ?? "";
+      if (type.includes("application/json")) {
+        return response.json();
+      }
+      return { value: await response.text() };
+    }
+
+    function snapshotSignalPaths(paths = [], signals) {
+      const snapshot = {};
+      for (const path of paths) {
+        snapshot[path] = readSignal(signals, path);
+      }
+      return snapshot;
+    }
+
+    function readSignal(signals, path) {
+      if (!signals || typeof signals.get !== "function") {
+        throw new Error(`Signal "${path}" cannot be read without a signal registry.`);
+      }
+      return signals.get(path);
+    }
+
+    function createSignalReader(signals) {
+      if (!signals || typeof signals.get === "function") {
+        return signals;
+      }
+
+      return {
+        get(path) {
+          return readPath(signals, path);
+        },
+        snapshot() {
+          return { ...signals };
+        }
+      };
+    }
+
+    function readPath(source, path) {
+      return String(path)
+        .split(".")
+        .reduce((value, part) => value?.[part], source);
+    }
+
+    function resolveLocal(name, context, { forServer } = {}) {
+      if ((name === "$event" || name === "$el") && forServer) {
+        throw new Error(`${name} cannot be passed to a server command.`);
+      }
+      if (name === "$event") {
+        return context.event;
+      }
+      if (name === "$el") {
+        return context.element ?? context.el;
+      }
+      if (name === "$value") {
+        const element = context.element ?? context.el ?? context.event?.target;
+        return element?.value;
+      }
+      if (name === "$checked") {
+        const element = context.element ?? context.el ?? context.event?.target;
+        return element?.checked;
+      }
+      if (name === "$form") {
+        const form = findForm(context);
+        return form ? formDataToObject(new form.ownerDocument.defaultView.FormData(form)) : {};
+      }
+      if (name === "$dataset") {
+        const element = context.element ?? context.el ?? context.event?.target;
+        return element?.dataset ? { ...element.dataset } : {};
+      }
+      throw new Error(`Event local "${name}" is not supported.`);
+    }
+
+    function findForm(context) {
+      const event = context.event;
+      const element = context.element ?? context.el ?? event?.target;
+      if (element?.tagName === "FORM") {
+        return element;
+      }
+      if (event?.type === "submit" && event.target?.tagName === "FORM") {
+        return event.target;
+      }
+      if (event?.type === "submit" && element?.form) {
+        return element.form;
+      }
+      return null;
+    }
+
+    function formDataToObject(formData) {
+      const output = {};
+      for (const [key, value] of formData.entries()) {
+        if (Object.hasOwn(output, key)) {
+          output[key] = Array.isArray(output[key]) ? [...output[key], value] : [output[key], value];
+          continue;
+        }
+        output[key] = value;
+      }
+      return output;
+    }
+
+    function joinEndpoint(endpoint, id) {
+      return `${String(endpoint).replace(/\/$/, "")}/${encodeURIComponent(id)}`;
+    }
+
+    function isServerEnvelope(value) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+      }
+      return Object.keys(value).some((key) => serverEnvelopeKeys.has(key));
+    }
+
+    function toError(value) {
+      if (value instanceof Error) {
+        return value;
+      }
+      if (value && typeof value === "object" && typeof value.message === "string") {
+        return Object.assign(new Error(value.message), value);
+      }
+      return new Error(String(value));
+    }
+
+    function assertServerId(id) {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new TypeError("Server function id must be a non-empty string.");
+      }
+    }
+    return { createServerRegistry, createServerProxy, resolveServerCommandArguments, applyServerResult, unwrapServerResult, defaultInput };
+  })();
+
+  const __handlersModule = (() => {
+    const { applyServerResult, defaultInput, resolveServerCommandArguments, unwrapServerResult } = __serverModule;
+    const { attachRegistryInspection, createRegistryStore } = __registryStoreModule;
+    const builtInTokens = new Set(["prevent", "preventDefault", "stopPropagation", "stopImmediatePropagation"]);
+    const builtInHandlers = {
+      prevent: preventDefault,
+      preventDefault,
+      stopPropagation() {
+        this.event?.stopPropagation?.();
+      },
+      stopImmediatePropagation() {
+        this.event?.stopImmediatePropagation?.();
+      }
+    };
+
+    function preventDefault() {
+      this.event?.preventDefault?.();
+    }
+
+    function createHandlerRegistry(initialMap = {}, options = {}) {
+      const registryStore = options.registry ?? createRegistryStore();
+      const type = options.type ?? "handler";
+      const handlers = registryStore._map(type);
+
+      const registry = attachRegistryInspection({
+        register(id, fn) {
+          assertId(id);
+          if (typeof fn !== "function") {
+            throw new TypeError(`Handler "${id}" must be a function.`);
+          }
+          if (handlers.has(id)) {
+            throw new Error(`Handler "${id}" is already registered.`);
+          }
+          handlers.set(id, fn);
+          return id;
+        },
+
+        registerMany(map) {
+          for (const [id, fn] of Object.entries(map ?? {})) {
+            registry.register(id, fn);
+          }
+          return registry;
+        },
+
+        unregister(id) {
+          assertId(id);
+          return handlers.delete(id);
+        },
+
+        resolve(id) {
+          assertId(id);
+          return handlers.get(id);
+        },
+
+        async run(ref, context = {}) {
+          const steps = parseHandlerRef(ref);
+          const results = [];
+          let stopped = false;
+          const runContext = {
+            ...context,
+            handlers: registry,
+            input: context.input ?? defaultInput(context),
+            stop() {
+              stopped = true;
+            }
+          };
+
+          for (const step of steps) {
+            if (stopped) {
+              break;
+            }
+
+            if (step.type === "server") {
+              if (!runContext.server || typeof runContext.server.run !== "function") {
+                throw new Error(`Server command "${step.id}" cannot run without a server registry.`);
+              }
+              const resolved = resolveServerCommandArguments(step.args, runContext);
+              const result = await runContext.server.run(step.id, resolved.args, {
+                ...runContext,
+                signalPaths: resolved.signalPaths,
+                signalValues: resolved.signalValues
+              });
+              await applyServerResult(result, runContext);
+              results.push(unwrapServerResult(result));
+              continue;
+            }
+
+            const handler = registry.resolve(step.id);
+            if (!handler) {
+              throw new Error(`Handler "${step.id}" is not registered.`);
+            }
+            const value = await handler.call(runContext, runContext);
+            if (!(builtInTokens.has(step.id) && handler === builtInHandlers[step.id])) {
+              results.push(value);
+            }
+          }
+
+          return results;
+        },
+
+        _adoptMany() {
+          return registry;
+        }
+      }, registryStore, type);
+
+      registerBuiltIns(registry, handlers);
+      registry.registerMany(initialMap);
+      return registry;
+    }
+
+    function registerBuiltIns(registry, handlers) {
+      for (const [id, fn] of Object.entries(builtInHandlers)) {
+        if (!handlers.has(id)) {
+          registry.register(id, fn);
+          continue;
+        }
+        if (handlers.get(id) !== fn) {
+          throw new Error(`Handler "${id}" is already registered.`);
+        }
+      }
+    }
+
+    function parseHandlerRef(ref) {
+      if (typeof ref !== "string" || ref.trim().length === 0) {
+        throw new TypeError("Handler ref must be a non-empty string.");
+      }
+
+      return ref
+        .split(";")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map(parseCommand);
+    }
+
+    function isHandlerToken(value) {
+      return builtInTokens.has(value);
+    }
+
+    function assertId(id) {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new TypeError("Handler id must be a non-empty string.");
+      }
+    }
+
+    function parseCommand(command) {
+      if (command.startsWith("server.")) {
+        return parseServerCommand(command);
+      }
+      if (command.includes("(") || command.includes(")")) {
+        throw new Error(`Command "${command}" is not supported.`);
+      }
+      return { type: "handler", id: command };
+    }
+
+    function parseServerCommand(command) {
+      const open = command.indexOf("(");
+      if (open === -1 || !command.endsWith(")")) {
+        throw new Error(`Server command "${command}" must be called with parentheses.`);
+      }
+
+      const id = command.slice("server.".length, open).trim();
+      if (!isServerCommandId(id)) {
+        throw new Error(`Server command "${command}" has an invalid function id.`);
+      }
+
+      return {
+        type: "server",
+        id,
+        args: parseArguments(command.slice(open + 1, -1))
+      };
+    }
+
+    function parseArguments(source) {
+      if (source.trim().length === 0) {
+        return [];
+      }
+
+      return source
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map(parseArgument);
+    }
+
+    function parseArgument(token) {
+      if (!/^[^\s,();]+$/.test(token)) {
+        throw new Error(`Argument "${token}" is not supported.`);
+      }
+      if (token.startsWith("$")) {
+        return { type: "local", name: token };
+      }
+      return { type: "signal", path: token };
+    }
+
+    function isServerCommandId(id) {
+      return /^[^.\s();]+(?:\.[^.\s();]+)*$/.test(id);
+    }
+    return { createHandlerRegistry, parseHandlerRef, isHandlerToken };
+  })();
+
+  const __loaderModule = (() => {
+    const { renderComponent } = __componentModule;
+    const { createHandlerRegistry } = __handlersModule;
+    const { createSignalRegistry, isSignalRef } = __signalsModule;
+    const { matchAttribute, normalizeAttributeConfig, readAttribute } = __attributesModule;
+    const inlineBindingPrefix = "__async:inline:";
+
+    function Loader({ root, signals, handlers, server, router, cache, attributes } = {}) {
+      const documentRef = root?.ownerDocument ?? root ?? globalThis.document;
+      const rootNode = root ?? documentRef;
+      const signalRegistry = signals ?? createSignalRegistry();
+      const handlerRegistry = handlers ?? createHandlerRegistry();
+      const attributeConfig = normalizeAttributeConfig(attributes);
+      const cleanups = new Set();
+      const eventBindings = new WeakMap();
+      const signalBindings = new WeakMap();
+      const mountedElements = new WeakSet();
+      const visibleElements = new WeakSet();
+      const boundaryState = new WeakMap();
+      const renderingBoundaries = new WeakSet();
+      const inlineBindings = new Map();
+      const scopedCleanups = new WeakMap();
+      let inlineBindingCounter = 0;
+      let destroyed = false;
+
+      const api = {
+        root: rootNode,
+        signals: signalRegistry,
+        handlers: handlerRegistry,
+        server,
+        router,
+        cache,
+        attributes: attributeConfig,
+
+        start() {
+          assertActive();
+          api.scan(rootNode);
+          return api;
+        },
+
+        scan(rootOrFragment = rootNode) {
+          assertActive();
+          bindSignalAttributes(rootOrFragment);
+          bindClassAttributes(rootOrFragment);
+          bindEventAttributes(rootOrFragment);
+          bindBoundaries(rootOrFragment);
+          runPseudoEvents(rootOrFragment);
+          return api;
+        },
+
+        swap(boundaryId, fragmentOrTemplate) {
+          assertActive();
+          const boundary = findBoundary(rootNode, boundaryId, attributeConfig);
+          if (!boundary) {
+            throw new Error(`Boundary "${boundaryId}" was not found.`);
+          }
+          cleanupChildren(boundary);
+          boundary.replaceChildren(toFragment(fragmentOrTemplate, documentRef));
+          api.scan(boundary);
+          return boundary;
+        },
+
+        mount(target, Component, props = {}) {
+          assertActive();
+          const rendered = renderComponent(Component, props, {
+            signals: signalRegistry,
+            handlers: handlerRegistry,
+            loader: api,
+            server: api.server,
+            router: api.router,
+            cache: api.cache,
+            attributes: attributeConfig
+          });
+          cleanupChildren(target);
+          target.replaceChildren(toFragment(rendered.html, target.ownerDocument));
+          api.scan(target);
+          rendered.mount(target);
+          rendered.visible(target, api._observeVisible);
+          addCleanup(rendered.cleanup, target, "children");
+          return rendered;
+        },
+
+        destroy() {
+          if (destroyed) {
+            return;
+          }
+          destroyed = true;
+          for (const cleanup of [...cleanups]) {
+            runCleanup(cleanup);
+          }
+          cleanups.clear();
+        },
+
+        _observeVisible(target, fn) {
+          return observeVisible(target, fn);
+        },
+
+        _registerBinding(value) {
+          const id = `${inlineBindingPrefix}${++inlineBindingCounter}`;
+          inlineBindings.set(id, value);
+          return id;
+        },
+
+        _releaseBinding(id) {
+          inlineBindings.delete(id);
+        }
+      };
+
+      signalRegistry._setContext?.({ server: api.server, router: api.router, loader: api, cache: api.cache });
+      api.server?._setContext?.({
+        signals: signalRegistry,
+        handlers: handlerRegistry,
+        loader: api,
+        router: api.router,
+        cache: api.cache
+      });
+
+      function bindEventAttributes(scope) {
+        for (const element of elementsIn(scope)) {
+          if (typeof element.getAttributeNames !== "function") {
+            continue;
+          }
+          for (const name of element.getAttributeNames()) {
+            const eventName = matchAttribute(name, attributeConfig, "on");
+            if (!eventName) {
+              continue;
+            }
+            if (eventName === "attach" || eventName === "mount" || eventName === "visible") {
+              continue;
+            }
+            bindEvent(element, eventName, element.getAttribute(name));
+          }
+        }
+      }
+
+      function bindEvent(element, eventName, ref) {
+        const key = `${eventName}:${ref}`;
+        const bound = eventBindings.get(element) ?? new Set();
+        if (bound.has(key)) {
+          return;
+        }
+        bound.add(key);
+        eventBindings.set(element, bound);
+
+        const listener = async (event) => {
+          try {
+            await handlerRegistry.run(ref, {
+              signals: signalRegistry,
+              handlers: handlerRegistry,
+              loader: api,
+              server: api.server,
+              router: api.router,
+              cache: api.cache,
+              event,
+              element,
+              el: element,
+              root: rootNode
+            });
+          } catch (error) {
+            dispatchAsyncError(element, error);
+          }
+        };
+
+        element.addEventListener(eventName, listener);
+        addCleanup(() => element.removeEventListener(eventName, listener), element);
+      }
+
+      function bindSignalAttributes(scope) {
+        for (const element of elementsIn(scope)) {
+          for (const name of element.getAttributeNames?.() ?? []) {
+            const signalName = matchAttribute(name, attributeConfig, "signal");
+            if (!signalName) {
+              continue;
+            }
+            if (signalName === "text") {
+              const path = element.getAttribute(name);
+              bindSignal(element, `text:${path}`, path, (value) => {
+                element.textContent = value ?? "";
+              });
+              continue;
+            }
+            if (signalName === "value") {
+              const path = element.getAttribute(name);
+              bindSignal(element, `value:${path}`, path, (value) => {
+                if ("value" in element && element.value !== String(value ?? "")) {
+                  element.value = value ?? "";
+                } else if (!("value" in element)) {
+                  element.setAttribute("value", value ?? "");
+                }
+              });
+              bindValueWriter(element, path);
+              continue;
+            }
+            if (signalName.startsWith("attr:")) {
+              const attr = signalName.slice("attr:".length);
+              const path = element.getAttribute(name);
+              bindSignal(element, `attr:${attr}:${path}`, path, (value) => updateAttribute(element, attr, value));
+              continue;
+            }
+            if (signalName.startsWith("prop:")) {
+              const prop = signalName.slice("prop:".length);
+              const path = element.getAttribute(name);
+              bindSignal(element, `prop:${prop}:${path}`, path, (value) => updateProperty(element, prop, value));
+              continue;
+            }
+            if (signalName.startsWith("class:")) {
+              const className = signalName.slice("class:".length);
+              const path = element.getAttribute(name);
+              if (className === "" || className === "{}") {
+                bindClass(element, className, path);
+              } else {
+                bindSignal(element, `class:${className}:${path}`, path, (value) => {
+                  element.classList.toggle(className, Boolean(value));
+                });
+              }
+              continue;
+            }
+            if (signalName === "class") {
+              const path = element.getAttribute(name);
+              bindClass(element, "{}", path);
+            }
+          }
+        }
+      }
+
+      function bindClassAttributes(scope) {
+        for (const element of elementsIn(scope)) {
+          for (const name of element.getAttributeNames?.() ?? []) {
+            const className = matchAttribute(name, attributeConfig, "class");
+            if (className == null) {
+              continue;
+            }
+            bindClass(element, className, element.getAttribute(name));
+          }
+        }
+      }
+
+      function bindClass(element, className, path) {
+        if (className === "" || className === "{}") {
+          const staticClasses = readClassTokens(element);
+          let previous = new Set();
+          bindSignal(element, `class:{}:${path}`, path, (value) => {
+            const next = normalizeClassTokens(value);
+            const current = readClassTokens(element);
+            for (const token of previous) {
+              if (!next.has(token) && !staticClasses.has(token)) {
+                current.delete(token);
+              }
+            }
+            for (const token of next) {
+              current.add(token);
+            }
+            writeClassTokens(element, current);
+            previous = next;
+          }, { rawInline: true });
+          return;
+        }
+
+        bindSignal(element, `class:${className}:${path}`, path, (value) => {
+          updateClassToken(element, className, Boolean(value));
+        });
+      }
+
+      function bindSignal(element, key, path, apply, options = {}) {
+        const bound = signalBindings.get(element) ?? new Set();
+        if (bound.has(key)) {
+          return;
+        }
+        bound.add(key);
+        signalBindings.set(element, bound);
+
+        const read = () => readBinding(path, options);
+        apply(read());
+        addCleanup(subscribeBinding(path, () => apply(read())), element);
+      }
+
+      function bindValueWriter(element, path) {
+        bindEvent(element, "input", `__async:set:${path}`);
+        bindEvent(element, "change", `__async:set:${path}`);
+        if (!handlerRegistry.resolve(`__async:set:${path}`)) {
+          handlerRegistry.register(`__async:set:${path}`, function writeValue({ element }) {
+            writeBinding(path, element.value);
+          });
+        }
+      }
+
+      function readBinding(path, options = {}) {
+        if (isInlineBinding(path)) {
+          const value = inlineBindings.get(path);
+          return options.rawInline ? value : resolveInlineValue(value);
+        }
+        return signalRegistry.get(path);
+      }
+
+      function writeBinding(path, value) {
+        if (!isInlineBinding(path)) {
+          return signalRegistry.set(path, value);
+        }
+        const binding = inlineBindings.get(path);
+        if (isSignalRef(binding)) {
+          return binding.set(value);
+        }
+        throw new Error(`Inline binding "${path}" is not writable.`);
+      }
+
+      function subscribeBinding(path, fn) {
+        if (!isInlineBinding(path)) {
+          return signalRegistry.subscribe(path, fn);
+        }
+        const cleanups = collectSignalRefs(inlineBindings.get(path)).map((ref) => ref.subscribe(fn));
+        return () => {
+          for (const cleanup of cleanups) {
+            cleanup();
+          }
+        };
+      }
+
+      function bindBoundaries(scope) {
+        for (const boundary of elementsIn(scope)) {
+          if (renderingBoundaries.has(boundary)) {
+            continue;
+          }
+          const id = readAttribute(boundary, attributeConfig, "async", "boundary");
+          if (id == null) {
+            continue;
+          }
+          if (!boundaryState.has(boundary)) {
+            const templates = collectBoundaryTemplates(boundary, id, attributeConfig);
+            if (Object.keys(templates).length === 0 || !signalRegistry.has(id)) {
+              continue;
+            }
+            const state = {
+              id,
+              templates,
+              cleanup: signalRegistry.subscribe(`${id}.$status`, () => renderBoundary(boundary))
+            };
+            boundaryState.set(boundary, state);
+            addCleanup(state.cleanup, boundary);
+          }
+          renderBoundary(boundary);
+        }
+      }
+
+      function renderBoundary(boundary) {
+        const state = boundaryState.get(boundary);
+        if (!state) {
+          return;
+        }
+        const status = signalRegistry.get(`${state.id}.$status`);
+        const template = chooseBoundaryTemplate(state.templates, status);
+        if (!template) {
+          return;
+        }
+        cleanupChildren(boundary);
+        boundary.replaceChildren(template.content.cloneNode(true));
+        renderingBoundaries.add(boundary);
+        try {
+          api.scan(boundary);
+        } finally {
+          renderingBoundaries.delete(boundary);
+        }
+      }
+
+      function runPseudoEvents(scope) {
+        for (const element of elementsIn(scope)) {
+          const refs = readPseudoRefs(element, ["attach", "mount"]);
+          if (refs.length === 0) {
+            continue;
+          }
+          if (mountedElements.has(element)) {
+            continue;
+          }
+          mountedElements.add(element);
+          for (const ref of refs) {
+            runPseudo(element, ref);
+          }
+        }
+
+        for (const element of elementsIn(scope)) {
+          const ref = readAttribute(element, attributeConfig, "on", "visible");
+          if (ref == null) {
+            continue;
+          }
+          if (visibleElements.has(element)) {
+            continue;
+          }
+          visibleElements.add(element);
+          addCleanup(observeVisible(element, () => runPseudo(element, ref)), element);
+        }
+      }
+
+      function readPseudoRefs(element, names) {
+        const refs = [];
+        for (const name of names) {
+          const ref = readAttribute(element, attributeConfig, "on", name);
+          if (ref != null) {
+            refs.push(ref);
+          }
+        }
+        return refs;
+      }
+
+      async function runPseudo(element, ref) {
+        try {
+          const results = await handlerRegistry.run(ref, {
+            signals: signalRegistry,
+            handlers: handlerRegistry,
+            loader: api,
+            server: api.server,
+            router: api.router,
+            cache: api.cache,
+            element,
+            el: element,
+            root: rootNode
+          });
+          for (const result of results) {
+            if (typeof result === "function") {
+              addCleanup(result, element);
+            }
+          }
+        } catch (error) {
+          dispatchAsyncError(element, error);
+        }
+      }
+
+      function observeVisible(target, fn) {
+        const ownerWindow = target.ownerDocument?.defaultView ?? globalThis;
+        const Observer = ownerWindow.IntersectionObserver ?? globalThis.IntersectionObserver;
+        if (!Observer) {
+          queueMicrotask(() => {
+            if (!destroyed) {
+              fn(target);
+            }
+          });
+          return () => {};
+        }
+
+        const observer = new Observer((entries) => {
+          if (entries.some((entry) => entry.isIntersecting)) {
+            observer.disconnect();
+            fn(target);
+          }
+        });
+        observer.observe(target);
+        return () => observer.disconnect();
+      }
+
+      function assertActive() {
+        if (destroyed) {
+          throw new Error("Loader has been destroyed.");
+        }
+      }
+
+      function addCleanup(cleanup, owner, mode = "self") {
+        if (typeof cleanup !== "function") {
+          return cleanup;
+        }
+        cleanups.add(cleanup);
+        if (owner) {
+          const records = scopedCleanups.get(owner) ?? [];
+          records.push({ cleanup, mode });
+          scopedCleanups.set(owner, records);
+        }
+        return cleanup;
+      }
+
+      function runCleanup(cleanup) {
+        if (typeof cleanup !== "function" || !cleanups.has(cleanup)) {
+          return;
+        }
+        cleanups.delete(cleanup);
+        cleanup();
+      }
+
+      function cleanupChildren(container) {
+        runScopedCleanups(container, "children");
+        for (const child of [...(container.childNodes ?? [])]) {
+          cleanupNode(child);
+        }
+      }
+
+      function cleanupNode(node) {
+        if (node.nodeType !== 1) {
+          return;
+        }
+        for (const element of elementsIn(node)) {
+          runScopedCleanups(element);
+        }
+      }
+
+      function runScopedCleanups(element, mode) {
+        const records = scopedCleanups.get(element);
+        if (!records) {
+          return;
+        }
+        const remaining = [];
+        for (const record of records) {
+          if (mode && record.mode !== mode) {
+            remaining.push(record);
+            continue;
+          }
+          runCleanup(record.cleanup);
+        }
+        if (remaining.length > 0) {
+          scopedCleanups.set(element, remaining);
+        } else {
+          scopedCleanups.delete(element);
+        }
+      }
+
+      return api;
+    }
+
+    const AsyncLoader = Loader;
+
+    function normalizeClassTokens(value, tokens = new Set()) {
+      if (value == null || value === false) {
+        return tokens;
+      }
+      if (isSignalRef(value)) {
+        const signalValue = value.value;
+        if (signalValue === true) {
+          tokens.add(signalClassName(value.id));
+          return tokens;
+        }
+        return normalizeClassTokens(signalValue, tokens);
+      }
+      if (typeof value === "string") {
+        for (const token of value.split(/\s+/).filter(Boolean)) {
+          tokens.add(token);
+        }
+        return tokens;
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          normalizeClassTokens(item, tokens);
+        }
+        return tokens;
+      }
+      if (typeof value === "object") {
+        for (const [token, enabled] of Object.entries(value)) {
+          const value = isSignalRef(enabled) ? enabled.value : enabled;
+          if (value) {
+            normalizeClassTokens(token, tokens);
+          }
+        }
+        return tokens;
+      }
+      if (value !== true) {
+        tokens.add(String(value));
+      }
+      return tokens;
+    }
+
+    function resolveInlineValue(value) {
+      if (isSignalRef(value)) {
+        return value.value;
+      }
+      if (Array.isArray(value)) {
+        return value.map(resolveInlineValue);
+      }
+      if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, resolveInlineValue(entry)]));
+      }
+      return value;
+    }
+
+    function collectSignalRefs(value, refs = new Map()) {
+      if (isSignalRef(value)) {
+        refs.set(value.id, value);
+        return [...refs.values()];
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          collectSignalRefs(item, refs);
+        }
+        return [...refs.values()];
+      }
+      if (value && typeof value === "object") {
+        for (const item of Object.values(value)) {
+          collectSignalRefs(item, refs);
+        }
+      }
+      return [...refs.values()];
+    }
+
+    function isInlineBinding(value) {
+      return typeof value === "string" && value.startsWith(inlineBindingPrefix);
+    }
+
+    function signalClassName(id) {
+      return id.split(".").at(-1);
+    }
+
+    function updateClassToken(element, className, enabled) {
+      const tokens = readClassTokens(element);
+      for (const token of normalizeClassTokens(className)) {
+        if (enabled) {
+          tokens.add(token);
+        } else {
+          tokens.delete(token);
+        }
+      }
+      writeClassTokens(element, tokens);
+    }
+
+    function readClassTokens(element) {
+      return normalizeClassTokens(element.getAttribute("class") ?? "");
+    }
+
+    function writeClassTokens(element, tokens) {
+      const value = [...tokens].join(" ");
+      if (value.length === 0) {
+        element.removeAttribute("class");
+        return;
+      }
+      element.setAttribute("class", value);
+    }
+
+    function collectBoundaryTemplates(boundary, id, attributeConfig) {
+      const templates = {};
+      for (const template of [...boundary.children].filter((child) => child.tagName === "TEMPLATE")) {
+        if (readAttribute(template, attributeConfig, "async", "loading") === id) {
+          templates.loading = template;
+        }
+        if (readAttribute(template, attributeConfig, "async", "ready") === id) {
+          templates.ready = template;
+        }
+        if (readAttribute(template, attributeConfig, "async", "error") === id) {
+          templates.error = template;
+        }
+      }
+      return templates;
+    }
+
+    function chooseBoundaryTemplate(templates, status) {
+      if (status === "ready") {
+        return templates.ready ?? templates.loading ?? templates.error;
+      }
+      if (status === "error") {
+        return templates.error ?? templates.ready ?? templates.loading;
+      }
+      return templates.loading ?? templates.ready ?? templates.error;
+    }
+
+    function updateAttribute(element, attr, value) {
+      if (value === false || value == null) {
+        element.removeAttribute(attr);
+        if (attr in element) {
+          element[attr] = false;
+        }
+        return;
+      }
+      element.setAttribute(attr, value === true ? "" : String(value));
+      if (attr in element) {
+        element[attr] = value;
+      }
+    }
+
+    function updateProperty(element, prop, value) {
+      if (value == null) {
+        element[prop] = "";
+        return;
+      }
+      element[prop] = value;
+    }
+
+    function selectAll(scope, selector) {
+      const elements = [];
+      if (scope?.nodeType === 1 && scope.matches?.(selector)) {
+        elements.push(scope);
+      }
+      elements.push(...(scope?.querySelectorAll?.(selector) ?? []));
+      return elements;
+    }
+
+    function elementsIn(scope) {
+      return selectAll(scope, "*");
+    }
+
+    function findBoundary(root, boundaryId, attributeConfig) {
+      for (const element of elementsIn(root)) {
+        if (readAttribute(element, attributeConfig, "async", "boundary") === String(boundaryId)) {
+          return element;
+        }
+      }
+      return null;
+    }
+
+    function toFragment(value, documentRef) {
+      if (value?.nodeType === 11) {
+        return value;
+      }
+      if (value?.tagName === "TEMPLATE") {
+        return value.content.cloneNode(true);
+      }
+      if (value?.nodeType) {
+        const fragment = documentRef.createDocumentFragment();
+        fragment.append(value);
+        return fragment;
+      }
+      const template = documentRef.createElement("template");
+      template.innerHTML = String(value ?? "");
+      return template.content.cloneNode(true);
+    }
+
+    function dispatchAsyncError(element, error) {
+      const EventCtor = element.ownerDocument?.defaultView?.CustomEvent ?? globalThis.CustomEvent;
+      element.dispatchEvent(
+        new EventCtor("async:error", {
+          bubbles: true,
+          detail: { error }
+        })
+      );
+    }
+    return { Loader, AsyncLoader };
+  })();
+
+  const __partialsModule = (() => {
+    const { isTemplateResult, renderTemplate } = __htmlModule;
+    const { attachRegistryInspection, createRegistryStore } = __registryStoreModule;
+    function createPartialRegistry(initialMap = {}, options = {}) {
+      const registryStore = options.registry ?? createRegistryStore();
+      const type = options.type ?? "partial";
+      const entries = registryStore._map(type);
+
+      const registry = attachRegistryInspection({
+        register(id, fn) {
+          assertId(id);
+          if (typeof fn !== "function") {
+            throw new TypeError(`Partial "${id}" must be a function.`);
+          }
+          if (entries.has(id)) {
+            throw new Error(`Partial "${id}" is already registered.`);
+          }
+          entries.set(id, fn);
+          return id;
+        },
+
+        registerMany(map) {
+          for (const [id, fn] of Object.entries(map ?? {})) {
+            registry.register(id, fn);
+          }
+          return registry;
+        },
+
+        unregister(id) {
+          assertId(id);
+          return entries.delete(id);
+        },
+
+        resolve(id) {
+          assertId(id);
+          return entries.get(id);
+        },
+
+        async render(id, props = {}, context = {}) {
+          assertId(id);
+          const fn = registry.resolve(id);
+          if (!fn) {
+            throw new Error(`Partial "${id}" is not registered.`);
+          }
+
+          const partialContext = {
+            ...context,
+            id,
+            props,
+            cache: context.cache,
+            partials: registry
+          };
+          const result = await fn.call(partialContext, props);
+          return normalizePartialResult(result, partialContext);
+        },
+
+        _adoptMany() {
+          return registry;
+        }
+      }, registryStore, type);
+
+      registry.registerMany(initialMap);
+      return registry;
+    }
+
+    function normalizePartialResult(result, context = {}) {
+      if (isPartialEnvelope(result)) {
+        return {
+          ...result,
+          html: Object.hasOwn(result, "html") ? renderPartialValue(result.html, context) : result.html
+        };
+      }
+
+      return { html: renderPartialValue(result, context) };
+    }
+
+    function renderPartialValue(value, context) {
+      if (value?.nodeType) {
+        return value;
+      }
+      if (typeof value === "string") {
+        return value;
+      }
+      if (isTemplateResult(value)) {
+        return renderTemplate(value, templateRenderOptions(context));
+      }
+      return renderTemplate(value, templateRenderOptions(context));
+    }
+
+    function templateRenderOptions(context) {
+      return {
+        attributes: context.loader?.attributes,
+        signals: context.signals,
+        bind: context.loader?._registerBinding?.bind(context.loader)
+      };
+    }
+
+    function isPartialEnvelope(value) {
+      return Boolean(
+        value &&
+          typeof value === "object" &&
+          !Array.isArray(value) &&
+          (Object.hasOwn(value, "html") ||
+            Object.hasOwn(value, "signals") ||
+            Object.hasOwn(value, "boundary") ||
+            Object.hasOwn(value, "redirect") ||
+            Object.hasOwn(value, "status") ||
+            Object.hasOwn(value, "cache"))
+      );
+    }
+
+    function assertId(id) {
+      if (typeof id !== "string" || id.length === 0) {
+        throw new TypeError("Partial id must be a non-empty string.");
+      }
+    }
+    return { createPartialRegistry, normalizePartialResult };
+  })();
+
+  const __routerModule = (() => {
+    const { Loader } = __loaderModule;
+    const { createHandlerRegistry } = __handlersModule;
+    const { createSignalRegistry } = __signalsModule;
+    const { applyServerResult } = __serverModule;
+    const { createRegistryStore } = __registryStoreModule;
+    const { normalizeAttributeConfig } = __attributesModule;
+    function defineRoute(partial, options = {}) {
+      return {
+        ...options,
+        partial
+      };
+    }
+
+    const route = defineRoute;
+
+    function createRouteRegistry(initialMap = {}, options = {}) {
+      const registryStore = options.registry ?? createRegistryStore();
+      const type = options.type ?? "route";
+      const entries = registryStore._map(type);
+      const routes = [];
+
+      const registry = {
+        registry: registryStore,
+
+        register(pattern, definition) {
+          assertPattern(pattern);
+          if (routes.some((candidate) => candidate.pattern === pattern)) {
+            throw new Error(`Route "${pattern}" is already registered.`);
+          }
+          const nextRoute = normalizeRoute(pattern, definition);
+          entries.set(pattern, nextRoute.definition);
+          routes.push(nextRoute);
+          return nextRoute;
+        },
+
+        registerMany(map) {
+          for (const [pattern, definition] of Object.entries(map ?? {})) {
+            registry.register(pattern, definition);
+          }
+          return registry;
+        },
+
+        unregister(pattern) {
+          assertPattern(pattern);
+          const index = routes.findIndex((candidate) => candidate.pattern === pattern);
+          if (index !== -1) {
+            routes.splice(index, 1);
+          }
+          return entries.delete(pattern);
+        },
+
+        match(url) {
+          const path = toUrl(url).pathname;
+          for (const candidate of routes) {
+            const match = candidate.regex.exec(path);
+            if (!match) {
+              continue;
+            }
+            const params = {};
+            candidate.keys.forEach((key, index) => {
+              params[key] = decodeURIComponent(match[index + 1] ?? "");
+            });
+            return {
+              pattern: candidate.pattern,
+              params,
+              route: candidate.definition
+            };
+          }
+          return null;
+        },
+
+        entries() {
+          return routes.map(({ pattern, definition }) => ({ pattern, route: definition }));
+        },
+
+        keys() {
+          return [...entries.keys()];
+        },
+
+        inspect() {
+          return registryStore.entries(type);
+        },
+
+        _adoptMany(map = {}) {
+          for (const pattern of Object.keys(map ?? {})) {
+            adoptRoute(pattern, entries.get(pattern));
+          }
+          return registry;
+        }
+      };
+
+      for (const [pattern, definition] of entries) {
+        adoptRoute(pattern, definition);
+      }
+      registry.registerMany(initialMap);
+      return registry;
+
+      function adoptRoute(pattern, definition) {
+        if (routes.some((candidate) => candidate.pattern === pattern)) {
+          return;
+        }
+        const nextRoute = normalizeRoute(pattern, definition);
+        entries.set(pattern, nextRoute.definition);
+        routes.push(nextRoute);
+      }
+    }
+
+    function createRouter({
+      mode = "ssr-spa",
+      root,
+      boundary = "route",
+      routes = createRouteRegistry(),
+      loader,
+      signals,
+      handlers,
+      server,
+      cache,
+      partials,
+      fetch: fetchImpl = globalThis.fetch?.bind(globalThis),
+      routeEndpoint = "/__async/route",
+      attributes
+    } = {}) {
+      const documentRef = root?.ownerDocument ?? root ?? globalThis.document;
+      const rootNode = root ?? documentRef;
+      const signalRegistry = signals ?? loader?.signals ?? createSignalRegistry();
+      const handlerRegistry = handlers ?? loader?.handlers ?? createHandlerRegistry();
+      const attributeConfig = normalizeAttributeConfig(attributes ?? loader?.attributes);
+      const loaderInstance =
+        loader ??
+        Loader({
+          root: rootNode,
+          signals: signalRegistry,
+          handlers: handlerRegistry,
+          server,
+          cache,
+          attributes: attributeConfig
+        });
+      const ownsLoader = !loader;
+      const cleanups = new Set();
+      let destroyed = false;
+
+      const api = {
+        mode,
+        root: rootNode,
+        boundary,
+        routes,
+        loader: loaderInstance,
+        signals: signalRegistry,
+        handlers: handlerRegistry,
+        server,
+        cache,
+        partials,
+        attributes: attributeConfig,
+
+        start() {
+          assertActive();
+          loaderInstance.router = api;
+          signalRegistry._setContext?.({ router: api, loader: loaderInstance, server, cache });
+          if (ownsLoader) {
+            loaderInstance.start();
+          }
+          if (mode === "mpa" || mode === "ssr") {
+            updateStateFromLocation();
+            return api;
+          }
+          bindNavigation();
+          if (mode === "csr") {
+            void api.navigate(currentUrl(), {
+              replace: true,
+              initial: true,
+              source: "client"
+            }).catch(() => {});
+            return api;
+          }
+          updateStateFromLocation();
+          return api;
+        },
+
+        match(url) {
+          return routes.match(url);
+        },
+
+        prefetch(url) {
+          assertActive();
+          if (mode === "ssr-spa" && typeof fetchImpl === "function") {
+            return fetchRoute(url, { prefetch: true });
+          }
+          const matched = api.match(url);
+          if (matched?.route?.partial && partials?.resolve?.(matched.route.partial)) {
+            return partials.render(matched.route.partial, matched.params, contextFor(matched));
+          }
+          if (typeof fetchImpl === "function") {
+            return fetchRoute(url, { prefetch: true });
+          }
+          return Promise.resolve(null);
+        },
+
+        async navigate(url, options = {}) {
+          assertActive();
+          if (mode === "mpa" || mode === "ssr") {
+            documentRef.defaultView?.location?.assign?.(url);
+            return null;
+          }
+
+          const target = toUrl(url);
+          if (mode === "ssr-spa") {
+            return fetchRoutePartial(target, options);
+          }
+          return renderLocalRoutePartial(target, options);
+        },
+
+        destroy() {
+          if (destroyed) {
+            return;
+          }
+          destroyed = true;
+          for (const cleanup of cleanups) {
+            cleanup();
+          }
+          cleanups.clear();
+        }
+      };
+
+      return api;
+
+      function bindNavigation() {
+        const click = (event) => {
+          const anchor = closest(event.target, "a[href]");
+          if (!anchor || shouldIgnoreLink(event, anchor)) {
+            return;
+          }
+          event.preventDefault();
+          api.navigate(anchor.href);
+        };
+        const submit = (event) => {
+          const form = closest(event.target, "form");
+          if (!form || shouldIgnoreForm(form)) {
+            return;
+          }
+          event.preventDefault();
+          api.navigate(formActionUrl(form));
+        };
+        const popstate = () => api.navigate(currentUrl(), { history: false });
+
+        rootNode.addEventListener?.("click", click);
+        rootNode.addEventListener?.("submit", submit);
+        documentRef.defaultView?.addEventListener?.("popstate", popstate);
+        cleanups.add(() => rootNode.removeEventListener?.("click", click));
+        cleanups.add(() => rootNode.removeEventListener?.("submit", submit));
+        cleanups.add(() => documentRef.defaultView?.removeEventListener?.("popstate", popstate));
+      }
+
+      async function renderLocalRoutePartial(target, options = {}) {
+        const matched = api.match(target);
+        if (!matched) {
+          setNoRouteError(target);
+          return null;
+        }
+
+        setMatchedRouterState(target, matched, { pending: true, error: null });
+
+        try {
+          if (!matched.route?.partial || !partials?.resolve?.(matched.route.partial)) {
+            const error = new Error(`Route "${target.pathname}" does not have a registered partial.`);
+            setRouterState({ pending: false, error });
+            return null;
+          }
+
+          const result = await partials.render(matched.route.partial, matched.params, contextFor(matched));
+          await applyNavigationResult(result, target, options);
+          setRouterState({ pending: false, error: null });
+          return result;
+        } catch (error) {
+          setRouterState({ pending: false, error });
+          throw error;
+        }
+      }
+
+      async function fetchRoutePartial(target, options = {}) {
+        const matched = api.match(target);
+        setMatchedRouterState(target, matched, { pending: true, error: null });
+
+        try {
+          const result = await fetchRoute(target.href);
+          await applyNavigationResult(result, target, options);
+          setRouterState({ pending: false, error: null });
+          return result;
+        } catch (error) {
+          setRouterState({ pending: false, error });
+          throw error;
+        }
+      }
+
+      async function applyNavigationResult(result, target, options) {
+        await applyServerResult(result, {
+          signals: signalRegistry,
+          loader: loaderInstance,
+          router: api,
+          cache
+        });
+        if (result?.html != null && !result.boundary && !result.redirect) {
+          loaderInstance.swap(boundary, result.html);
+        }
+        if (result?.redirect || options.history === false) {
+          return;
+        }
+        if (options.replace) {
+          documentRef.defaultView?.history?.replaceState?.({}, "", target.href);
+          return;
+        }
+        documentRef.defaultView?.history?.pushState?.({}, "", target.href);
+      }
+
+      async function fetchRoute(url, { prefetch = false } = {}) {
+        if (typeof fetchImpl !== "function") {
+          throw new Error("Router navigation requires a partial registry or fetch.");
+        }
+        const response = await fetchImpl(`${routeEndpoint}?to=${encodeURIComponent(String(url))}`, {
+          headers: {
+            accept: "application/json, text/html"
+          }
+        });
+        if (!response.ok) {
+          throw new Error(`Route "${url}" failed with ${response.status}.`);
+        }
+        if (prefetch) {
+          return response;
+        }
+        const type = response.headers.get("content-type") ?? "";
+        if (type.includes("application/json")) {
+          return response.json();
+        }
+        return { boundary, html: await response.text() };
+      }
+
+      function contextFor(matched) {
+        return {
+          params: matched.params,
+          route: matched.route,
+          router: api,
+          signals: signalRegistry,
+          handlers: handlerRegistry,
+          loader: loaderInstance,
+          server,
+          cache,
+          abort: undefined
+        };
+      }
+
+      function updateStateFromLocation() {
+        const url = currentUrl();
+        const matched = api.match(url);
+        setMatchedRouterState(url, matched, { pending: false, error: null });
+      }
+
+      function setMatchedRouterState(url, matched, patch = {}) {
+        signalRegistry.ensure("router", {});
+        setRouterState({
+          url: url.href,
+          path: url.pathname,
+          query: queryObject(url),
+          params: matched?.params ?? {},
+          route: matched?.route ?? null,
+          ...patch
+        });
+      }
+
+      function setNoRouteError(url) {
+        const error = new Error(`No route matched ${url.pathname}${url.search}`);
+        setMatchedRouterState(url, null, {
+          pending: false,
+          error
+        });
+      }
+
+      function setRouterState(patch) {
+        signalRegistry.ensure("router", {});
+        for (const [key, value] of Object.entries(patch)) {
+          signalRegistry.set(`router.${key}`, value);
+        }
+      }
+
+      function currentUrl() {
+        return toUrl(documentRef.defaultView?.location?.href ?? "http://localhost/");
+      }
+
+      function assertActive() {
+        if (destroyed) {
+          throw new Error("Router has been destroyed.");
+        }
+      }
+    }
+
+    function normalizeRoute(pattern, definition) {
+      const normalized = typeof definition === "string" ? defineRoute(definition) : definition;
+      const { regex, keys } = compilePattern(pattern);
+      return {
+        pattern,
+        regex,
+        keys,
+        definition: normalized
+      };
+    }
+
+    function compilePattern(pattern) {
+      const keys = [];
+      if (pattern === "*") {
+        return { regex: /^.*$/, keys };
+      }
+      if (pattern === "/") {
+        return { regex: /^\/$/, keys };
+      }
+
+      const source = pattern
+        .split("/")
+        .map((segment) => {
+          if (segment.startsWith(":")) {
+            keys.push(segment.slice(1));
+            return "([^/]+)";
+          }
+          return escapeRegExp(segment);
+        })
+        .join("/");
+
+      return { regex: new RegExp(`^${source}$`), keys };
+    }
+
+    function shouldIgnoreLink(event, anchor) {
+      if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
+        return true;
+      }
+      if (anchor.target || anchor.hasAttribute("download")) {
+        return true;
+      }
+      return toUrl(anchor.href).origin !== toUrl(anchor.ownerDocument.defaultView.location.href).origin;
+    }
+
+    function shouldIgnoreForm(form) {
+      const method = String(form.method || "get").toLowerCase();
+      return method !== "get" || toUrl(form.action).origin !== toUrl(form.ownerDocument.defaultView.location.href).origin;
+    }
+
+    function formActionUrl(form) {
+      const url = toUrl(form.action || form.ownerDocument.defaultView.location.href);
+      const formData = new form.ownerDocument.defaultView.FormData(form);
+      url.search = new URLSearchParams(formData).toString();
+      return url.href;
+    }
+
+    function closest(target, selector) {
+      return target?.closest?.(selector);
+    }
+
+    function toUrl(url) {
+      if (url instanceof URL) {
+        return url;
+      }
+      return new URL(String(url), globalThis.location?.href ?? "http://localhost/");
+    }
+
+    function queryObject(url) {
+      return Object.fromEntries(url.searchParams.entries());
+    }
+
+    function escapeRegExp(value) {
+      return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+
+    function assertPattern(pattern) {
+      if (typeof pattern !== "string" || (pattern !== "*" && !pattern.startsWith("/"))) {
+        throw new TypeError("Route pattern must be a path string or \"*\".");
+      }
+    }
+    return { defineRoute, createRouteRegistry, createRouter, route };
+  })();
+
+  const __appModule = (() => {
+    const { createCacheRegistry } = __cacheModule;
+    const { createComponentRegistry } = __componentModule;
+    const { createHandlerRegistry } = __handlersModule;
+    const { Loader } = __loaderModule;
+    const { createPartialRegistry } = __partialsModule;
+    const { createRouteRegistry, createRouter } = __routerModule;
+    const { createServerRegistry } = __serverModule;
+    const { createSignal, createSignalRegistry } = __signalsModule;
+    const { createRegistryStore } = __registryStoreModule;
+    const { attributeName, normalizeAttributeConfig } = __attributesModule;
+    const registryTypes = new Set(["signal", "handler", "server", "partial", "route", "component"]);
+
+    function defineApp(initial) {
+      const registry = createRegistryStore(undefined, { target: "browser" });
+      const runtimes = new Set();
+
+      const app = {
+        registry,
+
+        use(typeOrModule, entries) {
+          const normalized = normalizeUse(typeOrModule, entries);
+          appendDeclarations(registry, normalized);
+          for (const runtime of runtimes) {
+            runtime._applyUse(normalized);
+          }
+          return app;
+        },
+
+        snapshot() {
+          return registry.rawSnapshot();
+        },
+
+        start(options = {}) {
+          const runtime = createApp(app, options).start();
+          app.runtime = runtime;
+          return runtime;
+        },
+
+        _attach(runtime) {
+          runtimes.add(runtime);
+          return () => app._detach(runtime);
+        },
+
+        _detach(runtime) {
+          runtimes.delete(runtime);
+        }
+      };
+
+      if (initial) {
+        app.use(initial);
+      }
+
+      return app;
+    }
+
+    function createApp(appOrDefinition = Async, options = {}) {
+      const app = isAppHub(appOrDefinition) ? appOrDefinition : defineApp(appOrDefinition ?? {});
+      const target = options.target ?? "browser";
+      const attributes = normalizeAttributeConfig(options.attributes);
+      const registry = options.registry ?? app.registry.view({ target });
+      const signals = options.signals ?? createSignalRegistry(undefined, { registry, type: "signal" });
+      const handlers = options.handlers ?? createHandlerRegistry(undefined, { registry, type: "handler" });
+      const serverCache = createCacheRegistry(undefined, { registry, type: "cache.server" });
+      const browserCache = createCacheRegistry(undefined, { registry, type: "cache.browser" });
+      const server = options.server ?? createServerRegistry(undefined, { registry, type: "server" });
+      const partials = options.partials ?? createPartialRegistry(undefined, { registry, type: "partial" });
+      const routes = options.routes ?? createRouteRegistry(undefined, { registry, type: "route" });
+      const components = options.components ?? createComponentRegistry(undefined, { registry, type: "component" });
+      let loader = options.loader;
+      let router = options.router;
+      let detach = () => {};
+      let started = false;
+      let destroyed = false;
+
+      applySnapshot(signals, browserCache, options.snapshot);
+      attachServerCache(server, serverCache);
+
+      const runtime = {
+        app,
+        registry,
+        target,
+        signals,
+        handlers,
+        server,
+        partials,
+        routes,
+        components,
+        browser: {
+          cache: browserCache
+        },
+        loader,
+        router,
+        attributes,
+
+        start() {
+          assertActive();
+          if (started) {
+            return runtime;
+          }
+          started = true;
+
+          if (target !== "server") {
+            loader = loader ?? Loader({
+              root: options.root,
+              signals,
+              handlers,
+              server,
+              cache: browserCache,
+              attributes
+            });
+            runtime.loader = loader;
+
+            configureServerContext({ cache: browserCache });
+            signals._setContext?.({ server, loader, cache: browserCache });
+
+            loader.start();
+
+            if (router !== false && (router || shouldStartRouter(routes, options))) {
+              router = router ?? createRouter({
+                mode: options.mode ?? "ssr-spa",
+                root: options.root,
+                boundary: options.boundary ?? "route",
+                routes,
+                loader,
+                signals,
+                handlers,
+                server,
+                cache: browserCache,
+                partials,
+                fetch: options.fetch,
+                routeEndpoint: options.routeEndpoint,
+                attributes
+              });
+              runtime.router = router;
+              loader.router = router;
+              configureServerContext({ cache: browserCache, router });
+              router.start();
+            }
+          } else {
+            configureServerContext({ cache: serverCache });
+            signals._setContext?.({ server, cache: serverCache });
+          }
+
+          return runtime;
+        },
+
+        use(typeOrModule, entries) {
+          app.use(typeOrModule, entries);
+          return runtime;
+        },
+
+        async render(url) {
+          assertActive();
+          configureServerContext({ cache: serverCache });
+          signals._setContext?.({ server, cache: serverCache });
+          const matched = routes.match(url);
+          if (!matched) {
+            return {
+              html: renderDocument("", { status: 404, signals, browserCache, boundary: options.boundary ?? "route", attributes }),
+              status: 404,
+              signals: signals.snapshot(),
+              cache: { browser: browserCache.snapshot() }
+            };
+          }
+
+          const partialId = matched.route.partial;
+          const result = partialId && partials.resolve(partialId)
+            ? await partials.render(partialId, matched.params, {
+                params: matched.params,
+                route: matched.route,
+                signals,
+                handlers,
+                server,
+                cache: serverCache,
+                browserCache,
+                partials,
+                request: options.request,
+                locals: options.locals
+              })
+            : { html: "" };
+
+          if (result.signals) {
+            for (const [path, value] of Object.entries(result.signals)) {
+              setOrRegisterSignal(signals, path, value);
+            }
+          }
+          if (result.cache?.browser) {
+            browserCache.restore(result.cache.browser);
+          }
+
+          const status = result.status ?? 200;
+          return {
+            html: renderDocument(result.html, { status, signals, browserCache, boundary: result.boundary ?? options.boundary ?? "route", attributes }),
+            status,
+            signals: signals.snapshot(),
+            cache: { browser: browserCache.snapshot() }
+          };
+        },
+
+        destroy() {
+          if (destroyed) {
+            return;
+          }
+          destroyed = true;
+          detach();
+          router?.destroy?.();
+          loader?.destroy?.();
+          signals.destroy?.();
+        },
+
+        _applyUse(normalized) {
+          applyUseToRuntime(runtime, normalized);
+        }
+      };
+
+      server.cache = serverCache;
+      runtime.server.cache = serverCache;
+      detach = app._attach(runtime);
+
+      return runtime;
+
+      function configureServerContext(extra = {}) {
+        const cache = isLocalServerRegistry(server) ? serverCache : extra.cache;
+        server._setContext?.({
+          signals,
+          loader,
+          router,
+          cache,
+          request: options.request,
+          locals: options.locals
+        });
+      }
+
+      function assertActive() {
+        if (destroyed) {
+          throw new Error("Async app runtime has been destroyed.");
+        }
+      }
+    }
+
+    const Async = defineApp();
+
+    function applyUseToRuntime(runtime, normalized) {
+      applyRegistryUse(runtime.signals, runtime.registry, normalized.signal);
+      applyRegistryUse(runtime.handlers, runtime.registry, normalized.handler);
+      applyRegistryUse(runtime.server, runtime.registry, normalized.server);
+      applyRegistryUse(runtime.partials, runtime.registry, normalized.partial);
+      applyRegistryUse(runtime.routes, runtime.registry, normalized.route);
+      applyRegistryUse(runtime.components, runtime.registry, normalized.component);
+      applyRegistryUse(runtime.browser.cache, runtime.registry, normalized.cache.browser);
+      applyRegistryUse(runtime.server.cache, runtime.registry, normalized.cache.server);
+    }
+
+    function applyRegistryUse(registry, runtimeRegistry, entries) {
+      if (!entries || Object.keys(entries).length === 0) {
+        return;
+      }
+      if (registry?.registry === runtimeRegistry) {
+        registry._adoptMany?.(entries);
+        return;
+      }
+      registry?.registerMany?.(entries);
+    }
+
+    function emptyDeclarations() {
+      return {
+        signal: {},
+        handler: {},
+        server: {},
+        partial: {},
+        route: {},
+        component: {},
+        cache: {
+          browser: {},
+          server: {}
+        }
+      };
+    }
+
+    function normalizeUse(typeOrModule, entries) {
+      const normalized = emptyDeclarations();
+
+      if (typeof typeOrModule === "string") {
+        if (!registryTypes.has(typeOrModule)) {
+          throw new Error(`Unknown Async registry type "${typeOrModule}".`);
+        }
+        normalized[typeOrModule] = normalizeEntries(typeOrModule, entries);
+        return normalized;
+      }
+
+      if (!typeOrModule || typeof typeOrModule !== "object") {
+        throw new TypeError("Async.use(...) requires a registry type or module object.");
+      }
+
+      for (const [type, value] of Object.entries(typeOrModule)) {
+        if (type === "cache") {
+          normalized.cache.browser = { ...(value?.browser ?? {}) };
+          normalized.cache.server = { ...(value?.server ?? {}) };
+          continue;
+        }
+        if (!registryTypes.has(type)) {
+          throw new Error(`Unknown Async registry type "${type}".`);
+        }
+        normalized[type] = normalizeEntries(type, value);
+      }
+
+      return normalized;
+    }
+
+    function appendDeclarations(target, source) {
+      for (const type of registryTypes) {
+        addEntries(target, type, source[type]);
+      }
+      addEntries(target, "cache.browser", source.cache.browser);
+      addEntries(target, "cache.server", source.cache.server);
+    }
+
+    function addEntries(registry, type, source) {
+      for (const [id, value] of Object.entries(source ?? {})) {
+        registry.register(type, id, value);
+      }
+    }
+
+    function isAppHub(value) {
+      return Boolean(value && typeof value.use === "function" && typeof value.snapshot === "function" && value.registry);
+    }
+
+    function applySnapshot(signals, browserCache, snapshot = {}) {
+      for (const [path, value] of Object.entries(snapshot.signals ?? {})) {
+        setOrRegisterSignal(signals, path, value);
+      }
+      browserCache.restore(snapshot.cache?.browser);
+    }
+
+    function setOrRegisterSignal(signals, path, value) {
+      const id = String(path).split(".")[0];
+      if (signals.has?.(id)) {
+        signals.set(path, value);
+        return;
+      }
+      signals.register(id, createSignal(path === id ? value : {}));
+      if (path !== id) {
+        signals.set(path, value);
+      }
+    }
+
+    function attachServerCache(server, cache) {
+      try {
+        server.cache = cache;
+      } catch {
+        // Proxies that reject assignment can still receive cache through _setContext.
+      }
+    }
+
+    function normalizeEntries(type, entries = {}) {
+      if (type !== "signal") {
+        return { ...(entries ?? {}) };
+      }
+      const normalized = {};
+      for (const [id, value] of Object.entries(entries ?? {})) {
+        normalized[id] = normalizeSignalDeclaration(value);
+      }
+      return normalized;
+    }
+
+    function normalizeSignalDeclaration(value) {
+      if (value && typeof value === "object" && typeof value.subscribe === "function") {
+        return value;
+      }
+      return createSignal(value);
+    }
+
+    function isLocalServerRegistry(server) {
+      return typeof server?.registerMany === "function";
+    }
+
+    function shouldStartRouter(routes, options) {
+      return Boolean(options.routerOptions || options.mode || routes.entries().length > 0);
+    }
+
+    function renderDocument(routeHtml, { signals, browserCache, boundary, attributes }) {
+      const snapshot = {
+        signals: signals.snapshot(),
+        cache: {
+          browser: browserCache.snapshot()
+        }
+      };
+      const boundaryAttr = attributeName(attributes, "async", "boundary");
+      const snapshotAttr = attributeName(attributes, "async", "snapshot");
+      return `<section ${boundaryAttr}="${escapeAttribute(boundary)}">${routeHtml ?? ""}</section><script type="application/json" ${snapshotAttr}>${escapeScriptJson(snapshot)}</script>`;
+    }
+
+    function escapeAttribute(value) {
+      return String(value)
+        .replaceAll("&", "&amp;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("<", "&lt;");
+    }
+
+    function escapeScriptJson(value) {
+      return JSON.stringify(value).replaceAll("<", "\\u003c");
+    }
+    return { defineApp, createApp, Async };
+  })();
+
+  const __delayModule = (() => {
+    function delay(ms, signal) {
+      if (signal?.aborted) {
+        return Promise.reject(abortReason(signal));
+      }
+
+      return new Promise((resolve, reject) => {
+        let timer = setTimeout(done, ms);
+
+        function done() {
+          timer = undefined;
+          signal?.removeEventListener?.("abort", aborted);
+          resolve();
+        }
+
+        function aborted() {
+          if (timer !== undefined) {
+            clearTimeout(timer);
+          }
+          timer = undefined;
+          signal?.removeEventListener?.("abort", aborted);
+          reject(abortReason(signal));
+        }
+
+        signal?.addEventListener?.("abort", aborted, { once: true });
+      });
+    }
+
+    function abortReason(signal) {
+      return signal?.reason ?? new Error("Operation aborted");
+    }
+    return { delay };
+  })();
+
+  const { asyncSignal: asyncSignal } = __asyncSignalModule;
+  const { Async: Async } = __appModule;
+  const { createApp: createApp } = __appModule;
+  const { defineApp: defineApp } = __appModule;
+  const { attributeName: attributeName } = __attributesModule;
+  const { defineAttributeConfig: defineAttributeConfig } = __attributesModule;
+  const { createCacheRegistry: createCacheRegistry } = __cacheModule;
+  const { defineCache: defineCache } = __cacheModule;
+  const { component: component } = __componentModule;
+  const { createComponentRegistry: createComponentRegistry } = __componentModule;
+  const { defineComponent: defineComponent } = __componentModule;
+  const { delay: delay } = __delayModule;
+  const { createHandlerRegistry: createHandlerRegistry } = __handlersModule;
+  const { html: html } = __htmlModule;
+  const { Loader: Loader } = __loaderModule;
+  const { AsyncLoader: AsyncLoader } = __loaderModule;
+  const { createPartialRegistry: createPartialRegistry } = __partialsModule;
+  const { createRegistryStore: createRegistryStore } = __registryStoreModule;
+  const { createRouteRegistry: createRouteRegistry } = __routerModule;
+  const { createRouter: createRouter } = __routerModule;
+  const { defineRoute: defineRoute } = __routerModule;
+  const { route: route } = __routerModule;
+  const { createServerProxy: createServerProxy } = __serverModule;
+  const { createServerRegistry: createServerRegistry } = __serverModule;
+  const { computed: computed } = __signalsModule;
+  const { createSignal: createSignal } = __signalsModule;
+  const { createSignalRegistry: createSignalRegistry } = __signalsModule;
+  const { effect: effect } = __signalsModule;
+  const { signal: signal } = __signalsModule;
+  const api = { asyncSignal, Async, createApp, defineApp, attributeName, defineAttributeConfig, createCacheRegistry, defineCache, component, createComponentRegistry, defineComponent, delay, createHandlerRegistry, html, Loader, AsyncLoader, createPartialRegistry, createRegistryStore, createRouteRegistry, createRouter, defineRoute, route, createServerProxy, createServerRegistry, computed, createSignal, createSignalRegistry, effect, signal };
+  assertNoUmdNamespaceConflicts(api, Async);
+  Object.assign(Async, api);
+  Async.Async = Async;
+  return Async;
+
+  function assertNoUmdNamespaceConflicts(api, target) {
+    const conflicts = Object.keys(api).filter((key) => key !== "Async" && Object.prototype.hasOwnProperty.call(target, key));
+    if (conflicts.length > 0) {
+      throw new Error(`UMD Async namespace export conflict: ${conflicts.join(", ")}.`);
+    }
+  }
+});