vinext 0.0.53 → 0.0.54

package/dist/plugins/remove-console.d.ts

@@ -0,0 +1,16 @@
+//#region src/plugins/remove-console.d.ts
+type RemoveConsoleConfig = boolean | {
+  exclude: string[];
+};
+/**
+ * Walk the AST body looking for expression statements whose expression is a
+ * CallExpression with a callee of `console.<identifier>`. When found, check
+ * that the name is not in the excluded set and that `console` is not shadowed
+ * at this scope. If all conditions pass, replace the entire statement with `;`.
+ *
+ * Returns `null` if no console calls are removed.
+ */
+declare function removeConsoleCalls(code: string, config: RemoveConsoleConfig): string | null;
+//#endregion
+export { removeConsoleCalls };
+//# sourceMappingURL=remove-console.d.ts.map

package/dist/plugins/remove-console.js

@@ -0,0 +1,176 @@
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/remove-console.ts
+/**
+* Strip `console.*` calls from client bundle code.
+*
+* Mirrors Next.js's SWC `remove_console` transform:
+*   - Strips all `console.<method>()` calls regardless of context (top-level,
+*     JSX expressions, function arguments, return values, ternary branches)
+*   - Replaces removed calls with `void 0` to keep the AST valid in every
+*     position a CallExpression can appear
+*   - Respects `exclude: ["error"]` to preserve certain methods (case-insensitive)
+*   - Preserves calls when `console` is shadowed (local variable, function
+*     parameter, or destructured binding)
+*   - Preserves computed property access `console[prop]()`
+*
+* Uses Vite's `parseAst` (OXC/acorn) for parsing and `MagicString` for
+* surgical source replacement. Returns `null` when no changes are made.
+*/
+const SCOPE_ENTERING_TYPES = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* Walk the AST body looking for expression statements whose expression is a
+* CallExpression with a callee of `console.<identifier>`. When found, check
+* that the name is not in the excluded set and that `console` is not shadowed
+* at this scope. If all conditions pass, replace the entire statement with `;`.
+*
+* Returns `null` if no console calls are removed.
+*/
+function removeConsoleCalls(code, config) {
+	if (config === false) return null;
+	const excluded = typeof config === "object" ? new Set(config.exclude.map((s) => s.toLowerCase())) : /* @__PURE__ */ new Set();
+	if (!code.match(/\bconsole\b/)) return null;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		return null;
+	}
+	const scopeStack = [{ shadowed: false }];
+	function currentScope() {
+		return scopeStack[scopeStack.length - 1];
+	}
+	function pushScope() {
+		scopeStack.push({ shadowed: currentScope().shadowed });
+	}
+	function popScope() {
+		scopeStack.pop();
+	}
+	const s = new MagicString(code);
+	let changed = false;
+	/**
+	* Check if a node introduces a binding named "console" and mark scope.
+	* Recurses into all binding-pattern node types (destructuring shapes,
+	* defaults, rest elements).
+	*/
+	function checkBinding(node) {
+		if (!node) return;
+		switch (node.type) {
+			case "Identifier":
+				if (node.name === "console") currentScope().shadowed = true;
+				break;
+			case "ObjectPattern":
+				for (const prop of node.properties) checkBinding(prop);
+				break;
+			case "Property": {
+				const propertyNode = node;
+				if (propertyNode.value) checkBinding(propertyNode.value);
+				break;
+			}
+			case "ArrayPattern": {
+				const elements = node.elements;
+				if (elements) for (const el of elements) checkBinding(el);
+				break;
+			}
+			case "AssignmentPattern": {
+				const left = node.left;
+				checkBinding(left);
+				break;
+			}
+			case "RestElement": {
+				const argument = node.argument;
+				checkBinding(argument);
+				break;
+			}
+			default: break;
+		}
+	}
+	/**
+	* Check if an identifier refers to the *global* console.
+	* It's global only when:
+	*   1. Its name is "console"
+	*   2. No local binding of that name shadows it at this point
+	*/
+	function isGlobalConsole(node) {
+		return node.type === "Identifier" && node.name === "console" && !currentScope().shadowed;
+	}
+	/**
+	* Determine if a call expression is a `console.<method>()` that should be
+	* removed. The callee must be a MemberExpression with:
+	*   - object: Identifier "console" (global, not shadowed)
+	*   - property: Identifier (NOT computed — computed access like
+	*     `console[prop]()` is preserved per Next.js behavior)
+	* The method name must NOT be in the excluded set.
+	*/
+	function shouldRemove(node) {
+		if (node.type !== "CallExpression") return false;
+		const callee = node.callee;
+		if (callee.type !== "MemberExpression") return false;
+		if (callee.computed) return false;
+		if (!isGlobalConsole(callee.object)) return false;
+		const prop = callee.property;
+		if (prop.type !== "Identifier") return false;
+		const method = prop.name.toLowerCase();
+		if (excluded.has(method)) return false;
+		return true;
+	}
+	/**
+	* Recursively walk a node tree, managing scope for shadow detection.
+	* When a CallExpression matches `console.<method>()`, replace it with
+	* `void 0`. If the call is the sole expression of an ExpressionStatement,
+	* replace the entire statement with `;` for cleaner output.
+	*/
+	function walk(node, parent) {
+		if (!node) return;
+		if (node.type === "CallExpression" && shouldRemove(node)) {
+			if (parent?.type === "ExpressionStatement") s.overwrite(parent.start, parent.end, ";");
+			else s.overwrite(node.start, node.end, "void 0");
+			changed = true;
+			return;
+		}
+		if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+			const id = node.id;
+			checkBinding(id);
+		}
+		const isScopeEntering = SCOPE_ENTERING_TYPES.has(node.type);
+		if (isScopeEntering) {
+			pushScope();
+			if (node.type === "FunctionExpression") {
+				const id = node.id;
+				checkBinding(id);
+			}
+			const params = node.params;
+			if (params) for (const param of params) checkBinding(param);
+		}
+		const isCatchScope = node.type === "CatchClause";
+		if (isCatchScope) {
+			pushScope();
+			const param = node.param;
+			if (param) checkBinding(param);
+		}
+		const isBlockScope = node.type === "BlockStatement" || node.type === "Program" || node.type === "SwitchCase";
+		if (isBlockScope && !isScopeEntering) pushScope();
+		if (node.type === "VariableDeclaration") for (const decl of node.declarations ?? []) checkBinding(decl.id);
+		for (const key of Object.keys(node)) {
+			if (key === "parent" || key === "start" || key === "end") continue;
+			const child = node[key];
+			if (child && typeof child === "object") {
+				if (Array.isArray(child)) {
+					for (const item of child) if (item && typeof item === "object" && "type" in item) walk(item, node);
+				} else if ("type" in child) walk(child, node);
+			}
+		}
+		if (isScopeEntering || isBlockScope || isCatchScope) popScope();
+	}
+	for (const node of ast.body) walk(node);
+	if (!changed) return null;
+	return s.toString();
+}
+//#endregion
+export { removeConsoleCalls };
+
+//# sourceMappingURL=remove-console.js.map

