@streetui/router 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 StreetUI contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# @streetui/router
+
+Client-side routing for StreetUI applications: route matching, navigation,
+active-link state, 404 handling, and route lifecycle cleanup — built entirely on
+StreetUI's own primitives (signals, the compiler, the runtime, the renderer).
+
+It introduces **no** virtual DOM, **no** second reactive system, and **no**
+third-party dependencies. The router sits *above* the existing pipeline and
+composes it:
+
+```
+DSL → Compiler → Semantic Application Graph → Runtime → Renderer → DOM
+                                   ▲
+                              @streetui/router  (drives which page is mounted)
+```
+
+Route state is a StreetUI `signal`; route cleanup reuses the core
+`CleanupRegistry`; each route is compiled and mounted as an ordinary StreetUI
+application tree. Only the affected route subtree is re-created on navigation —
+the shell persists.
+
+## Quick start
+
+```ts
+import { createRouter, mountRouter, routerOutlet } from '@streetui/router';
+
+const router = createRouter({
+  routes: [
+    { path: '/',            builder: (page) => page.section('home', s => s.heading('Home')) },
+    { path: '/docs',        builder: (page) => page.section('docs', s => s.heading('Docs')) },
+    { path: '/docs/:section', builder: (page, ctx) =>
+        page.section('doc', s => s.heading(ctx.params.section ?? '')) },
+    { path: '/products',    builder: (page, ctx) =>
+        page.section('p', s => s.text(`page ${ctx.query.get('page') ?? '1'}`)) },
+    { path: '*',            builder: (page) => page.section('nf', s => s.heading('404')) },
+  ],
+});
+
+mountRouter(router, {
+  container: document.getElementById('app')!,
+  shell: (shell) => {
+    shell.section('nav', (n) => {
+      n.link('Home', { href: '/' });
+      n.link('Docs', { href: '/docs' });
+    });
+    routerOutlet(shell); // route content renders here
+  },
+});
+```
+
+## Routes
+
+A route is `{ path, builder }`. The builder receives the page scope and a
+`RouteContext`, and builds the page with the normal StreetUI DSL.
+
+Patterns support:
+
+| Pattern            | Matches                          | Captures            |
+| ------------------ | -------------------------------- | ------------------- |
+| `/`, `/docs`       | that exact path                  | —                   |
+| `/users/:id`       | `/users/123`                     | `params.id = "123"` |
+| `/files/*`         | `/files/a/b/c`                   | `params['*'] = "a/b/c"` |
+| `*`                | anything (use as the 404 route)  | `params['*']`       |
+
+Routes are matched in definition order — the first match wins, so list a `*`
+route last.
+
+## Dynamic parameters
+
+`:name` segments are captured into `ctx.params` (percent-decoded):
+
+```ts
+{ path: '/users/:id', builder: (page, ctx) => {
+    page.section('u', s => s.heading(`User ${ctx.params.id}`));
+} }
+```
+
+## Query parameters
+
+The query string is parsed into a standard `URLSearchParams` on `ctx.query`:
+
+```ts
+{ path: '/products', builder: (page, ctx) => {
+    const page$ = ctx.query.get('page') ?? '1'; // /products?page=2 → "2"
+} }
+```
+
+## Navigation
+
+```ts
+router.navigate('/docs');                 // push a new history entry
+router.navigate('/docs', { replace: true }); // replace the current entry
+router.navigate('/products?page=2');      // query strings are carried through
+router.back();
+router.forward();
+```
+
+Internal navigation uses `history.pushState`/`replaceState` — **no full-page
+reload**. Genuine browser back/forward is handled via `popstate`.
+
+Clicks on internal `<a>` elements (rendered by the existing `link()` DSL) are
+intercepted for client-side navigation. External links are left untouched:
+absolute URLs (`https://…`), `target="_blank"` (i.e. `link(…, { external: true })`),
+`mailto:`/`tel:`, in-page `#anchors`, and modified clicks (⌘/Ctrl/Shift/Alt or
+non-left button) all behave normally. Disable interception with
+`mountRouter(router, { …, interceptLinks: false })`.
+
+## Active links
+
+`isActive` returns a reactive `ReadonlySignal<boolean>` you can consume like any
+StreetUI signal (e.g. inside `when()`):
+
+```ts
+router.isActive('/docs');                 // true on /docs and /docs/anything (prefix)
+router.isActive('/docs', { exact: true }); // true only on exactly /docs
+```
+
+## 404 routes
+
+Add a `*` route as the last entry; it renders as a normal StreetUI page tree
+(no special renderer path). Its match reports `currentRoute.get().isFallback === true`.
+If you omit a `*` route, a minimal built-in 404 page is used; override it with
+`createRouter({ routes, notFound })`.
+
+## Route lifecycle & cleanup
+
+On navigation A → B, the router disposes route A completely before mounting B:
+
+1. runs A's route-scoped `CleanupRegistry` (everything registered via
+   `ctx.onCleanup`), then
+2. unmounts A's runtime — which disposes DOM nodes, event listeners and signal
+   subscriptions via the existing `NodeInstance.dispose()` / renderer teardown.
+
+Register any manually-created resources (effects, timers, subscriptions) with
+`ctx.onCleanup` so they are torn down on navigation:
+
+```ts
+{ path: '/live', builder: (page, ctx) => {
+    const stop = effect(() => console.log(count.get()));
+    ctx.onCleanup(stop);                       // disposed when leaving /live
+    const t = setInterval(tick, 1000);
+    ctx.onCleanup(() => clearInterval(t));
+} }
+```
+
+There is no second cleanup system — this is the same `CleanupRegistry` the
+runtime and renderer already use.
+
+## Hydration (SSR)
+
+When the shell + initial route were rendered on the server, hydrate instead of
+mounting cold:
+
+```ts
+mountRouter(router, { container, hydrate: true, shell });
+```
+
+With `hydrate: true`, `mountRouter` adopts the server-rendered shell and the
+initial route's DOM in place (same element objects, no rebuild), resolving
+dynamic params and query identically on both sides. Client-side navigation then
+takes over — subsequent route changes render fresh into the outlet while the
+shell persists. Use `createMemoryHistory(path)` with the same initial path on
+the server so the initial match agrees. See `packages/renderer/README.md` for
+`renderToString` and the state island.
+
+## History adapters
+
+`createRouter` uses a browser history by default. For tests or non-DOM
+environments, pass an in-memory history (deterministic `back()`/`forward()`):
+
+```ts
+import { createMemoryHistory } from '@streetui/router';
+const router = createRouter({ routes, history: createMemoryHistory('/docs') });
+```
+
+## API reference
+
+- `createRouter({ routes, history?, notFound? }): Router`
+  - `router.currentRoute: ReadonlySignal<RouteMatch>`
+  - `router.navigate(to, { replace? })`, `router.back()`, `router.forward()`
+  - `router.isActive(path, { exact? }): ReadonlySignal<boolean>`
+  - `router.destroy()`
+- `mountRouter(router, { container, shell?, outletId?, renderer?, interceptLinks?, hydrate? }): MountedRouter`
+- `routerOutlet(scope, id?)` — declare the outlet inside a shell
+- `createBrowserHistory()`, `createMemoryHistory(initial?)`
+- Matching helpers: `matchPattern`, `matchRoutes`, `normalizePath`, `splitTarget`
+- Types: `RouteDefinition`, `RouteContext`, `RouteMatch`, `Router`, `RouterHistory`

