@vobs/router 0.1.0 → 1.0.0

package/dist/history.d.ts

@@ -1,25 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type RouterHistoryOptions, type RouterWindow } from './types.js';
-export interface HistoryBinding {
-    readPath(): string;
-    commit(path: string, action: 'none' | 'push' | 'replace', key: string | undefined): string | undefined;
-    install(handlers: HistoryHandlers): void;
-    destroy(): void;
-}
-interface HistoryHandlers {
-    onLink(path: string): void;
-    onPop(path: string, historyEntryKey: string | undefined): void;
-}
-export declare function createHistoryBinding(options: boolean | RouterHistoryOptions | undefined): HistoryBinding | undefined;
-export declare function defaultRouterWindow(): RouterWindow | undefined;
-export declare function resolveHistoryWindow(options: boolean | RouterHistoryOptions | undefined): RouterWindow | undefined;
-export interface ScrollRestoration {
-    saveCurrent(): void;
-    settle(action: 'none' | 'push' | 'replace', historyEntryKey: string | undefined): void;
-    destroy(): void;
-}
-export declare function createScrollRestoration(window: RouterWindow | undefined): ScrollRestoration;
-export {};

package/dist/history.js

@@ -1,153 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import {} from './types.js';
-import { readHistoryEntryKey, readWindowPath } from './location.js';
-export function createHistoryBinding(options) {
-    if (options === undefined || options === false)
-        return undefined;
-    const window = resolveHistoryWindow(options);
-    if (window === undefined)
-        return undefined;
-    const interceptLinks = typeof options === 'object' ? (options.interceptLinks ?? true) : true;
-    let cleanup;
-    let nextHistoryEntryKey = 0;
-    function createHistoryEntryKey() {
-        nextHistoryEntryKey += 1;
-        return `vobs:${nextHistoryEntryKey}`;
-    }
-    return {
-        readPath() {
-            return readWindowPath(window.location);
-        },
-        commit(path, action, key) {
-            if (action === 'none')
-                return key;
-            const historyEntryKey = key ?? createHistoryEntryKey();
-            const state = { __vobsHistoryEntryKey: historyEntryKey };
-            if (action === 'replace') {
-                window.history.replaceState?.(state, '', path);
-                return historyEntryKey;
-            }
-            window.history.pushState(state, '', path);
-            return historyEntryKey;
-        },
-        install(handlers) {
-            const onPopState = (event) => {
-                handlers.onPop(readWindowPath(window.location), readHistoryEntryKey(event.state ?? window.history.state));
-            };
-            window.addEventListener('popstate', onPopState);
-            const onClick = (event) => {
-                if (!interceptLinks || shouldIgnoreClick(event))
-                    return;
-                const anchor = findAnchor(event.target);
-                if (anchor === undefined || shouldIgnoreAnchor(anchor))
-                    return;
-                let url;
-                try {
-                    url = new URL(anchor.href, window.location.href);
-                }
-                catch {
-                    return;
-                }
-                if (url.origin !== window.location.origin)
-                    return;
-                event.preventDefault();
-                handlers.onLink(`${url.pathname}${url.search}${url.hash}`);
-            };
-            window.document?.addEventListener('click', onClick);
-            cleanup = () => {
-                window.removeEventListener('popstate', onPopState);
-                window.document?.removeEventListener('click', onClick);
-            };
-        },
-        destroy() {
-            cleanup?.();
-            cleanup = undefined;
-        },
-    };
-}
-export function defaultRouterWindow() {
-    const candidate = globalThis;
-    if (candidate.location === undefined ||
-        candidate.history === undefined ||
-        typeof candidate.addEventListener !== 'function' ||
-        typeof candidate.removeEventListener !== 'function') {
-        return undefined;
-    }
-    return candidate;
-}
-export function resolveHistoryWindow(options) {
-    if (options === undefined || options === false)
-        return undefined;
-    return typeof options === 'object'
-        ? (options.window ?? defaultRouterWindow())
-        : defaultRouterWindow();
-}
-export function createScrollRestoration(window) {
-    const positions = new Map();
-    let currentKey;
-    if (window?.history?.scrollRestoration !== undefined) {
-        try {
-            window.history.scrollRestoration = 'manual';
-        }
-        catch {
-            // ignore read-only scrollRestoration (e.g. sandboxed iframes)
-        }
-    }
-    const readPosition = () => ({
-        x: window?.scrollX ?? 0,
-        y: window?.scrollY ?? 0,
-    });
-    const scrollTo = (position) => {
-        window?.scrollTo?.(position.x, position.y);
-    };
-    return {
-        saveCurrent() {
-            if (window === undefined || currentKey === undefined)
-                return;
-            positions.set(currentKey, readPosition());
-        },
-        settle(action, historyEntryKey) {
-            if (window === undefined)
-                return;
-            const restored = action === 'none' && historyEntryKey !== undefined
-                ? positions.get(historyEntryKey)
-                : undefined;
-            scrollTo(restored ?? { x: 0, y: 0 });
-            currentKey = historyEntryKey;
-        },
-        destroy() {
-            positions.clear();
-            currentKey = undefined;
-        },
-    };
-}
-function shouldIgnoreClick(event) {
-    const click = event;
-    return (click.defaultPrevented ||
-        click.button !== 0 ||
-        click.metaKey ||
-        click.ctrlKey ||
-        click.shiftKey ||
-        click.altKey);
-}
-function shouldIgnoreAnchor(anchor) {
-    const target = anchor.getAttribute('target');
-    return (anchor.hasAttribute('download') ||
-        (target !== null && target !== '' && target.toLowerCase() !== '_self'));
-}
-function findAnchor(target) {
-    if (target === null || typeof target !== 'object' || !('closest' in target))
-        return undefined;
-    const closest = target.closest('a[href]');
-    if (closest === null || typeof closest !== 'object')
-        return undefined;
-    const anchor = closest;
-    return typeof anchor.href === 'string' &&
-        typeof anchor.getAttribute === 'function' &&
-        typeof anchor.hasAttribute === 'function'
-        ? anchor
-        : undefined;
-}