package/dist/plugins/remove-console.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-console.js","names":[],"sources":["../../src/plugins/remove-console.ts"],"sourcesContent":["/**\n * Strip `console.*` calls from client bundle code.\n *\n * Mirrors Next.js's SWC `remove_console` transform:\n *   - Strips all `console.<method>()` calls regardless of context (top-level,\n *     JSX expressions, function arguments, return values, ternary branches)\n *   - Replaces removed calls with `void 0` to keep the AST valid in every\n *     position a CallExpression can appear\n *   - Respects `exclude: [\"error\"]` to preserve certain methods (case-insensitive)\n *   - Preserves calls when `console` is shadowed (local variable, function\n *     parameter, or destructured binding)\n *   - Preserves computed property access `console[prop]()`\n *\n * Uses Vite's `parseAst` (OXC/acorn) for parsing and `MagicString` for\n * surgical source replacement. Returns `null` when no changes are made.\n */\nimport { parseAst } from \"vite\";\nimport MagicString from \"magic-string\";\n\ntype ASTNode = ReturnType<typeof parseAst>[\"body\"][number][\"parent\"];\ntype BindingNode = Extract<ASTNode, { type: string }>;\n\ntype RemoveConsoleConfig = boolean | { exclude: string[] };\n\n// Node types that introduce a new function-style scope. Hoisted to a module-\n// level Set so the membership check in walk() is O(1) and doesn't allocate\n// per recursive call.\nconst SCOPE_ENTERING_TYPES = new Set([\n  \"FunctionDeclaration\",\n  \"FunctionExpression\",\n  \"ArrowFunctionExpression\",\n]);\n\n/**\n * Walk the AST body looking for expression statements whose expression is a\n * CallExpression with a callee of `console.<identifier>`. When found, check\n * that the name is not in the excluded set and that `console` is not shadowed\n * at this scope. If all conditions pass, replace the entire statement with `;`.\n *\n * Returns `null` if no console calls are removed.\n */\nexport function removeConsoleCalls(code: string, config: RemoveConsoleConfig): string | null {\n  if (config === false) return null;\n\n  const excluded =\n    typeof config === \"object\"\n      ? new Set(config.exclude.map((s) => s.toLowerCase()))\n      : new Set<string>();\n\n  // Fast path: if there's no bare \"console\" reference, skip parsing.\n  // This avoids the parse cost for the vast majority of modules.\n  const consoleMatch = code.match(/\\bconsole\\b/);\n  if (!consoleMatch) return null;\n\n  let ast: ReturnType<typeof parseAst>;\n  try {\n    ast = parseAst(code);\n  } catch {\n    // If parsing fails (shouldn't happen post-transform), bail out\n    return null;\n  }\n\n  // Collect shadowing scopes: tracks whether there's a local binding named\n  // \"console\" in the current or any parent scope. We do a simple top-down\n  // walk maintaining a stack of scope frames. Each function/arrow/block\n  // introduces a new frame. When we see a declaration/parameter of name\n  // \"console\", that frame (and its descendants) are shadowed.\n  type Scope = { shadowed: boolean };\n  const scopeStack: Scope[] = [{ shadowed: false }];\n\n  function currentScope(): Scope {\n    return scopeStack[scopeStack.length - 1]!;\n  }\n\n  function pushScope(): void {\n    // Child inherits parent shadowed status\n    scopeStack.push({ shadowed: currentScope().shadowed });\n  }\n\n  function popScope(): void {\n    scopeStack.pop();\n  }\n\n  const s = new MagicString(code);\n  let changed = false;\n\n  /**\n   * Check if a node introduces a binding named \"console\" and mark scope.\n   * Recurses into all binding-pattern node types (destructuring shapes,\n   * defaults, rest elements).\n   */\n  function checkBinding(node: BindingNode | null | undefined): void {\n    if (!node) return;\n    // oxlint-disable-next-line typescript/switch-exhaustiveness-check\n    switch (node.type) {\n      case \"Identifier\": {\n        if (node.name === \"console\") {\n          currentScope().shadowed = true;\n        }\n        break;\n      }\n      case \"ObjectPattern\": {\n        for (const prop of node.properties) {\n          checkBinding(prop as BindingNode);\n        }\n        break;\n      }\n      case \"Property\": {\n        // For `{ key: value }` and `{ console }` (shorthand) — the binding name\n        // is in `value`, not `key`. Recurse so AssignmentPattern defaults,\n        // nested patterns, etc. are all handled.\n        const propertyNode = node as unknown as { value?: BindingNode };\n        if (propertyNode.value) checkBinding(propertyNode.value);\n        break;\n      }\n      case \"ArrayPattern\": {\n        // oxlint-disable-next-line typescript/no-explicit-any\n        const elements = (node as any).elements as Array<BindingNode | null> | undefined;\n        if (elements) {\n          for (const el of elements) {\n            checkBinding(el);\n          }\n        }\n        break;\n      }\n      case \"AssignmentPattern\": {\n        // `x = default` — the binding is `left`, the default value is `right`.\n        // oxlint-disable-next-line typescript/no-explicit-any\n        const left = (node as any).left as BindingNode | undefined;\n        checkBinding(left);\n        break;\n      }\n      case \"RestElement\": {\n        // `...x` — the binding is `argument`.\n        // oxlint-disable-next-line typescript/no-explicit-any\n        const argument = (node as any).argument as BindingNode | undefined;\n        checkBinding(argument);\n        break;\n      }\n      default:\n        break;\n    }\n  }\n\n  /**\n   * Check if an identifier refers to the *global* console.\n   * It's global only when:\n   *   1. Its name is \"console\"\n   *   2. No local binding of that name shadows it at this point\n   */\n  function isGlobalConsole(node: BindingNode): boolean {\n    return node.type === \"Identifier\" && node.name === \"console\" && !currentScope().shadowed;\n  }\n\n  /**\n   * Determine if a call expression is a `console.<method>()` that should be\n   * removed. The callee must be a MemberExpression with:\n   *   - object: Identifier \"console\" (global, not shadowed)\n   *   - property: Identifier (NOT computed — computed access like\n   *     `console[prop]()` is preserved per Next.js behavior)\n   * The method name must NOT be in the excluded set.\n   */\n  function shouldRemove(node: BindingNode): boolean {\n    if (node.type !== \"CallExpression\") return false;\n    const callee = node.callee;\n    if (callee.type !== \"MemberExpression\") return false;\n\n    // Only handle dot access: console.log() — skip computed: console[prop]()\n    if (callee.computed) return false;\n\n    // The object must be the global console identifier\n    if (!isGlobalConsole(callee.object)) return false;\n\n    // Property must be an identifier (e.g., \"log\", \"warn\")\n    const prop = callee.property;\n    if (prop.type !== \"Identifier\") return false;\n\n    const method = prop.name.toLowerCase();\n    if (excluded.has(method)) return false;\n\n    return true;\n  }\n\n  /**\n   * Recursively walk a node tree, managing scope for shadow detection.\n   * When a CallExpression matches `console.<method>()`, replace it with\n   * `void 0`. If the call is the sole expression of an ExpressionStatement,\n   * replace the entire statement with `;` for cleaner output.\n   */\n  function walk(node: ASTNode, parent?: ASTNode): void {\n    if (!node) return;\n\n    if (node.type === \"CallExpression\" && shouldRemove(node)) {\n      if (parent?.type === \"ExpressionStatement\") {\n        // Replace the whole statement so we don't leave `void 0;` litter\n        s.overwrite(parent.start, parent.end, \";\");\n      } else {\n        s.overwrite(node.start, node.end, \"void 0\");\n      }\n      changed = true;\n      return; // don't recurse into children of a removed call\n    }\n\n    // `function console() {}` and `class console {}` bind `console` in the\n    // *enclosing* scope (function declarations are hoisted to function/module\n    // scope, class declarations are block-scoped). Check `id` against the\n    // current scope BEFORE pushing the function's own scope, so the binding\n    // is visible both outside and inside the function (via scope inheritance).\n    if (node.type === \"FunctionDeclaration\" || node.type === \"ClassDeclaration\") {\n      // oxlint-disable-next-line typescript/no-explicit-any\n      const id = (node as any).id as BindingNode | undefined;\n      checkBinding(id);\n    }\n\n    const isScopeEntering = SCOPE_ENTERING_TYPES.has(node.type);\n    if (isScopeEntering) {\n      pushScope();\n\n      // Named FunctionExpressions (`const x = function console() {}`) bind\n      // their name only in their *own* scope — not the enclosing one — so\n      // mark after pushing.\n      if (node.type === \"FunctionExpression\") {\n        // oxlint-disable-next-line typescript/no-explicit-any\n        const id = (node as any).id as BindingNode | undefined;\n        checkBinding(id);\n      }\n\n      // Mark params/destructured params\n      // oxlint-disable-next-line typescript/no-explicit-any\n      const params = (node as any).params as ASTNode[] | undefined;\n      if (params) {\n        for (const param of params) {\n          checkBinding(param as BindingNode);\n        }\n      }\n    }\n\n    // CatchClause introduces a binding for its param (`catch (e) { ... }`).\n    // If the param shadows \"console\", the catch block must treat console as\n    // local. We push a scope just for the param binding; the BlockStatement\n    // body below will push its own scope on top, which inherits the shadow.\n    const isCatchScope = node.type === \"CatchClause\";\n    if (isCatchScope) {\n      pushScope();\n      // oxlint-disable-next-line typescript/no-explicit-any\n      const param = (node as any).param as BindingNode | undefined;\n      if (param) {\n        checkBinding(param);\n      }\n    }\n\n    // Also enter a new scope for BlockStatement / Program bodies so that\n    // variable declarations are checked in the right frame.\n    //\n    // KNOWN LIMITATION: `var` is function-scoped, not block-scoped. A `var\n    // console = ...` inside a nested block (if/for/etc.) is hoisted to the\n    // enclosing function, but we treat it as block-scoped here, so console\n    // references after the block exits its scope frame will be incorrectly\n    // stripped. `let`/`const` are block-scoped so this only affects `var`.\n    // In real-world code, shadowing `console` with `var` is exceedingly rare.\n    const isBlockScope =\n      node.type === \"BlockStatement\" || node.type === \"Program\" || node.type === \"SwitchCase\";\n    if (isBlockScope && !isScopeEntering) {\n      pushScope();\n    }\n\n    // Check for local variable declarations of \"console\"\n    if (node.type === \"VariableDeclaration\") {\n      // oxlint-disable-next-line typescript/no-explicit-any\n      for (const decl of (node as any).declarations ?? []) {\n        checkBinding(decl.id as BindingNode);\n      }\n    }\n\n    // Recurse into child nodes, passing current node as parent\n    for (const key of Object.keys(node)) {\n      if (key === \"parent\" || key === \"start\" || key === \"end\") continue;\n      // oxlint-disable-next-line typescript/no-explicit-any\n      const child = (node as any)[key];\n      if (child && typeof child === \"object\") {\n        if (Array.isArray(child)) {\n          for (const item of child) {\n            if (item && typeof item === \"object\" && \"type\" in item) {\n              walk(item as BindingNode, node);\n            }\n          }\n        } else if (\"type\" in child) {\n          walk(child as BindingNode, node);\n        }\n      }\n    }\n\n    if (isScopeEntering || isBlockScope || isCatchScope) {\n      popScope();\n    }\n  }\n\n  for (const node of ast.body) {\n    walk(node);\n  }\n\n  if (!changed) return null;\n  return s.toString();\n}\n"],"mappings":"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"}

