@timber-js/app 0.2.0-alpha.13 → 0.2.0-alpha.131

package/dist/_chunks/cli-schema-sync-q-Ce6-iG.js

@@ -0,0 +1,785 @@
+import { a as isDynamicMetadataExtension, n as classifyMetadataRoute } from "./metadata-routes-DESG8uk5.js";
+import { r as DEFAULT_PAGE_EXTENSIONS, t as classifySegment } from "./segment-classify-BjfuctV2.js";
+import { h as swallow } from "./logger-CMd9P1xQ.js";
+import { basename, extname, join } from "node:path";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { performance } from "node:perf_hooks";
+//#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.
+*/
+/**
+* Pattern matching encoded path delimiters that must be rejected during route discovery.
+* %2F / %2f (forward slash) and %5C / %5c (backslash) can cause route collisions
+* when decoded. See design/13-security.md §"Encoded separators rejected".
+*/
+var ENCODED_SEPARATOR_PATTERN = /%(?:2[fF]|5[cC])/;
+/**
+* Pattern matching encoded null bytes (%00) that must be rejected.
+* See design/13-security.md §"Null bytes rejected".
+*/
+var ENCODED_NULL_PATTERN = /%00/;
+/**
+* File convention names that use pageExtensions (can be .tsx, .ts, .jsx, .js, .mdx, etc.)
+*/
+var PAGE_EXT_CONVENTIONS = 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 = 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 file = {
+				filePath: fullPath,
+				extension: ext
+			};
+			switch (name) {
+				case "page":
+					node.page = file;
+					break;
+				case "layout":
+					node.layout = file;
+					break;
+				case "error":
+					node.error = file;
+					break;
+				case "default":
+					node.default = file;
+					break;
+				case "denied":
+					node.denied = file;
+					break;
+			}
+			continue;
+		}
+		if (FIXED_CONVENTIONS.has(name) && /\.?[jt]sx?$/.test(ext)) {
+			const file = {
+				filePath: fullPath,
+				extension: ext
+			};
+			switch (name) {
+				case "middleware":
+					node.middleware = file;
+					break;
+				case "access":
+					node.access = file;
+					break;
+				case "route":
+					node.route = file;
+					break;
+				case "params":
+					node.params = file;
+					break;
+			}
+			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 = {};
+			node.statusFiles[name] = {
+				filePath: fullPath,
+				extension: ext
+			};
+			continue;
+		}
+		if (name in LEGACY_STATUS_FILES && extSet.has(ext)) {
+			if (!node.legacyStatusFiles) node.legacyStatusFiles = {};
+			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);
+				if (isDynamicMetadataExtension(name, ext) || !existingIsDynamic) 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.`);
+}
+/**
+* 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_PATTERN.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 (ENCODED_NULL_PATTERN.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.
+*
+* Parallel slots are excluded from collision detection — they intentionally coexist at
+* the same URL path as their parent (that's the whole point of parallel routes).
+*/
+function validateRouteGroupCollisions(root) {
+	collectRoutableLeaves(root, /* @__PURE__ */ new Map(), "", false);
+}
+/**
+* Walk the segment tree and collect all routable leaves (page or route files),
+* throwing on collision. Slots are tracked in their own collision space since
+* they are parallel routes that intentionally share URL paths with their parent.
+*/
+function collectRoutableLeaves(node, seen, segmentPath, insideSlot) {
+	const currentPath = segmentPath ? `${segmentPath}/${node.segmentName}` : node.segmentName || "(root)";
+	if (!insideSlot) {
+		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, insideSlot);
+	for (const slotNode of Object.values(node.slots)) collectRoutableLeaves(slotNode, seen, currentPath, true);
+}
+/**
+* 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/utils/startup-timer.ts
+/**
+* Startup timer — records named phases with their durations.
+*
+* Used by the plugin system to instrument cold start and report a
+* timing breakdown in dev mode. Zero overhead in production (disabled).
+*
+* See design/18-build-system.md, TIM-155.
+*/
+/**
+* Create a startup timer that records phase durations.
+*/
+function createStartupTimer() {
+	const pending = /* @__PURE__ */ new Map();
+	const phases = [];
+	return {
+		start(phase) {
+			pending.set(phase, performance.now());
+		},
+		end(phase) {
+			const startMs = pending.get(phase);
+			if (startMs === void 0) return 0;
+			pending.delete(phase);
+			const durationMs = performance.now() - startMs;
+			phases.push({
+				name: phase,
+				startMs,
+				durationMs
+			});
+			return durationMs;
+		},
+		getPhases() {
+			return [...phases].sort((a, b) => a.startMs - b.startMs);
+		},
+		totalMs() {
+			if (phases.length === 0) return 0;
+			const sorted = this.getPhases();
+			const first = sorted[0];
+			const last = sorted[sorted.length - 1];
+			return last.startMs + last.durationMs - first.startMs;
+		},
+		formatSummary() {
+			const sorted = this.getPhases();
+			if (sorted.length === 0) return "No phases recorded.";
+			const lines = sorted.map((p) => {
+				const ms = p.durationMs.toFixed(1);
+				return `  ${p.name.padEnd(30)} ${ms.padStart(8)}ms`;
+			});
+			const total = this.totalMs().toFixed(1);
+			lines.push(`  ${"total".padEnd(30)} ${total.padStart(8)}ms`);
+			return ["[timber] startup timing:", ...lines].join("\n");
+		}
+	};
+}
+/**
+* No-op timer for production builds — all methods are empty.
+*/
+function createNoopTimer() {
+	return {
+		start() {},
+		end() {
+			return 0;
+		},
+		getPhases() {
+			return [];
+		},
+		totalMs() {
+			return 0;
+		},
+		formatSummary() {
+			return "";
+		}
+	};
+}
+//#endregion
+//#region src/plugin-context.ts
+/**
+* Plugin context — internal types and helpers for timber sub-plugins.
+*
+* These are NOT part of the user-facing API. They are consumed by
+* sub-plugins (routing, entries, shims, etc.) via relative imports.
+* The root entry point (index.ts) does not re-export them.
+*
+* Design doc: 18-build-system.md §"Shared Plugin Context"
+*/
+/**
+* Resolve `clientJavascript` into a fully resolved config.
+*/
+function resolveClientJavascript(config) {
+	if (config.clientJavascript !== void 0) {
+		if (typeof config.clientJavascript === "boolean") return {
+			disabled: !config.clientJavascript,
+			enableHMRInDev: !config.clientJavascript
+		};
+		return {
+			disabled: config.clientJavascript.disabled,
+			enableHMRInDev: config.clientJavascript.enableHMRInDev ?? config.clientJavascript.disabled
+		};
+	}
+	return {
+		disabled: false,
+		enableHMRInDev: false
+	};
+}
+/**
+* Resolve the app directory. Checks (in order):
+* 1. Explicit `configAppDir` from timber.config.ts
+* 2. `<root>/app`
+* 3. `<root>/src/app`
+*
+* Throws if none exist.
+*/
+function resolveAppDir(root, configAppDir) {
+	if (configAppDir) {
+		const explicit = join(root, configAppDir);
+		if (!existsSync(explicit)) throw new Error(`[timber] Configured appDir "${configAppDir}" does not exist at ${explicit}`);
+		return explicit;
+	}
+	const rootApp = join(root, "app");
+	if (existsSync(rootApp)) return rootApp;
+	const srcApp = join(root, "src", "app");
+	if (existsSync(srcApp)) return srcApp;
+	throw new Error(`[timber] Could not find app directory. Expected "app/" or "src/app/" in ${root}. You can set appDir in timber.config.ts to specify a custom location.`);
+}
+function createPluginContext(config, root) {
+	const projectRoot = root ?? process.cwd();
+	const resolvedConfig = { ...config };
+	return {
+		config: resolvedConfig,
+		clientJavascript: resolveClientJavascript(resolvedConfig),
+		routeTree: null,
+		appDir: join(projectRoot, "app"),
+		root: projectRoot,
+		dev: false,
+		buildManifest: null,
+		deploymentId: null,
+		timer: createStartupTimer(),
+		holdingServer: null,
+		buildDir: resolveBuildDir(projectRoot, resolvedConfig.buildDir)
+	};
+}
+/** Default build output directory (relative to root). */
+var DEFAULT_BUILD_DIR = join(".timber", "dist");
+/**
+* Resolve the build output directory.
+*
+* Priority:
+* 1. Explicit `timberBuildDir` from timber.config.ts
+* 2. Explicit `viteBuildOutDir` from Vite's build.outDir (if not the default 'dist')
+* 3. Default: `.timber/dist`
+*
+* Returns an absolute path.
+*/
+function resolveBuildDir(root, timberBuildDir, viteBuildOutDir) {
+	if (timberBuildDir) return join(root, timberBuildDir);
+	if (viteBuildOutDir && viteBuildOutDir !== "dist") return join(root, viteBuildOutDir);
+	return join(root, DEFAULT_BUILD_DIR);
+}
+/**
+* Load timber.config.ts (or .js, .mjs) from the project root.
+* Returns the config object or null if no config file is found.
+*
+* Uses require() which works for ESM modules on Node 22.12+.
+* This keeps timber() synchronous — no async config loading needed.
+*/
+function loadTimberConfigFile(root) {
+	const configNames = [
+		"timber.config.ts",
+		"timber.config.js",
+		"timber.config.mjs"
+	];
+	const req = createRequire(join(root, "package.json"));
+	for (const name of configNames) {
+		const configPath = join(root, name);
+		if (existsSync(configPath)) {
+			const mod = req(configPath);
+			return mod.default ?? mod;
+		}
+	}
+	return null;
+}
+/**
+* Detect config keys set in both inline (vite.config.ts) and file (timber.config.ts)
+* and warn the user. The `output` key is excluded because it defaults to 'server'
+* in createPluginContext and would always appear as an inline key.
+*
+* Returns the list of conflicting key names (for testing).
+*/
+function warnConfigConflicts(inline, fileConfig) {
+	const conflicts = [];
+	for (const key of Object.keys(fileConfig)) if (key in inline && inline[key] !== void 0) conflicts.push(key);
+	if (conflicts.length > 0) console.warn(`[timber] Config conflict: ${conflicts.map((k) => `"${k}"`).join(", ")} set in both vite.config.ts (inline) and timber.config.ts. Move all config to timber.config.ts to avoid confusion. The inline value from vite.config.ts will be used.`);
+	return conflicts;
+}
+/**
+* Merge file-based config into ctx.config. Inline config (already in ctx.config)
+* takes precedence — file config only fills in missing fields.
+*/
+function mergeFileConfig(ctx, fileConfig) {
+	const inline = ctx.config;
+	warnConfigConflicts(inline, fileConfig);
+	ctx.config = {
+		...fileConfig,
+		...inline,
+		...fileConfig.limits && inline.limits ? { limits: {
+			...fileConfig.limits,
+			...inline.limits
+		} } : {},
+		...fileConfig.dev && inline.dev ? { dev: {
+			...fileConfig.dev,
+			...inline.dev
+		} } : {},
+		...fileConfig.mdx && inline.mdx ? { mdx: {
+			...fileConfig.mdx,
+			...inline.mdx
+		} } : {}
+	};
+}
+//#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
+*/
+/**
+* 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);
+}
+/**
+* Parse existing bracket keys from an app/schema.ts file.
+* Uses regex to find keys in segmentParams: { '[key]': ... } blocks.
+*/
+function parseExistingSchemaKeys(content) {
+	const keys = [];
+	const re = /['"](\[{1,2}(?:\.{3})?\w+\]{1,2})['"]\s*:/g;
+	let m;
+	while ((m = re.exec(content)) !== 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 CODEC_IMPORT + "\n" + content;
+	lines.splice(lastImportIndex + 1, 0, CODEC_IMPORT);
+	return lines.join("\n");
+}
+function appendToSchema(content, newSegments) {
+	content = ensureCodecImport(content);
+	const spIndex = content.indexOf("segmentParams");
+	if (spIndex === -1) throw new Error("[timber] Could not find segmentParams in schema file. Expected a defineSchema({ segmentParams: { ... } }) call.");
+	const openBrace = content.indexOf("{", spIndex + 13);
+	if (openBrace === -1) throw new Error("[timber] Could not find opening brace for segmentParams.");
+	let depth = 1;
+	let i = openBrace + 1;
+	while (i < content.length && depth > 0) {
+		if (content[i] === "{") depth++;
+		else if (content[i] === "}") depth--;
+		i++;
+	}
+	const closeBrace = i - 1;
+	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 line including trailing comma/whitespace.
+*/
+function removeFromSchema(content, staleSegments) {
+	for (const seg of staleSegments) {
+		const escaped = seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const keyRe = new RegExp(`^[ \t]*['"]${escaped}['"][ \t]*:`, "gm");
+		let m;
+		while ((m = keyRe.exec(content)) !== null) {
+			const start = m.index;
+			let i = m.index + m[0].length;
+			let depth = 0;
+			let inString = null;
+			while (i < content.length) {
+				const ch = content[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 < content.length && content[i] === "\n") i++;
+			content = content.slice(0, start) + content.slice(i);
+			keyRe.lastIndex = start;
+		}
+	}
+	return content;
+}
+/**
+* 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 { runSchemaSync as a, loadTimberConfigFile as c, resolveBuildDir as d, resolveClientJavascript as f, parseExistingSchemaKeys as i, mergeFileConfig as l, scanRoutes as m, defaultCodecForSegment as n, DEFAULT_BUILD_DIR as o, createNoopTimer as p, findSchemaFile as r, createPluginContext as s, collectDynamicSegments as t, resolveAppDir as u };
+
+//# sourceMappingURL=cli-schema-sync-q-Ce6-iG.js.map