@timber-js/app 0.2.0-alpha.184 → 0.2.0-alpha.186

package/dist/_chunks/cli-schema-sync-CKgHC2MB.js

@@ -0,0 +1,1857 @@
+import { o as __exportAll } from "./dist-BA3u1z3W.js";
+import { i as NULL_BYTE_RE, n as treePathDepth, r as ENCODED_SEPARATOR_RE, s as classifyMetadataRoute, t as computeSegmentTreePaths, u as isDynamicMetadataExtension } from "./segment-keys-BawYuNFO.js";
+import { i as DEFAULT_PAGE_EXTENSIONS, n as classifyUrlSegment, r as effectiveUrlSegment, t as classifySegment } from "./segment-classify-C539Pa2O.js";
+import { h as swallow } from "./logger-N7e5auP0.js";
+import { a as resolveAppDir } from "./plugin-context-DEGLSJs3.js";
+import { basename, extname, join } from "node:path";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } 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.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 is an
+* ambiguity — a children-path interceptor beside a slot one, tracked as
+* 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 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);
+}
+/**
+* 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);
+		}
+		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
+	});
+}
+/**
+* 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) and
+* `tree-builder.ts`. Neither is 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",
+	"params"
+]);
+/**
+* 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)$/;
+/**
+* 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
+//#region src/cli-schema-sync.ts
+/**
+* `timber schema sync` — scan filesystem for dynamic segments, append
+* missing entries with `codec.string` defaults, and remove stale entries
+* whose segments no longer exist in the filesystem.
+*
+* Design doc: design/41-global-params.md §Auto-Scaffolding
+*/
+var cli_schema_sync_exports = /* @__PURE__ */ __exportAll({
+	collectDynamicSegments: () => collectDynamicSegments,
+	defaultCodecForSegment: () => defaultCodecForSegment,
+	findSchemaFile: () => findSchemaFile,
+	findSegmentParamsBlock: () => findSegmentParamsBlock,
+	parseExistingSchemaKeys: () => parseExistingSchemaKeys,
+	runSchemaSync: () => runSchemaSync
+});
+function toBracketKey(node) {
+	if (node.paramPrefix || node.paramSuffix) return `[${node.paramName}]`;
+	switch (node.segmentType) {
+		case "catch-all": return `[...${node.paramName}]`;
+		case "optional-catch-all": return `[[...${node.paramName}]]`;
+		default: return `[${node.paramName}]`;
+	}
+}
+/**
+* Collect all unique bracket-keyed dynamic segment names from the route tree.
+* Returns entries like '[artistSlug]', '[...slug]', '[[...topic]]'.
+*/
+function collectDynamicSegments(appDir) {
+	const tree = scanRoutes(appDir);
+	const segments = /* @__PURE__ */ new Set();
+	walkSegments(tree.root, segments);
+	return [...segments].sort();
+}
+function walkSegments(node, segments) {
+	if (node.paramName) segments.add(toBracketKey(node));
+	for (const child of node.children) walkSegments(child, segments);
+	for (const slot of Object.values(node.slots)) walkSegments(slot, segments);
+}
+/**
+* Replace comment bodies (and optionally string contents) with spaces,
+* preserving length and newlines so every index maps 1:1 to the original.
+* Lets the structural scanning below ignore `segmentParams` mentions and
+* braces inside comments/strings without a TS parser (fine pre-alpha,
+* see TIM-1066).
+*
+* With `maskStrings`, string contents are blanked too — except literal
+* 'segmentParams' strings, kept so a quoted property key stays findable.
+*/
+function maskSource(content, maskStrings) {
+	const out = content.split("");
+	const n = content.length;
+	let i = 0;
+	const blank = (from, to) => {
+		for (let j = from; j < to; j++) if (content[j] !== "\n") out[j] = " ";
+	};
+	while (i < n) {
+		const ch = content[i];
+		const next = content[i + 1];
+		if (ch === "/" && next === "/") {
+			const start = i;
+			while (i < n && content[i] !== "\n") i++;
+			blank(start, i);
+		} else if (ch === "/" && next === "*") {
+			const start = i;
+			i += 2;
+			while (i < n && !(content[i] === "*" && content[i + 1] === "/")) i++;
+			i = Math.min(i + 2, n);
+			blank(start, i);
+		} else if (ch === "\"" || ch === "'" || ch === "`") {
+			const start = i;
+			i++;
+			while (i < n && content[i] !== ch) {
+				if (content[i] === "\\") i++;
+				i++;
+			}
+			const end = i;
+			if (maskStrings && content.slice(start + 1, end) !== "segmentParams") blank(start + 1, end);
+			i++;
+		} else i++;
+	}
+	return out.join("");
+}
+/**
+* Locate the `segmentParams: { ... }` block in a schema file.
+* Returns the indices of the opening and matching closing brace, or null
+* if no segmentParams property is found. Comments and strings are masked
+* first, so a JSDoc example mentioning `segmentParams: { ... }` above the
+* real defineSchema call is not mistaken for the block, and braces inside
+* comments/strings don't skew the depth count. The search is anchored to
+* the `defineSchema(` call when present, so helper objects with their own
+* segmentParams property earlier in the file are skipped.
+*/
+function findSegmentParamsBlock(content) {
+	const masked = maskSource(content, true);
+	const defineCall = /\bdefineSchema\s*\(/.exec(masked);
+	const keyRe = /(['"]?)segmentParams\1\s*:\s*\{/g;
+	keyRe.lastIndex = defineCall ? defineCall.index + defineCall[0].length : 0;
+	const keyMatch = keyRe.exec(masked);
+	if (!keyMatch) return null;
+	const openBrace = keyMatch.index + keyMatch[0].length - 1;
+	let depth = 1;
+	let i = openBrace + 1;
+	while (i < masked.length && depth > 0) {
+		if (masked[i] === "{") depth++;
+		else if (masked[i] === "}") depth--;
+		i++;
+	}
+	if (depth > 0) return null;
+	return {
+		openBrace,
+		closeBrace: i - 1
+	};
+}
+/**
+* Parse existing bracket keys from an app/schema.ts file.
+* Scoped to the segmentParams: { ... } block — bracket keys elsewhere in
+* the file (unrelated objects, comments above defineSchema) are ignored.
+* Comments inside the block are masked, so a commented-out entry does not
+* count as registered.
+*
+* The key charset matches the route classifier (segment-classify.ts):
+* any character except `]`, so hyphenated params like '[my-param]' parse.
+*/
+function parseExistingSchemaKeys(content) {
+	const block = findSegmentParamsBlock(content);
+	if (!block) return [];
+	const blockContent = maskSource(content, false).slice(block.openBrace, block.closeBrace);
+	const keys = [];
+	const re = /['"](\[{1,2}(?:\.{3})?[^\]]+\]{1,2})['"]\s*:/g;
+	let m;
+	while ((m = re.exec(blockContent)) !== null) keys.push(m[1]);
+	return keys;
+}
+/** Schema file extensions to check. */
+var SCHEMA_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+];
+/**
+* Find the schema file path if it exists.
+*/
+function findSchemaFile(appDir) {
+	for (const ext of SCHEMA_EXTENSIONS) {
+		const p = join(appDir, `schema${ext}`);
+		if (existsSync(p)) return p;
+	}
+}
+function defaultCodecForSegment(seg) {
+	if (seg.startsWith("[[...")) return "codec.optionalCatchAll(codec.string)";
+	if (seg.startsWith("[...")) return "codec.stringArray";
+	return "codec.string";
+}
+/**
+* Generate the content for a new app/schema.ts with the given segment keys.
+*/
+function generateNewSchema(segments) {
+	const lines = [];
+	lines.push("import { defineSchema } from '@timber-js/app/params';");
+	lines.push("import { codec } from '@timber-js/app/codec';");
+	lines.push("");
+	lines.push("export default defineSchema({");
+	lines.push("  segmentParams: {");
+	for (const seg of segments) lines.push(`    '${seg}': ${defaultCodecForSegment(seg)},`);
+	lines.push("  },");
+	lines.push("});");
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Append missing segment entries to an existing schema file.
+* Inserts new entries before the closing `}` of segmentParams.
+*/
+var CODEC_IMPORT = "import { codec } from '@timber-js/app/codec';";
+function hasCodecImport(content) {
+	return /import\s+\{[^}]*\bcodec\b[^}]*\}\s+from\s+['"]@timber-js\/app\/codec['"]/.test(content);
+}
+function ensureCodecImport(content) {
+	if (hasCodecImport(content)) return content;
+	const lines = content.split("\n");
+	let lastImportIndex = -1;
+	for (let i = 0; i < lines.length; i++) if (/^\s*import\s/.test(lines[i])) lastImportIndex = i;
+	if (lastImportIndex === -1) return "import { codec } from '@timber-js/app/codec';\n" + content;
+	lines.splice(lastImportIndex + 1, 0, CODEC_IMPORT);
+	return lines.join("\n");
+}
+function appendToSchema(content, newSegments) {
+	content = ensureCodecImport(content);
+	const block = findSegmentParamsBlock(content);
+	if (!block) throw new Error("[timber] Could not find segmentParams in schema file. Expected a defineSchema({ segmentParams: { ... } }) call.");
+	const { openBrace, closeBrace } = block;
+	const existingLine = content.slice(openBrace, closeBrace).match(/^(\s+)['"]\[/m);
+	const indent = existingLine ? existingLine[1] : "    ";
+	const insertion = newSegments.map((seg) => `${indent}'${seg}': ${defaultCodecForSegment(seg)},`).join("\n");
+	const before = content.slice(0, closeBrace);
+	const after = content.slice(closeBrace);
+	return before + (before.trimEnd().endsWith(",") ? "\n" : "\n") + insertion + "\n" + after;
+}
+/**
+* Remove entries from the segmentParams block whose keys match `staleSegments`.
+* Removes the entire entry including trailing comma/whitespace. Scoped to
+* the segmentParams block — identical keys in unrelated objects elsewhere
+* in the file are left untouched.
+*/
+function removeFromSchema(content, staleSegments) {
+	const block = findSegmentParamsBlock(content);
+	if (!block) return content;
+	let blockContent = content.slice(block.openBrace, block.closeBrace);
+	let blockMasked = maskSource(blockContent, false);
+	for (const seg of staleSegments) {
+		const escaped = seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const keyRe = new RegExp(`^[ \t]*['"]${escaped}['"][ \t]*:`, "gm");
+		let m;
+		while ((m = keyRe.exec(blockMasked)) !== null) {
+			const start = m.index;
+			let i = m.index + m[0].length;
+			let depth = 0;
+			let inString = null;
+			while (i < blockMasked.length) {
+				const ch = blockMasked[i];
+				if (inString) {
+					if (ch === "\\") i++;
+					else if (ch === inString) inString = null;
+				} else if (ch === "\"" || ch === "'" || ch === "`") inString = ch;
+				else if (ch === "(" || ch === "{" || ch === "[") depth++;
+				else if (ch === ")" || ch === "}" || ch === "]") depth--;
+				else if (depth === 0 && ch === ",") {
+					i++;
+					break;
+				} else if (depth === 0 && (ch === "\n" || ch === "}")) break;
+				i++;
+			}
+			if (i < blockMasked.length && blockMasked[i] === "\n") i++;
+			blockContent = blockContent.slice(0, start) + blockContent.slice(i);
+			blockMasked = blockMasked.slice(0, start) + blockMasked.slice(i);
+			keyRe.lastIndex = start;
+		}
+	}
+	return content.slice(0, block.openBrace) + blockContent + content.slice(block.closeBrace);
+}
+/**
+* Run the schema sync: scan filesystem, diff against schema, append missing.
+*/
+function runSchemaSync(projectRoot) {
+	const appDir = resolveAppDir(projectRoot);
+	const filesystemSegments = collectDynamicSegments(appDir);
+	const schemaPath = findSchemaFile(appDir);
+	if (filesystemSegments.length === 0 && !schemaPath) return {
+		filesystemSegments: [],
+		existingSegments: [],
+		addedSegments: [],
+		removedSegments: [],
+		created: false
+	};
+	if (!schemaPath) {
+		writeFileSync(join(appDir, "schema.ts"), generateNewSchema(filesystemSegments), "utf-8");
+		return {
+			filesystemSegments,
+			existingSegments: [],
+			addedSegments: filesystemSegments,
+			removedSegments: [],
+			created: true
+		};
+	}
+	const content = readFileSync(schemaPath, "utf-8");
+	const existingSegments = parseExistingSchemaKeys(content);
+	const missing = filesystemSegments.filter((seg) => !existingSegments.includes(seg));
+	const stale = existingSegments.filter((seg) => !filesystemSegments.includes(seg));
+	if (missing.length === 0 && stale.length === 0) return {
+		filesystemSegments,
+		existingSegments,
+		addedSegments: [],
+		removedSegments: [],
+		created: false
+	};
+	let updated = content;
+	if (stale.length > 0) updated = removeFromSchema(updated, stale);
+	if (missing.length > 0) updated = appendToSchema(updated, missing);
+	writeFileSync(schemaPath, updated, "utf-8");
+	return {
+		filesystemSegments,
+		existingSegments,
+		addedSegments: missing,
+		removedSegments: stale,
+		created: false
+	};
+}
+//#endregion
+export { collectInterceptionRewrites as a, scanRoutes as i, findSchemaFile as n, matchUrlParts as o, parseExistingSchemaKeys as r, cli_schema_sync_exports as t };
+
+//# sourceMappingURL=cli-schema-sync-CKgHC2MB.js.map