package/dist/index.d.ts

@@ -1,15 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import type { RouterPort } from '@vobs/runtime-core';
-/**
- * Router plugin capability: declares that this plugin provides route navigation (RouterPort contract).
- * Forms the extension trio with RouterPortKey (port) and createRouter (adapter implementation).
- */
-export declare const RouterCapability: import("@vobs/runtime-core").Capability<RouterPort>;
-export { CurrentRouteKey, PendingRouteKey, RouteRecordsKey } from './types.js';
-export type { RouteLocation, RouteMeta, RouteQuery, RouteQueryValue, RouteComponent, RouteInitialState, RouteLoaderContext, RouteGuardContext, RouteErrorState, RouteLoader, RouteGuardResult, RouteGuard, RouteLoaderCacheKey, RouteLoaderCachePolicy, RouteLoaderCache, RouteRecord, PageRouteRecord, PageRouteRecordWithoutInitialState, PageRouteRecordWithInitialState, PageRouteRecordWithLoader, NestedRouteRecord, RedirectRouteRecord, RouteNavigationMeta, RouteNavigationItem, CollectRouteNavigationOptions, RouteNavigationScopeOptions, RouteNavigationScope, RouterOptions, RouterNavigationOptions, RouterNavigationContext, RouterHistoryOptions, RouterWindow, RouterDocument, RouterPopStateEvent, Router, RouterPrefetchOptions, ResolvedRouteStatus, ResolvedRoute, ResolveRouteInitialStateOptions, ResolveRouteGuardOptions, ResolveRouteOptions, } from './types.js';
-export { collectRouteNavigation, resolveActiveRouteNavigationId, createRouteNavigationScope, } from './navigation.js';
-export { resolveRoute, resolveRouteGuard, resolveRouteInitialState, createRouteLoaderCache, createRouteResolver, loadRouteComponent, } from './resolve.js';
-export { createRouter } from './router.js';