package/dist/index.cjs

@@ -0,0 +1,373 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ROUTER_OUTLET_ID: () => ROUTER_OUTLET_ID,
+  createBrowserHistory: () => createBrowserHistory,
+  createMemoryHistory: () => createMemoryHistory,
+  createRouter: () => createRouter,
+  matchPattern: () => matchPattern,
+  matchRoutes: () => matchRoutes,
+  mountRouter: () => mountRouter,
+  normalizePath: () => normalizePath,
+  routerOutlet: () => routerOutlet,
+  splitTarget: () => splitTarget
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/matching.ts
+function segments(path) {
+  return path.split("/").filter((s) => s.length > 0);
+}
+function normalizePath(path) {
+  let p = path.trim();
+  if (p === "") return "/";
+  if (!p.startsWith("/")) p = `/${p}`;
+  if (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
+  return p;
+}
+function matchPattern(pattern, pathname) {
+  if (pattern === "*") {
+    return { "*": normalizePath(pathname).slice(1) };
+  }
+  const patSegs = segments(pattern);
+  const pathSegs = segments(normalizePath(pathname));
+  const params = {};
+  for (let i = 0; i < patSegs.length; i++) {
+    const patSeg = patSegs[i];
+    if (patSeg === "*") {
+      params["*"] = pathSegs.slice(i).map((s) => decodeURIComponent(s)).join("/");
+      return params;
+    }
+    const pathSeg = pathSegs[i];
+    if (pathSeg === void 0) return null;
+    if (patSeg.startsWith(":")) {
+      const name = patSeg.slice(1);
+      if (name === "") return null;
+      params[name] = decodeURIComponent(pathSeg);
+      continue;
+    }
+    if (patSeg !== pathSeg) return null;
+  }
+  if (pathSegs.length !== patSegs.length) return null;
+  return params;
+}
+function matchRoutes(routes, pathname) {
+  for (const route of routes) {
+    const params = matchPattern(route.path, pathname);
+    if (params !== null) return { route, params };
+  }
+  return null;
+}
+function splitTarget(to) {
+  const hashIndex = to.indexOf("#");
+  const withoutHash = hashIndex >= 0 ? to.slice(0, hashIndex) : to;
+  const qIndex = withoutHash.indexOf("?");
+  if (qIndex < 0) return { pathname: normalizePath(withoutHash), search: "" };
+  return {
+    pathname: normalizePath(withoutHash.slice(0, qIndex)),
+    search: withoutHash.slice(qIndex + 1)
+  };
+}
+
+// src/history.ts
+function buildLocation(pathname, search) {
+  return { pathname, search };
+}
+function toUrl(pathname, search) {
+  return search.length > 0 ? `${pathname}?${search}` : pathname;
+}
+function createBrowserHistory() {
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const cb of listeners) cb();
+  };
+  const onPopState = () => notify();
+  window.addEventListener("popstate", onPopState);
+  const current = () => {
+    const loc = window.location;
+    return buildLocation(loc.pathname, loc.search.replace(/^\?/, ""));
+  };
+  return {
+    location: current,
+    push(pathname, search) {
+      window.history.pushState({}, "", toUrl(pathname, search));
+      notify();
+    },
+    replace(pathname, search) {
+      window.history.replaceState({}, "", toUrl(pathname, search));
+      notify();
+    },
+    back() {
+      window.history.back();
+    },
+    forward() {
+      window.history.forward();
+    },
+    listen(cb) {
+      listeners.add(cb);
+      return () => listeners.delete(cb);
+    },
+    dispose() {
+      window.removeEventListener("popstate", onPopState);
+      listeners.clear();
+    }
+  };
+}
+function createMemoryHistory(initial = "/") {
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const cb of listeners) cb();
+  };
+  const parse = (entry) => {
+    const qIndex = entry.indexOf("?");
+    if (qIndex < 0) return buildLocation(entry, "");
+    return buildLocation(entry.slice(0, qIndex), entry.slice(qIndex + 1));
+  };
+  const stack = [initial];
+  let index = 0;
+  return {
+    location() {
+      return parse(stack[index]);
+    },
+    push(pathname, search) {
+      stack.splice(index + 1);
+      stack.push(toUrl(pathname, search));
+      index = stack.length - 1;
+      notify();
+    },
+    replace(pathname, search) {
+      stack[index] = toUrl(pathname, search);
+      notify();
+    },
+    back() {
+      if (index > 0) {
+        index--;
+        notify();
+      }
+    },
+    forward() {
+      if (index < stack.length - 1) {
+        index++;
+        notify();
+      }
+    },
+    listen(cb) {
+      listeners.add(cb);
+      return () => listeners.delete(cb);
+    },
+    dispose() {
+      listeners.clear();
+    }
+  };
+}
+
+// src/router.ts
+var import_state = require("@streetui/state");
+var DEFAULT_NOT_FOUND = {
+  path: "*",
+  builder: (page) => {
+    page.section("not-found", (s) => {
+      s.heading("404 \u2014 Page not found", { level: 1, id: "not-found-title" });
+      s.text("The page you were looking for does not exist.", { id: "not-found-text" });
+      s.link("Go home", { href: "/", id: "not-found-home" });
+    }, { id: "not-found" });
+  }
+};
+function createRouter(options) {
+  const routes = options.routes;
+  const history = options.history ?? createBrowserHistory();
+  const fallback = options.notFound ?? DEFAULT_NOT_FOUND;
+  const resolve = () => {
+    const loc = history.location();
+    const pathname = normalizePath(loc.pathname);
+    const query = new URLSearchParams(loc.search);
+    const matched = matchRoutes(routes, pathname);
+    if (matched !== null) {
+      return {
+        path: pathname,
+        pattern: matched.route.path,
+        params: matched.params,
+        query,
+        route: matched.route,
+        // A catch-all `*` match is the 404 route whether user-supplied or built-in.
+        isFallback: matched.route.path === "*"
+      };
+    }
+    const fallbackParams = matchRoutes([fallback], pathname)?.params ?? {};
+    return {
+      path: pathname,
+      pattern: fallback.path,
+      params: fallbackParams,
+      query,
+      route: fallback,
+      isFallback: true
+    };
+  };
+  const current = (0, import_state.signal)(resolve());
+  const stopListening = history.listen(() => {
+    current.set(resolve());
+  });
+  const navigate = (to, opts = {}) => {
+    const { pathname, search } = splitTarget(to);
+    if (opts.replace === true) history.replace(pathname, search);
+    else history.push(pathname, search);
+  };
+  const isActive = (path, opts = {}) => {
+    const target = normalizePath(path);
+    const exact = opts.exact === true;
+    return (0, import_state.derived)(() => {
+      const activePath = current.get().path;
+      if (activePath === target) return true;
+      if (exact || target === "/") return false;
+      return activePath.startsWith(`${target}/`);
+    });
+  };
+  return {
+    currentRoute: current,
+    navigate,
+    back: () => history.back(),
+    forward: () => history.forward(),
+    isActive,
+    destroy: () => {
+      stopListening();
+      history.dispose();
+    }
+  };
+}
+
+// src/mount-router.ts
+var import_dsl = require("@streetui/dsl");
+var import_compiler = require("@streetui/compiler");
+var import_runtime = require("@streetui/runtime");
+var import_renderer = require("@streetui/renderer");
+var import_core = require("@streetui/core");
+var ROUTER_OUTLET_ID = "streetui-router-outlet";
+function routerOutlet(scope, id = ROUTER_OUTLET_ID) {
+  scope.container("router-outlet", () => {
+  }, { id });
+}
+function isExternalHref(href) {
+  return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href) || // scheme: http:, https:, mailto:, tel:
+  href.startsWith("//");
+}
+function mountRouter(router, options) {
+  const { container } = options;
+  const renderer = options.renderer ?? (0, import_renderer.createRenderer)();
+  const outletId = options.outletId ?? ROUTER_OUTLET_ID;
+  const interceptLinks = options.interceptLinks ?? true;
+  const hydrateMode = options.hydrate ?? false;
+  let shellMounted = null;
+  let outlet;
+  if (options.shell !== void 0) {
+    const shellApp = import_dsl.streetui.app({ name: "router-shell" });
+    const shellBuilder = options.shell;
+    shellApp.page("shell", (page) => shellBuilder(page, router));
+    const shellRuntime = (0, import_runtime.createRuntime)({ renderer });
+    const shellCompiled = (0, import_compiler.compile)(shellApp);
+    if (hydrateMode) {
+      for (const node of shellCompiled.graph.findAll((n) => n.getProp("id") === outletId)) {
+        node.setProp("_hydrationBoundary", true);
+      }
+    }
+    shellMounted = hydrateMode ? shellRuntime.hydrate(shellCompiled, container) : shellRuntime.mount(shellCompiled, container);
+    const found = container.querySelector(`[id="${outletId}"]`);
+    if (found === null) {
+      throw new Error(
+        `[Router] The shell must contain a route outlet. Call routerOutlet(scope) (or add a container with id="${outletId}") inside your shell builder.`
+      );
+    }
+    outlet = found;
+  } else {
+    outlet = container;
+  }
+  let active = null;
+  let firstRender = hydrateMode;
+  const disposeActive = () => {
+    if (active === null) return;
+    active.registry.run();
+    active.mounted.unmount();
+    active = null;
+  };
+  const renderRoute = (match) => {
+    disposeActive();
+    const registry = new import_core.CleanupRegistry();
+    const ctx = {
+      path: match.path,
+      pattern: match.pattern,
+      params: match.params,
+      query: match.query,
+      onCleanup: (fn) => registry.add(fn)
+    };
+    const routeApp = import_dsl.streetui.app({ name: `route:${match.pattern}` });
+    routeApp.page("route", (page) => match.route.builder(page, ctx));
+    const runtime = (0, import_runtime.createRuntime)({ renderer });
+    const routeCompiled = (0, import_compiler.compile)(routeApp);
+    const mounted = firstRender ? runtime.hydrate(routeCompiled, outlet) : runtime.mount(routeCompiled, outlet);
+    firstRender = false;
+    active = { registry, mounted };
+  };
+  renderRoute(router.currentRoute.peek());
+  const stopRouteSub = router.currentRoute.subscribe((match) => renderRoute(match));
+  const onClick = (event) => {
+    if (event.defaultPrevented) return;
+    const mouse = event;
+    if (typeof mouse.button === "number" && mouse.button !== 0) return;
+    if (mouse.metaKey || mouse.ctrlKey || mouse.shiftKey || mouse.altKey) return;
+    const target = event.target;
+    const anchor = target?.closest?.("a") ?? null;
+    if (anchor === null) return;
+    const targetAttr = anchor.getAttribute("target");
+    if (targetAttr !== null && targetAttr !== "_self") return;
+    const href = anchor.getAttribute("href");
+    if (href === null || href === "" || href.startsWith("#")) return;
+    if (isExternalHref(href)) return;
+    event.preventDefault();
+    router.navigate(href);
+  };
+  if (interceptLinks) {
+    container.addEventListener("click", onClick);
+  }
+  return {
+    outlet,
+    unmount() {
+      if (interceptLinks) container.removeEventListener("click", onClick);
+      stopRouteSub();
+      disposeActive();
+      shellMounted?.unmount();
+      router.destroy();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ROUTER_OUTLET_ID,
+  createBrowserHistory,
+  createMemoryHistory,
+  createRouter,
+  matchPattern,
+  matchRoutes,
+  mountRouter,
+  normalizePath,
+  routerOutlet,
+  splitTarget
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/matching.ts","../src/history.ts","../src/router.ts","../src/mount-router.ts"],"sourcesContent":["/**\n * @streetui/router — client-side routing for StreetUI applications.\n *\n * Public surface:\n *   - createRouter            route table + reactive currentRoute + navigation\n *   - mountRouter             DOM integration (shell + outlet + link interception)\n *   - routerOutlet            declare the outlet inside a shell\n *   - createBrowserHistory    window.history-backed navigation source\n *   - createMemoryHistory     in-memory navigation source (tests / non-DOM)\n *   - matching helpers        matchPattern / matchRoutes / normalizePath\n *   - all router types\n */\n\nexport * from './types.js';\nexport * from './matching.js';\nexport * from './history.js';\nexport * from './router.js';\nexport * from './mount-router.js';\n","/**\n * Route matching — pure functions, no DOM, no reactivity.\n *\n * A pattern is matched segment-by-segment against a pathname:\n *  - a literal segment must equal the path segment,\n *  - a `:name` segment captures the path segment into `params.name`,\n *  - a `*` segment (or a whole-pattern `*`) is a catch-all that matches the\n *    remainder of the path and captures it into `params['*']`.\n *\n * Matching is intentionally small: no optional segments, no regex constraints,\n * no nested route trees. Composition of layouts is done in the DSL, not here.\n */\n\n/** Split a path into non-empty segments. `/` → [], `/a/b` → ['a','b']. */\nfunction segments(path: string): string[] {\n  return path.split('/').filter((s) => s.length > 0);\n}\n\n/** Normalize a pathname: ensure a single leading slash, drop a trailing slash. */\nexport function normalizePath(path: string): string {\n  let p = path.trim();\n  if (p === '') return '/';\n  if (!p.startsWith('/')) p = `/${p}`;\n  if (p.length > 1 && p.endsWith('/')) p = p.slice(0, -1);\n  return p;\n}\n\n/**\n * Try to match a single pattern against a pathname.\n * Returns the captured params on success, or `null` on no match.\n */\nexport function matchPattern(\n  pattern: string,\n  pathname: string,\n): Record<string, string> | null {\n  // Whole-pattern wildcard: matches everything.\n  if (pattern === '*') {\n    return { '*': normalizePath(pathname).slice(1) };\n  }\n\n  const patSegs = segments(pattern);\n  const pathSegs = segments(normalizePath(pathname));\n  const params: Record<string, string> = {};\n\n  for (let i = 0; i < patSegs.length; i++) {\n    const patSeg = patSegs[i]!;\n\n    // Trailing catch-all: capture the rest of the path.\n    if (patSeg === '*') {\n      params['*'] = pathSegs.slice(i).map((s) => decodeURIComponent(s)).join('/');\n      return params;\n    }\n\n    const pathSeg = pathSegs[i];\n    if (pathSeg === undefined) return null; // path ran out of segments\n\n    if (patSeg.startsWith(':')) {\n      const name = patSeg.slice(1);\n      if (name === '') return null; // malformed `:` with no name\n      params[name] = decodeURIComponent(pathSeg);\n      continue;\n    }\n\n    if (patSeg !== pathSeg) return null; // literal mismatch\n  }\n\n  // All pattern segments consumed — the path must be fully consumed too.\n  if (pathSegs.length !== patSegs.length) return null;\n  return params;\n}\n\nexport interface MatchResult<R> {\n  readonly route: R;\n  readonly params: Record<string, string>;\n}\n\n/**\n * Match a pathname against an ordered list of routes. The first route whose\n * pattern matches wins (definition order), so more specific routes should be\n * listed before a `*` fallback.\n */\nexport function matchRoutes<R extends { path: string }>(\n  routes: readonly R[],\n  pathname: string,\n): MatchResult<R> | null {\n  for (const route of routes) {\n    const params = matchPattern(route.path, pathname);\n    if (params !== null) return { route, params };\n  }\n  return null;\n}\n\n/** Split a `to` target into its pathname and (already-stripped) search string. */\nexport function splitTarget(to: string): { pathname: string; search: string } {\n  const hashIndex = to.indexOf('#');\n  const withoutHash = hashIndex >= 0 ? to.slice(0, hashIndex) : to;\n  const qIndex = withoutHash.indexOf('?');\n  if (qIndex < 0) return { pathname: normalizePath(withoutHash), search: '' };\n  return {\n    pathname: normalizePath(withoutHash.slice(0, qIndex)),\n    search: withoutHash.slice(qIndex + 1),\n  };\n}\n","/**\n * Router history — a small abstraction over the navigation source so the router\n * can run both in the browser (real `window.history` + `popstate`) and in tests\n * (an in-memory stack, fully deterministic, no globals).\n *\n * Internal navigation never triggers a full-page reload: the browser history\n * uses `pushState`/`replaceState` and notifies listeners synchronously.\n */\n\nexport interface RouterLocation {\n  /** Pathname, always normalized with a single leading slash. */\n  readonly pathname: string;\n  /** Query string without the leading `?`. */\n  readonly search: string;\n}\n\nexport interface RouterHistory {\n  /** The current location. */\n  location(): RouterLocation;\n  /** Push a new entry and notify listeners. */\n  push(pathname: string, search: string): void;\n  /** Replace the current entry and notify listeners. */\n  replace(pathname: string, search: string): void;\n  /** Go back one entry. */\n  back(): void;\n  /** Go forward one entry. */\n  forward(): void;\n  /** Subscribe to location changes. Returns an unsubscribe function. */\n  listen(cb: () => void): () => void;\n  /** Detach any global listeners (browser only). */\n  dispose(): void;\n}\n\nfunction buildLocation(pathname: string, search: string): RouterLocation {\n  return { pathname, search };\n}\n\nfunction toUrl(pathname: string, search: string): string {\n  return search.length > 0 ? `${pathname}?${search}` : pathname;\n}\n\n/**\n * Browser history backed by `window.history`. `pushState`/`replaceState` do not\n * emit `popstate`, so we notify listeners ourselves after those calls; genuine\n * back/forward navigation arrives via the `popstate` event.\n */\nexport function createBrowserHistory(): RouterHistory {\n  const listeners = new Set<() => void>();\n  const notify = (): void => {\n    for (const cb of listeners) cb();\n  };\n  const onPopState = (): void => notify();\n  window.addEventListener('popstate', onPopState);\n\n  const current = (): RouterLocation => {\n    const loc = window.location;\n    return buildLocation(loc.pathname, loc.search.replace(/^\\?/, ''));\n  };\n\n  return {\n    location: current,\n    push(pathname, search) {\n      window.history.pushState({}, '', toUrl(pathname, search));\n      notify();\n    },\n    replace(pathname, search) {\n      window.history.replaceState({}, '', toUrl(pathname, search));\n      notify();\n    },\n    back() {\n      window.history.back(); // async → emits popstate\n    },\n    forward() {\n      window.history.forward(); // async → emits popstate\n    },\n    listen(cb) {\n      listeners.add(cb);\n      return () => listeners.delete(cb);\n    },\n    dispose() {\n      window.removeEventListener('popstate', onPopState);\n      listeners.clear();\n    },\n  };\n}\n\n/**\n * In-memory history for tests and non-DOM environments. Maintains an explicit\n * stack and cursor so `back()`/`forward()` are deterministic.\n */\nexport function createMemoryHistory(initial = '/'): RouterHistory {\n  const listeners = new Set<() => void>();\n  const notify = (): void => {\n    for (const cb of listeners) cb();\n  };\n\n  const parse = (entry: string): RouterLocation => {\n    const qIndex = entry.indexOf('?');\n    if (qIndex < 0) return buildLocation(entry, '');\n    return buildLocation(entry.slice(0, qIndex), entry.slice(qIndex + 1));\n  };\n\n  const stack: string[] = [initial];\n  let index = 0;\n\n  return {\n    location() {\n      return parse(stack[index]!);\n    },\n    push(pathname, search) {\n      // Drop any forward entries, then append.\n      stack.splice(index + 1);\n      stack.push(toUrl(pathname, search));\n      index = stack.length - 1;\n      notify();\n    },\n    replace(pathname, search) {\n      stack[index] = toUrl(pathname, search);\n      notify();\n    },\n    back() {\n      if (index > 0) {\n        index--;\n        notify();\n      }\n    },\n    forward() {\n      if (index < stack.length - 1) {\n        index++;\n        notify();\n      }\n    },\n    listen(cb) {\n      listeners.add(cb);\n      return () => listeners.delete(cb);\n    },\n    dispose() {\n      listeners.clear();\n    },\n  };\n}\n","/**\n * StreetUI Router core — renderer-agnostic.\n *\n * Holds the route table, resolves the current location into a `RouteMatch`,\n * and exposes that match as a StreetUI `signal`. Navigation is delegated to a\n * `RouterHistory`; when the location changes (via `navigate`, `back`, `forward`,\n * or a browser `popstate`) the router recomputes the match and updates the\n * signal, which is how every consumer (`isActive`, the mount integration, any\n * `derived` the app builds) stays in sync. No second reactive system.\n */\n\nimport { signal, derived, type ReadonlySignal } from '@streetui/state';\nimport type { RouterHistory } from './history.js';\nimport { createBrowserHistory } from './history.js';\nimport { matchRoutes, normalizePath, splitTarget } from './matching.js';\nimport type { RouteDefinition, RouteMatch } from './types.js';\n\nexport interface RouterOptions {\n  /** The route table. Order matters — the first matching pattern wins. */\n  readonly routes: readonly RouteDefinition[];\n  /**\n   * Navigation source. Defaults to a browser history. Pass a memory history\n   * for tests or non-DOM environments.\n   */\n  readonly history?: RouterHistory;\n  /**\n   * Fallback route used when nothing else matches and no `*` route is present.\n   * Defaults to a built-in 404 page (a normal StreetUI tree — no special path).\n   */\n  readonly notFound?: RouteDefinition;\n}\n\nexport interface NavigateOptions {\n  /** Replace the current history entry instead of pushing a new one. */\n  readonly replace?: boolean;\n}\n\nexport interface IsActiveOptions {\n  /** Require an exact pathname match rather than a prefix match. */\n  readonly exact?: boolean;\n}\n\nexport interface Router {\n  /** Reactive current match. Consumers subscribe via StreetUI signals. */\n  readonly currentRoute: ReadonlySignal<RouteMatch>;\n  /** Navigate to a target path (may include a query string). */\n  navigate(to: string, options?: NavigateOptions): void;\n  /** Go back one history entry. */\n  back(): void;\n  /** Go forward one history entry. */\n  forward(): void;\n  /** Reactive predicate: is `path` the active route (or a prefix of it)? */\n  isActive(path: string, options?: IsActiveOptions): ReadonlySignal<boolean>;\n  /** Tear down history listeners. */\n  destroy(): void;\n}\n\n/** Built-in 404 route — a normal StreetUI page tree, overridable via a `*` route. */\nconst DEFAULT_NOT_FOUND: RouteDefinition = {\n  path: '*',\n  builder: (page) => {\n    page.section('not-found', (s) => {\n      s.heading('404 — Page not found', { level: 1, id: 'not-found-title' });\n      s.text('The page you were looking for does not exist.', { id: 'not-found-text' });\n      s.link('Go home', { href: '/', id: 'not-found-home' });\n    }, { id: 'not-found' });\n  },\n};\n\nexport function createRouter(options: RouterOptions): Router {\n  const routes = options.routes;\n  const history = options.history ?? createBrowserHistory();\n  const fallback = options.notFound ?? DEFAULT_NOT_FOUND;\n\n  const resolve = (): RouteMatch => {\n    const loc = history.location();\n    const pathname = normalizePath(loc.pathname);\n    const query = new URLSearchParams(loc.search);\n    const matched = matchRoutes(routes, pathname);\n    if (matched !== null) {\n      return {\n        path: pathname,\n        pattern: matched.route.path,\n        params: matched.params,\n        query,\n        route: matched.route,\n        // A catch-all `*` match is the 404 route whether user-supplied or built-in.\n        isFallback: matched.route.path === '*',\n      };\n    }\n    // No explicit route matched — use the fallback (a `*` route if the table\n    // has one, otherwise the built-in 404).\n    const fallbackParams =\n      matchRoutes([fallback], pathname)?.params ?? {};\n    return {\n      path: pathname,\n      pattern: fallback.path,\n      params: fallbackParams,\n      query,\n      route: fallback,\n      isFallback: true,\n    };\n  };\n\n  const current = signal<RouteMatch>(resolve());\n  const stopListening = history.listen(() => {\n    current.set(resolve());\n  });\n\n  const navigate = (to: string, opts: NavigateOptions = {}): void => {\n    const { pathname, search } = splitTarget(to);\n    if (opts.replace === true) history.replace(pathname, search);\n    else history.push(pathname, search);\n  };\n\n  const isActive = (path: string, opts: IsActiveOptions = {}): ReadonlySignal<boolean> => {\n    const target = normalizePath(path);\n    const exact = opts.exact === true;\n    return derived(() => {\n      const activePath = current.get().path;\n      if (activePath === target) return true;\n      if (exact || target === '/') return false;\n      return activePath.startsWith(`${target}/`);\n    });\n  };\n\n  return {\n    currentRoute: current,\n    navigate,\n    back: () => history.back(),\n    forward: () => history.forward(),\n    isActive,\n    destroy: () => {\n      stopListening();\n      history.dispose();\n    },\n  };\n}\n","/**\n * StreetUI Router — DOM integration.\n *\n * `mountRouter` wires a `Router` to real DOM:\n *\n *   1. Mounts an optional persistent shell (layout + navigation) ONCE. The shell\n *      declares an outlet element (see `routerOutlet`) into which route content\n *      is rendered.\n *   2. Subscribes to `router.currentRoute`. On every change it disposes the\n *      previous route (route-scoped `CleanupRegistry.run()` + `runtime.unmount()`)\n *      and mounts the new route's compiled application into the outlet.\n *      Only the outlet subtree is re-created — the shell persists.\n *   3. Intercepts clicks on internal `<a>` elements for client-side navigation.\n *      External links (absolute URLs, `target=\"_blank\"`, `mailto:`/`tel:`) keep\n *      their normal browser behaviour, and `link()` is used unchanged.\n *\n * Each route is an ordinary compiled StreetUI application — no special renderer\n * path, no virtual DOM, no full-application rerender on navigation.\n */\n\nimport { streetui, type PageDSL, type ContainerDSL } from '@streetui/dsl';\nimport { compile } from '@streetui/compiler';\nimport { createRuntime, type MountedApplication, type StreetRenderer } from '@streetui/runtime';\nimport { createRenderer } from '@streetui/renderer';\nimport { CleanupRegistry } from '@streetui/core';\nimport type { Router } from './router.js';\nimport type { RouteContext, RouteMatch } from './types.js';\n\n/** Default id used for the route outlet element inside a shell. */\nexport const ROUTER_OUTLET_ID = 'streetui-router-outlet';\n\n/**\n * Declare the route outlet inside a shell builder. The router replaces this\n * element's contents on every navigation.\n */\nexport function routerOutlet(scope: ContainerDSL, id: string = ROUTER_OUTLET_ID): void {\n  scope.container('router-outlet', () => { /* filled by the router at runtime */ }, { id });\n}\n\nexport type ShellBuilder = (shell: PageDSL, router: Router) => void;\n\nexport interface MountRouterOptions {\n  /** Element to mount into. With a shell, the shell fills this; otherwise routes do. */\n  readonly container: Element;\n  /** Optional persistent layout. Must include a `routerOutlet(...)`. */\n  readonly shell?: ShellBuilder;\n  /** Id of the outlet element within the shell. Defaults to `ROUTER_OUTLET_ID`. */\n  readonly outletId?: string;\n  /** Override the renderer (e.g. a custom DOM adapter for tests). */\n  readonly renderer?: StreetRenderer;\n  /** Intercept internal `<a>` clicks for client-side navigation. Defaults to true. */\n  readonly interceptLinks?: boolean;\n  /**\n   * Hydrate server-rendered HTML already present in the container instead of\n   * mounting fresh. The shell and the *initial* route adopt the existing DOM;\n   * subsequent client-side navigations mount normally. Defaults to false.\n   */\n  readonly hydrate?: boolean;\n}\n\nexport interface MountedRouter {\n  /** The element route content is rendered into. */\n  readonly outlet: Element;\n  /** Tear down the current route, the shell, link interception and the router. */\n  unmount(): void;\n}\n\n/** A URL is external when it targets another origin or a non-navigational scheme. */\nfunction isExternalHref(href: string): boolean {\n  return (\n    /^[a-zA-Z][a-zA-Z\\d+.-]*:/.test(href) || // scheme: http:, https:, mailto:, tel:\n    href.startsWith('//') // protocol-relative\n  );\n}\n\nexport function mountRouter(router: Router, options: MountRouterOptions): MountedRouter {\n  const { container } = options;\n  const renderer = options.renderer ?? createRenderer();\n  const outletId = options.outletId ?? ROUTER_OUTLET_ID;\n  const interceptLinks = options.interceptLinks ?? true;\n  const hydrateMode = options.hydrate ?? false;\n\n  // ── 1. Mount the shell once (if any) and resolve the outlet ──────────────────\n  let shellMounted: MountedApplication | null = null;\n  let outlet: Element;\n\n  if (options.shell !== undefined) {\n    const shellApp = streetui.app({ name: 'router-shell' });\n    const shellBuilder = options.shell;\n    shellApp.page('shell', (page) => shellBuilder(page, router));\n    const shellRuntime = createRuntime({ renderer });\n    const shellCompiled = compile(shellApp);\n    if (hydrateMode) {\n      // The outlet is a slot the router fills. When the shell hydrates, mark the\n      // outlet node as a hydration boundary so shell hydration adopts the outlet\n      // element itself but preserves the server-rendered route content inside it\n      // (instead of stripping it as surplus). The initial route then hydrates\n      // that content node-for-node.\n      for (const node of shellCompiled.graph.findAll((n) => n.getProp('id') === outletId)) {\n        node.setProp('_hydrationBoundary', true);\n      }\n    }\n    shellMounted = hydrateMode\n      ? shellRuntime.hydrate(shellCompiled, container)\n      : shellRuntime.mount(shellCompiled, container);\n\n    const found = container.querySelector(`[id=\"${outletId}\"]`);\n    if (found === null) {\n      throw new Error(\n        `[Router] The shell must contain a route outlet. Call routerOutlet(scope) ` +\n          `(or add a container with id=\"${outletId}\") inside your shell builder.`,\n      );\n    }\n    outlet = found;\n  } else {\n    outlet = container;\n  }\n\n  // ── 2. Route mounting / disposal ─────────────────────────────────────────────\n  interface ActiveRoute {\n    readonly registry: CleanupRegistry;\n    readonly mounted: MountedApplication;\n  }\n  let active: ActiveRoute | null = null;\n  // Only the very first route render hydrates the server HTML in the outlet;\n  // client-side navigations after that mount fresh.\n  let firstRender = hydrateMode;\n\n  const disposeActive = (): void => {\n    if (active === null) return;\n    // Run user-registered cleanup (effects, subscriptions) FIRST, then tear down\n    // the DOM + runtime signal bindings. Both reuse existing machinery.\n    active.registry.run();\n    active.mounted.unmount();\n    active = null;\n  };\n\n  const renderRoute = (match: RouteMatch): void => {\n    disposeActive();\n\n    const registry = new CleanupRegistry();\n    const ctx: RouteContext = {\n      path: match.path,\n      pattern: match.pattern,\n      params: match.params,\n      query: match.query,\n      onCleanup: (fn) => registry.add(fn),\n    };\n\n    const routeApp = streetui.app({ name: `route:${match.pattern}` });\n    routeApp.page('route', (page) => match.route.builder(page, ctx));\n    const runtime = createRuntime({ renderer });\n    const routeCompiled = compile(routeApp);\n    const mounted = firstRender\n      ? runtime.hydrate(routeCompiled, outlet)\n      : runtime.mount(routeCompiled, outlet);\n    firstRender = false;\n\n    active = { registry, mounted };\n  };\n\n  // Initial render, then react to every route change.\n  renderRoute(router.currentRoute.peek());\n  const stopRouteSub = router.currentRoute.subscribe((match) => renderRoute(match));\n\n  // ── 3. Client-side link interception ─────────────────────────────────────────\n  const onClick = (event: Event): void => {\n    if (event.defaultPrevented) return;\n    const mouse = event as MouseEvent;\n    if (typeof mouse.button === 'number' && mouse.button !== 0) return;\n    if (mouse.metaKey || mouse.ctrlKey || mouse.shiftKey || mouse.altKey) return;\n\n    const target = event.target as Element | null;\n    const anchor = target?.closest?.('a') ?? null;\n    if (anchor === null) return;\n\n    const targetAttr = anchor.getAttribute('target');\n    if (targetAttr !== null && targetAttr !== '_self') return; // _blank etc.\n\n    const href = anchor.getAttribute('href');\n    if (href === null || href === '' || href.startsWith('#')) return;\n    if (isExternalHref(href)) return;\n\n    event.preventDefault();\n    router.navigate(href);\n  };\n\n  if (interceptLinks) {\n    container.addEventListener('click', onClick);\n  }\n\n  // ── Teardown ─────────────────────────────────────────────────────────────────\n  return {\n    outlet,\n    unmount() {\n      if (interceptLinks) container.removeEventListener('click', onClick);\n      stopRouteSub();\n      disposeActive();\n      shellMounted?.unmount();\n      router.destroy();\n    },\n  };\n}\n"],"mappings":"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","names":[]}