package/dist/routing/app-route-graph.d.ts

@@ -281,6 +281,29 @@ declare function convertSegmentsToRouteParts(segments: readonly string[]): {
   params: string[];
   isDynamic: boolean;
 } | null;
+/**
+ * Returns the unique static sibling segment names at each dynamic URL level
+ * of the matched route. Mirrors Next.js's `getStaticSiblingSegments` from
+ * the next-app-loader: for `/products/[id]` with a sibling route at
+ * `/products/sale`, the dynamic `[id]` segment has `staticSiblings: ['sale']`.
+ *
+ * The returned list flattens siblings across all dynamic positions and is
+ * intended for the RSC payload — the client router uses it to determine if
+ * a cached dynamic-route prefetch can be reused when navigating to a static
+ * sibling URL.
+ *
+ * Ported from Next.js: packages/next/src/build/webpack/loaders/next-app-loader/index.ts
+ * (getStaticSiblingSegments).
+ *
+ * Route group segments and parallel-route slot segments are part of the
+ * filesystem tree but not the URL namespace — sibling computation is done on
+ * the URL-level `patternParts`, so they are correctly transparent here.
+ */
+declare function computeAppRouteStaticSiblings(allRoutes: readonly {
+  patternParts?: readonly string[] | null;
+}[], matchedRoute: {
+  patternParts?: readonly string[] | null;
+}): string[];
 //#endregion