package/dist/index.js

@@ -1,14 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { createCapability } from '@vobs/runtime-core';
-/**
- * Router plugin capability: declares that this plugin provides route navigation (RouterPort contract).
- * Forms the extension trio with RouterPortKey (port) and createRouter (adapter implementation).
- */
-export const RouterCapability = createCapability('vobs.router');
-export { CurrentRouteKey, PendingRouteKey, RouteRecordsKey } from './types.js';
-export { collectRouteNavigation, resolveActiveRouteNavigationId, createRouteNavigationScope, } from './navigation.js';
-export { resolveRoute, resolveRouteGuard, resolveRouteInitialState, createRouteLoaderCache, createRouteResolver, loadRouteComponent, } from './resolve.js';
-export { createRouter } from './router.js';

package/dist/keep-alive.d.ts

@@ -1,20 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type PageInstance } from '@vobs/runtime-core';
-import { type RouteLocation } from './types.js';
-/**
- * keep-alive identity key: defaults to route.path; overridable via meta.keepAliveKey.
- * A string is a fixed key, while a function `(route) => string` can derive from query/params,
- * preventing /list?page=2 and /list?page=3 from sharing the same cached instance (state bleed).
- */
-export declare function readKeepAliveKey(route: RouteLocation): string;
-export interface KeepAliveCache {
-    take(key: string): PageInstance | undefined;
-    put(key: string, value: PageInstance): void;
-    remove(key: string): void;
-    destroyAll(): void;
-}
-export declare function createKeepAliveCache(max: number): KeepAliveCache;
-export declare function disposeChainInstances(instances: readonly PageInstance[], previousRoute: RouteLocation | null, cache: KeepAliveCache): Promise<void>;

package/dist/keep-alive.js

@@ -1,75 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import {} from '@vobs/runtime-core';
-import {} from './types.js';
-import { destroyPageInstances } from './mount.js';
-/**
- * keep-alive identity key: defaults to route.path; overridable via meta.keepAliveKey.
- * A string is a fixed key, while a function `(route) => string` can derive from query/params,
- * preventing /list?page=2 and /list?page=3 from sharing the same cached instance (state bleed).
- */
-export function readKeepAliveKey(route) {
-    const custom = route.meta?.keepAliveKey;
-    if (typeof custom === 'function') {
-        return custom(route);
-    }
-    if (typeof custom === 'string')
-        return custom;
-    return route.path;
-}
-export function createKeepAliveCache(max) {
-    const entries = new Map();
-    const evict = () => {
-        while (entries.size > max) {
-            const oldest = entries.keys().next().value;
-            if (oldest === undefined)
-                break;
-            const victim = entries.get(oldest);
-            entries.delete(oldest);
-            victim?.destroy();
-        }
-    };
-    return {
-        take(key) {
-            const value = entries.get(key);
-            if (value !== undefined)
-                entries.delete(key);
-            return value;
-        },
-        put(key, value) {
-            const previous = entries.get(key);
-            if (previous !== undefined && previous !== value) {
-                previous.destroy();
-            }
-            entries.set(key, value);
-            evict();
-        },
-        remove(key) {
-            const value = entries.get(key);
-            if (value !== undefined) {
-                entries.delete(key);
-                value.destroy();
-            }
-        },
-        destroyAll() {
-            for (const value of entries.values())
-                value.destroy();
-            entries.clear();
-        },
-    };
-}
-export async function disposeChainInstances(instances, previousRoute, cache) {
-    if (instances.length === 0)
-        return;
-    const leaf = instances[instances.length - 1];
-    await leaf.leave();
-    if (previousRoute?.meta?.keepAlive === true && leaf !== undefined) {
-        leaf.deactivate();
-        cache.put(readKeepAliveKey(previousRoute), leaf);
-        destroyPageInstances(instances.slice(0, -1).reverse());
-        return;
-    }
-    destroyPageInstances([...instances].reverse());
-}

