@timber-js/app 0.2.0-alpha.120 → 0.2.0-alpha.121

package/src/routing/codegen.ts

@@ -321,10 +321,35 @@ function formatDeclarationFile(
         ? './' + relative(importBase, join(appDir, 'schema')).replace(/\\/g, '/')
         : '../app/schema';
     lines.push(`import type schema from '${schemaImport}';`);
-    lines.push("import type { InferCodecType } from '@timber-js/app/params';");
+    lines.push("import type { InferCodecType, SegmentParamCodec } from '@timber-js/app/params';");
     lines.push('');
-    // Emit TimberSegmentParams, TimberRoute, AllSegmentParams, RoutesWithParams
-    lines.push(...formatSchemaTypes(routes));
+    // Collect all unique bracket keys from routes for key validation
+    const allBracketKeys = new Set<string>();
+    for (const route of routes) {
+      for (const p of route.params) {
+        allBracketKeys.add(p.bracketName);
+      }
+    }
+
+    // Augment the ValidDynamicSegmentKeysRegistry so defineSchema constrains keys
+    // to known filesystem segments. Unknown keys produce inline TS errors.
+    if (allBracketKeys.size > 0) {
+      lines.push("declare module '@timber-js/app/params' {");
+      lines.push('  interface ValidDynamicSegmentKeysRegistry {');
+      for (const key of [...allBracketKeys].sort()) {
+        lines.push(`    ${JSON.stringify(key)}: true;`);
+      }
+      lines.push('  }');
+      lines.push('}');
+      lines.push('');
+    }
+    // Type-level validation: each schema value must be a Codec or Standard Schema.
+    // Running `pnpm run typecheck` will surface errors for invalid values.
+    lines.push('type _AssertSchemaValues = {');
+    lines.push(
+      "  [K in keyof typeof schema['segmentParams']]: typeof schema['segmentParams'][K] extends SegmentParamCodec ? true : ['Error: value for', K, 'is not a valid Codec or Standard Schema'];"
+    );
+    lines.push('};');
     lines.push('');
   }
 
@@ -350,6 +375,16 @@ function formatDeclarationFile(
   }
 
   lines.push('  }');
+
+  // When a global schema exists, emit segment param types inside the
+  // @timber-js/app module augmentation so that declare module blocks
+  // for @timber-js/app/server and @timber-js/app/client can reference
+  // AllSegmentParams via `import type { AllSegmentParams } from '@timber-js/app'`.
+  if (hasSchema) {
+    lines.push('');
+    lines.push(...formatSchemaTypes(routes).map((l) => `  ${l}`));
+  }
+
   lines.push('}');
   lines.push('');
 
@@ -359,13 +394,20 @@ function formatDeclarationFile(
   // Generate @timber-js/app/server augmentation — typed getSegmentParams
   if (dynamicRoutes.length > 0) {
     lines.push("declare module '@timber-js/app/server' {");
+    if (hasSchema) {
+      lines.push("  import type { AllSegmentParams } from '@timber-js/app'");
+    }
     for (const route of dynamicRoutes) {
       const paramsType = formatParamsType(route.params, importBase, hasSchema);
       lines.push(
         `  export function getSegmentParams(segmentPath: '${route.segmentPath}'): ${paramsType}`
       );
     }
-    lines.push('  export function getSegmentParams(): Record<string, string | string[]>');
+    lines.push(
+      hasSchema
+        ? '  export function getSegmentParams(): Partial<AllSegmentParams>'
+        : '  export function getSegmentParams(): Record<string, string | string[]>'
+    );
     lines.push('}');
     lines.push('');
   }
@@ -377,6 +419,9 @@ function formatDeclarationFile(
     lines.push(
       "  import type { SearchParamsDefinition, SetParams, QueryStatesOptions, SearchParamCodec } from '@timber-js/app/search-params'"
     );
+    if (hasSchema) {
+      lines.push("  import type { AllSegmentParams } from '@timber-js/app'");
+    }
     lines.push('');
 
     // useSegmentParams overloads
@@ -387,7 +432,11 @@ function formatDeclarationFile(
           `  export function useSegmentParams(segmentPath: '${route.segmentPath}'): ${paramsType}`
         );
       }
-      lines.push('  export function useSegmentParams(): Record<string, string | string[]>');
+      lines.push(
+        hasSchema
+          ? '  export function useSegmentParams(): Partial<AllSegmentParams>'
+          : '  export function useSegmentParams(): Record<string, string | string[]>'
+      );
       lines.push('');
     }
 

package/src/routing/index.ts

@@ -16,3 +16,8 @@ export { classifyUrlSegment, classifySegment } from './segment-classify.js';
 export type { UrlSegment, SegmentClassification } from './segment-classify.js';
 export { collectLeafRoutes } from './walkers.js';
 export type { LeafRoute, CollectLeafRoutesOptions } from './walkers.js';
