fimo 0.18.0 → 0.20.0

package/dist/runtime/app/FimoProviders.js

@@ -15,7 +15,7 @@ import { ScreenshotProvider } from '../iframe/ScreenshotProvider.js';
 import { getSafePreviewNavigationPath, isPreviewRuntimeEnabled } from '../preview/bridge.js';
 import { getPreviewLocationChange, getPreviewParentOrigin } from '../preview/location.js';
 import { getActiveRouterRoutes } from '../react-router/active-routes.js';
-import { matchFimoRoute } from '../routes/contract.js';
+import { matchFimoRoute } from '../routes/index.js';
 import { OptionalTracking } from '../t/OptionalTracking.js';
 export { getPreviewLocationChange, getPreviewLocationPath } from '../preview/location.js';
 const titleCase = (seg) => seg

package/dist/runtime/app/prefetch.js

@@ -1,7 +1,7 @@
 // @ts-ignore - virtual module provided by fimoConfigPlugin in fimo/vite
 import fimoConfig from 'virtual:fimo-config';
 import { resolveFimoLocale } from '../i18n/locale.js';
-import { matchFimoRoute } from '../routes/contract.js';
+import { matchFimoRoute } from '../routes/index.js';
 export function resolveFimoLocaleForUrl(url) {
     return resolveFimoLocale(url, fimoConfig);
 }

package/dist/runtime/i18n/locale.d.ts

@@ -1,4 +1,6 @@
+import { getFimoDefaultLocale, getFimoLocales, normalizeFimoLocale } from '../routes/index.js';
 import type { FimoConfig } from '../shared/fimo-config.types.js';