package/dist/location.d.ts

@@ -1,20 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type RouteLocation, type RouteMeta, type RouterWindow } from './types.js';
-export interface ParsedRoutePath {
-    readonly path: string;
-    readonly href: string;
-    readonly query?: RouteLocation['query'];
-    readonly hash?: string;
-}
-export declare function decodePathSegment(segment: string): string;
-export declare function normalizePath(path: string): string;
-export declare function splitPath(path: string): readonly string[];
-export declare function parseRoutePath(path: string): ParsedRoutePath;
-export declare function createRouteLocationFromParsed(parsed: ParsedRoutePath, params: Readonly<Record<string, string>>, meta?: RouteMeta): RouteLocation;
-export declare function createRouteLocation(path: string, params?: Readonly<Record<string, string>>, meta?: RouteMeta): RouteLocation;
-export declare function createRouteHref(path: string): string;
-export declare function readWindowPath(location: RouterWindow['location']): string;
-export declare function readHistoryEntryKey(state: unknown): string | undefined;

package/dist/location.js

@@ -1,107 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import {} from './types.js';
-function splitRoutePath(path) {
-    const trimmed = path.trim();
-    const hashIndex = trimmed.indexOf('#');
-    const beforeHash = hashIndex < 0 ? trimmed : trimmed.slice(0, hashIndex);
-    const hash = hashIndex < 0 ? '' : trimmed.slice(hashIndex);
-    const searchIndex = beforeHash.indexOf('?');
-    return {
-        pathname: searchIndex < 0 ? beforeHash : beforeHash.slice(0, searchIndex),
-        search: searchIndex < 0 ? '' : beforeHash.slice(searchIndex),
-        hash,
-    };
-}
-function parseRouteQuery(search) {
-    if (search.length <= 1)
-        return undefined;
-    const query = {};
-    for (const [key, value] of new URLSearchParams(search.slice(1))) {
-        const previous = query[key];
-        if (previous === undefined) {
-            query[key] = value;
-        }
-        else if (typeof previous === 'string') {
-            query[key] = [previous, value];
-        }
-        else {
-            query[key] = [...previous, value];
-        }
-    }
-    return Object.keys(query).length === 0 ? undefined : query;
-}
-function parseRouteHash(hash) {
-    if (hash.length <= 1)
-        return undefined;
-    const rawHash = hash.slice(1);
-    try {
-        return decodeURIComponent(rawHash);
-    }
-    catch {
-        return rawHash;
-    }
-}
-export function decodePathSegment(segment) {
-    try {
-        return decodeURIComponent(segment);
-    }
-    catch {
-        return segment;
-    }
-}
-export function normalizePath(path) {
-    const pathname = splitRoutePath(path).pathname;
-    if (pathname === '')
-        return '/';
-    const withLeadingSlash = pathname.startsWith('/') ? pathname : `/${pathname}`;
-    if (withLeadingSlash.length > 1 && withLeadingSlash.endsWith('/')) {
-        return withLeadingSlash.slice(0, -1);
-    }
-    return withLeadingSlash;
-}
-export function splitPath(path) {
-    const normalizedPath = normalizePath(path);
-    if (normalizedPath === '/')
-        return [];
-    return normalizedPath.slice(1).split('/');
-}
-export function parseRoutePath(path) {
-    const parts = splitRoutePath(path);
-    const normalizedPath = normalizePath(parts.pathname);
-    const query = parseRouteQuery(parts.search);
-    const hash = parseRouteHash(parts.hash);
-    return {
-        path: normalizedPath,
-        href: `${normalizedPath}${parts.search}${parts.hash}`,
-        ...(query === undefined ? {} : { query }),
-        ...(hash === undefined ? {} : { hash }),
-    };
-}
-export function createRouteLocationFromParsed(parsed, params, meta) {
-    return {
-        path: parsed.path,
-        params,
-        ...(parsed.query === undefined ? {} : { query: parsed.query }),
-        ...(parsed.hash === undefined ? {} : { hash: parsed.hash }),
-        ...(meta === undefined ? {} : { meta }),
-    };
-}
-export function createRouteLocation(path, params = {}, meta) {
-    return createRouteLocationFromParsed(parseRoutePath(path), params, meta);
-}
-export function createRouteHref(path) {
-    return parseRoutePath(path).href;
-}
-export function readWindowPath(location) {
-    return `${location.pathname}${location.search ?? ''}${location.hash ?? ''}`;
-}
-export function readHistoryEntryKey(state) {
-    if (typeof state !== 'object' || state === null || !('__vobsHistoryEntryKey' in state)) {
-        return undefined;
-    }
-    const key = state.__vobsHistoryEntryKey;
-    return typeof key === 'string' ? key : undefined;
-}