+export {
+  validateSchemaAgainstRoutes,
+  collectDynamicSegmentsFromTree,
+} from './schema-validation.js';
+export type { SchemaWarning } from './schema-validation.js';

package/src/routing/scanner.ts

@@ -106,6 +106,10 @@ export function scanRoutes(appDir: string, config: ScannerConfig = {}): RouteTre
   // e.g., /[id]/items/[id] — same param name in ancestor and descendant
   validateDuplicateParamNames(tree.root);
 
+  // Validate: detect same param name used with different bracket forms
+  // e.g., [id] in one route and [...id] in another
+  validateUniqueBracketForms(tree.root);
+
   return tree;
 }
 
@@ -457,6 +461,60 @@ function walkForDuplicateParams(node: SegmentNode, seen: Map<string, string>): v
   }
 }
 
+/**
+ * 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: SegmentNode): void {
+  const forms = new Map<string, { segmentType: SegmentType; urlPath: string }>();
+  collectBracketForms(root, forms);
+}
+
+function collectBracketForms(
+  node: SegmentNode,
+  forms: Map<string, { segmentType: SegmentType; urlPath: string }>
+): void {
+  if (node.paramName && node.segmentType !== 'static' && node.segmentType !== 'group') {
+    const existing = forms.get(node.paramName);
+    if (existing && existing.segmentType !== node.segmentType) {
+      const bracketExamples: Record<string, string> = {
+        '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.
  */

package/src/routing/schema-validation.ts

@@ -0,0 +1,149 @@
+/**
+ * Schema key/value validation against the filesystem route tree.
+ *
+ * Runs at codegen time (build + dev) to catch mismatches between
+ * app/schema.ts keys and the actual dynamic segments on disk.
+ *
+ * Design doc: design/41-global-params.md
+ */
+
+import { readFileSync } from 'node:fs';
+import type { RouteTree, SegmentNode } from './types.js';
+import { findSchemaFile, parseExistingSchemaKeys } from '../cli-schema-sync.js';
+import { classifyUrlSegment } from './segment-classify.js';
+
+export interface SchemaWarning {
+  type: 'stale-key' | 'missing-key' | 'bracket-mismatch';
+  key: string;
+  message: string;
+  filesystemKey?: string;
+}
+
+/**
+ * Collect all unique bracket-keyed dynamic segment names from a route tree.
+ * Returns entries like '[artistSlug]', '[...slug]', '[[...topic]]'.
+ */
+export function collectDynamicSegmentsFromTree(tree: RouteTree): Set<string> {
+  const segments = new Set<string>();
+  walkTree(tree.root, segments);
+  return segments;
+}
+
+function walkTree(node: SegmentNode, segments: Set<string>): void {
+  if (node.paramName && node.segmentName) {
+    const classified = classifyUrlSegment(node.segmentName);
+    if (classified.kind !== 'static') {
+      segments.add(node.segmentName);
+    }
+  }
+  for (const child of node.children) {
+    walkTree(child, segments);
+  }
+  for (const slot of Object.values(node.slots)) {
+    walkTree(slot, segments);
+  }
+}
+
+/**
+ * Extract the param name from a bracket key.
+ * '[id]' → 'id', '[...slug]' → 'slug', '[[...topic]]' → 'topic'
+ */
+function extractParamName(bracketKey: string): string | null {
+  const seg = classifyUrlSegment(bracketKey);
+  if (seg.kind === 'static') return null;
+  return seg.name;
+}
+
+/**
+ * Validate schema keys against the filesystem route tree.
+ *
+ * Returns warnings for:
+ * - Stale keys: schema keys that don't match any filesystem segment
+ * - Bracket form mismatches: same param name, different bracket form
+ * - Missing keys: filesystem segments not registered in schema (informational)
+ */
+export function validateSchemaAgainstRoutes(tree: RouteTree, appDir: string): SchemaWarning[] {
+  const schemaPath = findSchemaFile(appDir);
+  if (!schemaPath) return [];
+
+  const content = readFileSync(schemaPath, 'utf-8');
+  const schemaKeys = parseExistingSchemaKeys(content);
+
+  if (schemaKeys.length === 0) return [];
+
+  const filesystemSegments = collectDynamicSegmentsFromTree(tree);
+
+  return validateKeys(schemaKeys, filesystemSegments);
+}
+
+/**
+ * Core validation: compare schema keys against filesystem segments.
+ * Exported separately for testing without filesystem dependencies.
+ */
+export function validateKeys(
+  schemaKeys: string[],
+  filesystemSegments: Set<string>
+): SchemaWarning[] {
+  const warnings: SchemaWarning[] = [];
+
+  // Build a map of param name → bracket form for filesystem segments
+  const fsParamToKey = new Map<string, string>();
+  for (const fsKey of filesystemSegments) {
+    const name = extractParamName(fsKey);
+    if (name) {
+      fsParamToKey.set(name, fsKey);
+    }
+  }
+
+  // Build a set of schema param names for the missing-key check
+  const schemaParamNames = new Set<string>();
+
+  for (const schemaKey of schemaKeys) {
+    const schemaParamName = extractParamName(schemaKey);
+    if (!schemaParamName) continue;
+
+    schemaParamNames.add(schemaParamName);
+
+    if (filesystemSegments.has(schemaKey)) {
+      // Exact match — no issue
+      continue;
+    }
+
+    // Check if the param name exists but with a different bracket form
+    const fsKey = fsParamToKey.get(schemaParamName);
+    if (fsKey) {
+      warnings.push({
+        type: 'bracket-mismatch',
+        key: schemaKey,
+        filesystemKey: fsKey,
+        message:
+          `Schema key '${schemaKey}' does not match filesystem bracket form '${fsKey}'. ` +
+          `Update the schema key to '${fsKey}'.`,
+      });
+    } else {
+      warnings.push({
+        type: 'stale-key',
+        key: schemaKey,
+        message:
+          `Schema key '${schemaKey}' does not match any dynamic segment in the filesystem. ` +
+          `Remove it from app/schema.ts or create the corresponding route segment.`,
+      });
+    }
+  }
+
+  // Check for filesystem segments not in schema (informational)
+  for (const fsKey of filesystemSegments) {
+    const name = extractParamName(fsKey);
+    if (name && !schemaParamNames.has(name)) {
+      warnings.push({
+        type: 'missing-key',
+        key: fsKey,
+        message:
+          `Dynamic segment '${fsKey}' has no codec in app/schema.ts (defaults to string). ` +
+          `Run: timber schema sync`,
+      });
+    }
+  }
+
+  return warnings;
+}

