@rangojs/router 0.0.0-experimental.e16b7c00 → 0.0.0-experimental.e9c0b2f2

package/src/vite/utils/bundle-analysis.ts

@@ -5,9 +5,7 @@ import {
 
 /**
  * Find matching close paren in bundled code using depth counting.
- * Uses skipStringOrComment from expose-id-utils to correctly handle
- * template literal ${...} expressions, comments, and nested strings.
- * Returns the position after the closing paren, or -1 if unmatched.
+ * Uses skipStringOrComment to correctly handle template literals, comments, and nested strings.
  * @internal Exported for testing only.
  */
 export function findMatchingParenInBundle(
@@ -30,9 +28,8 @@ export function findMatchingParenInBundle(
 }
 
 /**
- * Scan a bundled chunk for handler exports of a given type and extract
- * their names + $$id values. Optionally detects passthrough flag.
- * @internal Exported for testing only.
+ * Scan a bundled chunk for handler exports and extract their names + $$id values.
+ * Optionally detects passthrough flag. @internal Exported for testing only.
  */
 export function extractHandlerExportsFromChunk(
   chunkCode: string,
@@ -67,7 +64,7 @@ export function extractHandlerExportsFromChunk(
           const closePos = findMatchingParenInBundle(chunkCode, afterOpen);
           if (closePos !== -1) {
             const callBody = chunkCode.slice(callStart.index, closePos);
-            isPassthrough = /passthrough\s*:\s*(!0|true)/.test(callBody);
+            isPassthrough = /passthrough\s*:\s*(!0|true)/.test(callBody); // !0 is minified true
           }
         }
       }
@@ -79,9 +76,8 @@ export function extractHandlerExportsFromChunk(
 }
 
 /**
- * Evict handler code from a bundled chunk, replacing full handler call
- * expressions with lightweight stub objects. Returns the modified code
- * and bytes saved, or null if no changes were made.
+ * Evict handler code from a bundled chunk, replacing full call expressions with stubs.
+ * Returns the modified code and bytes saved, or null if no changes were made.
  * @internal Exported for testing only.
  */
 export function evictHandlerCode(
@@ -110,13 +106,11 @@ export function evictHandlerCode(
     const closePos = findMatchingParenInBundle(modified, afterOpen);
     if (closePos === -1) continue;
 
-    // Skip trailing whitespace and optional semicolon
     let rangeEnd = closePos;
     while (rangeEnd < modified.length && /\s/.test(modified[rangeEnd]))
       rangeEnd++;
     if (modified[rangeEnd] === ";") rangeEnd++;
 
-    // Validate: matched range must contain the expected handlerId
     const matched = modified.slice(startMatch.index, rangeEnd);
     if (!matched.includes(handlerId)) continue;
 
@@ -124,7 +118,6 @@ export function evictHandlerCode(
     modified =
       modified.slice(0, startMatch.index) + stub + modified.slice(rangeEnd);
 
-    // Remove the now-redundant $$id assignment line.
     modified = modified.replace(
       new RegExp(`\\n${eName}\\.\\$\\$id\\s*=\\s*"[^"]+";`),
       "",

package/src/vite/utils/client-chunks.ts

@@ -1,9 +1,3 @@
-// Resolution of the public `clientChunks` option into the callback shape that
-// @vitejs/plugin-rsc expects. See plugin-types.ts (ClientChunks) and
-// docs/client-chunking.md for the contract. The mechanism: a distinct returned
-// name yields a distinct, dynamically-imported client chunk, independent of how
-// the RSC/server build chunked the importing modules.
-
 import type { ClientChunkMeta, ClientChunks } from "../plugin-types.js";
 import { createRangoDebugger, NS } from "../debug.js";
 import { hashRefKey } from "../plugins/client-ref-hashing.js";

package/src/vite/utils/directive-prologue.ts

@@ -0,0 +1,40 @@
+import { parseAst } from "vite";
+
+/**
+ * Detect a leading `"use client"` (or `'use client'`) directive in a module's
+ * directive prologue, tolerating leading comments/whitespace before it.
+ *
+ * A bare `source.trimStart().startsWith` check only strips whitespace, so a
+ * license banner / `// @ts-nocheck` before the directive would be missed. This
+ * walks the leading ExpressionStatement string-literal directives via the AST
+ * (a leading comment is not a `program.body` node), the single source of truth
+ * shared by both the rango plugin's HMR client-module sniff and the version
+ * plugin's getClientModuleSignature — so the two can never drift on what counts
+ * as a client module.
+ *
+ * Returns false when the source cannot be parsed (a syntactically broken file is
+ * not treated as a client module).
+ */
+export function hasUseClientDirective(source: string): boolean {
+  let program: { body?: any[] };
+  try {
+    program = parseAst(source, { lang: "tsx" }) as { body?: any[] };
+  } catch {
+    return false;
+  }
+  for (const node of program.body ?? []) {
+    if (
+      node?.type === "ExpressionStatement" &&
+      node.expression?.type === "Literal" &&
+      typeof node.expression.value === "string"
+    ) {
+      if (node.expression.value === "use client") return true;
+      // Another leading string-literal directive (e.g. "use strict"): keep
+      // scanning the prologue.
+      continue;
+    }
+    // First non-directive statement ends the prologue.
+    break;
+  }
+  return false;
+}

package/src/vite/utils/forward-user-plugins.ts

@@ -1,25 +1,3 @@
-/**
- * Discovery Runner Config Parity
- *
- * The discovery temp server (createTempRscServer) runs the user's handler
- * graph through a throwaway Node Vite server built with `configFile: false`.
- * Without help, that server only sees a fixed Rango-owned plugin set, so any
- * user resolution is absent during discovery, prerender, and static handler
- * rendering — even though it applies at request time. Two flavors of user
- * resolution must be carried across:
- *
- * - Third-party resolveId plugins (e.g. vite-tsconfig-paths) — forwarded as
- *   plugin instances, see selectForwardableResolvePlugins.
- * - Native config-driven resolution, including Vite 8's built-in
- *   `resolve.tsconfigPaths` (which supersedes vite-tsconfig-paths) — forwarded
- *   as the data slice, see pickForwardedRunnerConfig.
- *
- * These helpers extract the resolution-relevant slice of the user's resolved
- * config (resolve.*, define, oxc) and forward the user's resolution plugins
- * into the temp server so discovery resolves modules the same way the real
- * environment does.
- */
-
 import type { Plugin, ResolvedConfig, UserConfig } from "vite";
 
 /**

package/src/vite/utils/manifest-utils.ts

@@ -1,78 +1,7 @@
-/**
- * Flatten prefix tree leaf nodes into precomputed route entries.
- * Leaf nodes have no children (no nested includes), so their routes can be
- * used directly by evaluateLazyEntry() without running the handler.
- * Non-leaf nodes are skipped because they have nested lazy includes that
- * require the handler to run for discovery.
- *
- * A leaf is also skipped when its staticPrefix collides with an ancestor
- * include node's staticPrefix. That happens when a dynamic param collapses the
- * staticPrefix of nested includes onto the parent's (e.g. `/m/:id/edit` -> sp
- * `/m`): precomputing such a leaf under the collapsed prefix would let the
- * ancestor's lazy entry claim a route it cannot register (the route is behind
- * further nested lazy includes), producing a RouteNotFoundError at request time
- * (issue #506). Those routes are resolved via the handler chain instead.
- */
-export function flattenLeafEntries(
-  prefixTree: Record<string, any>,
-  routeManifest: Record<string, string>,
-  result: Array<{ staticPrefix: string; routes: Record<string, string> }>,
-): void {
-  function visit(node: any, ancestorStaticPrefixes: Set<string>): void {
-    const children = node.children || {};
-    if (
-      Object.keys(children).length === 0 &&
-      node.routes &&
-      node.routes.length > 0
-    ) {
-      // Leaf node. Skip if its staticPrefix collides with an ancestor include
-      // node's staticPrefix (dynamic-param collapse) — see doc comment above.
-      if (ancestorStaticPrefixes.has(node.staticPrefix)) {
-        return;
-      }
-      // Collect its routes from the manifest
-      const routes: Record<string, string> = {};
-      for (const name of node.routes) {
-        if (name in routeManifest) {
-          routes[name] = routeManifest[name];
-        }
-      }
-      result.push({ staticPrefix: node.staticPrefix, routes });
-    } else {
-      // Non-leaf: recurse into children, tracking this node's staticPrefix as
-      // an ancestor so a collapsed nested leaf below it is not over-claimed.
-      const nextAncestors = new Set(ancestorStaticPrefixes);
-      nextAncestors.add(node.staticPrefix);
-      for (const child of Object.values(children)) {
-        visit(child, nextAncestors);
-      }
-    }
-  }
-  for (const node of Object.values(prefixTree)) {
-    visit(node, new Set());
-  }
-}
-
-/**
- * Walk prefix tree to map each route name to its scope's staticPrefix.
- */
-export function buildRouteToStaticPrefix(
-  prefixTree: Record<string, any>,
-  result: Record<string, string>,
-): void {
-  function visit(node: any): void {
-    const sp = node.staticPrefix || "";
-    for (const name of node.routes || []) {
-      result[name] = sp;
-    }
-    for (const child of Object.values(node.children || {})) {
-      visit(child);
-    }
-  }
-  for (const node of Object.values(prefixTree)) {
-    visit(node);
-  }
-}
+export {
+  flattenLeafEntries,
+  buildRouteToStaticPrefix,
+} from "../../build/prefix-tree-utils.js";
 
 /**
  * Wrap a value as `JSON.parse('...')` instead of a JS object literal.

package/src/vite/utils/package-resolution.ts

@@ -1,10 +1,3 @@
-/**
- * Package Resolution Utilities
- *
- * Handles detection of workspace vs npm install context and generates
- * appropriate aliases and exclude lists for Vite configuration.
- */
-
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { resolve } from "node:path";
@@ -17,44 +10,20 @@ const require = createRequire(import.meta.url);
  */
 const VIRTUAL_PACKAGE_NAME = "@rangojs/router";
 
-/**
- * Get the published package name (e.g., "@rangojs/router")
- */
 export function getPublishedPackageName(): string {
   return packageJson.name;
 }
 
-/**
- * Check if the package is installed from npm (scoped) vs workspace (unscoped)
- *
- * In workspace development:
- * - Package is installed as "@rangojs/router" via pnpm workspace alias
- * - The scoped name (@rangojs/router) doesn't exist in node_modules
- *
- * When installed from npm:
- * - Package is installed as "@rangojs/router"
- * - We need aliases to map "@rangojs/router/*" to "@rangojs/router/*"
- */
 export function isInstalledFromNpm(): boolean {
   const packageName = getPublishedPackageName();
   // Check if the scoped package exists in node_modules
   return existsSync(resolve(process.cwd(), "node_modules", packageName));
 }
 
-/**
- * Check if we're in a monorepo/workspace development context
- */
 export function isWorkspaceDevelopment(): boolean {
   return !isInstalledFromNpm();
 }
 
-/**
- * Subpaths derived from package.json exports that use TypeScript source.
- * These must be excluded from Vite's dependency optimization (they ship
- * as .ts/.tsx, not compiled JS) and aliased when installed from npm.
- *
- * Derived automatically from the exports field to prevent drift.
- */
 const SOURCE_EXPORT_SUBPATHS = Object.keys(packageJson.exports)
   .filter((key) => {
     const entry = (
@@ -70,12 +39,6 @@ const SOURCE_EXPORT_SUBPATHS = Object.keys(packageJson.exports)
   })
   .map((key) => key.replace(/^\./, ""));
 
-/**
- * Generate the list of modules to exclude from Vite's dependency optimization.
- *
- * We include both the published name and the virtual name because
- * Vite's optimizer runs before alias resolution.
- */
 export function getExcludeDeps(): string[] {
   const packageName = getPublishedPackageName();
   const excludes: string[] = [];
@@ -92,24 +55,10 @@ export function getExcludeDeps(): string[] {
   return excludes;
 }
 
-/**
- * Subpaths that need aliasing — same as SOURCE_EXPORT_SUBPATHS.
- * When installed from npm, virtual entries may use a different package name
- * than the published one; aliases bridge them.
- */
 const ALIAS_SUBPATHS = SOURCE_EXPORT_SUBPATHS;
 
-/**
- * Generate aliases to map virtual package paths to the actual published package.
- *
- * Only needed when installed from npm, where the package is under @rangojs/router
- * but virtual entries import from rsc-router/*.
- *
- * Returns empty object in workspace development where rsc-router resolves directly.
- */
 export function getPackageAliases(): Record<string, string> {
   if (isWorkspaceDevelopment()) {
-    // No aliases needed - rsc-router resolves directly
     return {};
   }
 
@@ -123,28 +72,7 @@ export function getPackageAliases(): Record<string, string> {
   return aliases;
 }
 
-/**
- * Plugin-rsc pushes bare specs like
- * `@vitejs/plugin-rsc/vendor/react-server-dom/client.edge` into
- * `optimizeDeps.include` for the ssr and rsc environments. In strict pnpm
- * consumer apps, `@vitejs/plugin-rsc` is only reachable from @rangojs/router's
- * node_modules, so Vite's optimizer — which resolves from the project root —
- * can't find them and emits "Failed to resolve dependency" warnings.
- *
- * We resolve those specs from this plugin's location (where plugin-rsc is
- * guaranteed to be installed as our dep) and expose them as `resolve.alias`
- * entries. The optimizer's resolver honors aliases, so the bare specs map to
- * absolute paths and resolve cleanly.
- */
 export function getVendorAliases(): Record<string, string> {
-  // client.browser is intentionally NOT aliased. plugin-rsc injects it into
-  // the client env's optimizeDeps.include; Vite's manual-include path resolves
-  // and pre-bundles regardless of optimizeDeps.exclude, so aliasing would
-  // trigger esbuild pre-bundling of the CJS vendor file and bypass the
-  // cjs-to-esm transform that patches `require('react'|'react-dom')` into
-  // real ESM imports. The consumer may still see a single "Failed to resolve"
-  // warning for client.browser; runtime resolution from plugin-rsc's own
-  // importer works because Vite resolves relative to the importer (not root).
   const specs = [
     "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge",
     "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge",
@@ -154,7 +82,7 @@ export function getVendorAliases(): Record<string, string> {
     try {
       aliases[spec] = require.resolve(spec);
     } catch {
-      // Spec unresolvable (unexpected but non-fatal — Vite will warn as before).
+      // Non-fatal; Vite will warn if it cannot resolve the spec
     }
   }
   return aliases;

package/src/vite/utils/prerender-utils.ts

@@ -9,18 +9,8 @@ import {
 } from "node:fs";
 import { resolve } from "node:path";
 
-/**
- * Escape special RegExp characters in a string for safe interpolation
- * into new RegExp() patterns.
- */
-export function escapeRegExp(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+import { escapeRegExp } from "../../regex-escape.js";
 
-/**
- * Encode route param values for path interpolation while preserving path
- * separators for wildcard params (splat-style values can include `/`).
- */
 export function encodePathParam(value: unknown): string {
   return String(value)
     .split("/")
@@ -28,11 +18,6 @@ export function encodePathParam(value: unknown): string {
     .join("/");
 }
 
-/**
- * Substitute route params into a pattern, stripping constraint and optional
- * syntax (:param(a|b)? -> value). Also handles wildcard params (*key).
- * Optional params not present in `params` are removed from the output.
- */
 export function substituteRouteParams(
   pattern: string,
   params: Record<string, string>,
@@ -41,17 +26,9 @@ export function substituteRouteParams(
   let result = pattern;
   let hadOmittedOptional = false;
 
-  // First pass: substitute provided params.
-  // Empty string on an optional placeholder is treated as omitted —
-  // caller-supplied params or `getParams()` shapes may pass `""` for an
-  // absent optional, so letting the second pass strip them keeps slash
-  // cleanup consistent. Empty string on required `:key` or wildcard
-  // `*key` still substitutes, matching prior behaviour.
   for (const [key, value] of Object.entries(params)) {
     const escaped = escapeRegExp(key);
     if (value === "") {
-      // Only replace required placeholders (negative lookahead for `?`);
-      // leave `:key?` for the second pass.
       result = result.replace(
         new RegExp(`:${escaped}(\\([^)]*\\))?(?!\\?)`),
         "",
@@ -66,13 +43,11 @@ export function substituteRouteParams(
     }
   }
 
-  // Second pass: strip remaining optional param placeholders not in params
   result = result.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\([^)]*\))?\?/g, () => {
     hadOmittedOptional = true;
     return "";
   });
 
-  // Clean up slashes from omitted optional segments
   if (hadOmittedOptional) {
     const hadTrailingSlash = pattern.length > 1 && pattern.endsWith("/");
     result = result.replace(/\/\/+/g, "/").replace(/\/+$/, "") || "/";
@@ -82,10 +57,6 @@ export function substituteRouteParams(
   return result;
 }
 
-/**
- * Run an async function over items with bounded concurrency.
- * Errors propagate immediately and abort remaining work.
- */
 export async function runWithConcurrency<T>(
   items: T[],
   concurrency: number,
@@ -97,19 +68,30 @@ export async function runWithConcurrency<T>(
     return;
   }
   let nextIndex = 0;
+  // On first failure (the default prerender.onError: "fail" re-throws), stop
+  // scheduling new work so the remaining workers don't keep running full RSC
+  // renders before the build aborts. The first error is surfaced after all
+  // in-flight workers settle, preserving the throw-to-fail-build behavior.
+  let firstError: unknown;
+  let failed = false;
   async function worker() {
-    while (nextIndex < items.length) {
+    while (nextIndex < items.length && !failed) {
       const idx = nextIndex++;
-      await fn(items[idx]);
+      try {
+        await fn(items[idx]);
+      } catch (err) {
+        if (!failed) {
+          failed = true;
+          firstError = err;
+        }
+        return;
+      }
     }
   }
   await Promise.all(Array.from({ length: limit }, () => worker()));
+  if (failed) throw firstError;
 }
 
-/**
- * Group prerender entries by their concurrency setting so each group
- * can be rendered with the appropriate parallelism.
- */
 export function groupByConcurrency<T extends { concurrency: number }>(
   entries: T[],
 ): { concurrency: number; entries: T[] }[] {
@@ -129,10 +111,6 @@ export function groupByConcurrency<T extends { concurrency: number }>(
   }));
 }
 
-/**
- * Notify all routers' onError callbacks about a build-time error.
- * Uses a synthetic request since there is no real request during build.
- */
 export function notifyOnError(
   registry: Map<string, any>,
   error: unknown,
@@ -172,6 +150,42 @@ export function notifyOnError(
   }
 }
 
+/**
+ * Resolve a thrown build-time render error into the prerender build's policy and
+ * log a per-entry line. A `Skip` (or any render error under `prerender.onError:
+ * "warn"`) logs and returns so the caller skips the entry; a render error under
+ * the default "fail" logs FAIL, notifies `onError`, and re-throws to fail the
+ * build. Shared by `expandPrerenderRoutes` (prerender) and `renderStaticHandlers`
+ * (static) so the Skip/warn/fail policy lives in one place. `label` is the padded
+ * URL / handler name for the log line; `elapsed` is the per-entry duration string.
+ */
+export function resolvePrerenderError(
+  registry: Map<string, any>,
+  error: any,
+  onError: "fail" | "warn",
+  label: string,
+  elapsed: string,
+  phase: "prerender" | "static",
+  routeKey?: string,
+  pathname?: string,
+): void {
+  const isSkip = error?.name === "Skip";
+  if (isSkip || onError === "warn") {
+    if (isSkip) {
+      console.log(`[rango]   SKIP ${label} (${elapsed}ms) - ${error.message}`);
+    } else {
+      console.warn(
+        `[rango]   WARN ${label} (${elapsed}ms) - render error, not pre-rendered (prerender.onError: "warn"): ${error.message}`,
+      );
+    }
+    notifyOnError(registry, error, phase, routeKey, pathname, true);
+    return;
+  }
+  console.error(`[rango]   FAIL ${label} (${elapsed}ms) - ${error.message}`);
+  notifyOnError(registry, error, phase, routeKey, pathname);
+  throw error;
+}
+
 function getStagedAssetDir(projectRoot: string): string {
   return resolve(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
 }

package/src/vite/utils/shared-utils.ts

@@ -6,6 +6,7 @@ import {
   VIRTUAL_ENTRY_BROWSER,
   VIRTUAL_ENTRY_SSR,
   getVirtualEntryRSC,
+  getVirtualEntryRSCHost,
   getVirtualVersionContent,
   VIRTUAL_IDS,
 } from "../plugins/virtual-entries.js";
@@ -60,7 +61,7 @@ export const sharedRolldownOptions: {
  */
 export function createVirtualEntriesPlugin(
   entries: { client: string; ssr: string; rsc?: string },
-  routerPathRef?: { path?: string },
+  routerPathRef?: { path?: string; kind?: "router" | "host" },
 ): Plugin {
   // Build virtual modules map based on which entries use virtual IDs
   const virtualModules: Record<string, string> = {};
@@ -108,7 +109,9 @@ export function createVirtualEntriesPlugin(
             : routerPathRef.path;
           // Normalize backslashes for Windows (path.join/slice preserve native separators)
           const absoluteRouterPath = raw.replaceAll("\\", "/");
-          return getVirtualEntryRSC(absoluteRouterPath);
+          return routerPathRef.kind === "host"
+            ? getVirtualEntryRSCHost(absoluteRouterPath)
+            : getVirtualEntryRSC(absoluteRouterPath);
         }
       }
       return null;
@@ -161,23 +164,9 @@ function isContentHashedAssetConflict(message: string | undefined): boolean {
 }
 
 /**
- * Rollup onwarn handler that suppresses known harmless warnings:
- * - "use client" directives: handled by the RSC plugin, not relevant to Rollup
- * - sourcemap errors: caused by "use client" directive at line 1:0 confusing sourcemap resolution
- * - sourcemap incomplete: plugins that transform without generating sourcemaps (router + RSC plugin)
- * - dynamic/static mixed imports: expected for router internals (e.g. request-context, cache-scope).
- *   Under Rolldown (Vite 8) this surfaces as the INEFFECTIVE_DYNAMIC_IMPORT code emitted directly
- *   by the bundler, rather than the vite:reporter message handled below (Rollup/Vite 7 shape).
- * - empty bundle: @vitejs/plugin-rsc scan build (step 1/5) produces an empty "index" chunk
- *   because the RSC entry is fully externalized during client-reference analysis
- * - file name conflicts on content-hashed assets: @vitejs/plugin-rsc copies the rsc
- *   environment's imported CSS/assets into the client bundle (its assets-manifest
- *   generateBundle re-emits each via emitFile with an explicit content-hashed
- *   fileName). When the client bundle already produced that identical asset,
- *   rollup raises FILE_NAME_CONFLICT even though the bytes are identical (a
- *   content hash collision IS a content match). Only these are suppressed; a
- *   collision on a stable name still surfaces. No upstream fix as of
- *   @vitejs/plugin-rsc@0.5.27; remove when it skips the redundant emit.
+ * Suppress known harmless warnings: "use client" directives, sourcemap errors,
+ * mixed imports (expected for router internals), empty bundles, and content-hashed
+ * asset collisions from @vitejs/plugin-rsc copying RSC-env assets to the client bundle.
  */
 export function onwarn(
   warning: Vite.Rollup.RollupLog,
@@ -197,10 +186,6 @@ export function onwarn(
   ) {
     return;
   }
-  // @vitejs/plugin-rsc@0.5.14: rsc:virtual:vite-rsc/assets-manifest renderChunk
-  // returns { code } without map, causing Rollup to warn about incorrect sourcemaps.
-  // This is harmless (simple string replacement). Remove this suppression if a
-  // future version of @vitejs/plugin-rsc fixes the missing sourcemap.
   if (warning.message?.includes("Sourcemap is likely to be incorrect")) {
     return;
   }
@@ -215,10 +200,6 @@ export function onwarn(
   defaultHandler(warning);
 }
 
-/**
- * Manual chunks configuration for client build.
- * Splits React and router packages into separate chunks for better caching.
- */
 export function getManualChunks(id: string): string | undefined {
   const normalized = Vite.normalizePath(id);
 
@@ -230,16 +211,6 @@ export function getManualChunks(id: string): string | undefined {
   ) {
     return "react";
   }
-  // Use dynamic package name from package.json
-  // Check both npm install path and workspace symlink resolved path.
-  //
-  // The workspace patterns are anchored to the package's own `src`/`dist` so
-  // they match the router runtime but NOT consumer apps that merely live under a
-  // `packages/rangojs-router/` ancestor (the in-repo e2e apps at
-  // `packages/rangojs-router/e2e/<app>/src/...`). Without the anchor those apps'
-  // own client components were force-merged into the shared "router" chunk,
-  // which both misrepresented real-consumer bundles and blocked `clientChunks`
-  // splitting from relocating them.
   const packageName = getPublishedPackageName();
   if (
     normalized.includes(`node_modules/${packageName}/`) ||

package/src/browser/shallow.ts

@@ -1,40 +0,0 @@
-/**
- * Shallow comparison utility for selector optimization
- *
- * Used by useNavigation hook to prevent unnecessary re-renders
- * when the selected value hasn't changed.
- *
- * @param a - First value
- * @param b - Second value
- * @returns true if values are shallowly equal
- */
-export function shallow<T>(a: T, b: T): boolean {
-  // Same reference or primitive equality
-  if (Object.is(a, b)) return true;
-
-  // Different types or non-objects
-  if (typeof a !== "object" || typeof b !== "object") return false;
-
-  // Null checks
-  if (a === null || b === null) return false;
-
-  // Compare object keys
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-
-  if (keysA.length !== keysB.length) return false;
-
-  // Check each key's value with Object.is
-  for (const key of keysA) {
-    if (
-      !Object.is(
-        (a as Record<string, unknown>)[key],
-        (b as Record<string, unknown>)[key],
-      )
-    ) {
-      return false;
-    }
-  }
-
-  return true;
-}