@cookbook/urlkit 1.1.0 → 1.2.0

package/README.md

@@ -181,7 +181,7 @@ ArticleUrl.build({ params: { slug: 'post-1' } });
 // ArticleUrl.build({ pathname: '/articles/post-1' });
 ```
 
-Path params are inferred from the pattern. Built-in `int`, `decimal` and `range` path constraints parse to numbers in standalone `url(...)` contracts.
+Path params are inferred from the pattern. Built-in `int`, `decimal` and `range` path constraints parse to numbers in standalone `url(...)` contracts. PathKit does not expose a `{param:number}` built-in; use `{param:decimal}` for finite decimal path values.
 
 ```ts
 const UserUrl = url({ path: '/users/{id:int}' });
@@ -192,7 +192,7 @@ const user = UserUrl.parse('/users/42');
 
 ### Custom path constraints
 
-URLKit re-exports PathKit's `createConstraint` and provides global registration helpers for reusable path constraints. Custom constraints infer `string` params by default; built-in `int`, `decimal` and `range` still infer `number`.
+URLKit re-exports PathKit's `createConstraint` and provides global registration helpers for reusable path constraints. Custom constraints infer `string` params by default; built-in `int`, `decimal` and `range` still infer `number`. When a PathKit constraint rejects a value, URLKit wraps it as `UrlKitError` with `code: 'invalid-param'` and preserves the original PathKit error in `error.cause`.
 
 ```ts
 import { createConstraint, registerPathConstraint, url } from '@cookbook/urlkit';
@@ -403,35 +403,32 @@ const Reports = search({
 });
 ```
 
-| Builder                                  | Serialized format                      |
-| ---------------------------------------- | -------------------------------------- |
-| `date()`                                 | Date-only `YYYY-MM-DD`.                |
-| `dateTime()`                             | Strict UTC `YYYY-MM-DDTHH:mm:ss.sssZ`. |
-| `date({ format: 'unix-seconds' })`       | Finite integer seconds.                |
-| `date({ format: 'unix-ms' })`            | Finite integer milliseconds.           |
-| `date({ format: { parse, serialize } })` | Custom runtime date codec.             |
+| Builder                                       | Serialized format                      |
+| --------------------------------------------- | -------------------------------------- |
+| `date()`                                      | Date-only `YYYY-MM-DD`.                |
+| `dateTime()`                                  | Strict UTC `YYYY-MM-DDTHH:mm:ss.sssZ`. |
+| `date({ format: 'dd-MM-yyyy' })`              | Strict custom date format string.      |
+| `dateTime({ format: 'dd-MM-yyyy HH:mm:ss' })` | Strict custom date-time format string. |
+| `date({ format: { parse, serialize } })`      | Custom runtime date codec.             |
+| `dateTime({ format: { parse, serialize } })`  | Custom runtime date-time codec.        |
+| `date({ format: 'unix-seconds' })`            | Finite integer seconds.                |
+| `date({ format: 'unix-ms' })`                 | Finite integer milliseconds.           |
 
-Custom runtime date codecs are available only in runtime-builder schemas. Static date defaults use serialized values, not `Date` instances.
+Custom date and date-time format strings are available only in runtime-builder schemas. Supported tokens are `yyyy`, `MM`, `dd`, `HH`, `mm`, `ss`, and `SSS`. Static date defaults use serialized values, not `Date` instances.
 
 ```ts
 const CustomDate = search({
-  from: date({
-    format: {
-      parse(value) {
-        const [day, month, year] = value.split('-');
-        return new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)));
-      },
-      serialize(value) {
-        const day = String(value.getUTCDate()).padStart(2, '0');
-        const month = String(value.getUTCMonth() + 1).padStart(2, '0');
-        return `${day}-${month}-${value.getUTCFullYear()}`;
-      },
-    },
-  }),
+  from: date({ format: 'dd-MM-yyyy' }),
+  at: dateTime({ format: 'dd-MM-yyyy HH:mm:ss' }).optional(),
 });
 
-CustomDate.build({ search: { from: new Date('2026-06-02T00:00:00.000Z') } });
-// '?from=02-06-2026'
+CustomDate.build({
+  search: {
+    from: new Date('2026-06-02T00:00:00.000Z'),
+    at: new Date('2026-06-02T12:30:05.000Z'),
+  },
+});
+// '?from=02-06-2026&at=02-06-2026+12%3A30%3A05'
 ```
 
 ## Object search
