@valbuild/core 0.146.2 → 0.148.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @valbuild/core
 
+## 0.148.0
+
+### Patch Changes
+
+- [#818](https://github.com/valbuild/val/pull/818) [`562d032`](https://github.com/valbuild/val/commit/562d03280c3fcf97a80562e8b017dd2125ac4ad1) Thanks [@freekh](https://github.com/freekh)! - Remote files served from a project's own site (addresses like
+  `https://www.acme.no/_val/file/…`) are now checked for whether that address
+  still serves the project. When a custom domain has been removed or moved to
+  another project, the image or file is reported, and **Fix** on the Studio's
+  Validate page — or `val validate --fix` — points it at the project's permanent
+  `<id>.valstart.dev` address. Nothing is uploaded or downloaded: only the address
+  changes.
+
+  Remote file addresses with a `/_val` prefix after the host are now recognised.
+
+## 0.147.0
+
+### Minor Changes
+
+- [#816](https://github.com/valbuild/val/pull/816) [`2f09cd5`](https://github.com/valbuild/val/commit/2f09cd5e2f4fc37f06917899f24f9ad2ee8d3a8b) Thanks [@freekh](https://github.com/freekh)! - Routers can give each route parameter a schema, and a URL can say which language a page is in.
+
+  - **`s.router(router, params, item)`** takes a schema per route parameter, by the name the route file gives it (`$slug`, `[slug]`, `{-$locale}`). Each key's parameters are validated against them, and a name the route does not have is a schema error.
+
+    ```ts
+    s.router(tanstackRouter, { locale: urlLocale, slug: s.string() }, item);
+    ```
+
+  - **`s.enum(...).locales({ ... })`** says which of the project's languages each value means, so `/nb/…` can mean `nb-NO`. The tags are checked against `locales.available` in the settings module, like `s.locale()`. On a nullable enum, a second argument names the language of a URL that leaves the segment out, which only a router parameter may use:
+
+    ```ts
+    const urlLocale = s
+      .enum("nb")
+      .nullable()
+      .locales({ nb: "nb-NO" }, { null: "en-US" });
+    ```
+
+    A router with a locale parameter makes each page a locale scope, so the Studio and validation know which language every page is in.
+
+  - **A route's language segment can no longer be forgotten.** In a project that declares `locales.available`, a page route with a `locale` or `lang` segment (`{-$locale}`, `[lang]`) whose module gives that parameter no schema is reported, saying what to add. Any schema answers it, so a `$lang` that is not a language is silenced with its own, e.g. `{ lang: s.enum("typescript", "python") }`. It is an ordinary validation error: the Studio still opens and `val validate` lists it, but a project that already has such a route will see it after upgrading, and it blocks publishing until the parameter has a schema.
+  - **The Studio's new-page form offers a language as a list.** A route parameter whose schema is a locale is picked from the project's languages, each named in its own language, with "no prefix" where the URL may leave the segment out. Other enum parameters get a list of their values, and every parameter's description is shown under it. The URL row previews what the choice puts there.
+  - **TanStack optional segments (`{-$param}`)** are now understood: route validation, `useValRoute` and the Studio's new-page form accept keys with and without the segment.
+
 ## 0.146.2
 
 ### Patch Changes

package/dist/declarations/src/getSourcePathFromRoute.d.ts

@@ -22,3 +22,12 @@ export declare function getSourcePathFromRoute(pathname: string, schemas: Record
  * which is which.
  */
 export declare function isPageRouter(routerId: string): boolean;
+/**
+ * The route pattern a page router's module serves, or `null` for a router
+ * whose keys are not routes of this site.
+ *
+ * By router id, for the callers that hold a SERIALIZED schema — which carries
+ * the id and not the router. A schema instance asks its router directly
+ * (`ValRouter.getRoutePattern`), and both end at the same parser.
+ */
+export declare function routePatternOf(routerId: string, moduleFilePath: ModuleFilePath): string[] | null;

package/dist/declarations/src/index.d.ts

@@ -93,8 +93,8 @@ export { deserializeSchema } from "./schema/deserialize.js";
 export { type PreviewItem, type ItemPreviewInput, type RecordPreview, type ArrayPreview, type ReifiedPreview, type PreviewScope, previewScope, } from "./preview.js";
 export { type InlineRender, type FieldRender, type SliderRender, type NumberRender, isInlineRender, } from "./render.js";
 export type { ValRouter, ExternalPageRouter, RouteValidationError, } from "./router.js";
-export { parseNextJsRoutePattern, parseTanStackRoutePattern, tanStackSegmentsOfRoutePath, validateUrlAgainstPattern, } from "./router.js";
-export { getSourcePathFromRoute, isPageRouter } from "./getSourcePathFromRoute.js";
+export { parseNextJsRoutePattern, parseTanStackRoutePattern, tanStackSegmentsOfRoutePath, validateUrlAgainstPattern, matchRoutePattern, } from "./router.js";
+export { getSourcePathFromRoute, isPageRouter, routePatternOf, } from "./getSourcePathFromRoute.js";
 /**
  * Which URL schemes an external page key may carry.
  *
@@ -113,11 +113,12 @@ export declare const DEFAULT_APP_HOST = "https://admin.val.build";
  * Where Val's own immutable build artifacts are served from: the content
  * service's `/v1/static`.
  *
- * Only one kind of thing lives here so far: the WebAssembly binary of the
- * bundler the Studio builds a site with. It cannot travel with the Studio's
- * own bundle -- 10.9 MB of binary, and `/api/val/static` is a base64 record of
- * TEXT inside the server bundle, which both corrupts it and would carry it
- * into every project that installs `@valbuild/ui`.
+ * Only one kind of thing lives here so far: the WebAssembly the Studio loads
+ * -- the bundler it builds a site with, and the WebP encoder it uses where the
+ * canvas cannot write WebP. None of it can travel with the Studio's own bundle:
+ * `/api/val/static` is a base64 record of TEXT inside the server bundle, which
+ * both corrupts a binary and would carry it (10.9 MB of bundler) into every
+ * project that installs `@valbuild/ui`.
  *
  * Everything under this path is addressed by the SHA-256 of its own bytes, so
  * an upload is idempotent, a URL is immutable, and the artifact a build asks
@@ -129,11 +130,11 @@ export declare const DEFAULT_APP_HOST = "https://admin.val.build";
  * availability and one more domain to every customer's egress allowlist.
  *
  * A FIXED LITERAL, and deliberately not derived from a project's configured
- * content host (`VAL_CONTENT_URL`). Deriving it would make serving this binary
+ * content host (`VAL_CONTENT_URL`). Deriving it would make serving these binaries
  * an obligation of every content service anybody points Val at, self-hosted
- * ones included. A deployment that must fetch it from somewhere else sets
- * `globalThis.__VAL_ROLLDOWN_WASM_URL__` instead (see
- * `packages/ui/build/rolldownWasm.ts`).
+ * ones included. A deployment that must fetch them from somewhere else sets
+ * one global per binary instead -- `globalThis.__VAL_ROLLDOWN_WASM_URL__` and
+ * the others listed in `packages/ui/build/staticWasm.ts`.
  */
 export declare const DEFAULT_STATIC_HOST = "https://content.val.build/v1/static";
 declare const Internal: {

package/dist/declarations/src/initSchema.d.ts

@@ -393,6 +393,25 @@ export type InitSchema = {
      * });
      * ```
      *
+     * @example Route parameters, by the names the route file gives them
+     * ```typescript
+     * import { s, c, tanstackRouter } from "../val.config";
+     * // `/about` is English and `/nb/about` Norwegian: `{-$locale}` is an
+     * // optional segment, and `{ null }` says what a URL without it is in.
+     * const locale = s
+     *   .enum("nb")
+     *   .nullable()
+     *   .locales({ nb: "nb-NO" }, { null: "en-US" });
+     * export default c.define(
+     *   "/src/routes/{-$locale}.$slug.val.ts",
+     *   s.router(tanstackRouter, { locale, slug: s.string() }, s.object({ title: s.string() })),
+     *   {
+     *     "/about": { title: "About us" },
+     *     "/nb/about": { title: "Om oss" },
+     *   },
+     * );
+     * ```
+     *
      * @param router - The router configuration (e.g., nextAppRouter)
      * @param schema - The schema for each route item
      * @returns A RecordSchema configured as a router

package/dist/declarations/src/remote/fileHash.d.ts

@@ -1,3 +1,2 @@
-import { Buffer } from "buffer";
 export declare function hashToRemoteFileHash(hash: string): string;
-export declare function getFileHash(text: Buffer): string;
+export declare function getFileHash(bytes: Uint8Array): string;

package/dist/declarations/src/router.d.ts

@@ -33,6 +33,37 @@ export type RouteValidationError = {
         expectedPath: string | null;
     };
 };
+/**
+ * The value of each parameter a URL gives a route pattern, or `null` when the
+ * URL is not one of that pattern's.
+ *
+ * A parameter that an OPTIONAL segment left out is `null` rather than absent,
+ * so a caller can tell "this route has no such parameter" from "this URL did
+ * not use it". A catch-all's segments are joined with `/`, which is how they
+ * appear in the key; an optional catch-all with nothing to catch is `null`.
+ *
+ * The pattern vocabulary is the one both parsers produce: `[name]` is a
+ * segment, `[[name]]` an optional one, `[...name]` a catch-all and
+ * `[[...name]]` an optional catch-all; anything else is literal.
+ *
+ * Optional segments are what make this a search rather than a walk: in
+ * `/[[locale]]/blog/[slug]` the URL `/blog/hello` only matches once `blog`
+ * has been tried as the locale and given back. A present segment is tried
+ * first, so `/nb/blog/hello` reads as the locale `nb` — the reading the router
+ * itself makes.
+ */
+export declare function matchRoutePattern(urlPath: string, routePattern: string[]): Record<string, string | null> | null;
+/**
+ * The parameters a route pattern has, by name, and whether a URL may leave
+ * each one out.
+ */
+export declare function routeParamsOfPattern(routePattern: string[]): {
+    name: string;
+    optional: boolean;
+}[];
+/**
+ * Whether a URL is one of a route pattern's, and the pattern to show when not.
+ */
 export declare function validateUrlAgainstPattern(urlPath: string, routePattern: string[]): {
     isValid: boolean;
     expectedPath?: string;
@@ -61,6 +92,7 @@ export declare function parseNextJsRoutePattern(moduleFilePath: string): string[
  * - `.` and `/` both separate segments (`posts.$postId.val.ts` and
  *   `posts/$postId.val.ts` are the same route)
  * - `$param` is a dynamic segment, `$` on its own is a splat
+ * - `{-$param}` is an optional segment, written `[[param]]`
  * - `index` is the directory's own route and contributes no segment
  * - `route` is a layout for the directory, likewise
  * - `(group)` folders and `_pathless` layout segments are not in the URL
@@ -75,6 +107,7 @@ export declare function parseNextJsRoutePattern(moduleFilePath: string): string[
  * - /routes/posts/$postId.val.ts     -> ["posts", "[postId]"]
  * - /src/routes/index.val.ts         -> []
  * - /src/routes/files.$.val.ts       -> ["files", "[..._splat]"]
+ * - /src/routes/{-$locale}.about.val.ts -> ["[[locale]]", "about"]
  * - /src/routes/(app)/_layout.about.val.ts -> ["about"]
  */
 export declare function parseTanStackRoutePattern(moduleFilePath: string): string[];
@@ -105,5 +138,14 @@ export interface ValRouter {
      * than URLs, which is every other one.
      */
     getUrlSchemePolicy?(): ExternalUrlSchemePolicy;
+    /**
+     * The route pattern a module of this router serves, in the `[param]`
+     * vocabulary — see {@link matchRoutePattern}.
+     *
+     * What lets `s.router(router, { locale: …, slug: … }, item)` find a key's
+     * parameters by NAME. Absent on a router whose keys are not paths of this
+     * site, which therefore has no parameters to give a schema to.
+     */
+    getRoutePattern?(moduleFilePath: ModuleFilePath): string[];
     validate(moduleFilePath: ModuleFilePath, urlPaths: string[]): RouteValidationError[];
 }

package/dist/declarations/src/schema/enum.d.ts

@@ -11,6 +11,16 @@ export type SerializedEnumSchema = {
      * the editor's dropdown offers them in.
      */
     values: string[];
+    /**
+     * Set by `.locales(...)`: the project language each value MEANS, by value.
+     * Its presence is what makes this enum a locale — see `EnumSchema.locales`.
+     */
+    locales?: Record<string, string>;
+    /**
+     * Set by `.locales(..., { null: tag })`: the language of a URL that leaves
+     * this route parameter out. Only meaningful on a router parameter.
+     */
+    nullLocale?: string;
     opt: boolean;
     customValidate?: boolean;
     readonly?: boolean;
@@ -34,6 +44,10 @@ export declare class EnumSchema<Src extends string | null> extends Schema<Src> {
     private readonly isHidden;
     private readonly description?;
     private readonly previewInput;
+    /** Set by `.locales(...)`: the language each value means. */
+    private readonly localeMap;
+    /** Set by `.locales(..., { null })`: the language of a missing segment. */
+    private readonly nullLocale;
     /**
      * Type-only marker: as a record key, this declares the key set.
      *
@@ -43,7 +57,11 @@ export declare class EnumSchema<Src extends string | null> extends Schema<Src> {
      * cannot be a record key at all. See `LocaleSchema`.
      */
     readonly __declaresRecordKeys: true;
-    constructor(values: readonly string[], opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
+    constructor(values: readonly string[], opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null, 
+    /** Set by `.locales(...)`: the language each value means. */
+    localeMap?: Readonly<Record<string, string>> | null, 
+    /** Set by `.locales(..., { null })`: the language of a missing segment. */
+    nullLocale?: string | null);
     /**
      * Describe this field.
      *
@@ -85,10 +103,108 @@ export declare class EnumSchema<Src extends string | null> extends Schema<Src> {
      */
     validate(validationFunction: (src: Src) => false | string): EnumSchema<Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    /**
+     * Validate the value a URL gives a route parameter — see
+     * `s.router(router, params, item)`.
+     *
+     * Not `executeValidate`, because one thing is right here that is wrong on a
+     * field: `{ null: tag }`. A URL that leaves out an optional segment has a
+     * language someone chose; a field that holds `null` has none, and Val does
+     * not guess one for it.
+     */
+    protected validateRouteParam(path: SourcePath, src: Src): ValidationErrors;
+    private validateAs;
+    /**
+     * The tag `value` is mapped to, or `null` where the mapping does not name it.
+     *
+     * An OWN property, not `in`: a mapping that came back from JSON is a plain
+     * object, which inherits `toString` and its siblings — and an enum value may
+     * be spelled like one of them, which would read as mapped when it is not.
+     */
+    private localeTagOf;
+    /**
+     * The cross-module half of the check: is `tag` one of the project's
+     * languages? The same deferred error `s.locale()` reports, resolved by
+     * `resolveSchemaSourceFixes` against `locales.available` — so a mapped
+     * value and a written-out tag are checked by one implementation.
+     */
+    private checkLocale;
+    /**
+     * What is wrong with the mapping itself, whatever the value is.
+     *
+     * The compiler checks all of this for a schema written in TypeScript except
+     * the spelling and the uniqueness of the tags; the rest is here for a schema
+     * that came back from JSON.
+     */
+    protected localeMappingErrors(): ValidationError[];
+    private localeMappingErrorsMemo?;
+    private computeLocaleMappingErrors;
     protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): EnumSchema<Src | null>;
     readonly(isReadonly?: boolean): EnumSchema<Src>;
     hidden(isHidden?: boolean): EnumSchema<Src>;
+    /**
+     * Say which of the project's languages each value MEANS — which makes this
+     * enum a locale, the way `s.locale()` is one.
+     *
+     * For a value that is not a language tag itself: most often a route
+     * parameter, where a site writes `/nb/…` and means `nb-NO`. The values are
+     * what is stored (and what is in the URL); the tags on the right are what
+     * they mean, and those are checked against `locales.available` in the
+     * settings module exactly as an `s.locale()` value is.
+     *
+     * On a nullable enum it takes an optional second argument, `{ null: tag }`:
+     * the language of a URL that leaves the segment out, which is how a site
+     * serves its default language without a prefix. That is ONLY for a router
+     * parameter, where leaving it out of a nullable one is reported on every URL
+     * without the segment. On a field `null` means nobody chose a language, and
+     * saying which one it "really" is would file content under a language
+     * nobody picked, so there it is a schema error.
+     *
+     * One spelling per language: two values (or a value and `null`) that mean
+     * the same tag would give one page two URLs in that language.
+     *
+     * @example // a route parameter: `/about` is English, `/nb/about` Norwegian
+     * import { tanstackRouter } from "../val.config";
+     * const urlLocale = s
+     *   .enum("nb")
+     *   .nullable()
+     *   .locales({ nb: "nb-NO" }, { null: "en-US" });
+     * const schema = s.router(
+     *   tanstackRouter,
+     *   { locale: urlLocale },
+     *   s.object({ title: s.string() }),
+     * );
+     * export default c.define("/src/routes/{-$locale}.about.val.ts", schema, {
+     *   "/about": { title: "About us" },
+     *   "/nb/about": { title: "Om oss" },
+     * });
+     *
+     * @example // a field that stores a short code
+     * const schema = s.object({
+     *   language: s.enum("en", "nb").locales({ en: "en-US", nb: "nb-NO" }),
+     *   title: s.string(),
+     * });
+     * export default c.define("/example.val.ts", schema, {
+     *   language: "nb",
+     *   title: "Vinterjakke",
+     * });
+     */
+    locales(locales: {
+        readonly [Value in NonNullable<Src>]: string;
+    }, ...whenNull: null extends Src ? [whenNull?: {
+        null: string;
+    }] : []): EnumSchema<Src>;
+    /**
+     * The language of a URL that leaves this parameter out, where one was given.
+     * For `RecordSchema`, which checks that the route can leave it out at all.
+     */
+    protected routeParamNullLocale(): string | null;
+    /**
+     * Whether `.locales(...)` made this enum a language. If so, an object with
+     * it as a field is in that language, the same as one with `s.locale()`.
+     */
+    protected isLocaleField(): boolean;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     /**
      * How this VALUE is shown where a preview of it is needed — a row in a

package/dist/declarations/src/schema/index.d.ts

@@ -97,6 +97,11 @@ export declare abstract class Schema<Src extends SelectorSource> {
      * and the reason it is validated rather than typed.
      */
     protected opensLocaleScope(): "field" | "key" | null;
+    /**
+     * What to call this node in a message about the scope it opens: "object" for
+     * one with a locale field, "locale-keyed record" for a record keyed by one.
+     */
+    protected localeScopeName(): string;
     /**
      * The child schemas a locale scope reaches, by the path segment that reaches
      * them.

package/dist/declarations/src/schema/record.d.ts

@@ -59,6 +59,11 @@ export type SerializedRecordSchema = {
      * wide default, which the Studio knows on its own.
      */
     routerSchemes?: string[];
+    /**
+     * A router's parameter schemas, by the name the route file gives each one.
+     * See `s.router(router, params, item)`.
+     */
+    params?: Record<string, SerializedSchema>;
     customValidate?: boolean;
     mediaType?: MediaCollectionType;
     accept?: string;
@@ -116,28 +121,36 @@ RO extends boolean = false> extends Schema<Src> {
     /**
      * Set by `.external(label)`; the entries live behind that adapter.
      *
-     * LAST on purpose: every other `new RecordSchema(...,
-      this.externalLabel,
-    )` in the codebase
-     * passes its arguments positionally, so a new parameter anywhere else
-     * silently shifts `previewInput` and `renderInput` at each of those call
-     * sites.
+     * Appended rather than inserted, and so is everything after it: every
+     * `new RecordSchema(...)` in the codebase passes its arguments
+     * positionally, so a new parameter anywhere else silently shifts
+     * `previewInput` and `renderInput` at each of those call sites.
      */
     private readonly externalLabel;
+    /**
+     * Set by `s.router(router, { name: schema }, item)`: a schema for each
+     * route parameter, by the name the route file gives it. See
+     * `getRouteParamValidations`.
+     */
+    private readonly routeParams;
     constructor(item: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], currentRouter?: ValRouter | null, keySchema?: Schema<string> | null, mediaOptions?: MediaOptions | undefined, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, 
     /** When true, entry values are lazily loaded {@link JsonSource} thunks. */
     isJsonValues?: boolean, previewInput?: ItemPreviewInput<Src> | null, renderInput?: FieldRender | null, 
     /**
      * Set by `.external(label)`; the entries live behind that adapter.
      *
-     * LAST on purpose: every other `new RecordSchema(...,
-      this.externalLabel,
-    )` in the codebase
-     * passes its arguments positionally, so a new parameter anywhere else
-     * silently shifts `previewInput` and `renderInput` at each of those call
-     * sites.
+     * Appended rather than inserted, and so is everything after it: every
+     * `new RecordSchema(...)` in the codebase passes its arguments
+     * positionally, so a new parameter anywhere else silently shifts
+     * `previewInput` and `renderInput` at each of those call sites.
+     */
+    externalLabel?: string | null, 
+    /**
+     * Set by `s.router(router, { name: schema }, item)`: a schema for each
+     * route parameter, by the name the route file gives it. See
+     * `getRouteParamValidations`.
      */
-    externalLabel?: string | null);
+    routeParams?: Readonly<Record<string, Schema<string | null>>> | null);
     /**
      * Describe this field.
      *
@@ -212,6 +225,7 @@ RO extends boolean = false> extends Schema<Src> {
     private declaredKeys;
     private declaredKeySet;
     protected opensLocaleScope(): "field" | "key" | null;
+    protected localeScopeName(): string;
     protected localeScopeChildren(): {
         key: string;
         schema: Schema<SelectorSource>;
@@ -364,6 +378,38 @@ RO extends boolean = false> extends Schema<Src> {
      */
     private validateExternal;
     private getRouterValidations;
+    /**
+     * Validate what each key gives its route parameters, against the schema
+     * `s.router(router, { name: schema }, item)` gave that parameter.
+     *
+     * The parameters are bound by NAME — the name the route file gives them
+     * (`$slug`, `[slug]`, `{-$locale}`) — rather than by position, so renaming
+     * or adding a segment in the route file cannot silently hand one
+     * parameter's schema to another. A name the route does not have is
+     * therefore a schema error rather than a parameter that is never checked.
+     *
+     * Keys that do not match the route at all are left to the router's own
+     * validation, which says what the route expects; there is nothing here to
+     * give a parameter.
+     */
+    private getRouteParamValidations;
+    /**
+     * A marker for each `locale` or `lang` segment of this page's route that no
+     * route parameter schema describes.
+     *
+     * A router only checks a key's language when its module says which
+     * parameter is the language — `s.router(router, { locale: urlLocale, … },
+     * item)` — and that is written again in every route module. Forgetting it in
+     * one is silent: `/xx/blog/hello` validates and the page is in no language.
+     *
+     * A marker (`router:check-locale-param`) rather than an error, because
+     * whether it is a mistake depends on whether the project declares languages
+     * at all, which is in the settings module; `resolveSchemaSourceFixes`
+     * answers it. Any schema for the parameter is an answer — `{ lang:
+     * s.enum("typescript", "python") }` is how a `$lang` that is not a language
+     * says so.
+     */
+    private getUndescribedLocaleParamMarkers;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     protected executeSerialize(): SerializedRecordSchema;
     /**

package/dist/declarations/src/schema/router.d.ts

@@ -2,5 +2,13 @@ import { Schema, SelectorOfSchema } from "./index.js";
 import { ValRouter } from "../router.js";
 import { SelectorSource } from "../selector/index.js";
 import { RecordSchema } from "./record.js";
+/**
+ * A schema for each of a route's parameters, by the name the route file gives
+ * it: `$slug` / `[slug]` is `slug`, `{-$locale}` is `locale`.
+ */
+export type RouteParamSchemas = {
+    readonly [name: string]: Schema<string | null>;
+};
 export declare function router<K extends Schema<string>, T extends Schema<SelectorSource>>(router: ValRouter, key: K, item: T): RecordSchema<T, K, Record<SelectorOfSchema<K>, SelectorOfSchema<T>>>;
+export declare function router<T extends Schema<SelectorSource>>(router: ValRouter, params: RouteParamSchemas, item: T): RecordSchema<T, Schema<string>, Record<string, SelectorOfSchema<T>>>;
 export declare function router<T extends Schema<SelectorSource>>(router: ValRouter, item: T): RecordSchema<T, Schema<string>, Record<string, SelectorOfSchema<T>>>;

package/dist/declarations/src/schema/validation/ValidationFix.d.ts

@@ -1,2 +1,2 @@
-export declare const ValidationFix: readonly ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "images:check-remote", "images:upload-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", "files:check-remote", "files:upload-remote", "video:add-metadata", "video:upload-remote", "video:download-remote", "videos:add-metadata", "videos:check-remote", "videos:upload-remote", "keyof:check-keys", "image:check-gallery", "file:check-gallery", "video:check-gallery", "router:check-route", "locale:check-locale", "images:check-unique-folder", "files:check-unique-folder", "images:check-all-files", "files:check-all-files", "videos:check-unique-folder", "videos:check-all-files", "jsonValues:extract-entry", "record:fill-keys", "external:upload", "view:check-module"];
+export declare const ValidationFix: readonly ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "images:check-remote", "images:upload-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", "files:check-remote", "files:upload-remote", "video:add-metadata", "video:upload-remote", "video:download-remote", "videos:add-metadata", "videos:check-remote", "videos:upload-remote", "keyof:check-keys", "image:check-gallery", "file:check-gallery", "video:check-gallery", "router:check-route", "locale:check-locale", "router:check-locale-param", "images:check-unique-folder", "files:check-unique-folder", "images:check-all-files", "files:check-all-files", "videos:check-unique-folder", "videos:check-all-files", "jsonValues:extract-entry", "record:fill-keys", "external:upload", "view:check-module", "remote:rewrite-host"];
 export type ValidationFix = (typeof ValidationFix)[number];