typia 13.2.0 → 13.3.0

package/native/core/factories/internal/metadata/MetadataHelper.go

@@ -70,34 +70,11 @@ func metadata_type_full_name(
   return result
 }
 
-// metadata_type_symbol_name mirrors TypeFactory.getFullName({ aliasTypeArguments:
-// false }) from legacy typia: the name is derived from the type's *symbol*, not
-// from checker.typeToString. This matters for alias chains (e.g. MapAlias.MAP =
-// Map<K, V>) where typeToString prints the alias name ("MapAlias.MAP<...>")
-// instead of "Map<...>", which would defeat the Map/Set prefix guards.
-func metadata_type_symbol_name(checker *nativechecker.Checker, typ *nativechecker.Type) string {
-  if checker == nil || typ == nil {
-    return ""
-  }
-  symbol := typ.Symbol()
-  if symbol == nil {
-    return checker.TypeToString(typ)
-  }
-  name := metadata_symbol_name(symbol)
-  generic := metadata_get_type_arguments(checker, typ)
-  if len(generic) == 0 {
-    return name
-  }
-  if name == "Promise" {
-    return metadata_type_symbol_name(checker, generic[0])
-  }
-  names := make([]string, 0, len(generic))
-  for _, child := range generic {
-    names = append(names, metadata_type_symbol_name(checker, child))
-  }
-  return name + "<" + strings.Join(names, ", ") + ">"
-}
-
+// metadata_type_symbol_base_name derives the name from the type's own *symbol*,
+// never from checker.TypeToString. The Map / Set / native guards test this name
+// against a prefix, and an alias chain (e.g. `type MAP = Map<K, V>`) makes
+// TypeToString print the alias name ("MapAlias.MAP<...>") instead of "Map<...>",
+// which would defeat those guards.
 func metadata_type_symbol_base_name(typ *nativechecker.Type) string {
   if typ == nil {
     return ""

package/native/core/factories/metadata_comment_tag_factory_coverage_test.go

@@ -124,8 +124,8 @@ func TestMetadataCommentTagFactoryCoverage(t *testing.T) {
   if len(reports) != decimalReportCount || len(decimal["number"]) != 1 || len(decimal["bigint"]) != 0 {
     t.Fatalf("decimal multipleOf must remain a number-only JSDoc tag: %#v, reports=%#v", decimal, reports[decimalReportCount:])
   }
-  if decimal["number"][0].Validate != "$importInternal(\"_isMultipleOf\")($input, 0.01)" {
-    t.Fatalf("decimal multipleOf must use the shared exact helper: %s", decimal["number"][0].Validate)
+  if decimal["number"][0].Validate != "$input % 0.01 === 0" {
+    t.Fatalf("decimal multipleOf must spell the same remainder check the MultipleOf type tag declares: %s", decimal["number"][0].Validate)
   }
   invalidBefore := len(reports)
   _ = metadataCommentTagFactory_parse_number(struct {

package/native/core/programmers/RandomProgrammer.go

@@ -1442,8 +1442,11 @@ func randomProgrammer_is_typed_array(name string) bool {
 // `maximum` comment tags on a number-typed JSON schema, and `number` cannot
 // represent 2**63 - 1 or 2**64 - 1 -- both arrive rounded up to the next power of
 // two. That costs nothing here: the generator only picks a value from the range,
-// and the TypedArray constructor wraps whatever it is handed. Validation owns
-// exactness instead, in _isTypeInt64Bigint and its siblings.
+// and the TypedArray constructor wraps whatever it is handed. On the `number`
+// path validation owns exactness instead, in _isTypeInt64 and _isTypeUint64. The
+// `bigint` path owns none: Type<"int64"> declares no check and Type<"uint64">
+// only a lower bound, so that neither declaration names a runtime helper an
+// older `typia` cannot resolve (#2330). #2338 owns restoring the bound.
 func randomProgrammer_typed_array_range(name string) (string, string, string) {
   switch name {
   case "Uint8Array", "Uint8ClampedArray":

package/native/core/schemas/metadata/MetadataCollection.go

@@ -810,11 +810,31 @@ var metadataCollection_replacers = []metadataCollection_replacer{
 }
 
 func metadataCollection_getFullName(checker *nativechecker.Checker, typ *nativechecker.Type) string {
+  return metadataCollection_getFullNameOf(checker, typ, nil)
+}
+
+// metadataCollection_getFullNameOf carries the types whose name is still being
+// composed on the current path. A recursive type graph reaches the same *Type
+// again before its name is finished: `type Rec<T> = T extends Date ? string : T
+// extends (infer U)[] ? Rec<U>[] : never` instantiated at `Date | Node[]`
+// resolves to the union `string | Rec<Node>[]`, whose array member is a
+// reference whose sole type argument is that very union. Walking union member ->
+// array reference -> type argument returns to the union, so the unguarded walk
+// never terminates and overflows the plugin's stack instead of naming the type
+// (#2331). A type reached a second time on one path is therefore named by its
+// own symbol with its arguments left unexpanded -- the recursion's placeholder,
+// `Array<string | Array>` for the example above -- and a symbol-less one by the
+// anonymous marker the collection already allocates unique names from. Expanding
+// the checker's elided rendering there instead would name every such component
+// after a several-hundred-character structural dump.
+func metadataCollection_getFullNameOf(
+  checker *nativechecker.Checker,
+  typ *nativechecker.Type,
+  visiting map[*nativechecker.Type]bool,
+) string {
   if checker == nil || typ == nil {
     return "__type"
   }
-  rendered := metadataCollection_sanitizeName(checker.TypeToString(typ))
-
   // Mirror TypeFactory.getFullName: prefer the alias symbol, then the type's
   // own symbol. getTypeNameSymbol already returns t.alias.symbol first (the
   // alias symbol), so a non-nil result that differs from typ.Symbol() means the
@@ -826,6 +846,13 @@ func metadataCollection_getFullName(checker *nativechecker.Checker, typ *nativec
   if symbol == nil {
     symbol = rawSymbol
   }
+  if visiting[typ] {
+    if symbol != nil {
+      return metadataCollection_getName(symbol)
+    }
+    return "__type"
+  }
+  rendered := metadataCollection_sanitizeName(checker.TypeToString(typ))
   if symbol == nil {
     if typ.IsUnion() || typ.IsIntersection() {
       joiner := " | "
@@ -834,9 +861,11 @@ func metadataCollection_getFullName(checker *nativechecker.Checker, typ *nativec
       }
       children := typ.Types()
       names := make([]string, 0, len(children))
+      visiting = metadataCollection_markVisiting(visiting, typ)
       for _, child := range children {
-        names = append(names, metadataCollection_getFullName(checker, child))
+        names = append(names, metadataCollection_getFullNameOf(checker, child, visiting))
       }
+      delete(visiting, typ)
       return strings.Join(names, joiner)
     }
     if rendered != "" {
@@ -864,16 +893,29 @@ func metadataCollection_getFullName(checker *nativechecker.Checker, typ *nativec
     }
     return name
   }
+  visiting = metadataCollection_markVisiting(visiting, typ)
+  defer delete(visiting, typ)
   if name == "Promise" {
-    return metadataCollection_getFullName(checker, generic[0])
+    return metadataCollection_getFullNameOf(checker, generic[0], visiting)
   }
   names := make([]string, 0, len(generic))
   for _, child := range generic {
-    names = append(names, metadataCollection_getFullName(checker, child))
+    names = append(names, metadataCollection_getFullNameOf(checker, child, visiting))
   }
   return name + "<" + strings.Join(names, ", ") + ">"
 }
 
+func metadataCollection_markVisiting(
+  visiting map[*nativechecker.Type]bool,
+  typ *nativechecker.Type,
+) map[*nativechecker.Type]bool {
+  if visiting == nil {
+    visiting = map[*nativechecker.Type]bool{}
+  }
+  visiting[typ] = true
+  return visiting
+}
+
 func metadataCollection_getName(symbol *nativeast.Symbol) string {
   if symbol == nil || len(symbol.Declarations) == 0 || symbol.Declarations[0].Parent == nil {
     return "__type"

package/native/transform/CallExpressionTransformer.go

@@ -63,6 +63,7 @@ func (callExpressionTransformerNamespace) Transform(props CallExpressionTransfor
   location, _ := filepath.Abs(sourceFile.FileName())
   module, ok := callExpressionTransformer_targetModule(location)
   if ok == false {
+    callExpressionTransformer_rejectShadowedTypia(props, location)
     return props.Expression.AsNode()
   }
   typ := props.Context.Checker.GetTypeAtLocation(declaration)
@@ -127,6 +128,172 @@ func callExpressionTransformer_targetModule(location string) (string, bool) {
   return "", false
 }
 
+// callExpressionTransformer_rejectShadowedTypia raises a diagnostic when a call
+// the file-path identity test rejected is nevertheless a typia call the author
+// expects to be transformed, and names the file that declared it instead.
+//
+// Attribution by declaration file is deliberate: accepting a callee declared
+// anywhere else would let any package claim typia's transform, which is the
+// boundary default_library_spoof_native_identity_transform_test.go and
+// lib_replacement_native_identity_transform_test.go protect. That check is not
+// relaxed here. Silence is what needs correcting. A project-local `declare
+// module "typia"` moves the resolved signature's declaration out of typia's own
+// files, so the call is left untransformed with no diagnostic at all and the
+// failure surfaces only at run time as `no transform has been configured`
+// (samchon/typia#2328).
+//
+// Three conditions have to hold together, so an unrelated local function that
+// happens to share a name with a typia operation cannot trip this:
+//
+//  1. the callee spells an operation this transformer owns, in the namespace it
+//     actually lives in — `typia.json.assertParse`, never `typia.assertParse`;
+//  2. the root of the callee expression resolves to an import binding; and
+//  3. that import's module specifier is typia's own.
+//
+// Known gap: an alias chain is not followed, so a project that re-exports typia
+// through its own barrel and then shadows it is still silent. The specifier of
+// the import the call actually reads is the only evidence this collects.
+func callExpressionTransformer_rejectShadowedTypia(props CallExpressionTransformer_TransformProps, location string) {
+  code, ok := callExpressionTransformer_calleeOperation(props.Expression.Expression)
+  if ok == false {
+    return
+  }
+  root := callExpressionTransformer_calleeRoot(props.Expression.Expression)
+  if root == nil || root.Kind != shimast.KindIdentifier {
+    return
+  }
+  symbol := props.Context.Checker.GetSymbolAtLocation(root)
+  if symbol == nil || symbol.Flags&shimast.SymbolFlagsAlias == 0 {
+    return
+  }
+  for _, declaration := range symbol.Declarations {
+    if callExpressionTransformer_importsTypia(declaration) == false {
+      continue
+    }
+    // State only what was observed. The declaration file is the fact; a
+    // `declare module "typia"` is the usual cause but not the only way to move
+    // a declaration, and naming it as the cause would misdirect anyone whose
+    // build got here another way.
+    panic(nativecontext.NewTransformerError(nativecontext.TransformerError_IProps{
+      Code: code,
+      Message: "this call was declared in " +
+        filepath.ToSlash(location) +
+        ", not in typia's own module, so no transform was applied. A project-local `declare module \"typia\"` is the usual cause; remove it, or give the redeclaration another module name.",
+    }))
+  }
+}
+
+// callExpressionTransformer_calleeOperation answers whether a callee expression
+// spells one of this transformer's operations, and returns the diagnostic code
+// for it — the written spelling, qualified as `typia.json.assertParse`.
+//
+// The namespace is part of the spelling. `typia.json.assertParse` names the
+// `json` table, while `typia.createAssert` and a bare named import name the root
+// `module` table; a root-level `typia.assertParse` matches nothing, because that
+// operation does not live there. Matching a flat union of every table's names
+// instead would report a module augmentation that adds an unrelated `parse` or
+// `schema` to typia, which is a build that works today.
+//
+// Known gap: taking the namespace from the spelling means a renamed binding
+// (`import { json as j } from "typia"; j.assertParse(...)`) is not recognized.
+func callExpressionTransformer_calleeOperation(callee *shimast.Node) (string, bool) {
+  method := ""
+  first := true
+  // Segments to the left of the method, nearest first: `typia.json.assertParse`
+  // collects ["json", "typia"].
+  parts := []string{}
+  for current := callee; current != nil; {
+    if len(parts) > 2 {
+      return "", false
+    }
+    segment := ""
+    switch current.Kind {
+    case shimast.KindPropertyAccessExpression:
+      access := current.AsPropertyAccessExpression()
+      name := access.Name()
+      if name == nil || name.Kind != shimast.KindIdentifier {
+        return "", false
+      }
+      segment = name.Text()
+      current = access.Expression
+    case shimast.KindIdentifier:
+      segment = current.Text()
+      current = nil
+    default:
+      return "", false
+    }
+    if first {
+      method = segment
+      first = false
+    } else {
+      parts = append(parts, segment)
+    }
+  }
+  if method == "" || len(parts) > 2 {
+    return "", false
+  }
+  functors := callExpressionTransformer_FUNCTORS()
+  // `typia.json.assertParse` and `json.assertParse` both name the `json` table
+  // through the segment directly left of the method.
+  if len(parts) != 0 {
+    if _, found := functors[parts[0]][method]; found {
+      return "typia." + parts[0] + "." + method, true
+    }
+  }
+  // `typia.createAssert` and a bare `createAssert` name the root table. The
+  // qualifier, when present, is the imported binding rather than a namespace.
+  if len(parts) <= 1 {
+    if _, found := functors["module"][method]; found {
+      return "typia." + method, true
+    }
+  }
+  return "", false
+}
+
+// callExpressionTransformer_calleeRoot walks a property-access chain down to the
+// expression it starts from, which is the binding that has to come from typia.
+func callExpressionTransformer_calleeRoot(callee *shimast.Node) *shimast.Node {
+  current := callee
+  for current != nil && current.Kind == shimast.KindPropertyAccessExpression {
+    current = current.AsPropertyAccessExpression().Expression
+  }
+  return current
+}
+
+// callExpressionTransformer_importsTypia answers whether an alias declaration
+// belongs to an import whose module specifier is typia's own. Both `import ...
+// from "typia"` and `import typia = require("typia")` are matched; the walk
+// stops at the source file so a local declaration can never reach an unrelated
+// import above it.
+func callExpressionTransformer_importsTypia(declaration *shimast.Node) bool {
+  for node := declaration; node != nil; node = node.Parent {
+    switch node.Kind {
+    case shimast.KindImportDeclaration:
+      return callExpressionTransformer_isTypiaSpecifier(node.ModuleSpecifier())
+    case shimast.KindImportEqualsDeclaration:
+      reference := node.AsImportEqualsDeclaration().ModuleReference
+      if reference == nil || reference.Kind != shimast.KindExternalModuleReference {
+        return false
+      }
+      return callExpressionTransformer_isTypiaSpecifier(reference.AsExternalModuleReference().Expression)
+    case shimast.KindSourceFile:
+      return false
+    }
+  }
+  return false
+}
+
+// callExpressionTransformer_isTypiaSpecifier accepts typia's own package name
+// and its subpaths, and nothing that merely begins with those letters: a
+// `typia-codegen` package is a different package.
+func callExpressionTransformer_isTypiaSpecifier(specifier *shimast.Node) bool {
+  if specifier == nil || specifier.Kind != shimast.KindStringLiteral {
+    return false
+  }
+  text := specifier.AsStringLiteral().Text
+  return text == "typia" || strings.HasPrefix(text, "typia/")
+}
+
 func callExpressionTransformer_sourceFile(node *shimast.Node) *shimast.SourceFile {
   for current := node; current != nil; current = current.Parent {
     if current.Kind == shimast.KindSourceFile {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.2.0",
+  "version": "13.3.0",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -50,8 +50,8 @@
     "inquirer": "^8.2.5",
     "randexp": "^0.5.3",
     "tinyglobby": "^0.2.12",
-    "@typia/interface": "^13.2.0",
-    "@typia/utils": "^13.2.0"
+    "@typia/interface": "^13.3.0",
+    "@typia/utils": "^13.3.0"
   },
   "peerDependencies": {
     "ttsc": ">=0.19.2"

package/src/http.ts

@@ -550,10 +550,16 @@ export function createAssertFormData(
  */
 export function createAssertFormData<T extends object>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: FormData) => T;
+): (
+  input: FormData,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
-export function createAssertFormData<T>(): (input: FormData) => T {
+export function createAssertFormData<T>(): (
+  input: FormData,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T {
   NoTransformConfigurationError("http.createAssertFormData");
 }
 
@@ -652,11 +658,15 @@ export function createAssertQuery(
  */
 export function createAssertQuery<T extends object>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: string | IReadableURLSearchParams) => T;
+): (
+  input: string | IReadableURLSearchParams,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
 export function createAssertQuery<T>(): (
   input: string | IReadableURLSearchParams,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ) => T {
   NoTransformConfigurationError("http.createAssertQuery");
 }
@@ -758,11 +768,15 @@ export function createAssertHeaders(
  */
 export function createAssertHeaders<T extends object>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: Record<string, string | string[] | undefined>) => T;
+): (
+  input: Record<string, string | string[] | undefined>,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
 export function createAssertHeaders<T>(): (
   input: Record<string, string | string[] | undefined>,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
 ) => T {
   NoTransformConfigurationError("http.createAssertHeaders");
 }

package/src/internal/_assertGuard.ts

@@ -6,8 +6,19 @@ export const _assertGuard = (
   factory?: (props: TypeGuardError.IProps) => Error,
 ): false => {
   if (exceptionable === true) {
-    if (factory) throw factory(props);
-    else throw new TypeGuardError(props);
+    // `factory` arrives from the generated function's second parameter, which
+    // a pointwise hand-off fills with something that is not a factory at all:
+    // `rows.map(assertUser)` passes the element index. A truthiness test then
+    // called a number and reported `factory is not a function`, hiding the
+    // real assertion failure — and only for indices other than 0. Require a
+    // callable, and fall back to TypeGuardError for everything else.
+    //
+    // A create-time factory is the default of that same parameter, so a
+    // non-callable argument has already overridden it by the time this runs
+    // and cannot be recovered here. TypeGuardError still names the property
+    // that failed, which `factory is not a function` never did.
+    if (typeof factory === "function") throw factory(props);
+    throw new TypeGuardError(props);
   }
   return false;
 };

package/src/internal/_isFormatIdnHostname.ts

@@ -1,4 +1,8 @@
 export const _isFormatIdnHostname = (str: string): boolean => PATTERN.test(str);
 
+// The ASCII `hostname` structure with the label character class extended by the
+// non-ASCII range: every valid host name is a valid IDN host name, so this must
+// accept a single label, a one-to-63-character label in any position, and a
+// name up to 253 characters, exactly as `_isFormatHostname` does (issue #2317).
 const PATTERN =
-  /^([a-z0-9\u00a1-\uffff0-9]+(-[a-z0-9\u00a1-\uffff0-9]+)*\.)+[a-z\u00a1-\uffff]{2,}$/i;
+  /^(?=.{1,253}\.?$)[a-z0-9\u00a1-\uffff](?:[a-z0-9\u00a1-\uffff-]{0,61}[a-z0-9\u00a1-\uffff])?(?:\.[a-z0-9\u00a1-\uffff](?:[a-z0-9\u00a1-\uffff-]{0,61}[a-z0-9\u00a1-\uffff])?)*\.?$/i;

package/src/internal/_isFormatTime.ts

@@ -1,4 +1,21 @@
-export const _isFormatTime = (str: string): boolean => PATTERN.test(str);
+export const _isFormatTime = (str: string): boolean => {
+  const match: RegExpExecArray | null = PATTERN.exec(str);
+  if (match === null) return false;
+  if (match[3] !== "60") return true;
+
+  // RFC 3339 admits `:60` only where a leap second is inserted, which is
+  // always 23:59:60 UTC. `date-time` decides that from the instant it can
+  // build; a clock carries no date, so it shifts itself by its own offset and
+  // asks the same question, wrapping the result back into the day.
+  const offset: number =
+    match[4] === undefined
+      ? 0
+      : (match[4] === "+" ? 1 : -1) *
+        (Number(match[5]) * 60 + Number(match[6]));
+  const minutes: number = Number(match[1]) * 60 + Number(match[2]) - offset;
+  return ((minutes % DAY) + DAY) % DAY === DAY - 1;
+};
 
 const PATTERN =
-  /^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i;
+  /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(?:\.[0-9]+)?(?:[Zz]|([+-])((?:[01][0-9]|2[0-3])):([0-5][0-9]))$/;
+const DAY = 24 * 60;

package/src/internal/_randomArray.ts

@@ -7,6 +7,16 @@ const DEFAULT_MIN_ITEMS = 1;
 const DEFAULT_RANGE = 5;
 const DEFAULT_RECURSIVE_RANGE = 2;
 
+/**
+ * Consecutive duplicates that end a unique draw once its floor is satisfied.
+ *
+ * The worst case a domain can still hide is one value left among a handful:
+ * with one of four remaining, sixty-four misses in a row is a `0.75 ** 64`
+ * event, about one in a hundred million. Below the floor this limit does not
+ * apply at all, so it can never fail a request the domain could satisfy.
+ */
+const STALE_LIMIT = 64;
+
 export const _randomArray = <T>(
   props: Omit<OpenApi.IJsonSchema.IArray, "items"> & {
     element: (index: number, count: number) => T;
@@ -28,16 +38,42 @@ export const _randomArray = <T>(
   });
   if (props.uniqueItems !== true)
     return new Array(count).fill(null).map((_, i) => props.element(i, count));
+  // How many distinct values the element can take is not knowable from here --
+  // `element` is a closure over whatever the transform emitted, from `boolean`
+  // to a recursive object -- so the count above is a preference, not a
+  // contract. Draw until the budget says the domain has nothing new left, then
+  // keep what was reached.
+  //
+  // Failing on that budget instead is what made `Array<boolean> &
+  // UniqueItems` throw on two draws in three: `[true, false]` satisfies the
+  // declaration at every count, and a count of five is unreachable for a
+  // domain of two however many times it is redrawn. Only a result below the
+  // floor is a real failure, which is still the honest outcome for a window
+  // like `MinItems<3>` over a domain of two.
+  //
+  // Below the floor the whole budget is spent, because stopping early there
+  // would fail a request the domain can still satisfy. Above it every further
+  // attempt is only buying length, so a run of `STALE_LIMIT` duplicates is
+  // taken as the domain saying it has nothing left. Without that, each nesting
+  // level of a small-domain unique array multiplies the full budget into the
+  // level above it.
   const elements: T[] = [];
   const maximumAttempts: number = count * 100 + 1000;
-  for (let attempts = 0; elements.length !== count; attempts++) {
-    if (attempts === maximumAttempts)
-      throw new Error(
-        "Unable to generate enough unique items; the element domain may be too small.",
-      );
+  let stale: number = 0;
+  for (
+    let attempts = 0;
+    elements.length !== count && attempts !== maximumAttempts;
+    attempts++
+  ) {
     const candidate: T = props.element(elements.length, count);
-    if (elements.every((element) => _isUniqueItems([element, candidate])))
+    if (elements.every((element) => _isUniqueItems([element, candidate]))) {
       elements.push(candidate);
+      stale = 0;
+    } else if (elements.length >= minimum && ++stale === STALE_LIMIT) break;
   }
+  if (elements.length < minimum)
+    throw new Error(
+      "Unable to generate enough unique items; the element domain may be too small.",
+    );
   return elements;
 };

package/src/internal/_randomFormatByte.ts

@@ -1,18 +1,26 @@
-import { _randomString } from "./_randomString";
+import { _randomInteger } from "./_randomInteger";
 import {
   _ILengthProps,
   _RANDOM_LENGTH_ERROR,
   _randomLengthPick,
   _randomLengthWindow,
 } from "./_randomStringLength";
+import { __randomBase64 } from "./private/__randomComposition";
 
 export const _randomFormatByte = (props?: _ILengthProps): string => {
-  if (props?.minLength === undefined && props?.maxLength === undefined)
-    return FIXED;
   // Base64 encodes three bytes as four characters, so a valid length is always
-  // a multiple of four; the window is raised to the first multiple it contains
-  // and the draw steps by four from there. Every character `_randomString`
-  // emits is in the base64 alphabet, so the result needs no padding.
+  // a multiple of four; an unconstrained draw spends between four and twelve
+  // groups, and a constrained one raises the window to the first multiple it
+  // contains and steps by four from there.
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return __randomBase64(
+      4 *
+        _randomInteger({
+          type: "integer",
+          minimum: DEFAULT_GROUP_MIN,
+          maximum: DEFAULT_GROUP_MAX,
+        }),
+    );
   const window = _randomLengthWindow(props, { minimum: 0, spread: 16 });
   const low: number = Math.ceil(window.low / 4) * 4;
   if (low > window.high) throw new Error(_RANDOM_LENGTH_ERROR);
@@ -23,11 +31,8 @@ export const _randomFormatByte = (props?: _ILengthProps): string => {
         low: 0,
         high: Math.floor((window.high - low) / 4),
       });
-  return _randomString({
-    type: "string",
-    minLength: length,
-    maxLength: length,
-  });
+  return __randomBase64(length);
 };
 
-const FIXED = "vt7ekz4lIoNTTS9sDQYdWKharxIFAR54+z/umIxSgUM=";
+const DEFAULT_GROUP_MIN = 4;
+const DEFAULT_GROUP_MAX = 12;

package/src/internal/_randomFormatHostname.ts

@@ -29,8 +29,8 @@ const pickLength = (props: _ILengthProps): number => {
 
 /**
  * Builds dot-joined hostname labels totaling exactly `length` characters, each
- * label within 63 chars. Shared with the idn-hostname generator, which reserves
- * a fixed `.<tld>` suffix and realizes the rest as these leading labels.
+ * label within 63 chars. Shared with the idn-hostname generator, which realizes
+ * its length the same way since #2317 gave the two formats one structure.
  */
 export const _randomHostnameLabels = (length: number): string => {
   const parts: string[] = [];

package/src/internal/_randomFormatIdnHostname.ts

@@ -6,20 +6,19 @@ import { _ILengthProps } from "./_randomStringLength";
 export const _randomFormatIdnHostname = (props?: _ILengthProps): string => {
   if (props?.minLength === undefined && props?.maxLength === undefined)
     return `${random(10)}.${random(3)}`;
-  // `_isFormatIdnHostname` requires at least one label, a dot, and a >=2-char
-  // TLD (`(…\.)+[a-z¡-￿]{2,}`), none of which the non-idn hostname generator
-  // guarantees on its length path (it can emit a single dotless label). Reserve
-  // a fixed `.<2-char TLD>` and realize the rest as dot-joined leading labels.
-  const length: number = pickLength(props);
-  return `${_randomHostnameLabels(length - 3)}.${random(2)}`;
+  // idn-hostname shares hostname's structure (a single label of 1..63 chars is
+  // valid, no dot or trailing label required), so the requested length is
+  // realized the same way: split it across dot-joined labels. #2317 dropped the
+  // mandatory dot and two-character trailing label this generator used to
+  // reserve, which is why it now realizes a length below four.
+  return _randomHostnameLabels(pickLength(props));
 };
 
 const MAX_TOTAL = 253;
-const MIN_TOTAL = 4; // the shortest idn hostname, `x.yy`: label(1) + `.` + tld(2)
 
 const pickLength = (props: _ILengthProps): number => {
-  let low: number = props.minLength === undefined ? MIN_TOTAL : props.minLength;
-  if (low < MIN_TOTAL) low = MIN_TOTAL;
+  let low: number = props.minLength === undefined ? 1 : props.minLength;
+  if (low < 1) low = 1;
   const high: number =
     props.maxLength === undefined
       ? Math.min(MAX_TOTAL, low + 14)

package/src/internal/_randomFormatRegex.ts

@@ -6,11 +6,12 @@ import {
 } from "./_randomStringLength";
 
 export const _randomFormatRegex = (props?: _ILengthProps): string => {
-  if (props?.minLength === undefined && props?.maxLength === undefined)
-    return FIXED;
   // Every character `_randomString` emits is a literal in regular expression
   // syntax, so a source of any length — including the empty source `new
-  // RegExp("")` accepts — compiles.
+  // RegExp("")` accepts — compiles. An unconstrained draw is therefore an
+  // unconstrained string, and a constrained one fixes the length first.
+  if (props?.minLength === undefined && props?.maxLength === undefined)
+    return _randomString({ type: "string" });
   const length: number = _randomLengthPick(
     _randomLengthWindow(props, { minimum: 0, spread: 16 }),
   );
@@ -20,6 +21,3 @@ export const _randomFormatRegex = (props?: _ILengthProps): string => {
     maxLength: length,
   });
 };
-
-const FIXED =
-  "/^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/";