-export { AppRoute, AppRouteGraphParallelSlot, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, InterceptingRoute, ParallelSlot, RootBoundaryId, RouteManifest, RouteManifestBoundary, RouteManifestBoundaryOutcome, RouteManifestDefault, RouteManifestInterception, RouteManifestLayout, RouteManifestPage, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestRouteHandler, RouteManifestSlot, RouteManifestSlotBinding, RouteManifestSlotBindingState, RouteManifestTemplate, StaticSegmentGraph, buildAppRouteGraph, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
+export { AppRoute, AppRouteGraphParallelSlot, AppRouteGraphRoute, AppRouteSemanticIds, GraphVersion, InterceptingRoute, ParallelSlot, RootBoundaryId, RouteManifest, RouteManifestBoundary, RouteManifestBoundaryOutcome, RouteManifestDefault, RouteManifestInterception, RouteManifestLayout, RouteManifestPage, RouteManifestRootBoundary, RouteManifestRoute, RouteManifestRouteHandler, RouteManifestSlot, RouteManifestSlotBinding, RouteManifestSlotBindingState, RouteManifestTemplate, StaticSegmentGraph, buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
 //# sourceMappingURL=app-route-graph.d.ts.map

package/dist/routing/app-route-graph.js

@@ -329,7 +329,7 @@ function createRouteManifestGraphVersion(segmentGraph) {
 }
 async function buildAppRouteGraph(appDir, matcher) {
 	const routes = [];
-	const excludeDir = (name) => name.startsWith("@") || name.startsWith("_") || isInterceptionMarkerDir(name);
+	const excludeDir = (name) => name.startsWith("@") && name !== "@children" || name.startsWith("_") || isInterceptionMarkerDir(name);
 	for await (const file of scanWithExtensions("**/page", appDir, matcher.extensions, excludeDir)) {
 		const route = fileToAppRoute(file, appDir, "page", matcher);
 		if (route) routes.push(route);
@@ -367,7 +367,7 @@ async function buildAppRouteGraph(appDir, matcher) {
 }
 function hasParallelSlotDirectory(dir) {
 	try {
-		return fs.readdirSync(dir, { withFileTypes: true }).some((entry) => entry.isDirectory() && entry.name.startsWith("@"));
+		return fs.readdirSync(dir, { withFileTypes: true }).some((entry) => entry.isDirectory() && entry.name.startsWith("@") && entry.name !== "@children");
 	} catch {
 		return false;
 	}
@@ -555,7 +555,12 @@ function findSlotSubPages(slotDir, matcher) {
 * Convert a file path relative to app/ into an AppRoute.
 */
 function fileToAppRoute(file, appDir, type, matcher) {
-	return directoryToAppRoute(path.dirname(file), appDir, matcher, type === "page" ? path.join(appDir, file) : null, type === "route" ? path.join(appDir, file) : null);
+	let dir = path.dirname(file);
+	if (type === "page" && dir !== "." && path.basename(dir) === "@children") {
+		const parent = path.dirname(dir);
+		dir = parent === "" || parent === "." ? "." : parent;
+	}
+	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.join(appDir, file) : null, type === "route" ? path.join(appDir, file) : null);
 }
 function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 	const segments = dir === "." ? [] : dir.split(path.sep);
@@ -981,6 +986,7 @@ function discoverParallelSlots(dir, appDir, matcher) {
 	const slots = [];
 	for (const entry of entries) {
 		if (!entry.isDirectory() || !entry.name.startsWith("@")) continue;
+		if (entry.name === "@children") continue;
 		const slotName = entry.name.slice(1);
 		const slotDir = path.join(dir, entry.name);
 		const pagePath = findFile(slotDir, "page", matcher);
@@ -1284,7 +1290,49 @@ function joinRoutePattern(basePattern, subPath) {
 	if (!subPath) return basePattern;
 	return basePattern === "/" ? `/${subPath}` : `${basePattern}/${subPath}`;
 }
+/**
+* Returns the unique static sibling segment names at each dynamic URL level
+* of the matched route. Mirrors Next.js's `getStaticSiblingSegments` from
+* the next-app-loader: for `/products/[id]` with a sibling route at
+* `/products/sale`, the dynamic `[id]` segment has `staticSiblings: ['sale']`.
+*
+* The returned list flattens siblings across all dynamic positions and is
+* intended for the RSC payload — the client router uses it to determine if
+* a cached dynamic-route prefetch can be reused when navigating to a static
+* sibling URL.
+*
+* Ported from Next.js: packages/next/src/build/webpack/loaders/next-app-loader/index.ts
+* (getStaticSiblingSegments).
+*
+* Route group segments and parallel-route slot segments are part of the
+* filesystem tree but not the URL namespace — sibling computation is done on
+* the URL-level `patternParts`, so they are correctly transparent here.
+*/
+function computeAppRouteStaticSiblings(allRoutes, matchedRoute) {
+	const siblings = /* @__PURE__ */ new Set();
+	const parts = matchedRoute.patternParts;
+	if (!parts) return [];
+	for (let level = 0; level < parts.length; level++) {
+		const segmentAtLevel = parts[level];
+		if (!segmentAtLevel.startsWith(":")) continue;
+		for (const otherRoute of allRoutes) {
+			const otherParts = otherRoute.patternParts;
+			if (!otherParts || otherParts.length <= level) continue;
+			let prefixMatches = true;
+			for (let i = 0; i < level; i++) if (parts[i] !== otherParts[i]) {
+				prefixMatches = false;
+				break;
+			}
+			if (!prefixMatches) continue;
+			const otherSegmentAtLevel = otherParts[level];
+			if (otherSegmentAtLevel === segmentAtLevel) continue;
+			if (otherSegmentAtLevel.startsWith(":")) continue;
+			siblings.add(otherSegmentAtLevel);
+		}
+	}
+	return Array.from(siblings);
+}
 //#endregion
-export { buildAppRouteGraph, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
+export { buildAppRouteGraph, computeAppRouteStaticSiblings, computeRootParamNames, convertSegmentsToRouteParts, isInvisibleSegment };
 
 //# sourceMappingURL=app-route-graph.js.map