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

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

@@ -1,688 +0,0 @@
-import { o as __exportAll } from "./dist-BA3u1z3W.js";
-import { a as classifyMetadataRoute, c as isDynamicMetadataExtension, n as NULL_BYTE_RE, t as ENCODED_SEPARATOR_RE } from "./canonicalize-DQHyFClh.js";
-import { r as DEFAULT_PAGE_EXTENSIONS, t as classifySegment } from "./segment-classify-Byy425ng.js";
-import { h as swallow } from "./logger-AWfuX-KJ.js";
-import { a as resolveAppDir } from "./plugin-context---kTF5v8.js";
-import { basename, extname, join } from "node:path";
-import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-//#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"
-]);
-/**
-* Legacy compat status-code files.
-* Maps legacy file name → HTTP status code for the fallback chain.
-* See design/10-error-handling.md §"Fallback Chain".
-*/
-var LEGACY_STATUS_FILES = {
-	"not-found": 404,
-	"forbidden": 403,
-	"unauthorized": 401
-};
-/**
-* 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);
-	validateRouteGroupCollisions(tree.root);
-	validateDuplicateParamNames(tree.root);
-	validateUniqueBracketForms(tree.root);
-	validateAffixedSiblingConflicts(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;
-		}
-		if (name in LEGACY_STATUS_FILES && extSet.has(ext)) {
-			if (!node.legacyStatusFiles) node.legacyStatusFiles = {};
-			const existing = node.legacyStatusFiles[name];
-			if (existing) throwDuplicateConvention(name, existing.filePath, fullPath);
-			node.legacyStatusFiles[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 route groups don't produce conflicting pages/routes at the same URL path.
-*
-* 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) {
-	collectRoutableLeaves(root, /* @__PURE__ */ new Map(), "");
-}
-/**
-* Walk the segment tree and collect all routable leaves (page or route files),
-* throwing on collision. Each slot recurses with a FRESH collision map —
-* slots are parallel routes that intentionally share URL paths with their
-* parent tree, but collisions within a single slot are real errors.
-*/
-function collectRoutableLeaves(node, seen, segmentPath) {
-	if (node.segmentType === "intercepting") return;
-	const currentPath = segmentPath ? `${segmentPath}/${node.segmentName}` : node.segmentName || "(root)";
-	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: ${node.urlPath}\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
-		});
-	}
-	for (const child of node.children) collectRoutableLeaves(child, seen, currentPath);
-	for (const slotNode of Object.values(node.slots)) collectRoutableLeaves(slotNode, /* @__PURE__ */ new Map(), currentPath);
-}
-/**
-* 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) {
-	if (node.paramName) {
-		const existing = seen.get(node.paramName);
-		if (existing) throw new Error(`[timber] Duplicate param name '${node.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(node.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) {
-	if (node.paramName && node.segmentType !== "static" && node.segmentType !== "group") {
-		const existing = forms.get(node.paramName);
-		if (existing && existing.segmentType !== node.segmentType) {
-			const bracketExamples = {
-				"dynamic": `[${node.paramName}]`,
-				"catch-all": `[...${node.paramName}]`,
-				"optional-catch-all": `[[...${node.paramName}]]`
-			};
-			throw new Error(`[timber] Param name '${node.paramName}' uses multiple bracket forms.\n  ${bracketExamples[existing.segmentType] ?? existing.segmentType} at: ${existing.urlPath}\n  ${bracketExamples[node.segmentType] ?? node.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., [${node.paramName}] → [${node.paramName}Id]).`);
-		}
-		if (!existing) forms.set(node.paramName, {
-			segmentType: node.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.
-*
-* See design/07-routing.md §"Priority"
-*/
-function validateAffixedSiblingConflicts(node) {
-	const affixed = collectEffectiveAffixed(node);
-	if (affixed.length >= 2) {
-		const byLength = /* @__PURE__ */ new Map();
-		for (const child of affixed) {
-			const len = (child.paramPrefix?.length ?? 0) + (child.paramSuffix?.length ?? 0);
-			const group = byLength.get(len);
-			if (group) group.push(child);
-			else byLength.set(len, [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: ${(group[0].paramPrefix?.length ?? 0) + (group[0].paramSuffix?.length ?? 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);
-}
-/**
-* Collect affixed dynamic segments that are effective children of a node.
-* Route groups are URL-transparent, so we look through them recursively.
-*/
-function collectEffectiveAffixed(node) {
-	const result = [];
-	for (const child of node.children) if (child.segmentType === "dynamic" && (child.paramPrefix || child.paramSuffix)) result.push(child);
-	else if (child.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 { scanRoutes as i, findSchemaFile as n, parseExistingSchemaKeys as r, cli_schema_sync_exports as t };
-
-//# sourceMappingURL=cli-schema-sync-D3naS3eH.js.map