@@ -639,16 +636,16 @@ try {
 }
 ```
 
-| Code                 | Meaning                                                                    |
-| -------------------- | -------------------------------------------------------------------------- |
-| `invalid-url`        | URL input could not be parsed as a URL.                                    |
-| `path-mismatch`      | URL pathname does not satisfy the path contract.                           |
-| `missing-param`      | Required path param is missing.                                            |
-| `invalid-param`      | Path param is invalid.                                                     |
-| `missing-search`     | Required search field is missing.                                          |
-| `invalid-search`     | Search value, unknown search behavior, or object search shape is invalid.  |
-| `invalid-hash`       | Hash value is missing or invalid.                                          |
-| `invalid-descriptor` | Contract/schema/static descriptor is invalid at construction/compile time. |
+| Code                 | Meaning                                                                                    |
+| -------------------- | ------------------------------------------------------------------------------------------ |
+| `invalid-url`        | URL input could not be parsed as a URL.                                                    |
+| `path-mismatch`      | URL pathname does not satisfy the path contract.                                           |
+| `missing-param`      | Required path param is missing.                                                            |
+| `invalid-param`      | Path param is invalid. Constraint failures preserve the original PathKit error in `cause`. |
+| `missing-search`     | Required search field is missing.                                                          |
+| `invalid-search`     | Search value, unknown search behavior, or object search shape is invalid.                  |
+| `invalid-hash`       | Hash value is missing or invalid.                                                          |
+| `invalid-descriptor` | Contract/schema/static descriptor is invalid at construction/compile time.                 |
 
 ## TypeScript inference
 

package/dist/{compile-path-COU1uxXm.js → compile-path-oMMfpXR8.js}

@@ -1,6 +1,7 @@
 import compile from '@cookbook/pathkit/compile';
 import match from '@cookbook/pathkit/match';
-import { hasConstraint, getConstraint, registerConstraint, createConstraint } from '@cookbook/pathkit/constraints';
+import { hasConstraint, getConstraint, registerConstraint } from '@cookbook/pathkit/constraints';
+import tokenize from '@cookbook/pathkit/tokenize';
 
 const defaultMessages = {
     'invalid-url': 'Invalid URL.',
@@ -325,6 +326,209 @@ function validateBooleanDefault(value, context) {
     });
 }
 
+const supportedTokens = ['yyyy', 'SSS', 'MM', 'dd', 'HH', 'mm', 'ss'];
+const dateTokens = new Set(['yyyy', 'MM', 'dd']);
+const dateTimeTokens = new Set(['yyyy', 'MM', 'dd', 'HH', 'mm', 'ss', 'SSS']);
+function parseDateFormatString(input, format, mode, options = {}) {
+    const compiled = compileDateFormatString(format, mode);
+    const match = compiled.pattern.exec(input);
+    if (!match?.groups) {
+        throw createDateFormatStringError(`${getFormatLabel(mode)} value must match format "${format}".`, options);
+    }
+    const parts = readDateParts(match.groups, compiled);
+    assertValidDateParts(parts, mode, options);
+    const value = new Date(Date.UTC(0, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second, parts.millisecond));
+    value.setUTCFullYear(parts.year);
+    if (!matchesDateParts(value, parts)) {
+        throw createDateFormatStringError(`${getFormatLabel(mode)} value must be a valid UTC calendar ${mode === 'date' ? 'date' : 'instant'}.`, options);
+    }
+    return value;
+}
+function serializeDateFormatString(input, format, mode, options = {}) {
+    if (!(input instanceof Date) || !Number.isFinite(input.getTime())) {
+        throw createDateFormatStringError(`${getFormatLabel(mode)} value must be a valid Date.`, options);
+    }
+    const compiled = compileDateFormatString(format, mode);
+    const year = input.getUTCFullYear();
+    if (year < 0 || year > 9999) {
+        throw createDateFormatStringError(`${getFormatLabel(mode)} value year must be between 0000 and 9999 for yyyy format strings.`, options);
+    }
+    if (mode === 'date-time' && !compiled.hasMilliseconds && input.getUTCMilliseconds() !== 0) {
+        throw createDateFormatStringError('Date-time value cannot be serialized without losing milliseconds. Include SSS in the format or use a Date with zero milliseconds.', options);
+    }
+    return compiled.parts
+        .map((part) => {
+        if (part.kind === 'literal') {
+            return part.value;
+        }
+        return serializeToken(input, part.value);
+    })
+        .join('');
+}
+function validateDateFormatString(format, mode) {
+    compileDateFormatString(format, mode);
+}
+function compileDateFormatString(format, mode) {
+    const parts = tokenizeDateFormatString(format, mode);
+    validateDateFormatParts(format, parts, mode);
+    const pattern = new RegExp(`^${parts
+        .map((part) => part.kind === 'literal' ? escapeRegExp(part.value) : getTokenPattern(part.value))
+        .join('')}$`);
+    return {
+        format,
+        mode,
+        parts,
+        pattern,
+        hasMilliseconds: parts.some((part) => part.kind === 'token' && part.value === 'SSS'),
+    };
+}
+function tokenizeDateFormatString(format, mode) {
+    if (typeof format !== 'string' || format.length === 0) {
+        throw createInvalidDateFormatDescriptorError(`${getFormatLabel(mode)} format must be a non-empty string.`);
+    }
+    const parts = [];
+    let index = 0;
+    while (index < format.length) {
+        if (format[index] === "'") {
+            const literalEnd = format.indexOf("'", index + 1);
+            if (literalEnd === -1) {
+                throw createInvalidDateFormatDescriptorError(`${getFormatLabel(mode)} format contains an unterminated quoted literal.`);
+            }
+            const literal = format.slice(index + 1, literalEnd);
+            if (literal.length === 0) {
+                throw createInvalidDateFormatDescriptorError(`${getFormatLabel(mode)} format contains an empty quoted literal.`);
+            }
+            parts.push({ kind: 'literal', value: literal });
+            index = literalEnd + 1;
+            continue;
+        }
+        const token = findTokenAt(format, index);
+        if (token) {
+            parts.push({ kind: 'token', value: token });
+            index += token.length;
+            continue;
+        }
+        const character = format[index] ?? '';
+        if (isAsciiLetter(character)) {
+            throw createInvalidDateFormatDescriptorError(`${getFormatLabel(mode)} format contains unsupported token near "${format.slice(index)}".`);
+        }
+        parts.push({ kind: 'literal', value: character });
+        index += 1;
+    }
+    return mergeAdjacentLiterals(parts);
+}
+function findTokenAt(format, index) {
+    return supportedTokens.find((token) => format.startsWith(token, index));
+}
+function mergeAdjacentLiterals(parts) {
+    const merged = [];
+    for (const part of parts) {
+        const previous = merged[merged.length - 1];
+        if (part.kind === 'literal' && previous?.kind === 'literal') {
+            merged[merged.length - 1] = { kind: 'literal', value: `${previous.value}${part.value}` };
+            continue;
+        }
+        merged.push(part);
+    }
+    return merged;
+}
+function validateDateFormatParts(format, parts, mode) {
+    const allowedTokens = mode === 'date' ? dateTokens : dateTimeTokens;
+    const requiredTokens = mode === 'date' ? ['yyyy', 'MM', 'dd'] : ['yyyy', 'MM', 'dd', 'HH', 'mm', 'ss'];
+    const seenTokens = new Set();
+    for (const part of parts) {
+        if (part.kind === 'literal') {
+            continue;
+        }
+        if (!allowedTokens.has(part.value)) {
+            throw createInvalidDateFormatDescriptorError(`${getFormatLabel(mode)} format "${format}" contains unsupported token "${part.value}".`);
+        }
+        if (seenTokens.has(part.value)) {
+            throw createInvalidDateFormatDescriptorError(`${getFormatLabel(mode)} format "${format}" contains duplicate token "${part.value}".`);
+        }
+        seenTokens.add(part.value);
+    }
+    for (const token of requiredTokens) {
+        if (!seenTokens.has(token)) {
+            throw createInvalidDateFormatDescriptorError(`${getFormatLabel(mode)} format "${format}" is missing required token "${token}".`);
+        }
+    }
+}
+function readDateParts(groups, compiled) {
+    return {
+        year: Number(groups.yyyy),
+        month: Number(groups.MM),
+        day: Number(groups.dd),
+        hour: compiled.mode === 'date-time' ? Number(groups.HH) : 0,
+        minute: compiled.mode === 'date-time' ? Number(groups.mm) : 0,
+        second: compiled.mode === 'date-time' ? Number(groups.ss) : 0,
+        millisecond: compiled.hasMilliseconds ? Number(groups.SSS) : 0,
+    };
+}
+function assertValidDateParts(parts, mode, options) {
+    if (parts.month < 1 ||
+        parts.month > 12 ||
+        parts.day < 1 ||
+        parts.day > 31 ||
+        parts.hour < 0 ||
+        parts.hour > 23 ||
+        parts.minute < 0 ||
+        parts.minute > 59 ||
+        parts.second < 0 ||
+        parts.second > 59 ||
+        parts.millisecond < 0 ||
+        parts.millisecond > 999) {
+        throw createDateFormatStringError(`${getFormatLabel(mode)} value must be a valid UTC calendar ${mode === 'date' ? 'date' : 'instant'}.`, options);
+    }
+}
+function matchesDateParts(value, parts) {
+    return (value.getUTCFullYear() === parts.year &&
+        value.getUTCMonth() === parts.month - 1 &&
+        value.getUTCDate() === parts.day &&
+        value.getUTCHours() === parts.hour &&
+        value.getUTCMinutes() === parts.minute &&
+        value.getUTCSeconds() === parts.second &&
+        value.getUTCMilliseconds() === parts.millisecond);
+}
+function serializeToken(input, token) {
+    switch (token) {
+        case 'yyyy':
+            return String(input.getUTCFullYear()).padStart(4, '0');
+        case 'MM':
+            return String(input.getUTCMonth() + 1).padStart(2, '0');
+        case 'dd':
+            return String(input.getUTCDate()).padStart(2, '0');
+        case 'HH':
+            return String(input.getUTCHours()).padStart(2, '0');
+        case 'mm':
+            return String(input.getUTCMinutes()).padStart(2, '0');
+        case 'ss':
+            return String(input.getUTCSeconds()).padStart(2, '0');
+        case 'SSS':
+            return String(input.getUTCMilliseconds()).padStart(3, '0');
+    }
+}
+function getTokenPattern(token) {
+    return `(?<${token}>\\d{${token === 'yyyy' || token === 'SSS' ? token.length.toString() : '2'}})`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function isAsciiLetter(value) {
+    return /^[A-Za-z]$/.test(value);
+}
+function getFormatLabel(mode) {
+    return mode === 'date' ? 'Date' : 'Date-time';
+}
+function createDateFormatStringError(message, options) {
+    return new UrlKitError(options.code ?? 'invalid-search', message, {
+        path: [...(options.path ?? [])],
+    });
+}
+function createInvalidDateFormatDescriptorError(message) {
+    return new UrlKitError('invalid-descriptor', message);
+}
+
 const datePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
 function parseDate(input, options = {}) {
     const match = datePattern.exec(input);
@@ -596,21 +800,24 @@ const unixMsCodec = {
         return serializeUnixMs(input, { code: context.errorCode, path: context.path });
     },
 };
-function date(options = {}) {
-    const format = resolveDateFormat(options);
+function date(options = {}, formatStringMode = 'date') {
+    const format = resolveDateFormat(options, formatStringMode);
     return createRuntimeSchemaBuilder({
         kind: 'date',
         options: { format },
-        codec: getDateCodec(format),
+        codec: getDateCodec(format, formatStringMode),
         validateDefault(value, context) {
             validateDateDefault(value, context);
         },
     });
 }
-function getDateCodec(format) {
+function getDateCodec(format, formatStringMode) {
     if (isDateFormatCodec(format)) {
         return createCustomDateCodec(format);
     }
+    if (isDateFormatString(format) && !isBuiltInDateFormat(format)) {
+        return createDateFormatStringCodec(format, formatStringMode);
+    }
     if (format === 'date-time') {
         return dateTimeCodec;
     }
@@ -622,6 +829,25 @@ function getDateCodec(format) {
     }
     return dateOnlyCodec;
 }
+function createDateFormatStringCodec(format, mode) {
+    return {
+        parse(input, context) {
+            return parseDateFormatString(input, format, mode, {
+                code: context.errorCode,
+                path: context.path,
+            });
+        },
+        normalize(input, context) {
+            return validateDate(input, context);
+        },
+        serialize(input, context) {
+            return serializeDateFormatString(input, format, mode, {
+                code: context.errorCode,
+                path: context.path,
+            });
+        },
+    };
+}
 function createCustomDateCodec(format) {
     return {
         parse(input, context) {
@@ -635,7 +861,7 @@ function createCustomDateCodec(format) {
         },
     };
 }
-function resolveDateFormat(options) {
+function resolveDateFormat(options, formatStringMode) {
     if (!isDateOptions(options)) {
         throw new UrlKitError('invalid-descriptor', 'Date options must be an object.');
     }
@@ -643,11 +869,18 @@ function resolveDateFormat(options) {
     if (isBuiltInDateFormat(format) || isDateFormatCodec(format)) {
         return format;
     }
-    throw new UrlKitError('invalid-descriptor', 'Date format must be a supported built-in format or an explicit codec.');
+    if (isDateFormatString(format)) {
+        validateDateFormatString(format, formatStringMode);
+        return format;
+    }
+    throw new UrlKitError('invalid-descriptor', 'Date format must be a supported built-in format, a supported format string, or an explicit codec.');
 }
 function isDateOptions(input) {
     return typeof input === 'object' && input !== null && !Array.isArray(input);
 }
+function isDateFormatString(input) {
+    return typeof input === 'string';
+}
 function isBuiltInDateFormat(input) {
     return (input === 'date' || input === 'date-time' || input === 'unix-seconds' || input === 'unix-ms');
 }
@@ -1036,7 +1269,6 @@ function assertPathMatchFailure(pattern, pathname, segments) {
         const segment = segments[index];
         const pathnameSegment = pathnameSegments[index];
         if (!segment || pathnameSegment === undefined) {
-            console.log('ERROR', segment);
             throwPathMismatch(pattern, pathname);
         }
         if (segment.kind === 'literal') {
@@ -1045,9 +1277,11 @@ function assertPathMatchFailure(pattern, pathname, segments) {
             }
             continue;
         }
-        if (!isValidPathParamSegment(segment, pathnameSegment)) {
-            throw new UrlKitError('invalid-param', `Path parameter "${segment.name}" is invalid.`, {
+        const validationFailure = getPathParamValidationFailure(segment, pathnameSegment);
+        if (validationFailure) {
+            throw new UrlKitError('invalid-param', validationFailure.message, {
                 path: ['params', segment.name],
+                ...(validationFailure.cause === undefined ? {} : { cause: validationFailure.cause }),
             });
         }
     }
@@ -1063,22 +1297,43 @@ function splitPath(pathname) {
     }
     return Object.freeze(normalized.split('/'));
 }
-function isValidPathParamSegment(segment, value) {
-    if (!value || !segment.constraint) {
-        return false;
+function getPathParamValidationFailure(segment, value) {
+    if (!value) {
+        return {
+            message: `Path parameter "${segment.name}" is invalid.`,
+        };
+    }
+    if (!segment.constraint) {
+        return undefined;
     }
     const constraint = getConstraint(segment.constraint);
     if (!constraint) {
-        return false;
+        return {
+            message: `Path constraint "${segment.constraint}" is not registered.`,
+        };
     }
     try {
         constraint(segment.name, value, segment.constraintParams ?? '');
-        console.log(constraint, segment, value);
-        return true;
+        return undefined;
+    }
+    catch (error) {
+        const causeMessage = getCauseMessage(error);
+        return {
+            message: causeMessage
+                ? `Path parameter "${segment.name}" is invalid: ${causeMessage}`
+                : `Path parameter "${segment.name}" is invalid.`,
+            cause: error,
+        };
+    }
+}
+function getCauseMessage(error) {
+    if (error instanceof Error && error.message) {
+        return error.message;
     }
-    catch {
-        return false;
+    if (typeof error === 'string' && error) {
+        return error;
     }
+    return undefined;
 }
 function throwPathMismatch(pattern, pathname) {
     throw new UrlKitError('path-mismatch', `Pathname "${pathname}" does not match pattern "${pattern}".`, {
@@ -1091,14 +1346,18 @@ function getPathParamKind(segment) {
         case 'int':
             return 'int';
         case 'decimal':
+            return 'decimal';
         case 'range':
-            return 'number';
+            return 'range';
         case 'regex':
             return 'regex';
         default:
             return 'string';
     }
 }
+function isNumericPathParamKind(kind) {
+    return kind === 'int' || kind === 'decimal' || kind === 'range';
+}
 
 function coercePathParam(segment, value, paramsMode) {
     if (paramsMode === 'raw') {
@@ -1114,10 +1373,10 @@ function coercePathParam(segment, value, paramsMode) {
         }
         return parsed;
     }
-    if (kind === 'number') {
+    if (isNumericPathParamKind(kind)) {
         const parsed = Number(value);
         if (!Number.isFinite(parsed)) {
-            throw new UrlKitError('invalid-param', `Path parameter "${segment.name}" must be a finite number.`, {
+            throw new UrlKitError('invalid-param', `Path parameter "${segment.name}" must be a finite decimal number.`, {
                 path: ['params', segment.name],
             });
         }
@@ -1154,79 +1413,57 @@ function isRecord(input) {
 }
 
 function parsePathPattern(pattern) {
-    if (pattern === '') {
-        return Object.freeze([]);
-    }
-    const normalized = pattern.startsWith('/') ? pattern.slice(1) : pattern;
-    if (normalized === '') {
-        return Object.freeze([]);
-    }
-    return Object.freeze(normalized.split('/').map((segment, index) => parsePathSegment(segment, index)));
-}
-function parsePathSegment(segment, index) {
-    if (!segment.startsWith('{') || !segment.endsWith('}')) {
-        return Object.freeze({ kind: 'literal', value: segment });
+    try {
+        return Object.freeze(toParsedPathSegments(tokenize(pattern)));
     }
-    const token = segment.slice(1, -1);
-    const parsed = parseParamToken(token);
-    if (!parsed.name) {
-        throw new UrlKitError('invalid-descriptor', 'Path parameter name is required.', {
-            path: ['path', String(index)],
+    catch (error) {
+        if (error instanceof UrlKitError) {
+            throw error;
+        }
+        const causeMessage = error instanceof Error && error.message ? `: ${error.message}` : '';
+        throw new UrlKitError('invalid-descriptor', `Path pattern is invalid${causeMessage}.`, {
+            path: ['path'],
+            cause: error,
         });
     }
-    return Object.freeze({ kind: 'param', ...parsed });
 }
-function parseParamToken(token) {
-    const colonIndex = token.indexOf(':');
-    if (colonIndex === -1) {
-        return { name: token };
-    }
-    const name = token.slice(0, colonIndex);
-    const constraintToken = token.slice(colonIndex + 1);
-    const paramsStart = constraintToken.indexOf('(');
-    if (paramsStart === -1 || !constraintToken.endsWith(')')) {
-        return { name, constraint: constraintToken };
+function toParsedPathSegments(tokens) {
+    const segments = [];
+    for (const token of tokens) {
+        if (token.type === 'literal') {
+            appendLiteralSegments(segments, token.value);
+            continue;
+        }
+        segments.push(toParsedParamSegment(token));
     }
-    return {
-        name,
-        constraint: constraintToken.slice(0, paramsStart),
-        constraintParams: constraintToken.slice(paramsStart + 1, -1),
-    };
+    return segments.map((segment) => Object.freeze(segment));
 }
-
-const numberConstraint = createConstraint({
-    parse(paramName, value, params) {
-        numberConstraint.verify(paramName, params);
-        const serialized = String(value);
-        if (!isFinitePathNumber(serialized)) {
-            throw new UrlKitError('invalid-param', `Path parameter "${paramName}" must be a finite number.`, {
-                path: ['params', paramName],
-            });
-        }
-    },
-    verify(paramName, params) {
-        if (params.trim()) {
-            throw new UrlKitError('invalid-descriptor', `Constraint 'number' declared for '${paramName}' parameter does not accept arguments.`, { path: ['path', paramName] });
+function appendLiteralSegments(segments, value) {
+    if (!value) {
+        return;
+    }
+    for (const segment of value.split('/')) {
+        if (!segment) {
+            continue;
         }
-    },
-    toRegExp() {
-        return '-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)';
-    },
-});
-function registerUrlKitPathConstraints() {
-    if (!hasConstraint('number')) {
-        registerConstraint('number', numberConstraint);
+        segments.push({ kind: 'literal', value: segment });
     }
 }
-function isFinitePathNumber(value) {
-    if (!/^-?(?:\d+(?:\.\d+)?|\.\d+)$/.test(value)) {
-        return false;
-    }
-    return Number.isFinite(Number(value));
+function toParsedParamSegment(token) {
+    const constraint = token.constraints[0];
+    return {
+        kind: 'param',
+        name: token.name,
+        ...(constraint
+            ? {
+                constraint: constraint.type,
+                ...(constraint.params ? { constraintParams: constraint.params } : {}),
+            }
+            : {}),
+    };
 }
 
 function compilePath(pattern, options = {}) {
-    registerUrlKitPathConstraints();
     if (options.pathConstraints) {
         registerPathConstraints(options.pathConstraints);
     }
@@ -1301,5 +1538,5 @@ function compilePathPattern(pattern) {
     }
 }
 
-export { UrlKitError as U, compilePath as a, boolean as b, compileSearchSchema as c, date as d, enumOf as e, registerPathConstraints as f, handleRuntimeSchemaAbsence as g, hasPathConstraint as h, int as i, createSchemaValueError as j, createRuntimeSchemaValueContext as k, compileRuntimeSchemaValue as l, createRuntimeSchemaBuilder as m, number as n, normalizeRuntimeSchemaValue as o, getRuntimeSchemaInternals as p, runtimeSchemaSymbol as q, registerPathConstraint as r, string as s, compileRuntimeSchema as t, normalizeCompiledRuntimeSchemaValue as u, compileStaticHashDescriptor as v, parseUnixSeconds as w, parseUnixMs as x, parseDateTime as y, parseDate as z };
-//# sourceMappingURL=compile-path-COU1uxXm.js.map
+export { parseDate as A, UrlKitError as U, compilePath as a, boolean as b, compileSearchSchema as c, date as d, enumOf as e, registerPathConstraints as f, handleRuntimeSchemaAbsence as g, hasPathConstraint as h, int as i, createSchemaValueError as j, createRuntimeSchemaValueContext as k, compileRuntimeSchemaValue as l, createRuntimeSchemaBuilder as m, number as n, normalizeRuntimeSchemaValue as o, getRuntimeSchemaInternals as p, runtimeSchemaSymbol as q, registerPathConstraint as r, string as s, compileRuntimeSchema as t, normalizeCompiledRuntimeSchemaValue as u, validateDateFormatString as v, compileStaticHashDescriptor as w, parseUnixSeconds as x, parseUnixMs as y, parseDateTime as z };
+//# sourceMappingURL=compile-path-oMMfpXR8.js.map