akanjs 3.0.0-beta.9 → 3.0.1

package/server/robots.ts

@@ -2,33 +2,11 @@ import { getApiPrefix } from "akanjs/base";
 
 const DEFAULT_DISALLOW_PATHS = ["/_akan", "/admin", "/manager", "/private"] as const;
 
-const DEFAULT_AI_CRAWLERS = [
-  "GPTBot",
-  "ChatGPT-User",
-  "CCBot",
-  "ClaudeBot",
-  "Claude-Web",
-  "anthropic-ai",
-  "Google-Extended",
-  "PerplexityBot",
-  "Perplexity-User",
-  "Bytespider",
-  "Amazonbot",
-  "Applebot-Extended",
-  "Meta-ExternalAgent",
-  "FacebookBot",
-  "Diffbot",
-  "Omgilibot",
-  "Omgili",
-] as const;
-
 export function createDefaultRobotsTxt(): string {
   const lines = [
     "User-agent: *",
     "Allow: /",
     ...[getApiPrefix(), ...DEFAULT_DISALLOW_PATHS].map((path) => `Disallow: ${path}`),
-    "",
-    ...DEFAULT_AI_CRAWLERS.flatMap((crawler) => [`User-agent: ${crawler}`, "Disallow: /", ""]),
   ];
-  return `${lines.join("\n").trimEnd()}\n`;
+  return `${lines.join("\n")}\n`;
 }

package/server/routeElementComposer.tsx

@@ -10,9 +10,13 @@ import type {
 } from "akanjs/client";
 import { Children, cloneElement, isValidElement, type ReactElement, type ReactNode, Suspense } from "react";
 import { getExplicitPageConfigKeys, resolvePageState } from "../client/frameConfig";
