@rangojs/router 0.1.0 → 0.1.1

package/dist/bin/rango.js

@@ -1424,7 +1424,17 @@ async function initializeApp() {
   // context, including strictMode (default true) from createRouter. StrictMode
   // is the default; createRouter({ strictMode: false }) ships the opt-out in the
   // payload metadata. StrictMode emits no DOM, so toggling never changes markup.
-  const { strictMode } = await initBrowserApp({ rscStream, deps });
+  const { strictMode, initialPayload } = await initBrowserApp({ rscStream, deps });
+
+  if (import.meta.hot) {
+    const { startDevDiscoveryHandshake } = await import(
+      "@rangojs/router/internal/browser/dev-discovery"
+    );
+    startDevDiscoveryHandshake(
+      initialPayload.metadata?.devDiscoveryEpoch,
+      import.meta.hot
+    );
+  }
 
   const app = createElement(Rango);
   hydrateRoot(

package/dist/types/browser/dev-discovery.d.ts

@@ -0,0 +1,11 @@
+import { DEV_DISCOVERY_QUERY_EVENT, DEV_DISCOVERY_READY_EVENT } from "../dev-discovery-protocol.js";
+export interface DevDiscoveryHot {
+    on(event: typeof DEV_DISCOVERY_READY_EVENT | "vite:ws:connect", listener: (payload: unknown) => void): void;
+    send(event: typeof DEV_DISCOVERY_QUERY_EVENT, payload: {
+        epoch: number;
+    }): void;
+}
+export interface DevDiscoveryHandshakeOptions {
+    reload?: () => void;
+}
+export declare function startDevDiscoveryHandshake(documentEpoch: unknown, hot: DevDiscoveryHot, options?: DevDiscoveryHandshakeOptions): void;

package/dist/types/browser/navigation-store.d.ts

@@ -61,11 +61,10 @@ export interface NavigationStoreConfig {
     onCrossTabRefresh?: () => void;
 }
 /**
- * Create a navigation store for managing browser-side navigation state
+ * Create a navigation store for browser-side segment and history state.
  *
- * The store manages two types of state:
- * - NavigationState: Public state exposed via useNavigation hook
- * - SegmentState: Internal segment management for partial RSC updates
+ * The public navigation lifecycle lives in EventController; this store owns
+ * segment reconciliation, history snapshots, and cross-tab cache invalidation.
  *
  * @param config - Initial configuration
  * @returns NavigationStore instance
@@ -77,15 +76,6 @@ export interface NavigationStoreConfig {
  *   initialSegmentIds: [],
  * });
  *
- * // Subscribe to state changes (for useNavigation hook)
- * const unsubscribe = store.subscribe(() => {
- *   const state = store.getState();
- *   console.log('Navigation state:', state);
- * });
- *
- * // Update state
- * store.setState({ state: 'loading' });
- *
  * // Subscribe to UI updates (for re-rendering)
  * store.onUpdate((update) => {
  *   console.log('New root:', update.root);

package/dist/types/browser/prefetch/loader.d.ts

@@ -0,0 +1,10 @@
+import type { RscPayload } from "../types.js";
+type PrefetchDecoder = (response: Promise<Response>) => Promise<RscPayload>;
+export declare function setPrefetchDecoder(fn: PrefetchDecoder): void;
+export declare function setPrefetchConcurrency(value: number): void;
+export declare function prefetchDirect(url: string, segmentIds: string[], version?: string, routerId?: string, prefetchKey?: ":source"): void;
+export declare function prefetchQueued(url: string, segmentIds: string[], version?: string, routerId?: string, prefetchKey?: ":source"): void;
+export declare function observeForPrefetch(element: Element, callback: () => void): () => void;
+export declare function cancelAllPrefetches(keepUrl?: string | null): void;
+export declare function abortAllPrefetches(): void;
+export {};

package/dist/types/browser/prefetch/runtime.d.ts

@@ -0,0 +1,3 @@
+export { prefetchDirect, prefetchQueued, setPrefetchDecoder } from "./fetch.js";
+export { abortAllPrefetches, cancelAllPrefetches, setPrefetchConcurrency, } from "./queue.js";
+export { observeForPrefetch, unobserveForPrefetch } from "./observer.js";

package/dist/types/browser/types.d.ts

@@ -60,6 +60,8 @@ export interface RscMetadata {
      * Used to detect version mismatches after HMR/deployment.
      */
     version?: string;
+    /** Cloudflare dev worker generation used for stale-document convergence. */
+    devDiscoveryEpoch?: number;
     /**
      * TTL in milliseconds for the client-side in-memory prefetch cache.
      * Sent on initial render so the browser can configure its cache duration.
@@ -370,18 +372,10 @@ export type StateListener = () => void;
 /**
  * Navigation store interface
  *
- * Manages both:
- * - NavigationState: Public state exposed via useNavigation hook
- * - SegmentState: Internal segment management for partial updates
+ * Owns segment state, history snapshots, and partial-update notifications.
+ * EventController owns the public navigation lifecycle exposed by hooks.
  */
 export interface NavigationStore {
-    getState(): NavigationState;
-    setState(partial: Partial<NavigationState>): void;
-    subscribe(listener: StateListener): () => void;
-    addInflightAction(action: InflightAction): void;
-    removeInflightAction(id: string): void;
-    isActionInProgress(): boolean;
-    setActionInProgress(value: boolean): void;
     getSegmentState(): SegmentState;
     setPath(path: string): void;
     setCurrentUrl(url: string): void;
@@ -390,8 +384,6 @@ export interface NavigationStore {
     setHistoryKey(key: string): void;
     /** Monotonic token of the most recently committed navigation. */
     getNavInstance(): number;
-    /** Nav-instance token recorded on a cache entry (undefined if absent). */
-    getCacheEntryInstance(historyKey: string): number | undefined;
     cacheSegmentsForHistory(historyKey: string, segments: ResolvedSegment[], handleData?: HandleData): void;
     getCachedSegments(historyKey: string): {
         segments: ResolvedSegment[];
@@ -420,7 +412,6 @@ export interface NavigationStore {
      * probe and write into one historyCache scan for the per-yield streaming path.
      */
     updateCacheHandleDataIfOwned(historyKey: string, handleData: HandleData, ownerInstance: number, stale?: boolean, handlesPending?: boolean): void;
-    markCacheAsStale(): void;
     markHistoryCacheStale(): void;
     markCacheAsStaleAndBroadcast(): void;
     clearHistoryCache(): void;
@@ -431,9 +422,6 @@ export interface NavigationStore {
     setRouterId?(id: string): void;
     onUpdate(callback: UpdateSubscriber): () => void;
     emitUpdate(update: NavigationUpdate): void;
-    getActionState(actionId: string): TrackedActionState;
-    setActionState(actionId: string, state: Partial<TrackedActionState>): void;
-    subscribeToAction(actionId: string, listener: ActionStateListener): () => void;
 }
 /**
  * Options for partial navigation fetch

package/dist/types/build/generate-manifest.d.ts

@@ -79,6 +79,12 @@ export declare function generateManifest<TEnv>(urlpatterns: UrlPatterns<TEnv, an
  */
 export declare function generateManifestFull<TEnv>(urlpatterns: UrlPatterns<TEnv, any>, mountIndex?: number, options?: {
     urlPrefix?: string;
+    /**
+     * Owning router id. Threaded into the evaluation store so path() scopes
+     * its search-schema/root-scope registrations per router — same-named
+     * routes in different routers must not clobber each other.
+     */
+    routerId?: string;
     /**
      * Called once per `"use client"` component registered as an
      * errorBoundary/notFoundBoundary fallback, with its client-reference key

package/dist/types/cache/cache-scope.d.ts

@@ -30,11 +30,12 @@ export declare function resolveCacheTags(config: PartialCacheOptions | false, ct
  * 4. Hardcoded fallback (60 seconds)
  */
 export declare class CacheScope {
+    private readonly defaultKeyPrefix?;
     readonly config: PartialCacheOptions | false;
     readonly parent: CacheScope | null;
     /** Explicit store from cache() options, if specified */
     private readonly explicitStore;
-    constructor(config: PartialCacheOptions | false, parent?: CacheScope | null);
+    constructor(config: PartialCacheOptions | false, parent?: CacheScope | null, defaultKeyPrefix?: "doc" | undefined);
     /**
      * Whether caching is enabled for this scope
      */
@@ -121,10 +122,11 @@ export declare function createCacheScope(config: {
 /**
  * Shell fast path: when the route tree derived NO cache scope and the current
  * request context carries the `_shellImplicitCache` marker (a shell capture,
- * or a HIT tail serving an eligible entry), substitute an implicit doc-level
- * scope so withCacheLookup/withCacheStore treat the WHOLE matched route as a
- * cache() boundary — the shell entry IS a cache() of the handler layer, with
- * loaders as the live carve-outs (resolveFreshLoadersAndYield).
+ * an eligible HIT tail, or a normal partial navigation replay), substitute an
+ * implicit doc-level scope so withCacheLookup/withCacheStore treat the WHOLE
+ * matched route as a cache() boundary — the shell entry IS a cache() of the
+ * handler layer, with loaders as the live carve-outs
+ * (resolveFreshLoadersAndYield).
  *
  * An existing scope — including an explicit cache(false) opt-out — always
  * wins: the consumer's cache() semantics (their ttl/swr/store/condition) are

package/dist/types/cache/cf/cf-cache-store.d.ts

@@ -29,6 +29,7 @@ export { CACHE_STALE_AT_HEADER, CACHE_STATUS_HEADER, CACHE_TAGS_HEADER, CACHE_TA
 import type { KVNamespace, CFCacheReadDebugEvent, CFCacheDebug, CFCacheStoreOptions } from "./cf-cache-types.js";
 export type { KVNamespace, CFCacheReadDebugEvent, CFCacheDebug, CFCacheStoreOptions, };
 export declare class CFCacheStore<TEnv = unknown> implements SegmentCacheStore<TEnv> {
+    readonly supportsPassiveShellReads: true;
     readonly defaults?: CacheDefaults;
     readonly keyGenerator?: (ctx: RequestContext<TEnv>, defaultKey: string) => string | Promise<string>;
     private readonly namespace?;
@@ -265,7 +266,7 @@ export declare class CFCacheStore<TEnv = unknown> implements SegmentCacheStore<T
      * Get a cached PPR shell entry by key from KV (no L1). Applies the KV read
      * budget, corrupt-entry eviction, hard-expiry, and tag invalidation exactly
      * like kvGetItem, minus the L1 promote. SWR is a plain staleness flag — KV has
-     * no REVALIDATING herd guard, so the shell-cache middleware's module-level
+     * no REVALIDATING herd guard, so the capture scheduler's module-level
      * in-flight set is the recapture stampede guard.
      */
     getShell(key: string): Promise<{
@@ -273,11 +274,12 @@ export declare class CFCacheStore<TEnv = unknown> implements SegmentCacheStore<T
         shouldRevalidate?: boolean;
     } | null>;
     /**
-     * Store a PPR shell entry in KV with TTL and optional SWR window. Non-blocking
-     * (waitUntil) like the other KV writes. The tags/taggedAt ride in the envelope
+     * Store a PPR shell entry in KV with TTL and optional SWR window. The write is
+     * registered with waitUntil and awaited so invalidation rejection can be
+     * acknowledged to the capture scheduler. The tags/taggedAt ride in the envelope
      * so isGloballyInvalidated() can invalidate the shell via the shared KV markers.
      */
-    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<void>;
+    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<"stored" | "invalidated" | void>;
     /**
      * Convert string key to Request object for CF Cache API.
      * Includes version in URL if specified (for cache invalidation on code changes).
@@ -537,11 +539,10 @@ export declare class CFCacheStore<TEnv = unknown> implements SegmentCacheStore<T
      * eager purge still fires for the whole batch first (it is additive).
      */
     /**
-     * Build-shell read-through gate (SegmentCacheStore.isTagsInvalidatedSince):
-     * a baked shell entry is immutable in the build manifest, so eviction is
-     * answered by the SAME KV tag markers updateTag() writes, compared against
-     * the entry's build-time createdAt. Thin public wrapper over the private
-     * envelope check (identical semantics: marker >= since, fail open).
+     * Shell tag-generation gate (SegmentCacheStore.isTagsInvalidatedSince): the
+     * SAME KV markers used by runtime envelopes also evict immutable build shells
+     * and captures whose write races updateTag(). Thin public wrapper over the
+     * private envelope check (marker >= since, fail open).
      */
     isTagsInvalidatedSince(tags: string[], sinceMs: number): Promise<boolean>;
     invalidateTags(tags: string[]): Promise<void>;

package/dist/types/cache/memory-segment-store.d.ts

@@ -106,6 +106,7 @@ export interface MemorySegmentCacheStoreOptions<TEnv = unknown> {
  * ```
  */
 export declare class MemorySegmentCacheStore<TEnv = unknown> implements SegmentCacheStore<TEnv> {
+    readonly supportsPassiveShellReads: true;
     private cache;
     private responseCache;
     private itemCache;
@@ -115,11 +116,9 @@ export declare class MemorySegmentCacheStore<TEnv = unknown> implements SegmentC
     /** prefixed cache key -> set of tags (reverse index for O(tags) unregister) */
     private keyTags;
     /**
-     * tag -> epoch ms of its latest invalidateTags() call. The build-shell
-     * read-through's isTagsInvalidatedSince gate: baked shell entries are
-     * immutable in the build manifest, so eviction is answered by comparing
-     * these markers against the entry's build-time createdAt. Per-isolate,
-     * like every other map here — matching this store's tag semantics.
+     * tag -> epoch ms of its latest invalidateTags() call. Runtime capture races
+     * and immutable build shells are gated by comparing these markers with the
+     * shell generation start. Per-isolate, like every other map here.
      */
     private tagInvalidatedAt;
     readonly defaults?: CacheDefaults;
@@ -150,8 +149,9 @@ export declare class MemorySegmentCacheStore<TEnv = unknown> implements SegmentC
         entry: ShellCacheEntry;
         shouldRevalidate?: boolean;
     } | null>;
-    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<void>;
+    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<"stored" | "invalidated">;
     isTagsInvalidatedSince(tags: string[], sinceMs: number): Promise<boolean>;
+    private tagsInvalidatedSince;
     invalidateTags(tags: string[]): Promise<void>;
     private registerTags;
     private unregisterTags;

package/dist/types/cache/shell-snapshot.d.ts

@@ -47,6 +47,7 @@ export declare class RecordingShellStore<TEnv = unknown> implements SegmentCache
     constructor(inner: SegmentCacheStore<TEnv>);
     get defaults(): SegmentCacheStore<TEnv>["defaults"];
     get keyGenerator(): SegmentCacheStore<TEnv>["keyGenerator"];
+    get supportsPassiveShellReads(): true | undefined;
     private record;
     /** Track a deferred cache-write promise so the capture can await it pre-drain. */
     trackWrite(p: Promise<unknown>): void;
@@ -83,11 +84,13 @@ export declare class RecordingShellStore<TEnv = unknown> implements SegmentCache
     putResponse(key: string, response: Response, ttl: number, swr?: number, tags?: string[]): Promise<void>;
     getItem(key: string): Promise<CacheItemResult | null>;
     setItem(key: string, value: string, options?: CacheItemOptions): Promise<void>;
-    getShell(key: string): Promise<{
+    getShell(key: string, options?: {
+        claimRevalidation?: boolean;
+    }): Promise<{
         entry: ShellCacheEntry;
         shouldRevalidate?: boolean;
     } | null>;
-    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<void>;
+    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<"stored" | "invalidated" | void>;
     invalidateTags(tags: string[]): Promise<void>;
 }
 /** True iff `store` is a RecordingShellStore (duck-typed across module copies). */
@@ -141,18 +144,26 @@ export declare function buildShellLoaderSeed(snapshot: ShellSnapshotRecord[]): P
  * the snapshot it serves the recorded value AS FRESH (shouldRevalidate: false —
  * a pinned key must NOT kick SWR background revalidation) so the tail's payload
  * matches the frozen prelude. Every other read falls through to the real store
- * (the holes — masked loaders were never recorded — stay live). ALL writes pass
- * through unchanged: a live hole's loader may legitimately write. The shell
- * family always passes through.
+ * (the holes — masked loaders were never recorded — stay live). Writes pass
+ * through so a live hole may legitimately write, except that `segmentsOnly`
+ * fully isolates the segment family: misses do not fall through, and writes or
+ * deletes stay local to the navigation overlay. The shell family always passes
+ * through. With `segmentsOnly`, item and response reads also pass through so a
+ * partial navigation cannot freeze captured data or write a partial result into
+ * the canonical document namespace.
  */
 export declare class SeededShellStore<TEnv = unknown> implements SegmentCacheStore<TEnv> {
     private readonly inner;
     private readonly items;
     private readonly segments;
     private readonly responses;
-    constructor(inner: SegmentCacheStore<TEnv>, snapshot: ShellSnapshotRecord[]);
+    private readonly segmentsOnly;
+    constructor(inner: SegmentCacheStore<TEnv>, snapshot: ShellSnapshotRecord[], options?: {
+        segmentsOnly?: boolean;
+    });
     get defaults(): SegmentCacheStore<TEnv>["defaults"];
     get keyGenerator(): SegmentCacheStore<TEnv>["keyGenerator"];
+    get supportsPassiveShellReads(): true | undefined;
     get(key: string): Promise<CacheGetResult | null>;
     set(key: string, data: CachedEntryData, ttl: number, swr?: number): Promise<void>;
     delete(key: string): Promise<boolean>;
@@ -164,10 +175,12 @@ export declare class SeededShellStore<TEnv = unknown> implements SegmentCacheSto
     putResponse(key: string, response: Response, ttl: number, swr?: number, tags?: string[]): Promise<void>;
     getItem(key: string): Promise<CacheItemResult | null>;
     setItem(key: string, value: string, options?: CacheItemOptions): Promise<void>;
-    getShell(key: string): Promise<{
+    getShell(key: string, options?: {
+        claimRevalidation?: boolean;
+    }): Promise<{
         entry: ShellCacheEntry;
         shouldRevalidate?: boolean;
     } | null>;
-    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<void>;
+    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<"stored" | "invalidated" | void>;
     invalidateTags(tags: string[]): Promise<void>;
 }

package/dist/types/cache/types.d.ts

@@ -33,6 +33,12 @@ export interface CacheGetResult {
  * @typeParam TEnv - Platform bindings type (e.g., Cloudflare env)
  */
 export interface SegmentCacheStore<TEnv = unknown> {
+    /**
+     * The store honors getShell(..., { claimRevalidation: false }) without
+     * claiming an SWR lock. Navigation replay requires this opt-in because it
+     * cannot recapture an HTML shell after observing a stale entry.
+     */
+    readonly supportsPassiveShellReads?: true;
     /**
      * Default cache options for this store.
      * Used by cache() boundaries when ttl/swr are not explicitly specified.
@@ -120,8 +126,12 @@ export interface SegmentCacheStore<TEnv = unknown> {
      *
      * Optional: a store that does not implement the shell family disables the
      * shell-cache middleware (it fails open to the normal HTML render path).
+     * A passive read reports a stale entry as `shouldRevalidate: true` without
+     * claiming store-specific revalidation ownership.
      */
-    getShell?(key: string): Promise<{
+    getShell?(key: string, options?: {
+        claimRevalidation?: boolean;
+    }): Promise<{
         entry: ShellCacheEntry;
         shouldRevalidate?: boolean;
     } | null>;
@@ -136,8 +146,10 @@ export interface SegmentCacheStore<TEnv = unknown> {
      * @param swrSeconds - Optional stale-while-revalidate window in seconds
      * @param tags - Optional cache tags for invalidation (participates in
      *   invalidateTags via the same tag machinery as the item family)
+     * @returns `invalidated` when a generation marker rejected the write,
+     *   `stored` when acknowledged, or void for stores without acknowledgements.
      */
-    putShell?(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<void>;
+    putShell?(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<"stored" | "invalidated" | void>;
     /**
      * Get a cached function result by key.
      * Returns the serialized value, optional handle data, and staleness flag.
@@ -162,10 +174,9 @@ export interface SegmentCacheStore<TEnv = unknown> {
     /**
      * True when ANY of `tags` was invalidated (invalidateTags/updateTag) at or
      * after `sinceMs` (>= so a same-millisecond invalidation wins, favouring
-     * freshness). Consulted by the build-time shell read-through
-     * (rsc/shell-build-manifest.ts): a baked shell entry is immutable in the
-     * build manifest, so "was it evicted" is answered by the store's tag
-     * markers against the entry's createdAt rather than by deleting anything.
+     * freshness). Consulted by build-shell read-through and runtime shell stores:
+     * "was it evicted" is answered by tag markers against the entry's createdAt,
+     * including when invalidation races a capture that has not been written yet.
      * Optional: without it, TAGGED build entries are not served (untagged ones
      * are unaffected — they are evictable only by deploy/buildVersion anyway).
      * Fail open to `false` on marker-read errors: a transient store fault must
@@ -267,7 +278,13 @@ export interface ShellCacheEntry {
      * their holes always fill.
      */
     handlerLiveHoles?: boolean;
-    /** Epoch ms when the shell was captured. */
+    /**
+     * The capture encountered transition({ when }). Its effective hold policy is
+     * request-dependent, so handler-free document and navigation replay must
+     * re-run resolution to collect and evaluate the predicate.
+     */
+    transitionWhen?: true;
+    /** Capture-generation start time; tag invalidations at or after it win. */
     createdAt: number;
 }
 /**

package/dist/types/cache/vercel/vercel-cache-store.d.ts

@@ -184,6 +184,7 @@ export interface VercelCacheStoreOptions<TEnv = unknown> {
  * ```
  */
 export declare class VercelCacheStore<TEnv = unknown> implements SegmentCacheStore<TEnv> {
+    readonly supportsPassiveShellReads: true;
     readonly defaults?: CacheDefaults;
     readonly keyGenerator?: (ctx: RequestContext<TEnv>, defaultKey: string) => string | Promise<string>;
     private readonly cache;
@@ -203,18 +204,18 @@ export declare class VercelCacheStore<TEnv = unknown> implements SegmentCacheSto
     putResponse(key: string, response: Response, ttl: number, swr?: number, tags?: string[]): Promise<void>;
     getItem(key: string): Promise<CacheItemResult | null>;
     setItem(key: string, value: string, options?: CacheItemOptions): Promise<void>;
-    getShell(key: string): Promise<{
+    getShell(key: string, options?: {
+        claimRevalidation?: boolean;
+    }): Promise<{
         entry: ShellCacheEntry;
         shouldRevalidate?: boolean;
     } | null>;
-    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<void>;
+    putShell(key: string, entry: ShellCacheEntry, ttlSeconds?: number, swrSeconds?: number, tags?: string[]): Promise<"stored" | "invalidated" | void>;
     /**
-     * Build-shell read-through gate (SegmentCacheStore.isTagsInvalidatedSince).
-     * The platform's expireTag() DELETES tagged entries and keeps no queryable
-     * history, so invalidateTags() below writes its own "tm" marker entries and
-     * this compares them against the baked entry's build-time createdAt
-     * (>= so a same-millisecond invalidation wins). Fails open to `false` on
-     * read errors — the same posture as the CF marker check.
+     * Shell tag-generation gate (SegmentCacheStore.isTagsInvalidatedSince).
+     * expireTag() keeps no queryable history, so invalidateTags() writes "tm"
+     * markers for runtime capture races and immutable build shells. Marker >=
+     * generation start wins; read errors fail open like the CF marker check.
      */
     isTagsInvalidatedSince(tags: string[], sinceMs: number): Promise<boolean>;
     invalidateTags(tags: string[]): Promise<void>;

package/dist/types/dev-discovery-protocol.d.ts

@@ -0,0 +1,5 @@
+export declare const DEV_DISCOVERY_READY_EVENT = "rango:dev-discovery-ready";
+export declare const DEV_DISCOVERY_QUERY_EVENT = "rango:dev-discovery-query";
+export declare const DEV_DISCOVERY_PROBE_HEADER = "x-rango-dev-discovery-probe";
+export declare const DEV_DISCOVERY_EPOCH_HEADER = "x-rango-dev-discovery-epoch";
+export declare function isValidDevDiscoveryEpoch(value: unknown): value is number;

package/dist/types/prerender/store.d.ts

@@ -37,6 +37,7 @@ declare global {
     var __STATIC_MANIFEST: Record<string, () => Promise<{
         default: string | StaticEntry;
     }>> | undefined;
+    var __loadStaticManifestModule: (() => Promise<unknown>) | undefined;
     var __PRERENDER_DEV_URL: string | undefined;
 }
 /**

package/dist/types/route-map-builder.d.ts

@@ -7,10 +7,6 @@
  *
  * See docs/manifests.md for the full data flow.
  */
-declare let cachedPrecomputedEntries: Array<{
-    staticPrefix: string;
-    routes: Record<string, string>;
-}> | null;
 /**
  * Register routes into the global route map.
  * Routes are merged with any existing registered routes.
@@ -63,26 +59,6 @@ export declare function hasCachedManifest(): boolean;
  * Clear the cached manifest (for testing)
  */
 export declare function clearCachedManifest(): void;
-/**
- * Set pre-computed route entries from build-time data.
- *
- * Each entry corresponds to a leaf node in the prefix tree (no nested includes).
- * evaluateLazyEntry() checks these before running the handler, avoiding the
- * 5-50ms cost of handler evaluation for route matching on the first request.
- *
- * @param entries - Array of { staticPrefix, routes } from build-time prefix tree leaves
- */
-export declare function setPrecomputedEntries(entries: Array<{
-    staticPrefix: string;
-    routes: Record<string, string>;
-}> | null): void;
-/**
- * Get pre-computed route entries (if available)
- */
-export declare function getPrecomputedEntries(): typeof cachedPrecomputedEntries;
-declare let cachedRouteTrie: import("./build/route-trie.js").TrieNode | null;
-export declare function setRouteTrie(trie: typeof cachedRouteTrie): void;
-export declare function getRouteTrie(): typeof cachedRouteTrie;
 /**
  * Clear all cached route data (global and per-router).
  * Called during HMR when route definitions change so the handler rebuilds
@@ -115,13 +91,12 @@ export declare function waitForManifestReady(): Promise<void> | null;
  * Register whether a route is at root scope.
  * Called by path() during route evaluation.
  */
-export declare function registerRouteRootScope(routeName: string, rootScoped: boolean): void;
+export declare function registerRouteRootScope(routeName: string, rootScoped: boolean, routerId?: string): void;
 /**
  * Check if a route is at root scope.
  * Returns undefined if the route has not been registered (e.g. in unit tests).
  */
-export declare function isRouteRootScoped(routeName: string): boolean | undefined;
+export declare function isRouteRootScoped(routeName: string, routerId?: string): boolean | undefined;
 import type { SearchSchema } from "./search-params.js";
-export declare function registerSearchSchema(routeName: string, schema: SearchSchema): void;
-export declare function getSearchSchema(routeName: string): SearchSchema | undefined;
-export {};
+export declare function registerSearchSchema(routeName: string, schema: SearchSchema, routerId?: string): void;
+export declare function getSearchSchema(routeName: string, routerId?: string): SearchSchema | undefined;

package/dist/types/router/prerender-match.d.ts

@@ -6,6 +6,9 @@ import type { HandlerContext, ResolvedSegment } from "../types";
 import type { SerializedSegmentData } from "../cache/types.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
 export interface PrerenderMatchDeps<TEnv = any> {
+    /** Owning router id; scopes bake-time root-scope/search-schema lookups the
+     *  same way reqCtx._routerId does at runtime (issue #762). */
+    routerId?: string;
     findMatch: (pathname: string) => RouteMatchResult<TEnv> | null | Promise<RouteMatchResult<TEnv> | null>;
     buildRouterContext: () => RouterContext<TEnv>;
     mergedRouteMap: Record<string, string>;
@@ -44,7 +47,7 @@ devMode?: boolean): Promise<{
  * the component. Returns the encoded Flight string (or null on failure).
  * Used by the Vite plugin to collect static segment data at build time.
  */
-export declare function renderStaticSegment<TEnv = any>(handler: Function, handlerId: string, mergedRouteMap: Record<string, string>, routeName?: string, buildEnv?: TEnv, devMode?: boolean): Promise<{
+export declare function renderStaticSegment<TEnv = any>(handler: Function, handlerId: string, mergedRouteMap: Record<string, string>, routeName?: string, buildEnv?: TEnv, devMode?: boolean, routerId?: string, rootScoped?: boolean): Promise<{
     encoded: string;
     handles: string;
 } | null>;

package/dist/types/router/router-interfaces.d.ts

@@ -333,6 +333,8 @@ export interface RangoInternal<TEnv = any, TRoutes extends Record<string, unknow
     readonly __sourceFile?: string;
     /** @internal basename for runtime manifest generation */
     readonly __basename?: string;
+    /** @internal Cloudflare dev worker generation captured at construction. */
+    readonly __devDiscoveryEpoch?: number;
     /**
      * @internal Router-level error/notFound fallbacks (`createRouter` options),
      * exposed for the build-time clientChunks discovery so a `"use client"`
@@ -364,7 +366,7 @@ export interface RangoInternal<TEnv = any, TRoutes extends Record<string, unknow
      * Render a single Static handler at build time.
      * Returns the RSC-serialized component string and handle data, or null on failure.
      */
-    renderStaticSegment(handler: Function, handlerId: string, routeName?: string, buildEnv?: any, devMode?: boolean): Promise<{
+    renderStaticSegment(handler: Function, handlerId: string, routeName?: string, buildEnv?: any, devMode?: boolean, rootScoped?: boolean): Promise<{
         encoded: string;
         handles: string;
     } | null>;

package/dist/types/rsc/handler-context.d.ts

@@ -13,6 +13,7 @@ import type { SSRStreamMode } from "../router/router-options.js";
 export interface HandlerContext<TEnv = unknown> {
     router: RangoInternal<TEnv, any>;
     version: string;
+    devDiscoveryEpoch?: number;
     renderToReadableStream: RSCDependencies["renderToReadableStream"];
     decodeReply: RSCDependencies["decodeReply"];
     createTemporaryReferenceSet: RSCDependencies["createTemporaryReferenceSet"];

package/dist/types/rsc/render-pipeline.d.ts

@@ -39,8 +39,9 @@ export interface RscRenderStageTracking {
     /** Whole-render span receiving low-cardinality current/error phase attrs. */
     span?: TraceSpan;
 }
+type RscRenderContext<TEnv> = Pick<HandlerContext<TEnv>, "renderToReadableStream" | "callOnError" | "devDiscoveryEpoch">;
 export interface RscRenderInput<TEnv> {
-    ctx: Pick<HandlerContext<TEnv>, "renderToReadableStream" | "callOnError">;
+    ctx: RscRenderContext<TEnv>;
     request: Request;
     url: URL;
     env: TEnv;
@@ -51,7 +52,7 @@ export interface RscRenderInput<TEnv> {
     tracking?: RscRenderStageTracking;
 }
 export interface RscFlightStageInput<TEnv> {
-    ctx: Pick<HandlerContext<TEnv>, "renderToReadableStream" | "callOnError">;
+    ctx: RscRenderContext<TEnv>;
     request: Request;
     url: URL;
     env: TEnv;

package/dist/types/rsc/rsc-rendering.d.ts

@@ -9,15 +9,10 @@ import { getRequestContext } from "../server/request-context.js";
 import type { HandlerContext } from "./handler-context.js";
 export declare function handleRscRendering<TEnv>(ctx: HandlerContext<TEnv>, request: Request, env: TEnv, url: URL, isPartial: boolean, handleStore: ReturnType<typeof getRequestContext>["_handleStore"], nonce: string | undefined): Promise<Response>;
 /**
- * Neutralize the shell-HIT degradation redirect target.
- *
- * The inline `location.replace` emitted by serveShellHit when a shell HIT lands
- * on a URL whose route became redirecting mid-TTL is a document-native redirect
- * exit that BYPASSES the 3xx chokepoint (guardOutgoingRedirect acts only on 3xx
- * + Location responses, never a committed 200 body). So it reuses the ONE
- * same-origin resolver directly: a cross-origin/unparseable/unsafe target
- * neutralizes to the same safe same-origin landing as redirect-guard.ts
- * (basename root, or "/" when unset) rather than navigating the user off-host.
- * A safe same-origin/relative target passes through as its normalized href.
+ * Neutralize the shell-HIT degradation redirect target. The inline
+ * `location.replace` in a committed 200 body bypasses the 3xx chokepoint
+ * (guardOutgoingRedirect only sees 3xx + Location), so this reuses the same
+ * same-origin resolver directly: unsafe targets neutralize to the
+ * redirect-guard.ts landing instead of navigating the user off-host.
  */
 export declare function resolveShellHitRedirectTarget(rawTarget: string, requestOrigin: string, basename: string | undefined): string;