+export { getFimoDefaultLocale, getFimoLocales, normalizeFimoLocale };
 export interface FimoLocaleResolution {
     locale: string;
     defaultLocale: string;
@@ -13,8 +15,6 @@ export interface FimoLocaleRequestLike {
     url?: string;
     pathname?: string;
 }
-export declare function getFimoDefaultLocale(config: Pick<FimoConfig, 'i18n'> | undefined): string;
-export declare function getFimoLocales(config: Pick<FimoConfig, 'i18n'> | undefined): string[];
 export declare function resolveFimoLocale(requestLike: string | URL | FimoLocaleRequestLike, config: Pick<FimoConfig, 'i18n'> | undefined): FimoLocaleResolution;
 /**
  * Rewrite a path so it renders in `locale`. The default locale is always
@@ -23,5 +23,4 @@ export declare function resolveFimoLocale(requestLike: string | URL | FimoLocale
 export declare function localizeFimoPath(path: string, locale: string, config: Pick<FimoConfig, 'i18n'> | undefined): string;
 export declare function getFimoTextDirection(locale: string): 'ltr' | 'rtl';
 export declare function toHtmlLang(locale: string): string;
-export declare function normalizeFimoLocale(locale: string | null | undefined): string | null;
 //# sourceMappingURL=locale.d.ts.map

package/dist/runtime/i18n/locale.js

@@ -1,17 +1,5 @@
-export function getFimoDefaultLocale(config) {
-    return normalizeFimoLocale(config?.i18n?.defaultLocale) ?? 'en';
-}
-export function getFimoLocales(config) {
-    const defaultLocale = getFimoDefaultLocale(config);
-    const locales = new Set([defaultLocale]);
-    for (const locale of config?.i18n?.locales ?? []) {
-        const clean = normalizeFimoLocale(locale);
-        if (clean) {
-            locales.add(clean);
-        }
-    }
-    return [...locales];
-}
+import { getFimoDefaultLocale, getFimoLocales, normalizeFimoLocale } from '../routes/index.js';
+export { getFimoDefaultLocale, getFimoLocales, normalizeFimoLocale };
 export function resolveFimoLocale(requestLike, config) {
     const pathname = normalizePathname(readPathname(requestLike));
     const defaultLocale = getFimoDefaultLocale(config);
@@ -77,19 +65,6 @@ export function getFimoTextDirection(locale) {
 export function toHtmlLang(locale) {
     return locale.replace('_', '-');
 }
-export function normalizeFimoLocale(locale) {
-    const trimmed = locale?.trim();
-    if (!trimmed) {
-        return null;
-    }
-    const candidate = trimmed.replace(/_/g, '-');
-    try {
-        return Intl.getCanonicalLocales(candidate)[0] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
 function normalizePathname(pathname) {
     const withSlash = pathname.startsWith('/') ? pathname : `/${pathname}`;
     const normalized = withSlash.replace(/\/{2,}/g, '/');

package/dist/runtime/paths/get-fimo-paths.js

@@ -3,7 +3,7 @@
 // dynamic routes are expanded by fetching schema entries from the content API.
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { materializeRoutePath, resolveRouteContracts, routeLocaleTargets } from '../routes/contract.js';
+import { materializeRoutePath, resolveRouteContracts, routeLocaleTargets } from '../routes/index.js';
 import { resolveSeoForPath } from '../seo/resolver.js';
 import { getConfigServer } from '../shared/fimo-config.server.js';
 import { resolveLocalRuntimeEnv } from '../shared/local-runtime-env.js';

package/dist/runtime/react-router/legacy/routes.js

@@ -1,5 +1,5 @@
 import { getFimoDefaultLocale, getFimoLocales } from '../../i18n/locale.js';
-import { hasLocaleSegment } from '../../routes/contract.js';
+import { hasLocaleSegment } from '../../routes/index.js';
 import { getConfigServer } from '../../shared/fimo-config.server.js';
 /**
  * @deprecated New React Router projects should declare optional `:locale?`

package/dist/runtime/routes/index.d.ts

@@ -1,3 +1,162 @@
-export { FIMO_LOCALE_PARAM, hasLocaleSegment, materializeRoutePath, matchFimoRoute, normalizeRoutePath, resolveRouteContract, resolveRouteContracts, routeLocaleTargets, } from './contract.js';
-export type { FimoEntryParam, FimoLocaleParam, FimoRouteContract, FimoRouteIssue, FimoRouteLocaleTarget, FimoRouteMatch, FimoRouteParam, } from './contract.js';
+export interface FimoRouteSeoConfig {
+    title?: string;
+    description?: string;
+    url?: string;
+    image?: string;
+    favicon?: string;
+    twitterSite?: string;
+    robots?: string;
+    themeColor?: string;
+    locale?: string;
+    siteName?: string;
+}
+export interface FimoRouteParamConfig<Query = unknown> {
+    type?: 'entry' | 'locale';
+    schema?: string;
+    queryField?: string;
+    displayField?: string;
+    query?: Query;
+    optional?: boolean;
+}
+export interface FimoRouteConfig<Sources = unknown, Query = unknown, Seo = FimoRouteSeoConfig> {
+    label?: string;
+    path?: string;
+    group?: string;
+    content?: {
+        labels?: string[];
+        singles?: string[];
+    };
+    sources?: Sources;
+    icon?: string;
+    params?: Record<string, FimoRouteParamConfig<Query>>;
+    seo?: Seo;
+}
+export interface FimoRoutesI18nConfig {
+    defaultLocale?: string;
+    locales?: string[];
+    routing?: {
+        strategy?: 'path-prefix';
+    };
+}
+export interface FimoRoutesConfig<RouteConfig extends FimoRouteConfig = FimoRouteConfig> {
+    i18n?: FimoRoutesI18nConfig;
+    routes?: Record<string, RouteConfig>;
+}
+export declare function normalizeFimoLocale(locale: string | null | undefined): string | null;
+export declare function getFimoDefaultLocale(config: Pick<FimoRoutesConfig, 'i18n'> | undefined): string;
+export declare function getFimoLocales(config: Pick<FimoRoutesConfig, 'i18n'> | undefined): string[];
+/**
+ * The reserved parameter name for the locale segment. A `:locale` placeholder
+ * is always the locale, whether or not the route declares a descriptor for it.
+ */
+export declare const FIMO_LOCALE_PARAM = "locale";
+export interface FimoEntryParam {
+    type: 'entry';
+    name: string;
+    schema: string;
+    queryField: string;
+    displayField?: string;
+}
+export interface FimoLocaleParam {
+    type: 'locale';
+    name: string;
+    /**
+     * True (the default) means the default locale renders at the unprefixed
+     * path and only other locales carry a `/<locale>` prefix. False means every
+     * locale, the default included, renders behind the prefix.
+     */
+    optional: boolean;
+}
+export type FimoRouteParam = FimoEntryParam | FimoLocaleParam;
+export interface FimoRouteIssue {
+    /** The parameter the issue is about, when it is about one. */
+    param?: string;
+    message: string;
+    /** A concrete edit that resolves the issue. */
+    fix: string;
+}
+export interface FimoRouteContract<RouteConfig extends FimoRouteConfig = FimoRouteConfig> {
+    id: string;
+    /** The declared route entry, kept so callers can reach `label` / `seo`. */
+    config: RouteConfig;
+    /** The declared path, locale placeholder included (`/:locale/blog/:slug`). */
+    path: string;
+    /** The declared path without the locale placeholder (`/blog/:slug`). */
+    canonicalPath: string;
+    params: FimoRouteParam[];
+    entryParams: FimoEntryParam[];
+    localeParam: FimoLocaleParam | null;
+    /** Placeholders in the path that no usable descriptor resolves. */
+    unresolvedParams: string[];
+    issues: FimoRouteIssue[];
+}
+export interface FimoRouteMatch<RouteConfig extends FimoRouteConfig = FimoRouteConfig> {
+    contract: FimoRouteContract<RouteConfig>;
+    /** Every resolved path parameter, the locale segment included. */
+    params: Record<string, string>;
+    /** Entry parameters only — the subset a content lookup may use. */
+    entryParams: Record<string, string>;
+    /** The locale this URL renders. The project default when the path omits it. */
+    locale: string;
+    /** True when the locale came from a path segment rather than the default. */
+    localeFromPath: boolean;
+    /** Static segments matched. Higher wins when several routes match. */
+    score: number;
+}
+/** One URL shape a route produces for one locale. */
+export interface FimoRouteLocaleTarget {
+    locale: string;
+    /** Whether this locale renders behind a `/<locale>` prefix. */
+    prefixed: boolean;
+}
+export declare function normalizeRoutePath(path: string): string;
+/**
+ * True when the path declares a locale segment, in either spelling: the config
+ * writes `:locale`, a React Router registration writes `:locale?` when the
+ * segment may be omitted.
+ */
+export declare function hasLocaleSegment(path: string): boolean;
+/**
+ * Normalize one declared route into the contract every consumer reads.
+ *
+ * Parameter types resolve in this order:
+ * 1. an explicit `type`;
+ * 2. the reserved name `locale`, which infers the locale type;
+ * 3. otherwise the entry type, which is what every route written before
+ *    locale-aware routing existed relies on.
+ */
+export declare function resolveRouteContract<RouteConfig extends FimoRouteConfig>(id: string, route: RouteConfig): FimoRouteContract<RouteConfig>;
+export declare function resolveRouteContracts<RouteConfig extends FimoRouteConfig>(routes: Record<string, RouteConfig> | undefined): FimoRouteContract<RouteConfig>[];
+/**
+ * Match a concrete pathname against the project's routes.
+ *
+ * The truth table, for a route declared `/:locale/x/:slug` in a project whose
+ * default locale is `en`:
+ *
+ * | URL             | locale param | resolved locale | entry params        |
+ * | --------------- | ------------ | --------------- | ------------------- |
+ * | `/x/hello`      | optional     | `en` (default)  | `{ slug: 'hello' }` |
+ * | `/fr/x/bonjour` | optional     | `fr`            | `{ slug: 'bonjour'}`|
+ * | `/en/x/hello`   | optional     | no match        | —                   |
+ * | `/x/hello`      | required     | no match        | —                   |
+ * | `/en/x/hello`   | required     | `en`            | `{ slug: 'hello' }` |
+ *
+ * A route with no locale segment always resolves the default locale.
+ */
+export declare function matchFimoRoute<RouteConfig extends FimoRouteConfig>(pathnameOrUrl: string, config: Pick<FimoRoutesConfig<RouteConfig>, 'routes' | 'i18n'>): FimoRouteMatch<RouteConfig> | null;
+/**
+ * The URL shapes a route produces, one per locale it can render.
+ *
+ * A route without a locale segment produces a single default-locale URL: under
+ * path-prefix routing it has no way to express another locale in its path.
+ */
+export declare function routeLocaleTargets(contract: FimoRouteContract, config: Pick<FimoRoutesConfig, 'i18n'>): FimoRouteLocaleTarget[];
+/**
+ * Build the concrete URL for one locale target. Entry param values are
+ * URL-encoded; the locale segment is a prefix, never a substitution, so the
+ * canonical default-locale URL carries no locale at all.
+ */
+export declare function materializeRoutePath(contract: FimoRouteContract, target: FimoRouteLocaleTarget & {
+    params?: Record<string, string>;
+}): string;
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/routes/index.js

@@ -1,3 +1,335 @@
-// `fimo/routes` — the shared route contract read by every consumer of
-// `.fimo/config.json#routes`.
-export { FIMO_LOCALE_PARAM, hasLocaleSegment, materializeRoutePath, matchFimoRoute, normalizeRoutePath, resolveRouteContract, resolveRouteContracts, routeLocaleTargets, } from './contract.js';
+// ../../packages/routes/src/index.ts
+function normalizeFimoLocale(locale) {
+  const trimmed = locale?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const candidate = trimmed.replace(/_/g, "-");
+  try {
+    return Intl.getCanonicalLocales(candidate)[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function getFimoDefaultLocale(config) {
+  return normalizeFimoLocale(config?.i18n?.defaultLocale) ?? "en";
+}
+function getFimoLocales(config) {
+  const defaultLocale = getFimoDefaultLocale(config);
+  const locales = /* @__PURE__ */ new Set([defaultLocale]);
+  for (const locale of config?.i18n?.locales ?? []) {
+    const clean = normalizeFimoLocale(locale);
+    if (clean) {
+      locales.add(clean);
+    }
+  }
+  return [...locales];
+}
+var FIMO_LOCALE_PARAM = "locale";
+function normalizeRoutePath(path) {
+  const withSlash = path.startsWith("/") ? path : `/${path}`;
+  const collapsed = withSlash.replace(/\/{2,}/g, "/");
+  return collapsed.length > 1 ? collapsed.replace(/\/+$/, "") : collapsed;
+}
+function splitSegments(path) {
+  return path.split("/").filter(Boolean);
+}
+function isPlaceholder(segment) {
+  return segment.startsWith(":") && segment.length > 1;
+}
+function readPlaceholder(segment) {
+  if (!isPlaceholder(segment)) {
+    return null;
+  }
+  return {
+    name: segment.slice(1).replace(/[?*]$/, ""),
+    catchAll: segment.endsWith("*")
+  };
+}
+function hasLocaleSegment(path) {
+  return splitSegments(normalizeRoutePath(path)).some(
+    (segment) => segment === `:${FIMO_LOCALE_PARAM}` || segment === `:${FIMO_LOCALE_PARAM}?`
+  );
+}
+function resolveParamType(name, descriptor) {
+  if (descriptor?.type) {
+    return descriptor.type;
+  }
+  return name === FIMO_LOCALE_PARAM ? "locale" : "entry";
+}
+function buildLocaleParam(name, descriptor, index, issues) {
+  if (name !== FIMO_LOCALE_PARAM) {
+    issues.push({
+      param: name,
+      message: `Param "${name}" declares \`"type": "locale"\` but "${FIMO_LOCALE_PARAM}" is the only locale parameter name.`,
+      fix: `Rename the path segment and the descriptor to ":${FIMO_LOCALE_PARAM}", or use \`"type": "entry"\`.`
+    });
+    return null;
+  }
+  if (index !== 0) {
+    issues.push({
+      param: name,
+      message: `The ":${FIMO_LOCALE_PARAM}" segment must be the first segment of the path.`,
+      fix: `Move it to the front, for example "/:${FIMO_LOCALE_PARAM}/blog/:slug".`
+    });
+    return null;
+  }
+  for (const field of ["schema", "queryField", "displayField", "query"]) {
+    if (descriptor?.[field] !== void 0) {
+      issues.push({
+        param: name,
+        message: `Locale param "${name}" must not declare "${field}" \u2014 the locale is read from the URL, never from the CMS.`,
+        fix: `Remove "${field}" from \`params.${name}\`.`
+      });
+    }
+  }
+  return { type: "locale", name, optional: descriptor?.optional !== false };
+}
+function buildEntryParam(name, descriptor, issues) {
+  if (name === FIMO_LOCALE_PARAM) {
+    issues.push({
+      param: name,
+      message: `Param "${name}" is reserved for the locale segment and cannot use \`"type": "entry"\`.`,
+      fix: `Drop \`"type": "entry"\` from \`params.${name}\`, or rename the segment.`
+    });
+    return null;
+  }
+  if (!descriptor) {
+    issues.push({
+      param: name,
+      message: `":${name}" needs \`params\` metadata before its URLs can be generated.`,
+      fix: `Add \`"params": { "${name}": { "schema": "SchemaName", "queryField": "${name}" } }\`.`
+    });
+    return null;
+  }
+  if (descriptor.optional !== void 0) {
+    issues.push({
+      param: name,
+      message: `Entry param "${name}" cannot be optional \u2014 only the locale segment can be omitted from a URL.`,
+      fix: `Remove "optional" from \`params.${name}\`.`
+    });
+  }
+  if (!descriptor.schema || !descriptor.queryField) {
+    issues.push({
+      param: name,
+      message: `Entry param "${name}" is missing ${!descriptor.schema ? '"schema"' : '"queryField"'}.`,
+      fix: `Set \`"${name}": { "schema": "SchemaName", "queryField": "${name}" }\`.`
+    });
+    return null;
+  }
+  return {
+    type: "entry",
+    name,
+    schema: descriptor.schema,
+    queryField: descriptor.queryField,
+    ...descriptor.displayField ? { displayField: descriptor.displayField } : {}
+  };
+}
+function resolveRouteContract(id, route) {
+  const path = normalizeRoutePath(route.path ?? "/");
+  const segments = splitSegments(path);
+  const declared = route.params ?? {};
+  const issues = [];
+  const params = [];
+  const unresolvedParams = [];
+  const seen = /* @__PURE__ */ new Set();
+  segments.forEach((segment, index) => {
+    if (!isPlaceholder(segment)) {
+      return;
+    }
+    const placeholder = readPlaceholder(segment);
+    if (!placeholder) {
+      return;
+    }
+    const { name } = placeholder;
+    if (seen.has(name)) {
+      issues.push({
+        param: name,
+        message: `Placeholder ":${name}" appears more than once.`,
+        fix: "Give each placeholder a distinct name."
+      });
+      unresolvedParams.push(name);
+      return;
+    }
+    seen.add(name);
+    const descriptor = declared[name];
+    const resolved = resolveParamType(name, descriptor) === "locale" ? buildLocaleParam(name, descriptor, index, issues) : buildEntryParam(name, descriptor, issues);
+    if (resolved) {
+      params.push(resolved);
+    } else {
+      unresolvedParams.push(name);
+    }
+  });
+  for (const name of Object.keys(declared)) {
+    if (!seen.has(name)) {
+      issues.push({
+        param: name,
+        message: `Declared param "${name}" has no ":${name}" segment in the path.`,
+        fix: `Add ":${name}" to the path, or remove it from "params".`
+      });
+    }
+  }
+  const localeParam = params.find((param) => param.type === "locale") ?? null;
+  const canonicalPath = localeParam ? normalizeRoutePath(`/${segments.filter((segment) => segment !== `:${FIMO_LOCALE_PARAM}`).join("/")}`) : path;
+  return {
+    id,
+    config: route,
+    path,
+    canonicalPath,
+    params,
+    entryParams: params.filter((param) => param.type === "entry"),
+    localeParam,
+    unresolvedParams,
+    issues
+  };
+}
+function resolveRouteContracts(routes) {
+  return Object.entries(routes ?? {}).map(([id, route]) => resolveRouteContract(id, route));
+}
+function readLocaleVocabulary(config) {
+  return {
+    locales: config.i18n ? getFimoLocales(config) : null,
+    defaultLocale: getFimoDefaultLocale(config)
+  };
+}
+function acceptsLocaleSegment(segment, localeParam, vocabulary) {
+  if (!vocabulary.locales) {
+    return segment.length > 0;
+  }
+  if (!vocabulary.locales.includes(segment)) {
+    return false;
+  }
+  return localeParam.optional ? segment !== vocabulary.defaultLocale : true;
+}
+function matchContract(urlSegments, contract, vocabulary) {
+  const patternSegments = splitSegments(contract.path);
+  const localeParam = contract.localeParam;
+  const catchAllIndex = patternSegments.findIndex((segment) => readPlaceholder(segment)?.catchAll);
+  const hasCatchAll = catchAllIndex !== -1;
+  const hasLocaleLength = hasCatchAll ? urlSegments.length >= patternSegments.length : urlSegments.length === patternSegments.length;
+  const withLocale = localeParam?.optional ? hasLocaleLength && acceptsLocaleSegment(urlSegments[0] ?? "", localeParam, vocabulary) : hasLocaleLength;
+  const withoutLocale = Boolean(localeParam?.optional) && (hasCatchAll ? urlSegments.length >= patternSegments.length - 1 : urlSegments.length === patternSegments.length - 1);
+  if (!localeParam && !withLocale) {
+    return null;
+  }
+  if (localeParam && !withLocale && !withoutLocale) {
+    return null;
+  }
+  const params = {};
+  const entryParams = {};
+  let localeFromPath = null;
+  let score = 0;
+  let offset = 0;
+  for (const [index, patternSegment] of patternSegments.entries()) {
+    if (localeParam && patternSegment === `:${FIMO_LOCALE_PARAM}`) {
+      if (!withLocale) {
+        offset = -1;
+        continue;
+      }
+      const value2 = urlSegments[index];
+      if (!acceptsLocaleSegment(value2, localeParam, vocabulary)) {
+        return null;
+      }
+      localeFromPath = value2;
+      params[FIMO_LOCALE_PARAM] = value2;
+      continue;
+    }
+    const value = urlSegments[index + offset];
+    if (value === void 0) {
+      return null;
+    }
+    const placeholder = readPlaceholder(patternSegment);
+    if (placeholder) {
+      const { name, catchAll } = placeholder;
+      const rawValue = catchAll ? urlSegments.slice(index + offset).join("/") : value;
+      const decoded = safeDecode(rawValue);
+      params[name] = decoded;
+      entryParams[name] = decoded;
+      if (catchAll) {
+        break;
+      }
+      continue;
+    }
+    if (patternSegment !== value) {
+      return null;
+    }
+    score += 1;
+  }
+  return {
+    contract,
+    params,
+    entryParams,
+    locale: localeFromPath ?? vocabulary.defaultLocale,
+    localeFromPath: localeFromPath !== null,
+    score
+  };
+}
+function readPathname(input) {
+  try {
+    return new URL(input, "http://fimo.invalid").pathname;
+  } catch {
+    return input.split("#")[0].split("?")[0] || "/";
+  }
+}
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function matchFimoRoute(pathnameOrUrl, config) {
+  const urlSegments = splitSegments(normalizeRoutePath(readPathname(pathnameOrUrl)));
+  const vocabulary = readLocaleVocabulary(config);
+  let best = null;
+  for (const contract of resolveRouteContracts(config.routes)) {
+    if (!contract.config.path) {
+      continue;
+    }
+    const match = matchContract(urlSegments, contract, vocabulary);
+    if (match && (!best || match.score > best.score)) {
+      best = match;
+    }
+  }
+  return best;
+}
+function routeLocaleTargets(contract, config) {
+  const defaultLocale = getFimoDefaultLocale(config);
+  if (!contract.localeParam) {
+    return [{ locale: defaultLocale, prefixed: false }];
+  }
+  const optional = contract.localeParam.optional;
+  return getFimoLocales(config).map((locale) => ({
+    locale,
+    prefixed: optional ? locale !== defaultLocale : true
+  }));
+}
+function materializeRoutePath(contract, target) {
+  const params = target.params ?? {};
+  const substituted = splitSegments(contract.canonicalPath).map((segment) => {
+    const placeholder = readPlaceholder(segment);
+    if (!placeholder) {
+      return segment;
+    }
+    const value = params[placeholder.name];
+    if (value === void 0) {
+      return segment;
+    }
+    return placeholder.catchAll ? value.split("/").map((part) => encodeURIComponent(part)).join("/") : encodeURIComponent(value);
+  });
+  const prefix = target.prefixed ? [target.locale] : [];
+  return normalizeRoutePath(`/${[...prefix, ...substituted].join("/")}`);
+}
+export {
+  FIMO_LOCALE_PARAM,
+  getFimoDefaultLocale,
+  getFimoLocales,
+  hasLocaleSegment,
+  matchFimoRoute,
+  materializeRoutePath,
+  normalizeFimoLocale,
+  normalizeRoutePath,
+  resolveRouteContract,
+  resolveRouteContracts,
+  routeLocaleTargets
+};

package/dist/runtime/seo/resolver.js

@@ -1,4 +1,4 @@
-import { matchFimoRoute } from '../routes/contract.js';
+import { matchFimoRoute } from '../routes/index.js';
 /**
  * Shared SEO resolver for the generated app.
  *

package/dist/runtime/shared/fimo-config.types.d.ts

@@ -1,3 +1,4 @@
+import type { FimoRouteConfig as SharedFimoRouteConfig, FimoRouteParamConfig as SharedFimoRouteParamConfig } from '../routes/index.js';
 export type FimoFramework = 'astro' | 'nextjs' | 'nuxtjs' | 'react-router' | 'remix' | 'sveltekit' | 'vite' | 'vue';
 export interface FimoRuntimeCommands {
     dev?: string;
@@ -44,38 +45,12 @@ export interface RouteSEO {
  * A path parameter descriptor as it appears in `.fimo/config.json`.
  *
  * Deliberately permissive — it mirrors hand-written JSON. `resolveRouteContract`
- * in `runtime/routes/contract.ts` narrows it into the discriminated
+ * from the public `fimo/routes` entry narrows it into the discriminated
  * `FimoRouteParam` union and reports whatever does not add up; `fimo validate`
  * surfaces those issues.
  */
-export interface FimoRouteParamConfig {
-    /**
-     * Omitted means `'entry'`, which is what every route written before
-     * locale-aware routing relies on. The reserved name `locale` infers
-     * `'locale'` instead.
-     */
-    type?: 'entry' | 'locale';
-    /** Entry params only, and required for them. */
-    schema?: string;
-    queryField?: string;
-    displayField?: string;
-    query?: import('@fimo/api-contracts').PageCollectionSourceQuery;
-    /** Locale params only. Defaults to true: the default locale is unprefixed. */
-    optional?: boolean;
-}
-export interface FimoRouteConfig {
-    label?: string;
-    path?: string;
-    group?: string;
-    content?: {
-        labels?: string[];
-        singles?: string[];
-    };
-    sources?: import('@fimo/api-contracts').PageSources;
-    icon?: string;
-    params?: Record<string, FimoRouteParamConfig>;
-    seo?: RouteSEO;
-}
+export type FimoRouteParamConfig = SharedFimoRouteParamConfig<import('@fimo/api-contracts').PageCollectionSourceQuery>;
+export type FimoRouteConfig = SharedFimoRouteConfig<import('@fimo/api-contracts').PageSources, import('@fimo/api-contracts').PageCollectionSourceQuery, RouteSEO>;
 export interface FimoI18nRoutingConfig {
     /**
      * Legacy compatibility for projects that still carry a global routing

package/dist/runtime/templates.d.ts

@@ -62,6 +62,25 @@ interface PkgWithDeps {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;
 }
+interface PkgWithScripts {
+    scripts?: Record<string, string>;
+}
+/**
+ * Point the build script's `fimo validate` at the exact CLI that scaffolded the
+ * project.
+ *
+ * Inside an npm script a bare `fimo` resolves to whatever is installed in the
+ * project, which is normally the pinned dependency — but only when the install
+ * is current. The hosted build installs the tree itself and then runs this
+ * script, and `validate` is an API client: resolving it from install state
+ * means a project can be checked by a different version than the one it pins,
+ * which is how a project can look clean locally and fail on publish.
+ *
+ * Only an exact npm version is pinned. A source checkout resolves to
+ * `file:<path>`, which is not an npx spec — and there a bare `fimo` already
+ * runs the very binary being developed, which is the point of that flow.
+ */
+export declare function rewriteFimoValidateCommand(pkg: PkgWithScripts, pin?: string | null): boolean;
 /**
  * Rewrite `fimo` (in dependencies + devDependencies) to the current pin. Only
  * touches entries that look like a value we own: the template's dist-tag, an old