package/LICENSE

@@ -1,8 +0,0 @@
-DONTFUCKINGUSE LICENSE
-
-Copyright (c) 2025 Daniel Saewitz
-
-This software may not be used, copied, modified, merged, published,
-distributed, sublicensed, or sold by anyone other than the copyright holder.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.

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

@@ -1,2 +0,0 @@
-import { i as runSchemaSync } from "./cli-schema-sync-q2wB0DyJ.js";
-export { runSchemaSync };

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

@@ -1,358 +0,0 @@
-import { t as scanRoutes } from "./scanner-DmfoB7iK.js";
-import { join } from "node:path";
-import { createRequire } from "node:module";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { performance } from "node:perf_hooks";
-//#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 and append
-* missing entries to app/schema.ts with `codec.string` defaults.
-*
-* Only adds, never removes or modifies existing entries.
-*
-* 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;
-	}
-}
-/**
-* 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}': codec.string,`);
-	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.
-*/
-function appendToSchema(content, newSegments) {
-	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}': codec.string,`).join("\n");
-	const before = content.slice(0, closeBrace);
-	const after = content.slice(closeBrace);
-	return before + (before.trimEnd().endsWith(",") ? "\n" : "\n") + insertion + "\n" + after;
-}
-/**
-* Run the schema sync: scan filesystem, diff against schema, append missing.
-*/
-function runSchemaSync(projectRoot) {
-	const appDir = resolveAppDir(projectRoot);
-	const filesystemSegments = collectDynamicSegments(appDir);
-	if (filesystemSegments.length === 0) return {
-		filesystemSegments: [],
-		existingSegments: [],
-		addedSegments: [],
-		created: false
-	};
-	const schemaPath = findSchemaFile(appDir);
-	if (!schemaPath) {
-		writeFileSync(join(appDir, "schema.ts"), generateNewSchema(filesystemSegments), "utf-8");
-		return {
-			filesystemSegments,
-			existingSegments: [],
-			addedSegments: filesystemSegments,
-			created: true
-		};
-	}
-	const content = readFileSync(schemaPath, "utf-8");
-	const existingSegments = parseExistingSchemaKeys(content);
-	const missing = filesystemSegments.filter((seg) => !existingSegments.includes(seg));
-	if (missing.length === 0) return {
-		filesystemSegments,
-		existingSegments,
-		addedSegments: [],
-		created: false
-	};
-	writeFileSync(schemaPath, appendToSchema(content, missing), "utf-8");
-	return {
-		filesystemSegments,
-		existingSegments,
-		addedSegments: missing,
-		created: false
-	};
-}
-//#endregion
-export { DEFAULT_BUILD_DIR as a, mergeFileConfig as c, resolveClientJavascript as d, createNoopTimer as f, runSchemaSync as i, resolveAppDir as l, findSchemaFile as n, createPluginContext as o, parseExistingSchemaKeys as r, loadTimberConfigFile as s, collectDynamicSegments as t, resolveBuildDir as u };
-
-//# sourceMappingURL=cli-schema-sync-q2wB0DyJ.js.map