package/dist/match.d.ts

@@ -1,23 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type NestedRouteRecord, type RouteComponent, type RouteGuard, type RouteLoader, type RouteLoaderCachePolicy, type RouteLocation, type RouteMeta, type RouteRecord } from './types.js';
-export interface RouteMatch {
-    readonly component?: RouteComponent | undefined;
-    readonly layouts?: readonly RouteComponent[] | undefined;
-    readonly error?: RouteComponent | undefined;
-    readonly meta?: RouteMeta | undefined;
-    readonly guard?: RouteGuard | undefined;
-    readonly initialState?: unknown;
-    readonly loader?: RouteLoader | undefined;
-    readonly loaderCache?: RouteLoaderCachePolicy | undefined;
-    readonly redirect?: string | undefined;
-    readonly location: RouteLocation;
-    readonly href: string;
-}
-export declare function isNestedRouteRecord(route: RouteRecord): route is NestedRouteRecord;
-export declare function joinRouteRecordPath(parentPath: string, routePath: string): string;
-export declare function mergeRouteMeta(parent: RouteMeta | undefined, child: RouteMeta | undefined): RouteMeta | undefined;
-export declare function matchRoute(routes: readonly RouteRecord[], path: string): RouteMatch | undefined;
-export declare function resolveRouteMatch(routes: readonly RouteRecord[], path: string, redirectLimit: number, redirects: number): RouteMatch | undefined;

package/dist/match.js

