@timber-js/app 0.2.0-alpha.16 → 0.2.0-alpha.160

package/dist/_chunks/cli-schema-sync-BhYDz_-x.js

@@ -0,0 +1,638 @@
+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-P41GR6tY.js";
+import { r as DEFAULT_PAGE_EXTENSIONS, t as classifySegment } from "./segment-classify-CDDRVKs7.js";
+import { h as swallow } from "./logger-CPoQkGK6.js";
+import { a as resolveAppDir } from "./plugin-context-DeAxFRMq.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);
+	return tree;
+}
+/**
+* Create an empty segment node.
+*/
+function createSegmentNode(segmentName, segmentType, urlPath, paramName, interceptionMarker, interceptedSegmentName) {
+	return {
+		segmentName,
+		segmentType,
+		urlPath,
+		paramName,
+		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;
+		}
+		if (classifyMetadataRoute(entry)) {
+			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, interceptionMarker, interceptedSegmentName } = classifySegment(entry);
+		if (type === "private") continue;
+		const childNode = createSegmentNode(entry, type, computeUrlPath(parentNode.urlPath, entry, type), paramName, interceptionMarker, interceptedSegmentName);
+		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);
+}
+/**
+* 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
+});
+/**
+* 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(node.segmentName);
+	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-BhYDz_-x.js.map