-import { resolveHeadResult } from "./metadata";
-import { type AkanRouteSegmentState, createAkanRouteSegments, createAkanSegmentOutletKey } from "./routeState";
-import { isAkanRscPartialCommitEnabled } from "./rscPartialCommit";
+import { resolveHeadResult } from "./head";
+import {
+  type AkanRouteSegmentState,
+  createAkanRouteSegments,
+  createAkanSegmentOutletKey,
+  isAkanRscPartialCommitEnabled,
+} from "./routeState";
 import { AkanSegmentOutletReference } from "./rscSegmentOutletReference";
 
 export class RouteElementComposer {
@@ -26,14 +30,7 @@ export class RouteElementComposer {
     const pageConfigChain = await RouteElementComposer.#resolvePageConfigChain(pathRoute);
     return {
       ...pathRoute,
-      pageState: resolvePageState({
-        configChain: pageConfigChain,
-        path: pathRoute.path,
-        basePath: basePath ?? undefined,
-        platform: "web",
-        deviceSafeArea: { top: 0, bottom: 0 },
-        cssSafeArea: { top: 0, bottom: 0 },
-      }),
+      pageState: RouteElementComposer.#webPageState(pageConfigChain, pathRoute.path, basePath),
       pageConfigChain,
       explicitPageConfigKeys: getExplicitPageConfigKeys(pageConfigChain),
     };
@@ -47,9 +44,13 @@ export class RouteElementComposer {
     basePath?: string | null;
   }) {
     const pageConfigChain = await RouteElementComposer.#resolveLayoutPageConfigChain(route);
+    return RouteElementComposer.#webPageState(pageConfigChain, route.path, basePath);
+  }
+
+  static #webPageState(configChain: PageConfig[], path: string, basePath?: string | null) {
     return resolvePageState({
-      configChain: pageConfigChain,
-      path: route.path,
+      configChain,
+      path,
       basePath: basePath ?? undefined,
       platform: "web",
       deviceSafeArea: { top: 0, bottom: 0 },
@@ -118,7 +119,7 @@ export class RouteElementComposer {
     searchParams: Record<string, string | string[]>;
   }): Promise<Head | null | undefined> {
     return (
-      await RouteElementComposer.resolveHeadWithMetadata({
+      await RouteElementComposer.resolveHeadWithSnapshot({
         pathRoute,
         params,
         searchParams,
@@ -126,7 +127,7 @@ export class RouteElementComposer {
     ).node;
   }
 
-  static async resolveHeadWithMetadata({
+  static async resolveHeadWithSnapshot({
     pathRoute,
     params,
     searchParams,
@@ -164,15 +165,7 @@ export class RouteElementComposer {
       if (!fallback) continue;
       const renders = [
         ...layoutStack.slice(0, index + 1),
-        RouteElementComposer.#makeFallbackRouteRender({
-          kind,
-          fallback,
-          params,
-          searchParams,
-          pathname,
-          error,
-          digest,
-        }),
+        RouteElementComposer.#makeFallbackRouteRender({ kind, fallback, pathname, error, digest }),
       ];
       return RouteElementComposer.composeRenders({ renders, params, searchParams });
     }
@@ -207,12 +200,10 @@ export class RouteElementComposer {
         </Suspense>
       );
       const segment = segments?.[i];
-      if (segment?.kind === "page") {
-        const routeSegments = segments;
-        if (!routeSegments) continue;
+      if (segments && segment?.kind === "page") {
         const outletKey =
           createAkanSegmentOutletKey(
-            routeSegments.slice(0, i + 1).map((item) => item.key),
+            segments.slice(0, i + 1).map((item) => item.key),
             i,
           ) ?? segment.key;
         element = <AkanSegmentOutletReference segmentKey={outletKey}>{element}</AkanSegmentOutletReference>;
@@ -221,7 +212,7 @@ export class RouteElementComposer {
     return element;
   }
 
-  static async renderAsync({
+  static AsyncRender = async ({
     routeRender,
     children,
     params,
@@ -231,17 +222,7 @@ export class RouteElementComposer {
     children: ReactNode;
     params: Record<string, string>;
     searchParams: Record<string, string | string[]>;
-  }) {
-    const node = await routeRender.render({ children, params, searchParams } as never);
-    return RouteElementComposer.#normalizeReactNode(node);
-  }
-
-  static AsyncRender = (props: {
-    routeRender: RouteRender;
-    children: ReactNode;
-    params: Record<string, string>;
-    searchParams: Record<string, string | string[]>;
-  }) => RouteElementComposer.renderAsync(props);
+  }) => RouteElementComposer.#normalizeReactNode(await routeRender.render({ children, params, searchParams } as never));
 
   static #makeFallbackRouteRender({
     kind,
@@ -252,18 +233,13 @@ export class RouteElementComposer {
   }: {
     kind: "not-found" | "error";
     fallback: LayoutNotFoundRender | LayoutErrorRender;
-    params: Record<string, string>;
-    searchParams: Record<string, string | string[]>;
     pathname: string;
     error?: unknown;
     digest?: string;
   }): RouteRender {
     return {
       render: (props: { params: Record<string, string>; searchParams: Record<string, string | string[]> }) => {
-        const { params, searchParams } = props as {
-          params: Record<string, string>;
-          searchParams: Record<string, string | string[]>;
-        };
+        const { params, searchParams } = props;
         return kind === "not-found"
           ? (fallback as LayoutNotFoundRender)({ params, searchParams, pathname })
           : (fallback as LayoutErrorRender)({ params, searchParams, pathname, error, digest });
@@ -278,17 +254,12 @@ export class RouteElementComposer {
     const props = node.props as { children?: ReactNode };
     if (!("children" in props)) return node;
 
-    const normalizedChildren = RouteElementComposer.#normalizeReactChildren(props.children);
+    const normalizedChildren = RouteElementComposer.#normalizeReactNode(props.children);
     if (normalizedChildren === props.children) return node;
 
     return cloneElement(node as ReactElement<{ children?: ReactNode }>, undefined, normalizedChildren);
   }
 
-  static #normalizeReactChildren(children: ReactNode): ReactNode {
-    if (Array.isArray(children)) return Children.toArray(children).map(RouteElementComposer.#normalizeReactNode);
-    return RouteElementComposer.#normalizeReactNode(children);
-  }
-
   static #getRenderStack(pathRoute: PathRoute): RouteRender[] {
     return [...pathRoute.renderRootLayouts, ...pathRoute.renderLayouts, pathRoute.renderPage];
   }

package/server/routeState.ts

@@ -73,7 +73,8 @@ function encodeBase64Url(value: string): string {
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 
-function decodeBase64Url(value: string): string | null {
+function decodeBase64UrlJson(value: string | null | undefined): unknown {
+  if (!value) return undefined;
   try {
     const padded = value
       .replace(/-/g, "+")
@@ -82,9 +83,9 @@ function decodeBase64Url(value: string): string | null {
     const binary = atob(padded);
     const bytes = new Uint8Array(binary.length);
     for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
-    return new TextDecoder().decode(bytes);
+    return JSON.parse(new TextDecoder().decode(bytes)) as unknown;
   } catch {
-    return null;
+    return undefined;
   }
 }
 
@@ -150,30 +151,13 @@ export function decodeAkanHeadSnapshot(value: string | null | undefined): AkanHe
   if (new TextEncoder().encode(value).byteLength > AKAN_RSC_HEAD_SNAPSHOT_MAX_HEADER_BYTES) {
     return { status: "too-large" };
   }
-  const json = decodeBase64Url(value);
-  if (!json) return { status: "invalid" };
-  try {
-    const parsed = JSON.parse(json) as unknown;
-    return isAkanHeadSnapshotV1(parsed) ? { status: "ok", snapshot: parsed } : { status: "invalid" };
-  } catch {
-    return { status: "invalid" };
-  }
-}
-
-export function readAkanHeadSnapshotResponseHeader(headers: Headers): AkanHeadSnapshotDecodeResult {
-  return decodeAkanHeadSnapshot(headers.get(AKAN_RSC_PATCH_HEAD_SNAPSHOT_HEADER));
+  const parsed = decodeBase64UrlJson(value);
+  return isAkanHeadSnapshotV1(parsed) ? { status: "ok", snapshot: parsed } : { status: "invalid" };
 }
 
 export function decodeAkanRouterState(value: string | null | undefined): AkanRouterStateV1 | null {
-  if (!value) return null;
-  const json = decodeBase64Url(value);
-  if (!json) return null;
-  try {
-    const parsed = JSON.parse(json) as unknown;
-    return isAkanRouterStateV1(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
+  const parsed = decodeBase64UrlJson(value);
+  return isAkanRouterStateV1(parsed) ? parsed : null;
 }
 
 export function appendAkanRouterStateRequestHeaders(
@@ -195,15 +179,8 @@ export function encodeAkanRscPatchSegmentPath(segmentPath: string[]): string {
 }
 
 export function decodeAkanRscPatchSegmentPath(value: string | null | undefined): string[] | null {
-  if (!value) return null;
-  const json = decodeBase64Url(value);
-  if (!json) return null;
-  try {
-    const parsed = JSON.parse(json) as unknown;
-    return Array.isArray(parsed) && parsed.every((segment) => typeof segment === "string") ? parsed : null;
-  } catch {
-    return null;
-  }
+  const parsed = decodeBase64UrlJson(value);
+  return Array.isArray(parsed) && parsed.every((segment) => typeof segment === "string") ? parsed : null;
 }
 
 export function readAkanRscPatchMetadataResponseHeaders(headers: Headers): AkanRscPatchMetadata | null {
@@ -214,7 +191,7 @@ export function readAkanRscPatchMetadataResponseHeaders(headers: Headers): AkanR
   const segmentPath = decodeAkanRscPatchSegmentPath(headers.get(AKAN_RSC_PATCH_SEGMENT_PATH_HEADER));
   if (!Number.isInteger(patchStartIndex) || patchStartIndex < 0 || !patchStartSegmentKey || !segmentPath) return null;
   if (segmentPath[patchStartIndex] !== patchStartSegmentKey) return null;
-  const headSnapshotResult = readAkanHeadSnapshotResponseHeader(headers);
+  const headSnapshotResult = decodeAkanHeadSnapshot(headers.get(AKAN_RSC_PATCH_HEAD_SNAPSHOT_HEADER));
   return {
     patchStartIndex,
     patchStartSegmentKey,
@@ -377,3 +354,7 @@ export function countCommonRouteSegments(
   }
   return length;
 }
+
+export function isAkanRscPartialCommitEnabled(): boolean {
+  return process.env.AKAN_PUBLIC_RSC_PARTIAL_COMMIT === "1";
+}

package/server/routeTreeBuilder.ts

@@ -15,8 +15,9 @@ import {
   getRouteExports,
   Logger,
   matchRoutePattern,
-  parseBasePaths,
   parseRouteModuleKey,
+  type RouteLayer,
+  RouteLayering,
   routeSegmentToTreePath,
 } from "akanjs/common";
 import { createElement } from "react";
@@ -26,7 +27,7 @@ import {
   type RouteModuleSource,
   resolveRouteModule,
 } from "../client/route/resolveRouteModule";
-import { resolveHeadExport, resolveMetadataHead } from "./metadata";
+import { matchRoutePrefix } from "../common/routeConvention";
 
 type RouteModuleKindWithOverrides = "page" | "layout" | "overrides";
 
@@ -54,15 +55,12 @@ export class RouteTreeBuilder {
   };
 
   readonly #context: PagesContext;
-  readonly #baseLayoutPaths: string[];
   readonly #routeMap = new Map<string, Route>();
   readonly #pagePatterns: { key: string; pattern: string }[] = [];
   readonly #fallbackRoutes: LayoutFallbackRoute[] = [];
 
   constructor(context: PagesContext) {
     this.#context = context;
-    const basePaths = process.env.AKAN_PUBLIC_BASE_PATHS ? parseBasePaths(process.env.AKAN_PUBLIC_BASE_PATHS) : null;
-    this.#baseLayoutPaths = ["/", "/:lang", ...(basePaths?.map((bp) => `/:lang/${bp}`) ?? [])];
     this.#routeMap.set("/", { path: "/", children: new Map() });
   }
 
@@ -116,7 +114,7 @@ export class RouteTreeBuilder {
     const candidates = fallbackRoutes
       .map((fallbackRoute) => ({
         fallbackRoute,
-        params: RouteTreeBuilder.#matchRoutePrefix(fallbackRoute.path, pathname),
+        params: matchRoutePrefix(fallbackRoute.path, pathname),
       }))
       .filter((entry): entry is { fallbackRoute: LayoutFallbackRoute; params: Record<string, string> } =>
         Boolean(entry.params),
@@ -153,7 +151,6 @@ export class RouteTreeBuilder {
       if (!children) throw new Error("No children");
       return children;
     }, this.#routeMap);
-    if (!targetRouteMap) return;
 
     const targetPath = pathSegments[pathSegments.length - 1];
     if (!targetPath) return;
@@ -170,70 +167,42 @@ export class RouteTreeBuilder {
     targetRouteMap.set(targetPath, {
       ...(targetRouteMap.get(targetPath) ?? { path: targetPath, children: new Map<string, Route>() }),
       ...(parsed.kind === "layout"
-        ? { renderLayout: routeRender }
+        ? { renderLayout: routeRender, isRootLayout: parsed.isInternalRootLayout }
         : {
             renderPage: routeRender,
             pageIncludesOwnLayout: parsed.leaf === "_index",
-            isSpecialRoute: parsed.isSpecialRoute,
           }),
     } as Route);
   }
 
-  #getPathRoutes(
-    route: Route,
-    parentRootLayouts: RouteRender[] = [],
-    parentLayouts: RouteRender[] = [],
-    parentPaths: string[] = [],
-    parentHead?: ResolveHead,
-    parentOverrides: RouteRender[] = [],
-  ): PathRoute[] {
-    const parentPath = parentPaths.filter((p) => p !== "/").join("");
-    const currentPathSegment = /^\/\(.*\)$/.test(route.path) ? "" : route.path;
-    const isRoot = this.#baseLayoutPaths.includes(parentPath + currentPathSegment) && parentRootLayouts.length < 2;
-    const routePath = parentPath + currentPathSegment;
-    const pathSegments = [...parentPaths, ...(currentPathSegment ? [currentPathSegment] : [])];
-    const currentRootLayout = isRoot && route.renderLayout ? route.renderLayout : null;
-    const currentLayout = !isRoot && route.renderLayout ? route.renderLayout : null;
-
-    const currentOverrideRenders = route.renderOverrides ? [route.renderOverrides] : [];
-    const overrideRenders = [...parentOverrides, ...currentOverrideRenders];
-    const rootLayoutStack = [...parentRootLayouts, ...(currentRootLayout ? [currentRootLayout] : [])];
-    const renderRootLayouts = [...overrideRenders, ...rootLayoutStack];
-    const renderLayouts = [...parentLayouts, ...(currentLayout ? [currentLayout] : [])];
+  #getPathRoutes(route: Route, parent: RouteLayer<RouteRender> | null = null, parentHead?: ResolveHead): PathRoute[] {
+    const layer = RouteLayering.of(route, parent);
     if (route.renderLayout) {
       this.#fallbackRoutes.push({
-        path: routePath,
-        pathSegments,
-        renderRootLayouts,
-        renderLayouts,
+        path: layer.path,
+        pathSegments: layer.pathSegments,
+        renderRootLayouts: layer.renderRootLayouts,
+        renderLayouts: layer.renderLayouts,
       });
     }
     const routeHead = RouteTreeBuilder.#composeHeadResolvers(route.renderLayout?.resolveHead, parentHead);
-    const pageRenderRootLayouts =
-      route.pageIncludesOwnLayout === false && currentRootLayout
-        ? [...overrideRenders, ...parentRootLayouts]
-        : renderRootLayouts;
-    const pageRenderLayouts = route.pageIncludesOwnLayout === false && currentLayout ? parentLayouts : renderLayouts;
     const pageHead = route.pageIncludesOwnLayout === false ? parentHead : routeHead;
     return [
       ...(route.renderPage
         ? [
             {
-              path: routePath,
-              pathSegments,
+              path: layer.path,
+              pathSegments: layer.pathSegments,
               renderPage: route.renderPage,
-              renderRootLayouts: pageRenderRootLayouts,
-              renderLayouts: pageRenderLayouts,
+              renderRootLayouts: layer.pageRenderRootLayouts,
+              renderLayouts: layer.pageRenderLayouts,
               resolveHead: RouteTreeBuilder.#composeHeadResolvers(route.renderPage.resolveHead, pageHead),
-              isSpecialRoute: route.isSpecialRoute,
               pageState: route.pageState ?? defaultPageState,
             },
           ]
         : []),
       ...(route.children.size
-        ? [...route.children.values()].flatMap((child) =>
-            this.#getPathRoutes(child, rootLayoutStack, renderLayouts, pathSegments, routeHead, overrideRenders),
-          )
+        ? [...route.children.values()].flatMap((child) => this.#getPathRoutes(child, layer, routeHead))
         : []),
     ];
   }
@@ -261,10 +230,6 @@ export class RouteTreeBuilder {
     };
   }
 
-  /**
-   * A `page()` / `layout()` chain is unfolded into the named-export shape the rest of this file reads. The legacy
-   * shape still loads, and is named once per module so an app finds every file the migration guide covers.
-   */
   static #resolveModule(key: string, kind: RouteModuleKindWithOverrides, mod: RouteModuleSource): ResolvedRouteModule {
     if (kind === "overrides") return { module: mod as RouteModule };
     const parsed = parseRouteModuleKey(key);
@@ -280,7 +245,6 @@ export class RouteTreeBuilder {
 
   static #validateRouteModuleExports(key: string, kind: RouteModuleKindWithOverrides, mod: RouteModule) {
     if (kind === "overrides") {
-      
       if (!mod.default) throw new Error(`[route-convention] ${key} generated override wrapper has no default export`);
       return;
     }
@@ -295,22 +259,25 @@ export class RouteTreeBuilder {
     if ("head" in mod && "generateHead" in mod) {
       throw new Error(`[route-convention] head and generateHead cannot both be exported in ${key}`);
     }
-    if (
-      !parsed.isInternalRootLayout &&
-      ("head" in mod || "generateHead" in mod) &&
-      ("metadata" in mod || "generateMetadata" in mod)
-    ) {
-      throw new Error(
-        `[route-convention] head/generateHead and metadata/generateMetadata cannot both be exported in ${key}`,
-      );
-    }
-    if ("metadata" in mod && "generateMetadata" in mod) {
-      throw new Error(`[route-convention] metadata and generateMetadata cannot both be exported in ${key}`);
-    }
   }
 
   static #makeRouteRender(key: string, kind: "page" | "layout", loader: () => Promise<RouteModuleSource>): RouteRender {
     const loadModule = RouteTreeBuilder.#makeLazyModule(key, kind, loader);
+    const syncFallbacks = (mod: LayoutModule) => {
+      routeRender.NotFound = mod.NotFound;
+      routeRender.Error = mod.Error;
+      return mod;
+    };
+    const loadSynced = async () => {
+      const { module: mod } = await loadModule();
+      routeRender.Loading = mod.Loading as never;
+      if (kind === "layout") syncFallbacks(mod as LayoutModule);
+      return mod;
+    };
+    const pageConfigOf = async () => {
+      const { module: mod } = await loadModule();
+      return "pageConfig" in mod ? mod.pageConfig : undefined;
+    };
     const routeRender: RouteRender = {
       isAsync: true,
       resolveLoading: async () => {
@@ -318,60 +285,26 @@ export class RouteTreeBuilder {
         routeRender.Loading = mod.Loading as never;
       },
       render: async (props: LayoutProps | PageProps) => {
-        const { module: mod } = await loadModule();
-        routeRender.Loading = mod.Loading as never;
-        if (kind === "layout") {
-          const layoutMod = mod as LayoutModule;
-          routeRender.NotFound = layoutMod.NotFound;
-          routeRender.Error = layoutMod.Error;
-        }
+        const mod = await loadSynced();
         if (!mod.default) throw new Error(`[route-convention] ${key} has no default export`);
         return mod.default(props as never);
       },
       resolveHead: async (props: PageProps) => {
-        const { module: mod } = await loadModule();
-        routeRender.Loading = mod.Loading as never;
-        if (kind === "layout") {
-          const layoutMod = mod as LayoutModule;
-          routeRender.NotFound = layoutMod.NotFound;
-          routeRender.Error = layoutMod.Error;
-        }
-        if (mod.generateHead) {
-          const head = await mod.generateHead(props);
-          if (head !== null && head !== undefined) return resolveHeadExport(head, { includeHeadSnapshot: false });
-        }
-        if (mod.generateMetadata) {
-          const metadata = await mod.generateMetadata(props);
-          return metadata === null || metadata === undefined ? metadata : resolveMetadataHead(metadata);
-        }
-        if (mod.head !== undefined)
-          return mod.head === null ? null : resolveHeadExport(mod.head, { includeHeadSnapshot: false });
-        return mod.metadata === undefined ? undefined : resolveMetadataHead(mod.metadata);
+        const mod = await loadSynced();
+        return mod.generateHead ? await mod.generateHead(props) : mod.head;
       },
     };
     if (kind === "page") {
-      routeRender.getPageConfig = async () => {
-        const { module: mod } = await loadModule();
-        return "pageConfig" in mod ? mod.pageConfig : undefined;
-      };
+      routeRender.getPageConfig = pageConfigOf;
       routeRender.getRouteDefinition = async () => (await loadModule()).definition;
     } else {
-      routeRender.getLayoutPageConfig = async () => {
+      routeRender.getLayoutPageConfig = pageConfigOf;
+      routeRender.getLayoutTheme = async () => {
         const { module: mod } = await loadModule();
-        return "pageConfig" in mod ? mod.pageConfig : undefined;
-      };
-      routeRender.resolveNotFound = async () => {
-        const mod = (await loadModule()).module as LayoutModule;
-        routeRender.NotFound = mod.NotFound;
-        routeRender.Error = mod.Error;
-        return mod.NotFound;
-      };
-      routeRender.resolveError = async () => {
-        const mod = (await loadModule()).module as LayoutModule;
-        routeRender.NotFound = mod.NotFound;
-        routeRender.Error = mod.Error;
-        return mod.Error;
+        return "theme" in mod ? (mod.theme as string | undefined) : undefined;
       };
+      routeRender.resolveNotFound = async () => syncFallbacks((await loadModule()).module as LayoutModule).NotFound;
+      routeRender.resolveError = async () => syncFallbacks((await loadModule()).module as LayoutModule).Error;
     }
     return routeRender;
   }
@@ -399,22 +332,4 @@ export class RouteTreeBuilder {
       return undefined;
     };
   }
-
-  static #matchRoutePrefix(pattern: string, pathname: string): Record<string, string> | null {
-    const patternParts = pattern.split("/").filter(Boolean);
-    const pathParts = pathname.split("/").filter(Boolean);
-    if (patternParts.length > pathParts.length) return null;
-    const params: Record<string, string> = {};
-    for (let index = 0; index < patternParts.length; index++) {
-      const patternPart = patternParts[index];
-      const pathPart = pathParts[index];
-      if (!patternPart || !pathPart) return null;
-      if (patternPart.startsWith(":")) {
-        params[patternPart.slice(1)] = decodeURIComponent(pathPart);
-        continue;
-      }
-      if (patternPart !== pathPart) return null;
-    }
-    return params;
-  }
 }