@@ -1,203 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { createRuntimeError } from '@vobs/runtime-core';
-import {} from './types.js';
-import { createRouteLocationFromParsed, decodePathSegment, normalizePath, parseRoutePath, splitPath, } from './location.js';
-export function isNestedRouteRecord(route) {
-    return route.children !== undefined;
-}
-export function joinRouteRecordPath(parentPath, routePath) {
-    if (parentPath === '' || routePath.startsWith('/'))
-        return normalizePath(routePath);
-    if (routePath === '')
-        return normalizePath(parentPath);
-    return normalizePath(`${parentPath}/${routePath}`);
-}
-export function mergeRouteMeta(parent, child) {
-    if (parent === undefined)
-        return child;
-    if (child === undefined)
-        return parent;
-    return { ...parent, ...child };
-}
-function composeRouteGuards(guards) {
-    if (guards.length === 0)
-        return undefined;
-    if (guards.length === 1)
-        return guards[0];
-    return async (context) => {
-        for (const guard of guards) {
-            const result = await guard(context);
-            if (result === false || typeof result === 'string' || typeof result === 'object') {
-                return result;
-            }
-        }
-        return true;
-    };
-}
-function matchRouteSegments(routeSegments, pathSegments) {
-    const params = {};
-    for (let index = 0; index < routeSegments.length; index += 1) {
-        const routeSegment = routeSegments[index];
-        if (routeSegment === undefined)
-            return undefined;
-        if (routeSegment.startsWith('*')) {
-            const name = routeSegment.slice(1);
-            if (name === '' || index !== routeSegments.length - 1)
-                return undefined;
-            if (pathSegments.length <= index)
-                return undefined;
-            params[name] = pathSegments.slice(index).map(decodePathSegment).join('/');
-            return params;
-        }
-        const pathSegment = pathSegments[index];
-        if (pathSegment === undefined)
-            return undefined;
-        if (routeSegment.startsWith(':')) {
-            const name = routeSegment.slice(1);
-            if (name === '')
-                return undefined;
-            params[name] = decodePathSegment(pathSegment);
-            continue;
-        }
-        if (routeSegment !== pathSegment)
-            return undefined;
-    }
-    return pathSegments.length === routeSegments.length ? params : undefined;
-}
-function createPageRouteMatch(route, component, parsed, params, inherited) {
-    const guard = composeRouteGuards(inherited.guards);
-    return {
-        component,
-        ...(inherited.layouts.length === 0 ? {} : { layouts: inherited.layouts }),
-        ...(inherited.error === undefined ? {} : { error: inherited.error }),
-        ...(inherited.meta === undefined ? {} : { meta: inherited.meta }),
-        ...(guard === undefined ? {} : { guard }),
-        ...(isNestedRouteRecord(route)
-            ? {}
-            : {
-                initialState: route.initialState,
-                loader: route.loader,
-                loaderCache: route.loaderCache,
-            }),
-        location: createRouteLocationFromParsed(parsed, params, inherited.meta),
-        href: parsed.href,
-    };
-}
-function matchRouteRecords(routes, parsed, pathSegments, parentPath, inherited) {
-    const parentDepth = splitPath(parentPath).length;
-    const candidates = parentDepth === 0 ? readMatchCandidates(routes, pathSegments) : routes;
-    for (const route of candidates) {
-        const routePath = joinRouteRecordPath(parentPath, route.path);
-        const routeSegments = splitPath(routePath);
-        const leading = routeSegments[parentDepth];
-        if (leading !== undefined && !leading.startsWith(':') && !leading.startsWith('*')) {
-            if (pathSegments[parentDepth] !== leading)
-                continue;
-        }
-        if (isNestedRouteRecord(route)) {
-            const layouts = [...inherited.layouts, ...(route.layouts ?? [])];
-            const error = route.error ?? inherited.error;
-            const meta = mergeRouteMeta(inherited.meta, route.meta);
-            const guards = [...inherited.guards, ...(route.guard === undefined ? [] : [route.guard])];
-            const childMatch = matchRouteRecords(route.children, parsed, pathSegments, routePath, {
-                layouts: route.component === undefined ? layouts : [...layouts, route.component],
-                ...(error === undefined ? {} : { error }),
-                ...(meta === undefined ? {} : { meta }),
-                guards,
-            });
-            if (childMatch !== undefined)
-                return childMatch;
-            const params = matchRouteSegments(routeSegments, pathSegments);
-            if (params === undefined || route.component === undefined)
-                continue;
-            return createPageRouteMatch(route, route.component, parsed, params, {
-                layouts,
-                ...(error === undefined ? {} : { error }),
-                ...(meta === undefined ? {} : { meta }),
-                guards,
-            });
-        }
-        const params = matchRouteSegments(routeSegments, pathSegments);
-        if (params === undefined)
-            continue;
-        if ('redirect' in route) {
-            return {
-                redirect: route.redirect,
-                location: createRouteLocationFromParsed(parsed, params, inherited.meta),
-                href: parsed.href,
-            };
-        }
-        const error = route.error ?? inherited.error;
-        const meta = mergeRouteMeta(inherited.meta, route.meta);
-        return createPageRouteMatch(route, route.component, parsed, params, {
-            layouts: [...inherited.layouts, ...(route.layouts ?? [])],
-            ...(error === undefined ? {} : { error }),
-            ...(meta === undefined ? {} : { meta }),
-            guards: [...inherited.guards, ...(route.guard === undefined ? [] : [route.guard])],
-        });
-    }
-    return undefined;
-}
-const matchIndexCache = new WeakMap();
-function buildRouteMatchIndex(routes) {
-    const staticSegments = new Map();
-    const dynamicRoutes = [];
-    for (const route of routes) {
-        const leading = splitPath(normalizePath(route.path))[0];
-        if (leading !== undefined && !leading.startsWith(':') && !leading.startsWith('*')) {
-            const bucket = staticSegments.get(leading);
-            if (bucket === undefined) {
-                staticSegments.set(leading, [route]);
-            }
-            else {
-                bucket.push(route);
-            }
-        }
-        else {
-            dynamicRoutes.push(route);
-        }
-    }
-    return { staticSegments, dynamicRoutes };
-}
-function readRouteMatchIndex(routes) {
-    let index = matchIndexCache.get(routes);
-    if (index === undefined) {
-        index = buildRouteMatchIndex(routes);
-        matchIndexCache.set(routes, index);
-    }
-    return index;
-}
-/**
- * Top-level match candidates: static-bucket hits take priority (more specific),
- * while dynamic-segment routes (:param/*) serve as fallback since they match any leading segment.
- * Reduces an O(n) scan to O(bucket) + O(dynamic routes).
- */
-function readMatchCandidates(routes, pathSegments) {
-    const index = readRouteMatchIndex(routes);
-    const leading = pathSegments[0];
-    if (leading === undefined)
-        return index.dynamicRoutes;
-    const staticBucket = index.staticSegments.get(leading);
-    if (staticBucket === undefined)
-        return index.dynamicRoutes;
-    return [...staticBucket, ...index.dynamicRoutes];
-}
-export function matchRoute(routes, path) {
-    const parsed = parseRoutePath(path);
-    return matchRouteRecords(routes, parsed, splitPath(parsed.path), '', {
-        layouts: [],
-        guards: [],
-    });
-}
-export function resolveRouteMatch(routes, path, redirectLimit, redirects) {
-    if (redirects > redirectLimit) {
-        throw createRuntimeError('VOR604', `Redirect limit exceeded: ${path}`);
-    }
-    const match = matchRoute(routes, path);
-    if (match?.redirect === undefined)
-        return match;
-    return resolveRouteMatch(routes, match.redirect, redirectLimit, redirects + 1);
-}

