@timber-js/app 0.2.0-alpha.2 → 0.2.0-alpha.200

package/dist/_chunks/scanner-AiazgH_f.js

@@ -0,0 +1,1771 @@
+import { h as swallow } from "./logger-uLBuGKDI.js";
+import { i as classifyMetadataRoute, n as treePathDepth, s as isDynamicMetadataExtension, t as computeSegmentTreePaths } from "./segment-keys-lqtdookO.js";
+import { n as NULL_BYTE_RE, t as ENCODED_SEPARATOR_RE } from "./canonicalize-CgHoscYO.js";
+import { i as DEFAULT_PAGE_EXTENSIONS, n as classifyUrlSegment, r as effectiveUrlSegment, t as classifySegment } from "./segment-classify-C539Pa2O.js";
+import { basename, extname, join } from "node:path";
+import { readdirSync, statSync } from "node:fs";
+//#region src/server/tree-match.ts
+/**
+* Match URL path parts against a segment tree.
+*
+* Walks the tree depth-first with backtracking, applying priority
+* ordering globally across group boundaries. Returns the matched
+* segment chain and collected params, or null if no route matches.
+*
+* By default, a match requires a terminal node (one with `page` or
+* `route`) at the leaf. Pass `{ requireTerminal: false }` to match
+* any segment (used by metadata route matching).
+*
+* @param root  The root segment node to start matching from.
+* @param parts URL path parts (e.g. ['blog', 'hello-world']).
+*              Empty array matches the root itself (if terminal).
+*/
+function matchUrlParts(root, parts, options) {
+	const chain = [];
+	const params = {};
+	if (matchNode(root, parts, 0, chain, params, options?.requireTerminal ?? true)) return {
+		chain,
+		params
+	};
+	return null;
+}
+/**
+* Flatten children through group segments.
+*
+* Groups are transparent for URL matching — their non-group descendants
+* are returned with the chain of group nodes leading to them. This lets
+* the caller apply priority ordering (static > dynamic > catch-all >
+* optional-catch-all) across all groups uniformly instead of per-group.
+*/
+function collectEffectiveChildren(node, groupChain = []) {
+	const result = [];
+	for (const child of node.children) if (child.segmentType === "group") {
+		const nested = collectEffectiveChildren(child, [...groupChain, child]);
+		result.push(...nested);
+	} else result.push({
+		child,
+		groupChain
+	});
+	return result;
+}
+/** A node is terminal if it can serve a response (has a page or route handler). */
+function isTerminal(node) {
+	return !!(node.page || node.route);
+}
+/** Combined affix length for specificity ordering. */
+function affixLength(node) {
+	return (node.paramPrefix?.length ?? 0) + (node.paramSuffix?.length ?? 0);
+}
+/**
+* Recursive depth-first matcher with backtracking.
+*
+* Mutates `chain` and `params` in place for performance; backtracks
+* (restores previous state) when a candidate doesn't lead to a match.
+*/
+function matchNode(node, parts, index, chain, params, requireTerminal) {
+	chain.push(node);
+	if (index >= parts.length) {
+		if (!requireTerminal || isTerminal(node)) return true;
+		for (const child of node.children) if (child.segmentType === "group") {
+			if (matchNode(child, parts, index, chain, params, requireTerminal)) return true;
+		}
+		const effective = collectEffectiveChildren(node);
+		for (const { child, groupChain } of effective) if (child.segmentType === "optional-catch-all" && (!requireTerminal || isTerminal(child))) {
+			chain.push(...groupChain, child);
+			return true;
+		}
+		chain.pop();
+		return false;
+	}
+	const part = parts[index];
+	const effective = collectEffectiveChildren(node);
+	for (const { child, groupChain } of effective) if (child.segmentType === "static" && child.segmentName === part) {
+		chain.push(...groupChain);
+		if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) return true;
+		chain.length -= groupChain.length;
+	}
+	const affixed = effective.filter(({ child }) => child.segmentType === "dynamic" && child.paramName && (child.paramPrefix || child.paramSuffix));
+	affixed.sort((a, b) => affixLength(b.child) - affixLength(a.child));
+	for (const { child, groupChain } of affixed) {
+		const prefix = child.paramPrefix ?? "";
+		const suffix = child.paramSuffix ?? "";
+		if (part.length > prefix.length + suffix.length && (!prefix || part.startsWith(prefix)) && (!suffix || part.endsWith(suffix))) {
+			const value = part.slice(prefix.length, part.length - (suffix.length || 0));
+			chain.push(...groupChain);
+			const prev = params[child.paramName];
+			params[child.paramName] = value;
+			if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) return true;
+			chain.length -= groupChain.length;
+			if (prev !== void 0) params[child.paramName] = prev;
+			else delete params[child.paramName];
+		}
+	}
+	for (const { child, groupChain } of effective) if (child.segmentType === "dynamic" && child.paramName && !child.paramPrefix && !child.paramSuffix) {
+		chain.push(...groupChain);
+		const prev = params[child.paramName];
+		params[child.paramName] = part;
+		if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) return true;
+		chain.length -= groupChain.length;
+		if (prev !== void 0) params[child.paramName] = prev;
+		else delete params[child.paramName];
+	}
+	for (const { child, groupChain } of effective) if (child.segmentType === "catch-all" && child.paramName && (!requireTerminal || isTerminal(child))) {
+		chain.push(...groupChain, child);
+		params[child.paramName] = parts.slice(index);
+		return true;
+	}
+	for (const { child, groupChain } of effective) if (child.segmentType === "optional-catch-all" && child.paramName && (!requireTerminal || isTerminal(child))) {
+		chain.push(...groupChain, child);
+		params[child.paramName] = parts.slice(index);
+		return true;
+	}
+	chain.pop();
+	return false;
+}
+//#endregion
+//#region src/routing/collision-probe.ts
+/**
+* Find a URL in this collision space whose winner depends on `children` order,
+* or null if every probed URL resolves the same way in both orderings.
+*
+* `spaceRoot` is the node `matchUrlParts` starts from — the app root, a slot
+* node, or an intercepting directory. `base` is the URL that root sits at, used
+* only to render the reported URL.
+*/
+function findOrderDependentCollision(spaceRoot, leaves, base) {
+	const reversed = withReversedChildren(spaceRoot);
+	const longTail = longTailLength(spaceRoot) + 1;
+	const minLength = longestStaticName(spaceRoot);
+	const seen = /* @__PURE__ */ new Set();
+	for (const leaf of leaves) for (const { parts, display } of probeUrlsForLeaf(spaceRoot, reversed, leaf, longTail, minLength)) {
+		const key = parts.join("/");
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const first = matchedLeafFile(spaceRoot, parts);
+		const second = matchedLeafFile(reversed, parts);
+		if (!first || !second || first === second) continue;
+		return {
+			url: describeProbeUrl(base, display),
+			first,
+			second
+		};
+	}
+	return null;
+}
+/** Join a probe's display parts onto its space's base. */
+function describeProbeUrl(base, display) {
+	if (display.length === 0) return base || "/";
+	return `${base === "/" ? "" : base}/${display.join("/")}`;
+}
+/**
+* The file `matchUrlParts` resolves for a URL, or null if nothing does.
+*
+* A `route.ts` counts: `isTerminal` accepts either, so a route handler is a
+* legitimate winner of the walk and an ambiguity between a page and a route
+* handler is as real as one between two pages.
+*/
+function matchedLeafFile(node, parts) {
+	const match = matchUrlParts(node, parts);
+	if (!match) return null;
+	const leaf = match.chain[match.chain.length - 1];
+	return leaf.page?.filePath ?? leaf.route?.filePath ?? null;
+}
+/**
+* The values a probe's dynamic parts are tried with, in order.
+*
+* A probe stands in for "any value" at a dynamic position, so it is only useful
+* if it reaches the leaf it was built for. A *static* sibling's literal name or
+* a more specific *affixed* sibling's pattern can claim it instead, and that
+* higher-priority segment then wins in both orderings — a genuine tie
+* underneath goes unreported, which is safe but is the whole thing these
+* validators are for.
+*
+* Which values are claimable is a question about `matchNode`'s precedence, so
+* `probeUrlsForLeaf` asks `matchUrlParts` rather than deciding it here. This
+* only has to offer enough shapes for the search to find one that works: an
+* affixed sibling constrains the head of the value, its tail, or both, so head
+* and tail are varied over an alphanumeric alphabet. The head varies fastest
+* because a prefix is the more common affix. Exhausting the list is a missed
+* collision like any other inadequate probe, so this is a search and not a
+* proof — nothing downstream may treat it as one.
+*
+* Exported so a test that has to *name* a capturing static sibling can derive
+* the name from this list rather than restate it — a fixture spelling the value
+* out by hand stops being a capture the moment the list changes, and passes.
+*
+* Three revisions of a hand-built value each dodged one more capture and were
+* each followed by another (avoid static names; avoid affix boundary
+* characters; avoid re-affixed forms of static names — then a strictly more
+* specific affixed sibling, TIM-1313). Each rule was modelling affix precedence
+* by hand, which is what the match-shape model was deleted for.
+*/
+function* probeCandidates(minLength = 0) {
+	const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+	const base = "timber-probe";
+	function* wave(core) {
+		for (const tail of alphabet) for (const head of alphabet) yield `${head}${core}${tail}`;
+	}
+	yield* wave(base);
+	const padded = base.padEnd(Math.max(12, minLength), "x");
+	if (padded !== base) yield* wave(padded);
+}
+/**
+* The longest static segment name anywhere in the space.
+*
+* Read through `effectiveUrlSegment` so an intercepting directory counts as the
+* segment it intercepts, and only static kinds count: a dynamic sibling claims
+* a probe by pattern rather than by equality, which no length can escape.
+*/
+function longestStaticName(node) {
+	let longest = 0;
+	for (const child of node.children) {
+		const seg = effectiveUrlSegment(child);
+		if (seg.segmentType === "static") longest = Math.max(longest, seg.segmentName.length);
+		longest = Math.max(longest, longestStaticName(child));
+	}
+	return longest;
+}
+/**
+* The probe URLs for one leaf, built from the first candidate value that
+* actually reaches it.
+*
+* "Reaches it" is `matchUrlParts` resolving one of the leaf's own URLs to the
+* leaf's file, in either ordering — either is enough, because a leaf that wins
+* only in the reversed ordering is precisely the contention being looked for.
+* A catch-all leaf may be reached by its long probe and not its short one (at
+* one part it loses to a bare dynamic sibling deterministically), so any one of
+* the generated URLs landing is enough to accept the value.
+*
+* A leaf that no candidate reaches is shadowed at its position for every value
+* tried — most often because it sits below a catch-all, which `matchNode`
+* accepts only as a terminal and never descends past. Its probes are still
+* emitted, from the first candidate: a probe that misses its own leaf is never
+* *wrong* — it is a real URL, and a winner that differs between the two
+* orderings is a real ambiguity whichever leaf it belongs to. Nothing here may
+* report the leaf as unreachable; that is the universal claim these validators
+* do not make.
+*/
+function probeUrlsForLeaf(root, reversed, leaf, longTail, minLength) {
+	let fallback = null;
+	for (const value of probeCandidates(minLength)) {
+		const urls = probeUrlsFor(leaf.chain, value, longTail);
+		if (urls.some(({ parts }) => matchedLeafFile(root, parts) === leaf.filePath || matchedLeafFile(reversed, parts) === leaf.filePath)) return urls;
+		fallback ??= urls;
+		if (!urls.some(({ dynamic }) => dynamic)) break;
+	}
+	return fallback ?? [];
+}
+/**
+* The URL part one segment contributes to a probe.
+*
+* A dynamic segment stands for any single value, so it contributes the
+* candidate value — re-affixed, since an affixed segment only matches parts
+* that carry its prefix and suffix, so a probe without them could not reach it.
+* A catch-all stands for one or more parts, and one is enough to reach the leaf.
+*
+* The re-affixed part is the reason a value cannot be checked once for the
+* whole space: it exposes the value to every affixed sibling that *extends*
+* this segment's affixes, which differs per position. `probeUrlsForLeaf` asks
+* the matcher whether the assembled URL reaches its leaf, and moves to the next
+* candidate when it does not.
+*
+* Segments are read through `effectiveUrlSegment` so an intercepting directory
+* contributes the part the segment it intercepts would.
+*/
+function probePartFor(node, value) {
+	const seg = effectiveUrlSegment(node);
+	switch (seg.segmentType) {
+		case "dynamic": {
+			const prefix = seg.paramPrefix ?? "";
+			const suffix = seg.paramSuffix ?? "";
+			return {
+				part: `${prefix}${value}${suffix}`,
+				shown: `${prefix}<any>${suffix}`,
+				dynamic: true
+			};
+		}
+		case "catch-all":
+		case "optional-catch-all": return {
+			part: value,
+			shown: "<any>",
+			dynamic: true
+		};
+		default: return {
+			part: seg.segmentName,
+			shown: seg.segmentName,
+			dynamic: false
+		};
+	}
+}
+/**
+* The URLs that reach a leaf.
+*
+* An **optional catch-all also matches zero parts**, so it answers the URL its
+* parent sits at as well as longer ones. Both are probed: whether the shorter
+* one is actually *its* to answer is `matchUrlParts`' business, not something
+* to decide here — a page above it, or in a route group beside it, may take
+* that URL deterministically, and the probe will simply report the same winner
+* in both orderings.
+*/
+function probeUrlsFor(chain, value, longTail) {
+	const probeParts = chain.map((node) => probePartFor(node, value));
+	const url = (ps) => ({
+		parts: ps.map((p) => p.part),
+		display: ps.map((p) => p.shown),
+		dynamic: ps.some((p) => p.dynamic)
+	});
+	const leaf = chain[chain.length - 1];
+	const kind = leaf && effectiveUrlSegment(leaf).segmentType;
+	if (!(kind === "catch-all" || kind === "optional-catch-all")) return [url(probeParts)];
+	const head = probeParts.slice(0, -1);
+	const urls = [url(probeParts)];
+	if (longTail > 1) {
+		const tail = Array.from({ length: longTail }, () => ({
+			part: value,
+			shown: "<any>",
+			dynamic: true
+		}));
+		urls.push(url([...head, ...tail]));
+	}
+	if (kind === "optional-catch-all") urls.push(url(head));
+	return urls;
+}
+/**
+* One more than the longest fixed-length path in the space.
+*
+* A probe of this length cannot be claimed by any branch that consumes a fixed
+* number of URL parts, so whatever matches it is a catch-all — which is
+* exactly the competition a short probe hides.
+*/
+function longTailLength(node) {
+	let deepest = 0;
+	for (const child of node.children) {
+		const own = child.segmentType === "group" ? 0 : 1;
+		deepest = Math.max(deepest, own + longTailLength(child));
+	}
+	return deepest;
+}
+/**
+* The subtree with every `children` array reversed, top to bottom.
+*
+* Nodes are shallow-copied, so files and slots are shared with the original —
+* only the ordering `matchNode` reads is different. Slots are not reversed
+* because `matchNode` never walks them; each slot is validated as its own
+* collision space, with its own reversed clone.
+*/
+function withReversedChildren(node) {
+	return {
+		...node,
+		children: [...node.children].reverse().map(withReversedChildren)
+	};
+}
+//#endregion
+//#region src/routing/interception-overlap.ts
+/**
+* Pattern intersection for intercepted URL patterns.
+*
+* Checks whether two intercepted URL patterns can both match the same concrete
+* URL. Used by the cross-mode claim check (TIM-1319) to detect when a
+* children-path interceptor and a slot interceptor from the same owner overlap.
+*
+* This is not the order-dependence oracle (`findOrderDependentCollision`) the
+* within-mode collision checks use. `findInterceptionMatch` picks the mode by
+* first-match on `pathnameMatchesPattern`, which has no priority tiers, so a
+* static `/feed/foo` and a dynamic `/feed/[id]` both match `/feed/foo` even
+* though `matchUrlParts` would resolve the static deterministically. The
+* intersection test catches that: it walks both patterns segment by segment and
+* asks whether any value satisfies both.
+*
+* This is not a model of `matchNode` precedence — that decides *which*
+* candidate wins when several match one URL. This decides the prior question:
+* *do* they both match one URL at all? The two questions are independent, and
+* conflating them is what caused TIM-1308's five-round drift.
+*/
+/**
+* Check whether two intercepted URL patterns can both match the same concrete
+* URL. Returns a display string for the overlapping URL, or null.
+*
+* Walks both patterns segment by segment:
+* - Two statics: must be identical.
+* - Static + dynamic: static must satisfy the dynamic's affix constraints.
+* - Two dynamics: affix constraints must be compatible.
+* - A catch-all at either side: compatible with everything remaining.
+*
+* If the patterns differ in length, they can only overlap if the longer one's
+* extra part is an optional catch-all (which also matches zero segments).
+*/
+function interceptedPatternsOverlap(p1, p2) {
+	if (p1 === p2) return p1;
+	const parts1 = p1 === "/" ? [] : p1.slice(1).split("/");
+	const parts2 = p2 === "/" ? [] : p2.slice(1).split("/");
+	const display = [];
+	let i = 0;
+	while (i < parts1.length && i < parts2.length) {
+		const seg1 = classifyUrlSegment(parts1[i]);
+		const seg2 = classifyUrlSegment(parts2[i]);
+		if (seg1.kind === "catch-all" || seg1.kind === "optional-catch-all" || seg2.kind === "catch-all" || seg2.kind === "optional-catch-all") {
+			display.push("<any>");
+			return "/" + display.join("/");
+		}
+		const part = segmentsOverlap(seg1, seg2);
+		if (part === null) return null;
+		display.push(part);
+		i++;
+	}
+	const remaining = i < parts1.length ? parts1 : i < parts2.length ? parts2 : null;
+	if (remaining) {
+		if (classifyUrlSegment(remaining[i]).kind !== "optional-catch-all") return null;
+	}
+	return display.length === 0 ? "/" : "/" + display.join("/");
+}
+/**
+* Can some concrete value satisfy both classified URL segments?
+*
+* An affixed dynamic (`a-[id].png`) constrains both the prefix and suffix of
+* the value, so a static segment must satisfy those constraints and two
+* dynamics must have compatible affixes — prefixes where one extends the other,
+* and likewise for suffixes. Without this check, `/feed/photo.jpg` beside
+* `/feed/asset-[id].png` would be falsely rejected.
+*/
+function segmentsOverlap(seg1, seg2) {
+	if (seg1.kind === "static" && seg2.kind === "static") return seg1.value === seg2.value ? seg1.value : null;
+	if (seg1.kind === "static" && seg2.kind === "dynamic") return staticMatchesAffix(seg1.value, seg2) ? seg1.value : null;
+	if (seg2.kind === "static" && seg1.kind === "dynamic") return staticMatchesAffix(seg2.value, seg1) ? seg2.value : null;
+	if (seg1.kind === "dynamic" && seg2.kind === "dynamic") return dynamicAffixesCompatible(seg1, seg2) ? "<any>" : null;
+	return "<any>";
+}
+/**
+* Does a static value satisfy an affixed dynamic's prefix, suffix, and
+* non-empty capture constraints?
+*
+* Mirrors the check `pathnameMatchesPattern` applies: the value must start with
+* the prefix, end with the suffix, and be strictly longer than their combined
+* length (a capture of zero characters is not a match).
+*/
+function staticMatchesAffix(value, dynamic) {
+	const prefix = dynamic.prefix ?? "";
+	const suffix = dynamic.suffix ?? "";
+	if (!prefix && !suffix) return true;
+	if (prefix && !value.startsWith(prefix)) return false;
+	if (suffix && !value.endsWith(suffix)) return false;
+	return value.length > prefix.length + suffix.length;
+}
+/**
+* Can some value simultaneously satisfy two affixed dynamics?
+*
+* Two prefix constraints are compatible when one extends the other (a value
+* starting with the longer one also starts with the shorter). Suffixes are
+* analogous. Without affixes on either side, every value works.
+*/
+function dynamicAffixesCompatible(d1, d2) {
+	const p1 = d1.prefix ?? "", s1 = d1.suffix ?? "";
+	const p2 = d2.prefix ?? "", s2 = d2.suffix ?? "";
+	if (p1 && p2 && !p1.startsWith(p2) && !p2.startsWith(p1)) return false;
+	if (s1 && s2 && !s1.endsWith(s2) && !s2.endsWith(s1)) return false;
+	return true;
+}
+//#endregion
+//#region src/routing/interception.ts
+/**
+* Group an owner's intercepting children by the URL position they contend for.
+*
+* This is the definition of *which interceptors compete*, and it has exactly
+* one caller shape on each side of the build: `findInterceptingMatch` resolves
+* a group with one `matchUrlParts` walk, and
+* `assertNoInterceptedPatternCollisions` validates the same group as one
+* collision space. Written twice, the two would be free to disagree about what
+* competes — and a resolver that walks a wider set than the validator checked
+* is precisely the order-dependence the validator exists to reject (TIM-1310).
+*
+* Contention is keyed by the computed intercepted **base**, not by the marker:
+* under an owner at `/feed`, `(..)` and `(...)` both base at `/` and are both
+* matched at index 0, so they are one group. Different bases are different
+* positions — a `(.)` interceptor can never claim a target that belongs to a
+* `(..)` one beside it, because the base must also match the target's leading
+* parts.
+*
+* The base is a URL *pattern*, so its length is its part count only because
+* every pattern part stands for exactly one URL part. A catch-all in the base
+* breaks that, and `assertInterceptedBaseIsCountable` rejects the shape at
+* build time.
+*
+* A node missing either marker field is skipped, which `classifySegment` never
+* produces — it sets both whenever it reports `'intercepting'`. Stating the
+* filter here rather than defaulting the marker is what makes the validator and
+* the resolver see the same set: such a node renders nothing either way, and a
+* validator more permissive than the resolver would be checking a candidate
+* that never competes while the resolver walks one nobody checked.
+*
+* `children` is read directly rather than flattened through route groups,
+* matching both resolvers: the slot resolver reads `slotNode.children`, and an
+* interceptor deeper inside a slot subtree is rejected by
+* `validateInterceptionPlacement`. On the children path an interceptor under a
+* route group is legal and the *group* is its owner, so it is grouped with that
+* group's other interceptors — which is again exactly what the resolver walks,
+* since it resolves the owner by tree path.
+*/
+function groupByInterceptedAnchor(ownerUrlPath, children) {
+	const byBase = /* @__PURE__ */ new Map();
+	for (const child of children) {
+		if (child.segmentType !== "intercepting") continue;
+		if (!child.interceptionMarker || !child.interceptedSegmentName) continue;
+		const base = computeInterceptedBase(ownerUrlPath, child.interceptionMarker);
+		const group = byBase.get(base);
+		if (group) group.interceptors.push(child);
+		else byBase.set(base, {
+			base,
+			anchorIndex: base === "/" ? 0 : base.slice(1).split("/").length,
+			interceptors: [child]
+		});
+	}
+	return [...byBase.values()].sort((a, b) => b.anchorIndex - a.anchorIndex);
+}
+/**
+* Collect all interception rewrite rules from the route tree.
+*
+* Walks the tree recursively. For each intercepting segment, computes the
+* intercepted URL based on the marker and the segment's position.
+*
+* The list is returned **deepest scope first**, which is what makes
+* `findInterceptionMatch`'s first-match rule deterministic; see
+* `sortByScopeDepth`.
+*/
+function collectInterceptionRewrites(root) {
+	const rewrites = [];
+	walkForInterceptions(root, [root], false, rewrites);
+	return sortByScopeDepth(rewrites);
+}
+/**
+* Order the rewrites deepest scope first, so the request-time first-match rule
+* resolves two applicable rewrites by *nesting* rather than by tree-walk order.
+*
+* `findInterceptionMatch` returns the first rewrite whose pattern matches the
+* target and whose scope the source route reports. More than one can satisfy
+* both, and the case is not exotic — an owner and a directory *beneath* it may
+* each hold an interceptor for one URL:
+*
+* ```
+* app/feed/(.)photo/page.tsx        scope /feed
+* app/feed/(a)/(.)photo/page.tsx    scope /feed/(a)
+* ```
+*
+* A page inside `(a)` renders both owners' layouts, so the client reports both
+* tree paths and both scopes pass. Unsorted, the winner is whichever the
+* filesystem enumerated first — renaming the group flips which page a click
+* opens, the defect class TIM-1305/TIM-1308/TIM-1310 each rejected in a
+* different space. Here it is an ambiguity between *rewrites* rather than
+* between pages inside one walk, so no collision space sees it.
+*
+* **Deepest wins, and it is specified rather than rejected** because the shape
+* is one a correct app writes on purpose: a nested layout refining the
+* interception its parent declares, exactly as `groupByInterceptedAnchor`
+* already prefers the deepest *anchor* within one owner. The two rules are the
+* same preference — the more local interception is the author's more specific
+* statement — applied at the two levels the mechanism has.
+*
+* Depth is counted on the **tree path**, the identity that never collapses
+* (TIM-1279/TIM-1280); a `urlPath` prefix test would relate `(browse)` and
+* `(landing)`, which render different layouts and share no chain. Two scopes on
+* one rendered chain are strictly nested, so depth orders them totally, and two
+* scopes that are *not* on one chain — sibling groups, `feed/(a)` beside
+* `feed/(b)` — never both pass the scope check, so their relative order is not
+* observable. That is why this sorts on depth alone rather than testing
+* ancestry: it is a total order over the pairs that can compete, and it costs
+* nothing per request.
+*
+* Sorting is stable, so rewrites sharing one scope keep tree-walk order. Equal
+* scopes mean one owner, and of the three pairings that produces only one was
+* ambiguous — a children-path interceptor beside a slot one — and that is now
+* rejected at build time by `assertNoCrossModeClaims` (TIM-1319). The
+* enumeration is in design/07-routing.md §"Selection Between Owners" rather
+* than repeated here, so there is one place to correct if a rewrite ever grows
+* a field that makes two of them distinguishable.
+*/
+function sortByScopeDepth(rewrites) {
+	return rewrites.sort((a, b) => treePathDepth(b.interceptingScope) - treePathDepth(a.interceptingScope));
+}
+/**
+* Validate that every intercepting segment sits where it can actually render.
+*
+* There are exactly two positions a renderer exists for, and they are the two
+* shapes interception has:
+*
+* 1. **Direct child of a parallel slot** — the modal overlay. The slot
+*    resolver scans a slot node's *direct children* for an intercepting
+*    segment (`server/slot-interception.ts`). Nothing between the slot and
+*    the intercepting directory is allowed, because nothing walks it.
+* 2. **Direct child of an ordinary segment or route group** — the sibling
+*    layout swap (TIM-1280). The pipeline resolves the owner by tree path and
+*    builds the rendered chain through the intercepting node itself
+*    (`server/children-interception.ts`).
+*
+* Everywhere else, rewrite generation still emits a rewrite and nothing
+* renders it: the rewrite matches the soft navigation, and the user is served
+* the page they were already on under a changed URL (TIM-1278). The rejected
+* positions are:
+*
+* - **Inside a slot subtree but not directly under the slot**
+*   (`@modal/(inner)/(.)photo`). Neither renderer applies: the slot resolver
+*   only reads direct children, and the children-path resolver builds a
+*   *chain*, which cannot express a descent through a slot.
+* - **Inside another intercepting subtree** (`(.)a/(.)b`). Left unvalidated
+*   `collectLeavesWithRewrites` walks the inner one as an ordinary URL
+*   segment and emits a pattern containing a literal "(.)b".
+*
+* Two further shapes are rejected here (TIM-1288). Both are about a catch-all,
+* and both are specific to interception: elsewhere in the tree the same
+* shapes are inert or fail safely, and the general "nothing below a catch-all
+* is reachable" rule is tracked as TIM-1286.
+*
+* And one is specific to the children path: an owner chain that binds params
+* (see `assertOwnerChainBindsNoParams`).
+*/
+function validateInterceptionPlacement(root) {
+	walkForPlacement(root, "", {
+		parentIsSlot: false,
+		inSlotSubtree: false,
+		inInterceptingSubtree: false,
+		ancestorsBindParams: false
+	});
+}
+/**
+* Reject a children-path interception whose owner chain binds params.
+*
+* The rendered chain is `[…owner ancestors, interceptingNode, …descendants]`,
+* and the only pathname available to bind params from is the **target** — the
+* URL being navigated to. The intercepting subtree's own params come from it
+* by construction. The owner chain's do not, in general:
+*
+* - With a climbing marker the owner's URL segments are not in the target at
+*   all. `app/[team]/(..)photo/[id]` bases at "/", so the target is
+*   `/photo/9` — there is no team value anywhere in it, and `[team]`'s layout
+*   would render with the param it declares missing.
+* - With `(.)` the base *is* the owner's `urlPath`, so the target's leading
+*   parts would bind it. Supporting only that half means one marker behaves
+*   differently from its siblings for reasons the author cannot see from the
+*   directory names, so the rule is stated once, on the owner chain.
+*
+* A layout that silently renders without the param it declares is the failure
+* this prevents; it is rejected where it can be explained rather than left to
+* surface as `undefined` deep inside user code. Route groups and static
+* segments bind nothing and are unrestricted, which is the whole motivating
+* shape (`app/(browse)/(...)[artistSlug]/…`).
+*
+* The rule stops at a slot boundary: a slot-mode interception re-matches the
+* *source* route, which supplies the owner's params, so a dynamic owner is
+* fine there and always has been.
+*/
+/**
+* Require a children-path interception's owner to have a `layout.tsx`.
+*
+* The scope is the owner's tree path, and the client reports which tree paths
+* it has mounted from `X-Timber-Segments` — which carries **one entry per
+* layout-bearing segment**, because those are the segments the client needs an
+* outlet and a cache node for. `buildSegmentInfo` skips the rest.
+*
+* For the modal shape that set is exactly the set of possible scope owners, by
+* construction: a slot is only resolved inside a rendering layout
+* (`route-element-builder.ts`), so a layoutless segment can never own one. A
+* children-path interception broke that equivalence — its owner is an ordinary
+* directory and needs no layout.
+*
+* Left unchecked the result is a swap that works exactly once: the first soft
+* navigation renders, then the client reports no such tree path, and the next
+* navigation fails the scope check and falls back to the canonical page. That
+* is fail-safe but silent, and the address-bar channel cannot recover it —
+* once the swap is on screen the address holds the *intercepted* URL, which
+* re-matches the canonical chain (the TIM-1282 problem, in the one shape the
+* rendered-scope fix does not reach).
+*
+* Requiring the layout restores the invariant the state tree is built on
+* rather than widening the wire format to carry segments that own no outlet
+* and no payload. It also costs the author nothing they were not already
+* doing: the point of this shape is to render inside the owner's own layout,
+* so an owner with no layout has no chrome to preserve.
+*/
+function assertOwnerHasLayout(ownerPath, childPath) {
+	const owner = ownerPath || "(app root)";
+	throw new Error(`Build error: intercepting route whose owner has no layout.\n  Directory: app/${childPath}\n  Owner:     app/${owner}\nAn intercepting directory outside a parallel slot renders inside its owner's layout chain, and the owner must have a layout.tsx: the client reports which directories it has mounted from its layout segments, and a scope it cannot report would let the interception fire once and then silently stop.\nAdd app/${owner}/layout.tsx (a pass-through returning {children} is enough), or move the interception under a directory that has one.\nSee design/07-routing.md §"Intercepting Routes".`);
+}
+function assertOwnerChainBindsNoParams(childPath, marker) {
+	throw new Error(`Build error: intercepting route under a dynamic segment.\n  Directory: app/${childPath}\nAn intercepting directory outside a parallel slot renders inside its own layout chain, and the only pathname available to bind params from is the intercepted URL — which does not carry the values of the segments above "${marker}".\nMove the interception so every directory above it is a static segment or a route group, or place it inside a parallel slot (@modal/) to render it as an overlay over the source route instead.\nSee design/07-routing.md §"Intercepting Routes".`);
+}
+/**
+* Reject an intercepting route whose intercepted level is not well-defined.
+*
+* "One level up" is counted in URL segments, which works because every
+* pattern part stands for exactly one URL part — except a catch-all, which
+* stands for a number that varies per request. `anchorIndex` fixes the anchor
+* at the base's pattern length, so with an owner at `/docs/[...path]` the
+* interception resolves when the catch-all consumed exactly one segment
+* (`/docs/a/photo/5`) and is dropped when it consumed more
+* (`/docs/a/b/photo/5`), because the base no longer matches the target's
+* leading parts.
+*
+* Dropping is fail-safe — the canonical route renders, as on hard navigation
+* — so this is never a wrong page. But it is a modal that opens at one depth
+* and silently does not at another, with nothing to tell the author why, and
+* no request-time input can fix it: the only available source depth is
+* `X-Timber-URL`, which is the browser's address bar, and once a modal is
+* open that holds the *intercepted* URL rather than the source.
+*
+* So the shape is rejected where it can be explained. A marker that climbs
+* *past* the catch-all is fine — `(..)` from `/docs/[...path]` bases at
+* `/docs` — and so is `(...)`, which always bases at the root. The rule is on
+* the *computed* base, not on having a catch-all anywhere above.
+*/
+function assertInterceptedBaseIsCountable(child, ownerUrlPath, childPath) {
+	const marker = child.interceptionMarker ?? "(.)";
+	const base = computeInterceptedBase(ownerUrlPath, marker);
+	const ambiguous = (base === "/" ? [] : base.slice(1).split("/")).find((part) => {
+		const kind = classifyUrlSegment(part).kind;
+		return kind === "catch-all" || kind === "optional-catch-all";
+	});
+	if (!ambiguous) return;
+	throw new Error(`Build error: intercepting route below a catch-all segment.\n  Directory: app/${childPath}\n  Intercepted base: ${base}\nA catch-all (${ambiguous}) matches a number of URL segments that varies per request, so "${marker}" cannot identify which segment of a target pathname the interception starts at — the modal would open at one depth and silently not at another.\nMove the interception above the catch-all, or use a marker that climbs past it ((..) or (...)).\nSee design/07-routing.md §"Intercepting Routes".`);
+}
+/**
+* Reject a catch-all inside an intercepting subtree that has directories
+* below it.
+*
+* A catch-all consumes the whole remaining path, so nothing under it is
+* reachable — `matchUrlParts` only accepts a catch-all as a terminal leaf and
+* never descends past one. Rewrite generation is not so strict: it walks the
+* subtree and emits `/feed/[...rest]/child`, and `pathnameMatchesPattern`
+* returns as soon as it reaches the catch-all without ever looking at
+* `child`. So the rewrite matches the navigation and then no renderer exists
+* — the TIM-1278 failure mode reached by a different route, with the user
+* served the page they were already on under a changed URL.
+*
+* The check covers the whole intercepting subtree, not just the intercepted
+* segment: `(.)photo/[...rest]/child` emits `/feed/photo/[...rest]/child` and
+* hijacks `/feed/photo/a/b` by exactly the same mechanism. And it does not
+* exempt a catch-all that carries its own page — that one does render, but
+* the rewrite generated for the unreachable descendant is broader than any
+* route in the tree, so the tail modal fires on navigations no directory
+* describes.
+*
+* Outside a slot the same shape merely 404s, which is why the general rule is
+* tracked separately (TIM-1286); here it is unsafe, and it only became
+* reachable when catch-all intercepted segments started matching at all
+* (TIM-1281).
+*
+* The walk descends `children` and not `slots`, mirroring
+* `collectLeavesWithRewrites` exactly: what this rejects is precisely the set
+* of paths rewrite generation emits, so the two cannot disagree about which
+* shapes exist. A slot nested inside an intercepting subtree produces no
+* rewrite and so cannot hijack anything.
+*/
+function assertInterceptedCatchAllsAreTerminal(node, nodePath) {
+	const { segmentType, segmentName } = effectiveUrlSegment(node);
+	if ((segmentType === "catch-all" || segmentType === "optional-catch-all") && node.children.length > 0) throw new Error(`Build error: catch-all with nested segments inside an intercepting route.\n  Directory: app/${nodePath}\n  Nested: ${node.children.map((c) => c.segmentName).join(", ")}\nA catch-all (${segmentName}) consumes every remaining URL segment, so nothing below it can ever match — but the interception rewrite would still be generated and would hijack the navigation with no page to render.\nMove the nested routes above the catch-all, or intercept a named segment instead.\nSee design/07-routing.md §"Intercepting Routes".`);
+	for (const child of node.children) assertInterceptedCatchAllsAreTerminal(child, `${nodePath}/${child.segmentName}`);
+}
+/**
+* Reject a `route.ts` anywhere inside an intercepting subtree.
+*
+* An interception is a soft-navigation variant of a page — it swaps which
+* page component renders. A route handler returns a `Response` and cannot
+* be an interception target: `walkInterceptedLeaves` visits `node.page`
+* only, so no rewrite is emitted for it, but `isTerminal` in
+* `tree-match.ts` counts both `page` and `route`, so `matchUrlParts` can
+* resolve to the route handler. `slot-interception.ts` then drops the
+* match (`if (!leaf.page) continue`), silently disabling the page's
+* interception. Fail-safe (the canonical route renders) but silent.
+*
+* The walk mirrors `assertInterceptedCatchAllsAreTerminal`: it descends
+* `children` (not `slots`), matching `collectLeavesWithRewrites` exactly.
+*/
+function assertNoRouteHandlersInSubtree(node, nodePath) {
+	if (node.route) throw new Error(`Build error: route handler inside an intercepting route.\n  File: ${node.route.filePath}\n  Directory: app/${nodePath}\nAn intercepting subtree renders a page component on soft navigation — a route handler returns a Response and cannot be an interception target. The route handler would silently shadow the interception: the resolver would match it and then discard it because it has no page, so the modal would stop opening with no diagnostic.\nRemove the route.ts, or move it outside the intercepting subtree.\nSee design/07-routing.md §"Intercepting Routes".`);
+	for (const child of node.children) assertNoRouteHandlersInSubtree(child, `${nodePath}/${child.segmentName}`);
+}
+/**
+* Reject two pages that answer one URL among the interceptors an owner
+* resolves in a single walk.
+*
+* `validateRouteGroupCollisions` in the scanner returns early on an
+* intercepting node, so nothing else validates in here. That exemption exists
+* for a real reason — an interception's computed URL legitimately mirrors the
+* canonical route it replaces, and interceptors at *different* anchors
+* deliberately target one URL, which the resolver then orders (deepest anchor
+* first). But the exemption was broader than its reason. Two shapes slip
+* through it, and they are the same shape seen from two levels:
+*
+*   feed/(.)photo/(a)/page.tsx      feed/@modal/(.)[a]/page.tsx
+*   feed/(.)photo/(b)/page.tsx      feed/@modal/(.)[b]/page.tsx
+*
+* Both pairs answer one URL, and in both `matchUrlParts` resolves the tie by
+* whichever `children` array lists first — so the winner is whichever the
+* filesystem enumerated first, and renaming a directory flips it. That is
+* exactly what `validateRouteGroupCollisions` and
+* `validateAffixedSiblingConflicts` exist to reject for ordinary siblings.
+*
+* **The collision space is the anchor group, not the directory.** An earlier
+* revision ran once per intercepting directory, which sees the left-hand pair
+* and not the right-hand one: those leaves live in two different directories.
+* The space is `groupByInterceptedAnchor`'s output — the same grouping
+* `findInterceptingMatch` hands to one `matchUrlParts` call — so what is
+* validated together is exactly what is resolved together. Interceptors at
+* different anchors stay independent, which is the documented case, and two
+* slots on one owner are two owners and so two spaces.
+*
+* **Two checks, and the difference between them matters.** A duplicate
+* intercepted *pattern* is decided by string equality, which is exact: two
+* leaves with one pattern claim one set of URLs, whatever the precedence rules
+* are. Everything else is decided by asking the matcher — `collision-probe.ts`,
+* the same oracle the main tree and every slot use, so the spaces cannot
+* disagree about whether a pair of pages collides.
+*
+* Not covered: two affixed dynamics that tie on specificity (`(x)/a-[id]` vs
+* `(y)/[slug]-b`, ambiguous only for a part shaped `a-…-b`). No single probe
+* URL exercises both, and `validateAffixedSiblingConflicts` already rejects
+* that pair by affix length — including through groups, inside intercepting
+* subtrees, and between two interceptors sharing an anchor.
+*
+* The shape applies to both interception mechanisms — a slot interceptor and a
+* children-path one produce their leaves through the same walk, and both are
+* resolved by `findInterceptingMatch` — so this is called from the one place in
+* `walkForPlacement` that sees every owner regardless of position.
+*/
+function assertNoInterceptedPatternCollisions(owner, ownerPath) {
+	for (const group of groupByInterceptedAnchor(owner.urlPath, owner.children)) assertAnchorGroupHasNoCollisions(group, ownerPath);
+}
+/**
+* Reject a children-path interceptor and a slot interceptor from the same owner
+* that claim URLs in common.
+*
+* Within one mode the ambiguity is either non-existent (two children-path
+* rewrites are interchangeable, §"Selection Between Owners") or harmless (two
+* slots on one owner both render). Across modes one is a layout swap and the
+* other is a modal overlay, and the walk order picks the children-path shape —
+* making the modal dead, silently and deterministically (TIM-1319).
+*
+* Overlap is a **pattern intersection** test: do two intercepted URL patterns
+* share any concrete URL? This is not the same question the within-mode
+* collision oracle answers. `findOrderDependentCollision` checks whether two
+* candidates in one `matchUrlParts` walk produce different winners when
+* `children` order is reversed — that is, order-dependence. A static segment
+* always beats a dynamic one deterministically (no order-dependence), so
+* `/feed/foo` and `/feed/[id]` pass the oracle even though
+* `pathnameMatchesPattern` — the actual rewrite matcher — accepts both. The
+* pattern intersection test catches that: it walks both patterns segment by
+* segment and asks whether any value satisfies both.
+*
+* The check collects intercepted patterns from children-path interceptors and
+* from each slot's interceptors independently. Slots are checked one at a time
+* so two slot interceptors from *different* slots claiming one URL — the legal
+* "two slots on one owner" case — are never compared.
+*/
+function assertNoCrossModeClaims(node, ownerPath) {
+	const childrenLeaves = [];
+	for (const child of node.children) {
+		if (child.segmentType !== "intercepting" || !child.interceptionMarker || !child.interceptedSegmentName) continue;
+		walkInterceptedLeaves(child, computeInterceptedUrlBase(node.urlPath, child.interceptionMarker, child.interceptedSegmentName), [child], (page, leaf) => {
+			childrenLeaves.push({
+				pattern: leaf.interceptedPattern,
+				filePath: page.filePath
+			});
+		});
+	}
+	if (childrenLeaves.length === 0) return;
+	const owner = ownerPath || "(app root)";
+	for (const slot of Object.values(node.slots)) {
+		const slotLeaves = [];
+		for (const child of slot.children) {
+			if (child.segmentType !== "intercepting" || !child.interceptionMarker || !child.interceptedSegmentName) continue;
+			walkInterceptedLeaves(child, computeInterceptedUrlBase(node.urlPath, child.interceptionMarker, child.interceptedSegmentName), [child], (page, leaf) => {
+				slotLeaves.push({
+					pattern: leaf.interceptedPattern,
+					filePath: page.filePath
+				});
+			});
+		}
+		for (const cl of childrenLeaves) for (const sl of slotLeaves) {
+			const overlap = interceptedPatternsOverlap(cl.pattern, sl.pattern);
+			if (overlap !== null) throwCrossModeClaim(owner, overlap, cl.filePath, sl.filePath);
+		}
+	}
+}
+function throwCrossModeClaim(owner, url, childFile, slotFile) {
+	throw new Error(`Build error: a children-path interception and a slot interception both claim the same URL.
+  Owner:    app/${owner}\n  URL:      ${url}\n  Children: ${childFile}\n  Slot:     ${slotFile}\nThe children-path interceptor replaces the owner's children (layout swap) while the slot interceptor renders inside a parallel slot (modal overlay). Both apply from the same scope at the same URL, and which one wins would depend on internal walk order rather than an explicit rule.\nRemove one of the two, or move them to different scopes.\nSee design/07-routing.md §"Selection Between Owners".`);
+}
+/**
+* The URL-matching identity of an intercepting node, as a node.
+*
+* `matchUrlParts` reads `segmentType` directly and knows nothing about
+* interception, so a marker'd directory has to be handed to it under the
+* identity of the segment it intercepts — `(.)[id]` as `[id]`. Priority
+* ordering, affix stripping and catch-all handling then come from the shared
+* walker rather than from a second classifier here.
+*
+* Shared with `findInterceptingMatch` for the same reason the grouping is: the
+* collision space is the resolver's synthetic anchor parent, so its children
+* have to carry the identity the resolver gives them or the validator would be
+* probing a tree that does not match the one served. The caller keeps its own
+* map back to the real node — the proxy is a matching identity, not a
+* replacement (tree paths still need the directory name).
+*/
+function interceptorProxy(node) {
+	return {
+		...node,
+		...effectiveUrlSegment(node)
+	};
+}
+function assertAnchorGroupHasNoCollisions(group, ownerPath) {
+	const { base } = group;
+	const owner = ownerPath || "(app root)";
+	const proxies = group.interceptors.map(interceptorProxy);
+	const anchorNode = {
+		segmentName: "",
+		segmentType: "static",
+		urlPath: base,
+		children: proxies,
+		slots: {}
+	};
+	const patterns = /* @__PURE__ */ new Map();
+	const probeLeaves = [];
+	for (const proxy of proxies) walkInterceptedLeaves(proxy, joinInterceptedBase(base, proxy.segmentName), [proxy], (page, leaf) => {
+		const duplicate = patterns.get(leaf.interceptedPattern);
+		if (duplicate) throw new Error(`Build error: route collision between intercepting routes — two pages intercept the same URL.\n  Owner:            app/${owner}\n  Intercepted base: ${base}\n  URL:              ${leaf.interceptedPattern}\n  File 1:           ${duplicate}\n  File 2:           ${page.filePath}\nA route group is transparent for matching, so moving a page into one does not give it a URL of its own — these two claim the same one. Rename or move one of them.\nSee design/07-routing.md §"Collisions Among Intercepting Routes".`);
+		patterns.set(leaf.interceptedPattern, page.filePath);
+		probeLeaves.push({
+			filePath: page.filePath,
+			chain: leaf.chain
+		});
+	});
+	const collision = findOrderDependentCollision(anchorNode, probeLeaves, base);
+	if (collision) throw new Error(`Build error: route collision between intercepting routes — two pages answer the same URL.\n  Owner:            app/${owner}\n  Intercepted base: ${base}\n  URL:              ${collision.url}\n  File 1:           ${collision.first}\n  File 2:           ${collision.second}\nBoth match it, so which one renders would be decided by filesystem enumeration order — renaming a route group can flip it. Rename or move one of them.\nPages are compared by the URLs they match, not by how they are spelled: [id] and [slug] match the same URLs, and an optional catch-all also matches with zero segments.\nIntercepting directories based at *different* URLs may target one page — the resolver tries the deepest first — so this rejects only an ambiguity among the ones based at ${base}.\nSee design/07-routing.md §"Collisions Among Intercepting Routes".`);
+}
+function walkForPlacement(node, path, ctx) {
+	for (const child of node.children) {
+		const childPath = path ? `${path}/${child.segmentName}` : child.segmentName;
+		if (child.segmentType === "intercepting") {
+			const marker = child.interceptionMarker ?? "(.)";
+			if (ctx.inInterceptingSubtree) throw new Error(`Build error: intercepting route nested inside another intercepting route.\n  Directory: app/${childPath}\nAn intercepting directory (${marker}) resolves against the URL its own parent renders at, and an intercepting subtree has no such URL — nothing walks it, so the rewrite would match the navigation and then have nothing to render.\nSee design/07-routing.md §"Intercepting Routes".`);
+			if (ctx.inSlotSubtree && !ctx.parentIsSlot) throw new Error(`Build error: intercepting route inside a parallel slot but not directly under it.\n  Directory: app/${childPath}\nAn intercepting directory (${marker}) inside an @slot must be a *direct* child of that slot, e.g. app/feed/@modal/${child.segmentName}/page.tsx. The slot resolver scans the slot's direct children only; elsewhere the rewrite would match the navigation and then have nothing to render.\nSee design/07-routing.md §"Intercepting Routes".`);
+			if (!ctx.parentIsSlot && ctx.ancestorsBindParams) assertOwnerChainBindsNoParams(childPath, marker);
+			if (!ctx.parentIsSlot && !node.layout) assertOwnerHasLayout(path, childPath);
+			assertInterceptedBaseIsCountable(child, node.urlPath, childPath);
+			assertInterceptedCatchAllsAreTerminal(child, childPath);
+			assertNoRouteHandlersInSubtree(child, childPath);
+		}
+		walkForPlacement(child, childPath, {
+			parentIsSlot: false,
+			inSlotSubtree: ctx.inSlotSubtree,
+			inInterceptingSubtree: ctx.inInterceptingSubtree || child.segmentType === "intercepting",
+			ancestorsBindParams: ctx.ancestorsBindParams || !!child.paramName
+		});
+	}
+	assertNoInterceptedPatternCollisions(node, path);
+	for (const [slotName, slotNode] of Object.entries(node.slots)) walkForPlacement(slotNode, path ? `${path}/@${slotName}` : `@${slotName}`, {
+		parentIsSlot: true,
+		inSlotSubtree: true,
+		inInterceptingSubtree: ctx.inInterceptingSubtree,
+		ancestorsBindParams: false
+	});
+	assertNoCrossModeClaims(node, path);
+}
+/**
+* Recursively walk the segment tree to find intercepting routes.
+*
+* `ancestors` deliberately excludes slot nodes: a slot doesn't appear in a
+* matched route chain, so the last entry is always the nearest chain-visible
+* ancestor — the segment that owns the slot, and therefore the segment whose
+* presence in the source route gates the interception.
+*
+* Intercepting nodes only ever appear as a direct child of a slot or of an
+* ordinary chain segment in a valid tree; `validateInterceptionPlacement`
+* rejects every other placement at scan time, so this walk never has to
+* decide what an unrenderable intercepting node should generate.
+*
+* `parentIsSlot` is what distinguishes the two shapes, and it is the only
+* input that does: the owner, the scope and the intercepted pattern are all
+* computed identically either way.
+*/
+function walkForInterceptions(node, ancestors, parentIsSlot, rewrites) {
+	for (const child of node.children) if (child.segmentType === "intercepting" && child.interceptionMarker) collectFromInterceptingNode(child, ancestors, parentIsSlot, rewrites);
+	else walkForInterceptions(child, [...ancestors, child], false, rewrites);
+	for (const slot of Object.values(node.slots)) walkForInterceptions(slot, ancestors, true, rewrites);
+}
+/**
+* For an intercepting segment, find all leaf pages in its sub-tree and
+* generate rewrite rules for each.
+*/
+function collectFromInterceptingNode(interceptingNode, ancestors, parentIsSlot, rewrites) {
+	const marker = interceptingNode.interceptionMarker;
+	const segmentName = interceptingNode.interceptedSegmentName;
+	const parentUrlPath = ancestors[ancestors.length - 1].urlPath;
+	const interceptedUrlBase = computeInterceptedUrlBase(parentUrlPath, marker, segmentName);
+	const ancestorPaths = computeSegmentTreePaths(ancestors);
+	const interceptingScope = ancestorPaths[ancestorPaths.length - 1];
+	collectLeavesWithRewrites(interceptingNode, interceptedUrlBase, parentIsSlot ? {
+		mode: "slot",
+		interceptingPrefix: parentUrlPath,
+		interceptingScope
+	} : {
+		mode: "children",
+		interceptingScope
+	}, rewrites);
+}
+/**
+* Walk an intercepting sub-tree and visit every page-bearing node with the URL
+* pattern it is intercepted at, and URLs that reach it.
+*
+* Route groups are transparent, exactly as they are in the main tree — which
+* is what makes two groups under one interceptor able to claim one URL, and is
+* why the collision validator has to walk the same shape this does.
+*
+* Rewrite generation and that validator are the two callers. They share this
+* walk rather than each having their own so they cannot disagree about which
+* URLs an interceptor claims: a leaf the validator did not see is a rewrite
+* nobody checked, and a leaf only the validator sees is a build error for a
+* route that does not exist. Slots are not descended, here or in either caller
+* — a slot nested inside an intercepting subtree produces no rewrite.
+*
+* That answers the rewrite question only, and the resolution question is
+* answered elsewhere: `validateSlotsInsideInterceptingSubtree`
+* (`collision-spaces.ts`) gives each such slot its own collision space, and
+* `validateSlotPlacement` (`slot-placement.ts`) rejects the ones no renderer
+* reaches. Between them the slots this walk skips are covered; do not conclude
+* from the skip here that they are unvalidated (TIM-1308, TIM-1311).
+*
+* The walk reports the chain of URL-contributing nodes rather than building
+* probe URLs itself: choosing a probe value means running the matcher over the
+* whole subtree, which is the validator's business and not something rewrite
+* generation should be paying for or passing dummy arguments around.
+*/
+function walkInterceptedLeaves(node, interceptedUrlPath, chain, visit) {
+	if (node.page) visit(node.page, {
+		interceptedPattern: interceptedUrlPath,
+		chain
+	});
+	for (const child of node.children) {
+		const isGroup = child.segmentType === "group";
+		walkInterceptedLeaves(child, isGroup ? interceptedUrlPath : `${interceptedUrlPath}/${child.segmentName}`, isGroup ? chain : [...chain, child], visit);
+	}
+}
+/**
+* Recursively find leaf pages in an intercepting sub-tree and generate
+* rewrite rules for each.
+*/
+function collectLeavesWithRewrites(node, interceptedUrlPath, shape, rewrites) {
+	walkInterceptedLeaves(node, interceptedUrlPath, [], (_page, leaf) => {
+		rewrites.push({
+			...shape,
+			interceptedPattern: leaf.interceptedPattern
+		});
+	});
+}
+/**
+* How many URL levels a marker climbs from the slot owner to reach the
+* intercepted segment, or `'root'` for a marker that climbs all the way.
+*
+* Level counting operates on URL path segments, NOT filesystem directories.
+* Route groups and parallel slots are already excluded from urlPath (they
+* don't add URL depth), so (..) correctly climbs visible segments. This
+* avoids the Vinext bug where path.dirname() on filesystem paths would
+* waste climbs on invisible route groups.
+*
+* Used only by `computeInterceptedBase` below — both rewrite generation and
+* the slot resolver go through that, so the arithmetic exists once.
+*/
+function interceptionClimb(marker) {
+	switch (marker) {
+		case "(.)": return 0;
+		case "(..)": return 1;
+		case "(..)(..)": return 2;
+		case "(...)": return "root";
+	}
+}
+/**
+* Compute the base URL that an intercepting route intercepts, given the
+* parent's URL path and the interception marker.
+*
+* - (.)  — same level: parent's URL path
+* - (..) — one level up: parent's parent URL path
+* - (...) — root level: /
+* - (..)(..) — two levels up: parent's grandparent URL path
+*
+* The result is a URL **pattern**, not a URL — `parentUrlPath` carries the
+* directory names, so a dynamic ancestor appears as `/docs/[...path]`.
+* Rewrite generation wants exactly that. The slot resolver imports this to
+* locate the intercepted segment in a concrete target pathname, and must
+* therefore account for a bracket part standing for a different number of
+* URL parts than itself (TIM-1281).
+*
+* Climbing past the root clamps to `/` rather than erroring, so generation
+* and resolution never disagree about what an over-reaching marker
+* intercepts.
+*/
+/**
+* The URL pattern an intercepting directory's own page sits at — its
+* `computeInterceptedBase` joined with the segment it intercepts.
+*
+* The root case is why this is a function rather than a template literal at
+* each caller: a base of `/` must not produce `//photo`. Rewrite generation
+* and the collision validator both start their walk from this value, so the
+* two describe the same URLs by construction.
+*/
+function computeInterceptedUrlBase(parentUrlPath, marker, interceptedSegmentName) {
+	return joinInterceptedBase(computeInterceptedBase(parentUrlPath, marker), interceptedSegmentName);
+}
+/**
+* An intercepted base joined with one segment beneath it.
+*
+* The whole content of the "function rather than a template literal" rule
+* above: a base of `/` must not produce `//photo`. The collision validator has
+* the base in hand already (it groups by it) and joins through this rather than
+* re-deriving it from an owner path, so both callers spell the root case once.
+*/
+function joinInterceptedBase(base, segmentName) {
+	return base === "/" ? `/${segmentName}` : `${base}/${segmentName}`;
+}
+function computeInterceptedBase(parentUrlPath, marker) {
+	const climb = interceptionClimb(marker);
+	if (climb === "root") return "/";
+	const parts = parentUrlPath.split("/").filter(Boolean);
+	for (let i = 0; i < climb; i++) parts.pop();
+	return parts.length === 0 ? "/" : `/${parts.join("/")}`;
+}
+//#endregion
+//#region src/routing/collision-spaces.ts
+/**
+* Validate that no two pages/routes in one collision space answer the same URL.
+*
+* Two route groups like (auth)/login/page.tsx and (marketing)/login/page.tsx both claim
+* /login — the scanner must detect and reject this at build time.
+*
+* Each parallel slot is validated as its OWN collision space: a slot's pages
+* intentionally share URL paths with the parent tree (that's the point of
+* parallel routes), but two route groups INSIDE one slot claiming the same
+* URL — e.g. @side/(a)/x/page.tsx + @side/(b)/x/page.tsx — still collide.
+*/
+function validateRouteGroupCollisions(root) {
+	validateCollisionSpace(root, "", root.urlPath);
+}
+/**
+* Validate one collision space — the main tree, or one parallel slot.
+*
+* **Two checks, and the difference between them matters.** Two leaves at the
+* same `urlPath` are decided by string equality, which is exact and needs no
+* probing: `(auth)/login` and `(marketing)/login` claim one set of URLs
+* whatever the precedence rules are, and naming the shared path is the clearest
+* thing to tell the author.
+*
+* Everything else is decided by asking the matcher, through the shared oracle
+* in `collision-probe.ts` (TIM-1308). Comparing `urlPath` spellings misses
+* every pair that matches the same URLs while being *spelled* differently:
+* `x/(a)/[id]` beside `x/(b)/[slug]` are two bare dynamics in one priority
+* tier, and `x/(a)/page.tsx` beside `x/(b)/[[...rest]]` both answer `/x`
+* because an optional catch-all also matches zero parts. Both built before
+* TIM-1308 with filesystem enumeration order deciding which page renders,
+* which is precisely what this validator and `validateAffixedSiblingConflicts`
+* exist to reject.
+*
+* Segment *kinds* stay distinct without any special-casing here, because the
+* oracle inherits `matchNode`'s priority ordering: `x/(a)/[id]` beside
+* `x/(b)/[...rest]` resolves the same way in either `children` order, so it is
+* not reported. So does an affixed sibling against a bare one; the
+* equal-specificity affix tie is `validateAffixedSiblingConflicts`' job, and
+* duplicating it here would double-report.
+*/
+function validateCollisionSpace(spaceRoot, segmentPath, base) {
+	const leaves = [];
+	collectRoutableLeaves(spaceRoot, /* @__PURE__ */ new Map(), segmentPath, [], leaves, base);
+	const collision = findOrderDependentCollision(spaceRoot, leaves, base);
+	if (!collision) return;
+	throw new Error(`Build error: route collision — two pages/routes answer the same URL.\n  URL:    ${collision.url}\n  File 1: ${collision.first}\n  File 2: ${collision.second}\nBoth match it, so which one renders would be decided by filesystem enumeration order — renaming a route group can flip it. Rename or move one of them.\nRoutes are compared by the URLs they match, not by how they are spelled: [id] and [slug] match the same URLs, and an optional catch-all also matches with zero segments.`);
+}
+/**
+* Walk one collision space and collect its routable leaves (page or route
+* files), throwing on an exact `urlPath` collision. Each slot recurses as its
+* OWN space — slots are parallel routes that intentionally share URL paths with
+* their parent tree, but collisions within a single slot are real errors.
+*
+* The early return at an intercepting node drops that subtree's own pages from
+* this space, but not its slots: a slot is its own collision space wherever it
+* sits, so `validateSlotsInsideInterceptingSubtree` picks those up before
+* returning.
+*
+* `chain` accumulates the URL-contributing nodes from the space root down, for
+* the probe oracle. Route groups are excluded because they are transparent for
+* matching, and the space root itself is excluded because `matchUrlParts`
+* matches parts against its *children* — the root consumes nothing.
+*/
+function collectRoutableLeaves(node, seen, segmentPath, chain, leaves, base) {
+	const currentPath = segmentPath ? `${segmentPath}/${node.segmentName}` : node.segmentName || "(root)";
+	if (node.segmentType === "intercepting") {
+		validateSlotsInsideInterceptingSubtree(node, currentPath, interceptedBaseOf(node, node.urlPath));
+		return;
+	}
+	const routableFile = node.page ?? node.route;
+	if (routableFile) {
+		const existing = seen.get(node.urlPath);
+		if (existing) throw new Error(`Build error: route collision — multiple route groups produce a page/route at the same URL path.\n  URL path: ${urlFromChain(base, chain)}\n  File 1:   ${existing.filePath} (via ${existing.segmentPath})\n  File 2:   ${routableFile.filePath} (via ${currentPath})\nEach URL path must map to exactly one page or route handler. Rename or move one of the conflicting files.`);
+		seen.set(node.urlPath, {
+			filePath: routableFile.filePath,
+			segmentPath: currentPath
+		});
+		leaves.push({
+			filePath: routableFile.filePath,
+			chain
+		});
+	}
+	for (const child of node.children) collectRoutableLeaves(child, seen, currentPath, child.segmentType === "group" ? chain : [...chain, child], leaves, base);
+	for (const slotNode of Object.values(node.slots)) validateCollisionSpace(slotNode, currentPath, urlFromChain(base, chain));
+}
+/**
+* Validate every parallel slot nested anywhere inside an intercepting subtree.
+*
+* Two walks each skip these slots for their own good reason, and together they
+* left them checked by nothing: `collectRoutableLeaves` returns at the
+* intercepting node before it reaches them, and `walkInterceptedLeaves`
+* deliberately does not descend slots — correct for rewrite generation, since a
+* slot inside an intercepting subtree produces no rewrite. But "produces no
+* rewrite" answers the rewrite question and not the resolution one, so
+* `@side/(a)/x/page.tsx` beside `@side/(b)/x/page.tsx` under an interceptor
+* built with filesystem order picking the page — the ordinary per-slot
+* collision that fails the build anywhere else in the tree (codex, on PR #1002).
+*
+* A slot is its own collision space wherever it sits, so each one is validated
+* as one.
+*
+* **Which interception shape this still applies to.** TIM-1311 answered the
+* question this was written under — whether such a slot renders at all — and
+* the answer is per-shape:
+*
+* - **Children path** (`(browse)/(...)photo/@side`): the intercepting node
+*   joins the main route chain, so `route-element-builder.ts` resolves slots on
+*   it and below it like any other chain segment. They render, and this is the
+*   space where the check is load-bearing.
+* - **Modal** (`feed/@modal/(.)photo/@side`): the slot sits inside another
+*   slot's subtree, which no renderer descends for slots — so it never renders,
+*   and `validateSlotPlacement` now rejects the placement before this runs.
+*   That rule subsumes this one for the modal shape rather than conflicting
+*   with it, exactly as anticipated.
+*
+* So this walk is reached only for children-path interceptors in a valid tree.
+* It is not narrowed to them: the rule it states — a slot is its own collision
+* space wherever it sits — is shape-independent, and making it conditional on a
+* property the placement validator already guarantees would just be a second
+* place for the two to disagree.
+*
+* The walk covers the whole subtree, not just the interceptor's direct slot
+* children: `(...)photo/[id]/@side` is reached by neither walk for exactly the
+* same reason as `(...)photo/@side`.
+*/
+function validateSlotsInsideInterceptingSubtree(node, segmentPath, base) {
+	for (const slotNode of Object.values(node.slots)) validateCollisionSpace(slotNode, segmentPath, base);
+	for (const child of node.children) validateSlotsInsideInterceptingSubtree(child, `${segmentPath}/${child.segmentName}`, childInterceptedBase(child, base));
+}
+/**
+* The URL a leaf answers, built from its space's base and its own chain.
+*
+* Read instead of `node.urlPath` because `urlPath` inside an intercepting
+* subtree is parent-relative and is not an address — the collision URL has to
+* be one the author can actually find. Outside an intercepting subtree the two
+* are identical by construction: the base is the space root's `urlPath` and the
+* chain is every URL-contributing segment below it.
+*/
+function urlFromChain(base, chain) {
+	if (chain.length === 0) return base || "/";
+	const tail = chain.map((n) => n.segmentName).join("/");
+	return `${base === "/" ? "" : base}/${tail}`;
+}
+/**
+* The intercepted URL an intercepting directory's own page sits at.
+*
+* `urlPath` inside an intercepting subtree is deliberately parent-relative and
+* is **not** an address (see design/07-routing.md §"Why urlPath Stays
+* Parent-Relative Inside an Intercepting Subtree"), so a collision reported
+* from one names a URL the author cannot find. The intercepted base is the real
+* address, and it is what rewrite generation and the interception collision
+* validator both already use.
+*/
+function interceptedBaseOf(node, ownerUrlPath) {
+	return computeInterceptedUrlBase(ownerUrlPath, node.interceptionMarker ?? "(.)", node.interceptedSegmentName ?? node.segmentName);
+}
+/**
+* Extend an intercepted base by one child segment.
+*
+* Route groups are transparent and contribute nothing. A nested intercepting
+* node re-bases from its own marker rather than appending — that tree is
+* rejected by `validateInterceptionPlacement`, but collision validation runs
+* first, so it still has to produce a sensible URL rather than one containing a
+* literal "(.)b".
+*/
+function childInterceptedBase(child, base) {
+	if (child.segmentType === "group") return base;
+	if (child.segmentType === "intercepting") return interceptedBaseOf(child, base);
+	return base === "/" ? `/${child.segmentName}` : `${base}/${child.segmentName}`;
+}
+//#endregion
+//#region src/routing/slot-placement.ts
+/**
+* Reject every parallel slot that no renderer reaches.
+*
+* **Where slots are resolved.** Two places read `segment.slots`, and both walk
+* the main route chain: `route-element-builder.ts` (the RSC render).
+* It is not reachable from inside a slot. The slot's own
+* subtree is rendered by `slot-resolver.ts`, which walks the slot's matched
+* chain to apply that chain's layouts, error boundaries and access gates
+* (`wrapWithIntermediateSegments`, `wrapWithLayout`) and never reads `.slots`
+* on any of those nodes. So `app/feed/@modal/photo/@side/page.tsx` and
+* everything below it is dead: the file is scanned, typed, code-split and
+* shipped, and no request can render it.
+*
+* That is the TIM-1278 failure — a directory that silently never renders —
+* and the reason it is a build error rather than a documented limit is that
+* nothing at request time can report it. A slot that does not match renders
+* `default.tsx` or `null`, which is exactly what a slot the resolver never
+* looked at also produces, so the author sees the *designed* behaviour of a
+* non-matching slot and has no signal to distinguish it from a slot that
+* cannot match at all.
+*
+* **Interception is incidental.** TIM-1311 arrived as
+* `feed/@modal/(.)photo/@side`, and the interception contributes nothing: the
+* identical `feed/@modal/photo/@side` never renders either, for the same
+* reason and with no marker anywhere. Rejecting only the intercepting spelling
+* would have drawn a line the author cannot see from the directory names.
+*
+* The children-path interception shape is **not** affected and must not be:
+* its intercepting node joins the main chain (`server/children-interception.ts`
+* splices `[…owner ancestors, interceptingNode, …descendants]` into an ordinary
+* `RouteMatch`), so `route-element-builder.ts` resolves slots on it and below
+* it exactly as it does for any other chain segment. `(browse)/(...)photo/[id]/@side`
+* renders; `feed/@modal/(.)photo/@side` does not. The discriminator is the slot
+* boundary, which is what this walk tracks — not the marker.
+*/
+function validateSlotPlacement(root) {
+	walkForSlotPlacement(root, "", null);
+}
+/**
+* `enclosingSlotPath` is the `app/`-relative path of the nearest slot at or
+* above `node`, or null on the main chain. It is carried rather than recomputed
+* so the error can name the slot that swallows the offender — "this is inside
+* @modal" is the part of the diagnosis the author cannot see from the offending
+* path alone.
+*/
+function walkForSlotPlacement(node, path, enclosingSlotPath) {
+	for (const [slotName, slotNode] of Object.entries(node.slots)) {
+		const slotPath = path ? `${path}/@${slotName}` : `@${slotName}`;
+		if (enclosingSlotPath !== null) throwNestedSlot(slotPath, enclosingSlotPath);
+		walkForSlotPlacement(slotNode, slotPath, slotPath);
+	}
+	for (const child of node.children) walkForSlotPlacement(child, path ? `${path}/${child.segmentName}` : child.segmentName, enclosingSlotPath);
+}
+function throwNestedSlot(slotPath, enclosingSlotPath) {
+	throw new Error(`Build error: parallel slot nested inside another parallel slot.\n  Directory: app/${slotPath}\n  Inside:    app/${enclosingSlotPath}\nA parallel slot is resolved only for a segment on the matched route chain, and a slot's own subtree is never on that chain — the slot resolver walks the slot's matched chain to apply its layouts, error boundaries and access gates, and never looks at slots declared inside it. So app/${slotPath} and everything below it can never render, and no request-time signal can tell you: an unreachable slot produces exactly what a slot that simply did not match produces.\nDeclare the slot on a segment of the main route chain instead, or move its pages into app/${enclosingSlotPath}'s own subtree.\nSee design/07-routing.md §"Parallel Routes".`);
+}
+//#endregion
+//#region src/routing/scanner.ts
+/**
+* Route discovery scanner.
+*
+* Pure function: (appDir, config) → RouteTree
+*
+* Scans the app/ directory and builds a segment tree recognizing all
+* timber.js file conventions. Does NOT handle request matching — this
+* is discovery only.
+*/
+/**
+* File convention names that use pageExtensions (can be .tsx, .ts, .jsx, .js, .mdx, etc.)
+*/
+var PAGE_EXT_CONVENTIONS = /* @__PURE__ */ new Set([
+	"page",
+	"layout",
+	"error",
+	"default",
+	"denied"
+]);
+/**
+* File convention names that are always .ts/.tsx (never .mdx etc.)
+*/
+var FIXED_CONVENTIONS = /* @__PURE__ */ new Set([
+	"middleware",
+	"access",
+	"route"
+]);
+/**
+* Status-code file patterns:
+* - Exact 3-digit codes: 401.tsx, 429.tsx, 503.tsx
+* - Category catch-alls: 4xx.tsx, 5xx.tsx
+*/
+var STATUS_CODE_PATTERN = /^(\d{3}|[45]xx)$/;
+/**
+* Whether a basename + extension pair is a route-convention file the
+* framework itself imports: page/layout/error/default/denied and
+* global-error on pageExtensions, middleware/access/route/proxy on
+* .ts/.tsx/.js/.jsx only, and status-code files (404, 4xx, …) on
+* pageExtensions or .json — mirroring this scanner's own recognition
+* rules per family.
+*
+* Exported for the analyze classifier so its provisional classification
+* (design/47 §2) derives from the scanner's real conventions instead of
+* a duplicate list that can drift.
+*/
+function isRouteConventionFile(base, ext, pageExtensions = DEFAULT_PAGE_EXTENSIONS) {
+	const isPageExt = pageExtensions.includes(ext);
+	if ((PAGE_EXT_CONVENTIONS.has(base) || base === "global-error") && isPageExt) return true;
+	if ((FIXED_CONVENTIONS.has(base) || base === "proxy") && /^[jt]sx?$/.test(ext)) return true;
+	if (STATUS_CODE_PATTERN.test(base) && (isPageExt || ext === "json")) return true;
+	return false;
+}
+/**
+* Scan the app/ directory and build the route tree.
+*
+* @param appDir - Absolute path to the app/ directory
+* @param config - Scanner configuration
+* @returns The complete route tree
+*/
+function scanRoutes(appDir, config = {}) {
+	const pageExtensions = config.pageExtensions ?? DEFAULT_PAGE_EXTENSIONS;
+	const extSet = new Set(pageExtensions);
+	const tree = { root: createSegmentNode("", "static", "/") };
+	const proxyFile = findFixedFile(appDir, "proxy");
+	if (proxyFile) tree.proxy = proxyFile;
+	const globalErrorFile = findPageExtFile(appDir, "global-error", extSet);
+	if (globalErrorFile) tree.globalError = globalErrorFile;
+	scanSegmentFiles(appDir, tree.root, extSet);
+	scanChildren(appDir, tree.root, extSet);
+	validateSlotPlacement(tree.root);
+	validateRouteGroupCollisions(tree.root);
+	validateDuplicateParamNames(tree.root);
+	validateUniqueBracketForms(tree.root);
+	validateAffixedSiblingConflicts(tree.root);
+	validateInterceptionPlacement(tree.root);
+	return tree;
+}
+/**
+* Create an empty segment node.
+*/
+function createSegmentNode(segmentName, segmentType, urlPath, paramName, interceptionMarker, interceptedSegmentName, paramPrefix, paramSuffix) {
+	return {
+		segmentName,
+		segmentType,
+		urlPath,
+		paramName,
+		paramPrefix,
+		paramSuffix,
+		interceptionMarker,
+		interceptedSegmentName,
+		children: [],
+		slots: {}
+	};
+}
+/**
+* Compute the URL path for a child segment given its parent's URL path.
+* Route groups, slots, and intercepting routes do NOT add URL depth.
+*/
+function computeUrlPath(parentUrlPath, dirName, segmentType) {
+	if (segmentType === "group" || segmentType === "slot" || segmentType === "intercepting") return parentUrlPath;
+	return `${parentUrlPath === "/" ? "" : parentUrlPath}/${dirName}`;
+}
+/**
+* Scan a directory for file conventions and populate the segment node.
+*/
+function scanSegmentFiles(dirPath, node, extSet) {
+	let entries;
+	try {
+		entries = readdirSync(dirPath);
+	} catch (err) {
+		swallow(err, `scanSegmentFiles: unreadable directory ${dirPath}`, { level: "warn" });
+		return;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dirPath, entry);
+		try {
+			if (statSync(fullPath).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const ext = extname(entry).slice(1);
+		const name = basename(entry, `.${ext}`);
+		if (PAGE_EXT_CONVENTIONS.has(name) && extSet.has(ext)) {
+			const key = name;
+			const existing = node[key];
+			if (existing) throwDuplicateConvention(name, existing.filePath, fullPath);
+			node[key] = {
+				filePath: fullPath,
+				extension: ext
+			};
+			continue;
+		}
+		if (FIXED_CONVENTIONS.has(name) && /^[jt]sx?$/.test(ext)) {
+			const key = name;
+			const existing = node[key];
+			if (existing) throwDuplicateConvention(name, existing.filePath, fullPath);
+			node[key] = {
+				filePath: fullPath,
+				extension: ext
+			};
+			continue;
+		}
+		if (STATUS_CODE_PATTERN.test(name) && ext === "json") {
+			if (!node.jsonStatusFiles) node.jsonStatusFiles = {};
+			node.jsonStatusFiles[name] = {
+				filePath: fullPath,
+				extension: ext
+			};
+			continue;
+		}
+		if (STATUS_CODE_PATTERN.test(name) && extSet.has(ext)) {
+			if (!node.statusFiles) node.statusFiles = {};
+			const existing = node.statusFiles[name];
+			if (existing) throwDuplicateConvention(name, existing.filePath, fullPath);
+			node.statusFiles[name] = {
+				filePath: fullPath,
+				extension: ext
+			};
+			continue;
+		}
+		const metaInfo = classifyMetadataRoute(entry);
+		if (metaInfo) {
+			if (!metaInfo.nestable && node.segmentName !== "") throw new Error(`Build error: '${name}' is a root-only metadata convention and must be in the app root directory.\n  File: ${fullPath}\n  Move this file to the app root (not a route group or nested segment).`);
+			if (!node.metadataRoutes) node.metadataRoutes = {};
+			const existing = node.metadataRoutes[name];
+			if (existing) {
+				const existingIsDynamic = isDynamicMetadataExtension(name, existing.extension);
+				const newIsDynamic = isDynamicMetadataExtension(name, ext);
+				if (existingIsDynamic === newIsDynamic) throwDuplicateConvention(name, existing.filePath, fullPath);
+				if (newIsDynamic) node.metadataRoutes[name] = {
+					filePath: fullPath,
+					extension: ext
+				};
+			} else node.metadataRoutes[name] = {
+				filePath: fullPath,
+				extension: ext
+			};
+		}
+	}
+	if (node.route && node.page) throw new Error(`Build error: route.ts and page.* cannot coexist in the same segment.\n  route.ts: ${node.route.filePath}\n  page:     ${node.page.filePath}\nA URL is either an API endpoint or a rendered page, not both.`);
+}
+/**
+* Throw a build error for two files claiming the same convention slot in
+* one segment (e.g. page.tsx + page.jsx). Which file readdir returns first
+* is platform-dependent (APFS sorts entries, ext4 does not) — silently
+* picking one would let macOS dev and Linux CI serve different
+* implementations of the same route.
+*/
+function throwDuplicateConvention(convention, firstPath, secondPath) {
+	throw new Error(`Build error: duplicate '${convention}' files in the same route segment.\n  File 1: ${firstPath}\n  File 2: ${secondPath}\nEach segment may define '${convention}' at most once. Remove one of the files.`);
+}
+/**
+* Recursively scan child directories and build the segment tree.
+*/
+function scanChildren(dirPath, parentNode, extSet) {
+	let entries;
+	try {
+		entries = readdirSync(dirPath);
+	} catch (err) {
+		swallow(err, `scanChildren: unreadable directory ${dirPath}`, { level: "warn" });
+		return;
+	}
+	for (const entry of entries) {
+		const fullPath = join(dirPath, entry);
+		try {
+			if (!statSync(fullPath).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		if (ENCODED_SEPARATOR_RE.test(entry)) throw new Error(`Build error: directory name contains an encoded path delimiter (%2F or %5C).\n  Directory: ${fullPath}\nEncoded separators in directory names cause route collisions when decoded. Rename the directory to remove the encoded delimiter.`);
+		if (NULL_BYTE_RE.test(entry)) throw new Error(`Build error: directory name contains an encoded null byte (%00).\n  Directory: ${fullPath}\nEncoded null bytes in directory names are not allowed. Rename the directory to remove the null byte encoding.`);
+		const { type, paramName, paramPrefix, paramSuffix, interceptionMarker, interceptedSegmentName } = classifySegment(entry);
+		if (type === "private") continue;
+		const childNode = createSegmentNode(entry, type, computeUrlPath(parentNode.urlPath, entry, type), paramName, interceptionMarker, interceptedSegmentName, paramPrefix, paramSuffix);
+		scanSegmentFiles(fullPath, childNode, extSet);
+		scanChildren(fullPath, childNode, extSet);
+		if (type === "slot") {
+			const slotName = entry.slice(1);
+			parentNode.slots[slotName] = childNode;
+		} else parentNode.children.push(childNode);
+	}
+}
+/**
+* Validate that no route chain contains duplicate dynamic param names.
+*
+* Example violation:
+*   app/[id]/items/[id]/page.tsx — 'id' appears twice in the ancestor chain.
+*
+* Route groups are transparent — params accumulate through them.
+* Slots are independent — duplicate detection does NOT cross slot boundaries.
+*
+* See design/07-routing.md §"Duplicate Param Name Detection"
+*/
+function validateDuplicateParamNames(root) {
+	walkForDuplicateParams(root, /* @__PURE__ */ new Map());
+}
+/**
+* Recursively walk the segment tree, tracking seen param names → segment paths.
+* Throws on the first duplicate found.
+*/
+function walkForDuplicateParams(node, seen) {
+	const { paramName } = effectiveUrlSegment(node);
+	if (paramName) {
+		const existing = seen.get(paramName);
+		if (existing) throw new Error(`[timber] Duplicate param name '${paramName}' in route chain.\n  First defined at: ${existing}\n  Duplicate at: ${node.urlPath || "/"}\n  Rename one of the segments to avoid ambiguity.`);
+		seen = new Map(seen);
+		seen.set(paramName, node.urlPath || "/");
+	}
+	for (const child of node.children) walkForDuplicateParams(child, seen);
+	for (const slotNode of Object.values(node.slots)) walkForDuplicateParams(slotNode, new Map(seen));
+}
+/**
+* Validate that each param name uses a single bracket form across the entire route tree.
+*
+* Different bracket forms produce different types:
+*   [id]      → string
+*   [...id]   → string[]
+*   [[...id]] → string[] | undefined
+*
+* If the same param name appears with multiple forms, the no-argument
+* getSegmentParams() / useSegmentParams() return type becomes ambiguous.
+*
+* Same name + same form across different routes is fine and expected.
+*/
+function validateUniqueBracketForms(root) {
+	collectBracketForms(root, /* @__PURE__ */ new Map());
+}
+function collectBracketForms(node, forms) {
+	const { paramName, segmentType } = effectiveUrlSegment(node);
+	if (paramName && segmentType !== "static" && segmentType !== "group") {
+		const existing = forms.get(paramName);
+		if (existing && existing.segmentType !== segmentType) {
+			const bracketExamples = {
+				"dynamic": `[${paramName}]`,
+				"catch-all": `[...${paramName}]`,
+				"optional-catch-all": `[[...${paramName}]]`
+			};
+			throw new Error(`[timber] Param name '${paramName}' uses multiple bracket forms.\n  ${bracketExamples[existing.segmentType] ?? existing.segmentType} at: ${existing.urlPath}\n  ${bracketExamples[segmentType] ?? segmentType} at: ${node.urlPath || "/"}\n  Each param name must use a single bracket form across all routes.\n  Rename one of the segments to fix this (e.g., [${paramName}] → [${paramName}Id]).`);
+		}
+		if (!existing) forms.set(paramName, {
+			segmentType,
+			urlPath: node.urlPath || "/"
+		});
+	}
+	for (const child of node.children) collectBracketForms(child, forms);
+	for (const slotNode of Object.values(node.slots)) collectBracketForms(slotNode, forms);
+}
+/**
+* Validate that no sibling affixed dynamic segments have equal specificity.
+*
+* Among affixed siblings, longer combined prefix+suffix length wins. When two
+* siblings tie (same total affix length), the router would fall back to
+* filesystem scan order — which is platform-dependent. This is a build error.
+*
+* Route groups are URL-transparent, so affixed segments inside different groups
+* at the same level still conflict with each other.
+*
+* Ambiguity requires the two segments to be candidates for the *same* URL
+* part, which is narrower than "same parent" once interception is involved:
+*
+* - Plain children and intercepting children never compete. They are resolved
+*   by different walks — `findSlotMatch` matches the slot subtree (where
+*   `tree-match.ts` ignores intercepting nodes outright) and
+*   `findInterceptingMatch` builds a synthetic parent holding only
+*   interceptors.
+* - Two interceptors compete only at the same anchor. `(.)a-[id]` and
+*   `(..)[slug]-b` in one slot are based at different URL depths, so no
+*   pathname reaches both, and `anchorIndex` rejects the one whose base does
+*   not match the target. Grouping them together would fail the build for a
+*   pair that can never be ambiguous.
+*
+* So candidates are keyed by the position they contend for, then by affix
+* length. See design/07-routing.md §"Priority" and §"Intercepting Routes".
+*/
+function validateAffixedSiblingConflicts(node) {
+	const affixed = collectEffectiveAffixed(node);
+	if (affixed.length >= 2) {
+		const byLength = /* @__PURE__ */ new Map();
+		for (const child of affixed) {
+			const key = `${contentionKey(node, child)}\0${affixLengthOf(child)}`;
+			const group = byLength.get(key);
+			if (group) group.push(child);
+			else byLength.set(key, [child]);
+		}
+		for (const [, group] of byLength) if (group.length >= 2) throw new Error(`Build error: ambiguous affixed dynamic siblings with equal specificity.\n  Parent: ${node.urlPath || "/"}\n  Segments: ${group.map((s) => s.segmentName).join(", ")}\n  Combined prefix+suffix length: ${affixLengthOf(group[0])}\nThe router cannot deterministically choose between these — filesystem scan order is platform-dependent.\nRename one segment to give it a longer or shorter combined affix.`);
+	}
+	for (const child of node.children) validateAffixedSiblingConflicts(child);
+	for (const slotNode of Object.values(node.slots)) validateAffixedSiblingConflicts(slotNode);
+}
+/**
+* The URL position a child contends for, as a comparable key.
+*
+* Plain children contend for the parent's next part. An intercepting child
+* contends for a part determined by its marker's intercepted base, so two
+* markers of different depth are simply different positions — and two markers
+* that compute the *same* base do contend, which is why the key is the base
+* rather than the marker (`(..)` and `(...)` under `/feed` both base at `/`).
+*
+* `groupByInterceptedAnchor` (`routing/interception.ts`) is the canonical
+* statement of that grouping — it is what the resolver walks and what the
+* collision validator checks. This computes the same key from the same
+* `computeInterceptedBase` rather than calling it, because affix ambiguity is
+* decided per *child* and `collectEffectiveAffixed` looks through route groups,
+* so the two do not partition the same set of nodes.
+*/
+function contentionKey(parent, child) {
+	if (child.segmentType !== "intercepting") return "child";
+	return `intercept:${computeInterceptedBase(parent.urlPath, child.interceptionMarker ?? "(.)")}`;
+}
+/** Combined affix length of a node, read through its effective identity. */
+function affixLengthOf(node) {
+	const { paramPrefix, paramSuffix } = effectiveUrlSegment(node);
+	return (paramPrefix?.length ?? 0) + (paramSuffix?.length ?? 0);
+}
+/**
+* Collect affixed dynamic segments that are effective children of a node.
+* Route groups are URL-transparent, so we look through them recursively.
+*
+* Segments are read through `effectiveUrlSegment`, so an intercepting
+* directory counts as the affixed segment it intercepts: `(.)a-[id]` is
+* `a-[id]`. The proxy the slot resolver builds hands those affixes to
+* `matchUrlParts`, whose equal-length sort is not stable across equal
+* specificity — so two intercepting siblings with the same combined affix
+* length would resolve by filesystem enumeration order, which is precisely
+* what this validator exists to prevent for ordinary siblings (TIM-1288).
+*/
+function collectEffectiveAffixed(node) {
+	const result = [];
+	for (const child of node.children) {
+		const { segmentType, paramPrefix, paramSuffix } = effectiveUrlSegment(child);
+		if (segmentType === "dynamic" && (paramPrefix || paramSuffix)) result.push(child);
+		else if (segmentType === "group") result.push(...collectEffectiveAffixed(child));
+	}
+	return result;
+}
+/**
+* Find a fixed-extension file (proxy.ts) in a directory.
+*/
+function findFixedFile(dirPath, name) {
+	for (const ext of ["ts", "tsx"]) {
+		const fullPath = join(dirPath, `${name}.${ext}`);
+		try {
+			if (statSync(fullPath).isFile()) return {
+				filePath: fullPath,
+				extension: ext
+			};
+		} catch {}
+	}
+}
+/**
+* Find a file using the configured page extensions (tsx, ts, jsx, js, mdx, etc.).
+* Used for app-root conventions like global-error that aren't per-segment.
+*/
+function findPageExtFile(dirPath, name, extSet) {
+	for (const ext of extSet) {
+		const fullPath = join(dirPath, `${name}.${ext}`);
+		try {
+			if (statSync(fullPath).isFile()) return {
+				filePath: fullPath,
+				extension: ext
+			};
+		} catch {}
+	}
+}
+//#endregion
+export { matchUrlParts as i, scanRoutes as n, collectInterceptionRewrites as r, isRouteConventionFile as t };
+
+//# sourceMappingURL=scanner-AiazgH_f.js.map