@ivogt/rsc-router 0.0.0-experimental.12 → 0.0.0-experimental.14

package/src/router.ts

@@ -2,6 +2,7 @@ import type { ComponentType } from "react";
 import { type ReactNode } from "react";
 import { CacheScope, createCacheScope } from "./cache/cache-scope.js";
 import type { SegmentCacheStore } from "./cache/types.js";
+import { assertClientComponent } from "./component-utils.js";
 import { DefaultDocument } from "./components/DefaultDocument.js";
 import { DefaultErrorFallback } from "./default-error-boundary.js";
 import {
@@ -13,10 +14,14 @@ import {
 import {
   createHref,
   type HrefFunction,
-  type PrefixedRoutes,
-  type SanitizePrefix,
+  type PrefixRoutePatterns,
 } from "./href.js";
 import { registerRouteMap } from "./route-map-builder.js";
+import {
+  createRouteHelpers,
+  type RouteHelpers,
+} from "./route-definition.js";
+import MapRootLayout from "./server/root-layout.js";
 import type { AllUseItems } from "./route-types.js";
 import {
   EntryData,
@@ -264,14 +269,131 @@ export interface RSCRouterOptions<TEnv = any> {
     | ((env: TEnv) => { store: SegmentCacheStore; enabled?: boolean });
 }
 
+/**
+ * Type-level detection of conflicting route keys.
+ * Extracts keys that exist in both TExisting and TNew but with different URL patterns.
+ * Returns `never` if no conflicts exist.
+ *
+ * @example
+ * ```typescript
+ * ConflictingKeys<{ a: "/a" }, { a: "/b" }> // "a" (conflict - same key, different URLs)
+ * ConflictingKeys<{ a: "/a" }, { a: "/a" }> // never (no conflict - same key and URL)
+ * ConflictingKeys<{ a: "/a" }, { b: "/b" }> // never (no conflict - different keys)
+ * ```
+ */
+type ConflictingKeys<
+  TExisting extends Record<string, string>,
+  TNew extends Record<string, string>
+> = {
+  [K in keyof TExisting & keyof TNew]: TExisting[K] extends TNew[K]
+    ? TNew[K] extends TExisting[K]
+      ? never // Same value, no conflict
+      : K // Different values, conflict
+    : K; // Different values, conflict
+}[keyof TExisting & keyof TNew];
+
+/**
+ * Simplified route helpers for inline route definitions.
+ * Uses TRoutes (Record<string, string>) instead of RouteDefinition.
+ *
+ * Note: Some helpers use `any` for context types as a trade-off for simpler usage.
+ * The main type safety is in the `route` helper which enforces valid route names.
+ * For full type safety, use the standard map() API with separate handler files.
+ */
+type InlineRouteHelpers<
+  TRoutes extends Record<string, string>,
+  TEnv,
+> = {
+  /**
+   * Define a route handler for a specific route pattern
+   */
+  route: <K extends keyof TRoutes & string>(
+    name: K,
+    handler:
+      | ((ctx: HandlerContext<{}, TEnv>) => ReactNode | Promise<ReactNode>)
+      | ReactNode
+  ) => AllUseItems;
+
+  /**
+   * Define a layout that wraps child routes
+   */
+  layout: (
+    component: ReactNode | ((ctx: HandlerContext<any, TEnv>) => ReactNode | Promise<ReactNode>),
+    use?: () => AllUseItems[]
+  ) => AllUseItems;
+
+  /**
+   * Define parallel routes
+   */
+  parallel: (
+    slots: Record<`@${string}`, ReactNode | ((ctx: HandlerContext<any, TEnv>) => ReactNode | Promise<ReactNode>)>,
+    use?: () => AllUseItems[]
+  ) => AllUseItems;
+
+  /**
+   * Define route middleware
+   */
+  middleware: (fn: (ctx: any, next: () => Promise<void>) => Promise<void>) => AllUseItems;
+
+  /**
+   * Define revalidation handlers
+   */
+  revalidate: (fn: (ctx: any) => boolean | Promise<boolean>) => AllUseItems;
+
+  /**
+   * Define data loaders
+   */
+  loader: (loader: any, use?: () => AllUseItems[]) => AllUseItems;
+
+  /**
+   * Define loading states
+   */
+  loading: (component: ReactNode) => AllUseItems;
+
+  /**
+   * Define error boundaries
+   */
+  errorBoundary: (
+    handler: ReactNode | ((props: { error: Error }) => ReactNode)
+  ) => AllUseItems;
+
+  /**
+   * Define not found boundaries
+   */
+  notFoundBoundary: (
+    handler: ReactNode | ((props: { pathname: string }) => ReactNode)
+  ) => AllUseItems;
+
+  /**
+   * Define intercept routes
+   */
+  intercept: (
+    name: string,
+    handler: ReactNode | ((ctx: HandlerContext<any, TEnv>) => ReactNode | Promise<ReactNode>),
+    use?: () => AllUseItems[]
+  ) => AllUseItems;
+
+  /**
+   * Define when conditions for intercepts
+   */
+  when: (condition: (ctx: any) => boolean | Promise<boolean>) => AllUseItems;
+
+  /**
+   * Define cache configuration
+   */
+  cache: (config: { ttl?: number; swr?: number } | false, use?: () => AllUseItems[]) => AllUseItems;
+};
+
 /**
  * Router builder for chaining .use() and .map()
  * TRoutes accumulates all registered route types through the chain
+ * TLocalRoutes contains the routes for the current .routes() call (for inline handler typing)
  */
 interface RouteBuilder<
   T extends RouteDefinition,
   TEnv,
   TRoutes extends Record<string, string>,
+  TLocalRoutes extends Record<string, string> = Record<string, string>,
 > {
   /**
    * Add middleware scoped to this mount
@@ -288,8 +410,34 @@ interface RouteBuilder<
   use(
     patternOrMiddleware: string | MiddlewareFn<TEnv>,
     middleware?: MiddlewareFn<TEnv>
-  ): RouteBuilder<T, TEnv, TRoutes>;
+  ): RouteBuilder<T, TEnv, TRoutes, TLocalRoutes>;
 
+  /**
+   * Map routes to handlers
+   *
+   * Supports two patterns:
+   *
+   * 1. Lazy loading (code-split):
+   * ```typescript
+   * .routes(homeRoutes)
+   * .map(() => import("./handlers/home"))
+   * ```
+   *
+   * 2. Inline definition:
+   * ```typescript
+   * .routes({ index: "/", about: "/about" })
+   * .map(({ route }) => [
+   *   route("index", () => <HomePage />),
+   *   route("about", () => <AboutPage />),
+   * ])
+   * ```
+   */
+  // Inline definition overload - handler receives helpers (must be first for correct inference)
+  // Uses TLocalRoutes so route names don't need the prefix
+  map<H extends (helpers: InlineRouteHelpers<TLocalRoutes, TEnv>) => Array<AllUseItems>>(
+    handler: H
+  ): RSCRouter<TEnv, TRoutes>;
+  // Lazy loading overload - no parameters
   map(
     handler: () =>
       | Array<AllUseItems>
@@ -314,24 +462,40 @@ export interface RSCRouter<
 > {
   /**
    * Register routes with a prefix
-   * Route types are accumulated through the chain
+   * Route keys stay unchanged, only URL patterns get the prefix applied.
+   * This enables composable route modules that work regardless of mount point.
+   *
+   * @throws Compile-time error if route keys conflict with previously registered routes
    */
   routes<TPrefix extends string, T extends ResolvedRouteMap<any>>(
     prefix: TPrefix,
     routes: T
-  ): RouteBuilder<
-    RouteDefinition,
-    TEnv,
-    TRoutes & PrefixedRoutes<T, SanitizePrefix<TPrefix>>
-  >;
+  ): ConflictingKeys<TRoutes, T> extends never
+    ? RouteBuilder<
+        RouteDefinition,
+        TEnv,
+        TRoutes & PrefixRoutePatterns<T, TPrefix>,
+        T
+      >
+    : {
+        __error: `Route key conflict! Keys [${ConflictingKeys<TRoutes, T> & string}] already exist with different URL patterns.`;
+        hint: "Use unique key names for each route definition.";
+      };
 
   /**
    * Register routes without a prefix
    * Route types are accumulated through the chain
+   *
+   * @throws Compile-time error if route keys conflict with previously registered routes
    */
   routes<T extends ResolvedRouteMap<any>>(
     routes: T
-  ): RouteBuilder<RouteDefinition, TEnv, TRoutes & T>;
+  ): ConflictingKeys<TRoutes, T> extends never
+    ? RouteBuilder<RouteDefinition, TEnv, TRoutes & T, T>
+    : {
+        __error: `Route key conflict! Keys [${ConflictingKeys<TRoutes, T> & string}] already exist with different URL patterns.`;
+        hint: "Use unique key names for each route definition.";
+      };
 
   /**
    * Add global middleware that runs on all routes
@@ -354,11 +518,13 @@ export interface RSCRouter<
   /**
    * Type-safe URL builder for registered routes
    * Types are inferred from the accumulated route registrations
+   * Route keys stay unchanged regardless of mount prefix.
    *
    * @example
    * ```typescript
-   * router.href("shop.cart"); // "/shop/cart"
-   * router.href("shop.products.detail", { slug: "widget" }); // "/shop/product/widget"
+   * // Given: .routes("/shop", { cart: "/cart", detail: "/product/:slug" })
+   * router.href("cart"); // "/shop/cart"
+   * router.href("detail", { slug: "widget" }); // "/shop/product/widget"
    * ```
    */
   href: HrefFunction<TRoutes>;
@@ -476,14 +642,16 @@ export interface RSCRouter<
  * });
  *
  * // Route types accumulate through the chain - no module augmentation needed!
+ * // Keys stay unchanged, only URL patterns get the prefix
  * router
  *   .routes(homeRoutes)          // accumulates homeRoutes
  *   .map(() => import('./home'))
- *   .routes('/shop', shopRoutes) // accumulates PrefixedRoutes<shopRoutes, "shop">
+ *   .routes('/shop', shopRoutes) // accumulates shopRoutes with prefixed URLs
  *   .map(() => import('./shop'));
  *
  * // router.href now has type-safe autocomplete for all registered routes
- * router.href("shop.cart");
+ * // Given shopRoutes = { cart: "/cart" }, href uses original key:
+ * router.href("cart"); // "/shop/cart"
  * ```
  */
 export function createRSCRouter<TEnv = any>(
@@ -511,16 +679,9 @@ export function createRSCRouter<TEnv = any>(
     invokeOnError(onError, error, phase, context, "Router");
   }
 
-  // Validate document is a function (component)
-  // Note: We cannot validate "use client" at runtime since it's a bundler directive.
-  // If a server component is passed, React will throw during rendering with a
-  // "Functions cannot be passed to Client Components" error.
-  if (documentOption !== undefined && typeof documentOption !== "function") {
-    throw new Error(
-      `document must be a client component function with "use client" directive. ` +
-        `Make sure to pass the component itself, not a JSX element: ` +
-        `document: MyDocument (correct) vs document: <MyDocument /> (incorrect)`
-    );
+  // Validate document is a client component
+  if (documentOption !== undefined) {
+    assertClientComponent(documentOption, "document");
   }
 
   // Use default document if none provided (keeps internal name as rootLayout)
@@ -3399,15 +3560,13 @@ export function createRSCRouter<TEnv = any>(
   function createRouteBuilder<TNewRoutes extends Record<string, string>>(
     prefix: string,
     routes: TNewRoutes
-  ): RouteBuilder<RouteDefinition, TEnv, TNewRoutes> {
+  ): RouteBuilder<RouteDefinition, TEnv, any, TNewRoutes> {
     const currentMountIndex = mountIndex++;
 
-    // Merge routes into the href map with prefixes
-    // This enables type-safe router.href() calls
+    // Merge routes into the href map
+    // Keys stay unchanged for composability - only URL patterns get prefixed
     const routeEntries = routes as Record<string, string>;
     for (const [key, pattern] of Object.entries(routeEntries)) {
-      // Build prefixed key: "shop" + "cart" -> "shop.cart"
-      const prefixedKey = prefix ? `${prefix.slice(1)}.${key}` : key;
       // Build prefixed pattern: "/shop" + "/cart" -> "/shop/cart"
       const prefixedPattern =
         prefix && pattern !== "/"
@@ -3415,7 +3574,18 @@ export function createRSCRouter<TEnv = any>(
           : prefix && pattern === "/"
             ? prefix
             : pattern;
-      mergedRouteMap[prefixedKey] = prefixedPattern;
+
+      // Runtime validation: warn if key already exists with different pattern
+      const existingPattern = mergedRouteMap[key];
+      if (existingPattern !== undefined && existingPattern !== prefixedPattern) {
+        console.warn(
+          `[rsc-router] Route key conflict: "${key}" already maps to "${existingPattern}", ` +
+            `overwriting with "${prefixedPattern}". Use unique key names to avoid this.`
+        );
+      }
+
+      // Use original key - enables reusable route modules
+      mergedRouteMap[key] = prefixedPattern;
     }
 
     // Auto-register route map for runtime href() usage
@@ -3427,7 +3597,7 @@ export function createRSCRouter<TEnv = any>(
       | undefined;
 
     // Create builder object so .use() can return it
-    const builder: RouteBuilder<RouteDefinition, TEnv, TNewRoutes> = {
+    const builder: RouteBuilder<RouteDefinition, TEnv, any, TNewRoutes> = {
       use(
         patternOrMiddleware: string | MiddlewareFn<TEnv>,
         middleware?: MiddlewareFn<TEnv>
@@ -3438,16 +3608,22 @@ export function createRSCRouter<TEnv = any>(
       },
 
       map(
-        handler: () =>
-          | Array<AllUseItems>
-          | Promise<{ default: () => Array<AllUseItems> }>
-          | Promise<() => Array<AllUseItems>>
+        handler:
+          | ((helpers: InlineRouteHelpers<TNewRoutes, TEnv>) => Array<AllUseItems>)
+          | (() =>
+              | Array<AllUseItems>
+              | Promise<{ default: () => Array<AllUseItems> }>
+              | Promise<() => Array<AllUseItems>>)
       ) {
+        // Store handler as-is - detection happens at call time based on return type
+        // Both patterns use the same signature:
+        // - Inline: ({ route }) => [...] - receives helpers, returns Array
+        // - Lazy: () => import(...) - ignores helpers, returns Promise
         routesEntries.push({
           prefix,
           routes: routes as ResolvedRouteMap<any>,
           trailingSlash: trailingSlashConfig,
-          handler,
+          handler: handler as any,
           mountIndex: currentMountIndex,
         });
         // Return router with accumulated types

package/src/rsc/handler.ts

@@ -32,7 +32,7 @@ import type {
 } from "./types.js";
 import { hasBodyContent, createResponseWithMergedHeaders } from "./helpers.js";
 import { generateNonce } from "./nonce.js";
-import { VERSION } from "rsc-router:version";
+import { VERSION } from "@ivogt/rsc-router:version";
 import type { ErrorPhase } from "../types.js";
 import { invokeOnError } from "../router/error-handling.js";
 
@@ -60,9 +60,10 @@ import { invokeOnError } from "../router/error-handling.js";
  * });
  * ```
  */
-export function createRSCHandler<TEnv = unknown>(
-  options: CreateRSCHandlerOptions<TEnv>
-) {
+export function createRSCHandler<
+  TEnv = unknown,
+  TRoutes extends Record<string, string> = Record<string, string>,
+>(options: CreateRSCHandlerOptions<TEnv, TRoutes>) {
   const { router, version = VERSION, nonce: nonceProvider } = options;
 
   // Use provided deps or default to @vitejs/plugin-rsc/rsc exports

package/src/rsc/types.ts

@@ -140,11 +140,14 @@ export type NonceProvider<TEnv = unknown> = (
 /**
  * Options for creating an RSC handler
  */
-export interface CreateRSCHandlerOptions<TEnv = unknown> {
+export interface CreateRSCHandlerOptions<
+  TEnv = unknown,
+  TRoutes extends Record<string, string> = Record<string, string>,
+> {
   /**
    * The RSC router instance
    */
-  router: RSCRouter<TEnv>;
+  router: RSCRouter<TEnv, TRoutes>;
 
   /**
    * RSC dependencies from @vitejs/plugin-rsc/rsc.

package/src/server.ts

@@ -30,6 +30,7 @@ export {
   createHref,
   type HrefFunction,
   type PrefixedRoutes,
+  type PrefixRoutePatterns,
   type ParamsFor,
   type SanitizePrefix,
   type MergeRoutes,
@@ -82,6 +83,12 @@ export {
   sanitizeError,
 } from "./errors.js";
 
+// Component utilities
+export {
+  isClientComponent,
+  assertClientComponent,
+} from "./component-utils.js";
+
 // Types (re-exported for convenience)
 export type {
   RouterEnv,

package/src/vite/__tests__/expose-loader-id.test.ts

@@ -4,7 +4,7 @@ import { describe, it, expect } from "vitest";
  * Mock function to test createLoader detection patterns
  */
 function hasCreateLoaderImport(code: string): boolean {
-  const pattern = /import\s*\{[^}]*\bcreateLoader\b[^}]*\}\s*from\s*["']rsc-router(?:\/server)?["']/;
+  const pattern = /import\s*\{[^}]*\bcreateLoader\b[^}]*\}\s*from\s*["']@ivogt\/rsc-router(?:\/server)?["']/;
   return pattern.test(code);
 }
 
@@ -24,22 +24,22 @@ function extractLoaderExports(code: string): string[] {
 describe("exposeLoaderId plugin", () => {
   describe("hasCreateLoaderImport", () => {
     it("should detect direct import from rsc-router", () => {
-      const code = `import { createLoader } from "rsc-router";`;
+      const code = `import { createLoader } from "@ivogt/rsc-router";`;
       expect(hasCreateLoaderImport(code)).toBe(true);
     });
 
     it("should detect import from rsc-router/server", () => {
-      const code = `import { createLoader } from "rsc-router/server";`;
+      const code = `import { createLoader } from "@ivogt/rsc-router/server";`;
       expect(hasCreateLoaderImport(code)).toBe(true);
     });
 
     it("should detect createLoader with other imports", () => {
-      const code = `import { map, createLoader, route } from "rsc-router";`;
+      const code = `import { map, createLoader, route } from "@ivogt/rsc-router";`;
       expect(hasCreateLoaderImport(code)).toBe(true);
     });
 
     it("should NOT detect aliased import", () => {
-      const code = `import { createLoader as cl } from "rsc-router";`;
+      const code = `import { createLoader as cl } from "@ivogt/rsc-router";`;
       // Our simple pattern doesn't support aliasing - this is intentional
       expect(hasCreateLoaderImport(code)).toBe(true); // Still matches the word
     });
@@ -50,12 +50,12 @@ describe("exposeLoaderId plugin", () => {
     });
 
     it("should NOT detect default import", () => {
-      const code = `import createLoader from "rsc-router";`;
+      const code = `import createLoader from "@ivogt/rsc-router";`;
       expect(hasCreateLoaderImport(code)).toBe(false);
     });
 
     it("should NOT detect namespace import", () => {
-      const code = `import * as router from "rsc-router";`;
+      const code = `import * as router from "@ivogt/rsc-router";`;
       expect(hasCreateLoaderImport(code)).toBe(false);
     });
   });

package/src/vite/expose-action-id.ts

@@ -229,7 +229,7 @@ export function exposeActionId(): Plugin {
   let rscPluginApi: RscPluginApi | undefined;
 
   return {
-    name: "rsc-router:expose-action-id",
+    name: "@ivogt/rsc-router:expose-action-id",
     // Run after all other plugins (including RSC plugin's transforms)
     enforce: "post",
 
@@ -251,7 +251,7 @@ export function exposeActionId(): Plugin {
       if (!rscPluginApi) {
         throw new Error(
           "[rsc-router] Could not find @vitejs/plugin-rsc. " +
-            "rsc-router requires the Vite RSC plugin.\n" +
+            "@ivogt/rsc-router requires the Vite RSC plugin.\n" +
             "The RSC plugin should be included automatically. If you disabled it with\n" +
             "rscRouter({ rsc: false }), add rsc() before rscRouter() in your config."
         );

package/src/vite/expose-handle-id.ts

@@ -25,9 +25,9 @@ function hashHandleId(filePath: string, exportName: string): string {
  * Check if file imports createHandle from rsc-router
  */
 function hasCreateHandleImport(code: string): boolean {
-  // Match: import { createHandle } from "rsc-router" or "rsc-router/..."
+  // Match: import { createHandle } from "@ivogt/rsc-router" or "@ivogt/rsc-router/..."
   const pattern =
-    /import\s*\{[^}]*\bcreateHandle\b[^}]*\}\s*from\s*["']rsc-router(?:\/[^"']+)?["']/;
+    /import\s*\{[^}]*\bcreateHandle\b[^}]*\}\s*from\s*["']@ivogt\/rsc-router(?:\/[^"']+)?["']/;
   return pattern.test(code);
 }
 
@@ -167,7 +167,7 @@ function transformHandleExports(
  * The name is auto-generated from file path + export name.
  *
  * Requirements:
- * - Must use direct import: import { createHandle } from "rsc-router"
+ * - Must use direct import: import { createHandle } from "@ivogt/rsc-router"
  * - Must use named export: export const MyHandle = createHandle(...)
  */
 export function exposeHandleId(): Plugin {
@@ -175,7 +175,7 @@ export function exposeHandleId(): Plugin {
   let isBuild = false;
 
   return {
-    name: "rsc-router:expose-handle-id",
+    name: "@ivogt/rsc-router:expose-handle-id",
     enforce: "post",
 
     configResolved(resolvedConfig) {

package/src/vite/expose-loader-id.ts

@@ -25,10 +25,10 @@ function hashLoaderId(filePath: string, exportName: string): string {
  * Check if file imports createLoader from rsc-router
  */
 function hasCreateLoaderImport(code: string): boolean {
-  // Match: import { createLoader } from "rsc-router" or "rsc-router/server"
+  // Match: import { createLoader } from "@ivogt/rsc-router" or "@ivogt/rsc-router/server"
   // Must be exact - no aliasing support
   const pattern =
-    /import\s*\{[^}]*\bcreateLoader\b[^}]*\}\s*from\s*["']rsc-router(?:\/server)?["']/;
+    /import\s*\{[^}]*\bcreateLoader\b[^}]*\}\s*from\s*["']@ivogt\/rsc-router(?:\/server)?["']/;
   return pattern.test(code);
 }
 
@@ -176,7 +176,7 @@ let manifestGenerated = false;
  * The manifest can be imported by the RSC handler to get all loaders.
  *
  * Requirements:
- * - Must use direct import: import { createLoader } from "rsc-router"
+ * - Must use direct import: import { createLoader } from "@ivogt/rsc-router"
  * - No aliasing support (import { createLoader as cl } won't work)
  * - Must use named export: export const MyLoader = createLoader(...)
  */
@@ -194,7 +194,7 @@ export function exposeLoaderId(): Plugin {
   const pendingLoaderScans = new Map<string, Promise<void>>();
 
   return {
-    name: "rsc-router:expose-loader-id",
+    name: "@ivogt/rsc-router:expose-loader-id",
     enforce: "post",
 
     configResolved(resolvedConfig) {
@@ -276,7 +276,7 @@ export function exposeLoaderId(): Plugin {
         if (!isBuild) {
           // Dev mode: empty map - use fallback path parsing in loader registry
           // IDs in dev mode are "filePath#exportName" format for easier debugging
-          return `import { setLoaderImports } from "rsc-router/server";
+          return `import { setLoaderImports } from "@ivogt/rsc-router/server";
 
 // Dev mode: empty map, loaders are resolved dynamically via path parsing
 setLoaderImports({});
@@ -297,14 +297,14 @@ setLoaderImports({});
 
         // If no loaders discovered, set empty map
         if (lazyImports.length === 0) {
-          return `import { setLoaderImports } from "rsc-router/server";
+          return `import { setLoaderImports } from "@ivogt/rsc-router/server";
 
 // No fetchable loaders discovered during build
 setLoaderImports({});
 `;
         }
 
-        const code = `import { setLoaderImports } from "rsc-router/server";
+        const code = `import { setLoaderImports } from "@ivogt/rsc-router/server";
 
 // Lazy import map - loaders are loaded on-demand when first requested
 setLoaderImports({

package/src/vite/expose-location-state-id.ts

@@ -25,9 +25,9 @@ function hashLocationStateKey(filePath: string, exportName: string): string {
  * Check if file imports createLocationState from rsc-router
  */
 function hasCreateLocationStateImport(code: string): boolean {
-  // Match: import { createLocationState } from "rsc-router" or "rsc-router/client"
+  // Match: import { createLocationState } from "@ivogt/rsc-router" or "@ivogt/rsc-router/client"
   const pattern =
-    /import\s*\{[^}]*\bcreateLocationState\b[^}]*\}\s*from\s*["']rsc-router(?:\/[^"']+)?["']/;
+    /import\s*\{[^}]*\bcreateLocationState\b[^}]*\}\s*from\s*["']@ivogt\/rsc-router(?:\/[^"']+)?["']/;
   return pattern.test(code);
 }
 
@@ -135,7 +135,7 @@ function transformLocationStateExports(
  * The key is auto-generated from file path + export name.
  *
  * Requirements:
- * - Must use direct import: import { createLocationState } from "rsc-router"
+ * - Must use direct import: import { createLocationState } from "@ivogt/rsc-router"
  * - Must use named export: export const MyState = createLocationState(...)
  */
 export function exposeLocationStateId(): Plugin {
@@ -143,7 +143,7 @@ export function exposeLocationStateId(): Plugin {
   let isBuild = false;
 
   return {
-    name: "rsc-router:expose-location-state-id",
+    name: "@ivogt/rsc-router:expose-location-state-id",
     enforce: "post",
 
     configResolved(resolvedConfig) {