package/dist/mount.d.ts

@@ -1,18 +0,0 @@
-/** @license MIT
- * Copyright (c) 2026 vobsjs
- * @vobs/router
- */
-import { type PageDefinition, type PageEnvironment, type PageInstance } from '@vobs/runtime-core';
-import { type RouteComponent } from './types.js';
-export interface MountedRouteChain {
-    readonly layouts: readonly RouteComponent[];
-    readonly instances: readonly PageInstance[];
-    readonly outlets: readonly Element[];
-    destroy(): void;
-}
-export declare function mountPageWithLayouts(page: PageDefinition, layouts: readonly RouteComponent[], container: Element, environment: PageEnvironment, cachedLeaf?: PageInstance): Promise<MountedRouteChain>;
-export declare function hydratePageWithLayouts(page: PageDefinition, layouts: readonly RouteComponent[], container: Element, environment: PageEnvironment): Promise<MountedRouteChain>;
-export declare function createMountedRouteChain(layouts: readonly RouteComponent[], instances: readonly PageInstance[], outlets: readonly Element[]): MountedRouteChain;
-export declare function errorLayoutsForFailure(layouts: readonly RouteComponent[], error: unknown): readonly RouteComponent[];
-export declare function unwrapRouteMountFailure(error: unknown): unknown;
-export declare function destroyPageInstances(instances: readonly PageInstance[]): void;