typia 13.1.19 → 13.3.0

package/native/transform/features/protobuf/ProtobufMessageTransformer.go

@@ -20,7 +20,7 @@ func (protobufMessageTransformerNamespace) Transform(props nativetransform.ITran
   typ := props.Context.Checker.GetTypeFromTypeNode(props.Expression.TypeArguments.Nodes[0])
   if typ != nil && typ.IsTypeParameter() {
     panic(nativetransform.NewTransformerError(nativetransform.TransformerError_IProps{
-      Code:    "tyipa.protobuf.message",
+      Code:    "typia.protobuf.message",
       Message: "non-specified generic argument.",
     }))
   }

package/package.json

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

package/src/executable/FileSystemIdentity.ts

@@ -147,6 +147,39 @@ export namespace FileSystemIdentity {
     );
   }
 
+  /**
+   * Builds the key that decides whether two paths are the same filesystem
+   * object.
+   *
+   * The identity is read from `fs.BigIntStats` rather than `fs.Stats`, because
+   * `fs.Stats.ino` is a JavaScript number. An NTFS file ID is `(sequenceNumber
+   * << 48) | mftRecordIndex` and routinely exceeds `Number.MAX_SAFE_INTEGER` —
+   * in a 4000-directory probe, 1879 of them did — where the spacing between
+   * representable doubles is 8 or more. Two entries sharing a sequence number
+   * with MFT record indices within that spacing round to one double. The
+   * traversal callers would then treat a distinct directory or file as already
+   * visited and skip it with no diagnostic, and the overwrite guard would
+   * refuse a legitimate output (samchon/typia#2269).
+   *
+   * A filesystem that reports no inode at all keeps the canonical path
+   * fallback, which is the only identity available there.
+   *
+   * @param stat Stats read with `{ bigint: true }`.
+   * @param realpath Canonical path of the same object.
+   * @returns Key that is equal for two paths only when they are one object.
+   */
+  export function identityKey(
+    stat: Pick<fs.BigIntStats, "dev" | "ino">,
+    realpath: string,
+  ): string {
+    // `BigInt(0)` rather than `0n`: this package compiles at ES2016, where a
+    // BigInt literal is a syntax error, while the constructor and the `bigint`
+    // type are fine.
+    return stat.ino === BigInt(0)
+      ? `path:${path.normalize(realpath)}`
+      : `inode:${stat.dev}:${stat.ino}`;
+  }
+
   function alternateCase(name: string): string | undefined {
     let changed: boolean = false;
     let output: string = "";

package/src/executable/TypiaGenerateWizard.ts

@@ -453,7 +453,7 @@ export namespace TypiaGenerateWizard {
     for (const entry of entries) {
       inputs.add(
         fileIdentityKey(
-          await fs.promises.stat(entry.file),
+          await fs.promises.stat(entry.file, { bigint: true }),
           await fs.promises.realpath(entry.file),
         ),
       );
@@ -461,9 +461,9 @@ export namespace TypiaGenerateWizard {
     }
 
     for (const entry of files.values()) {
-      let stat: fs.Stats;
+      let stat: fs.BigIntStats;
       try {
-        stat = await fs.promises.lstat(entry.target);
+        stat = await fs.promises.lstat(entry.target, { bigint: true });
       } catch (exp) {
         if (isMissingFileError(exp)) {
           continue;
@@ -486,7 +486,7 @@ export namespace TypiaGenerateWizard {
           `Error on TypiaGenerateWizard.generate(): output file would overwrite input file through a physical file alias: ${entry.target}`,
         );
       }
-      if (stat.nlink > 1) {
+      if (stat.nlink > BigInt(1)) {
         throw new URIError(
           `Error on TypiaGenerateWizard.generate(): output file has multiple hard links: ${entry.target}`,
         );
@@ -874,7 +874,9 @@ export namespace TypiaGenerateWizard {
       real: currentReal,
     });
 
-    const currentStat: fs.Stats = await fs.promises.stat(props.from);
+    const currentStat: fs.BigIntStats = await fs.promises.stat(props.from, {
+      bigint: true,
+    });
     const directoryIdentity: string = fileIdentityKey(currentStat, currentReal);
     if (props.visitedDirectories.has(directoryIdentity)) {
       const lexicalStat: fs.Stats = await fs.promises.lstat(props.from);
@@ -907,14 +909,16 @@ export namespace TypiaGenerateWizard {
     entries.sort((x, y) => {
       const linkOrder: number =
         Number(x.stat.isSymbolicLink()) - Number(y.stat.isSymbolicLink());
-      return linkOrder !== 0 ? linkOrder : x.name.localeCompare(y.name);
+      return linkOrder !== 0
+        ? linkOrder
+        : Buffer.compare(Buffer.from(x.name), Buffer.from(y.name));
     });
 
     for (const entry of entries) {
-      let stat: fs.Stats;
+      let stat: fs.BigIntStats;
       let real: string;
       try {
-        stat = await fs.promises.stat(entry.file);
+        stat = await fs.promises.stat(entry.file, { bigint: true });
         real = await fs.promises.realpath(entry.file);
       } catch (error) {
         throw new URIError(
@@ -1086,10 +1090,12 @@ export namespace TypiaGenerateWizard {
     );
   }
 
-  function fileIdentityKey(stat: fs.Stats, realpath: string): string {
-    return stat.ino === 0
-      ? `path:${path.normalize(realpath)}`
-      : `inode:${stat.dev}:${stat.ino}`;
+  /**
+   * Delegates to {@link FileSystemIdentity.identityKey}, which owns the rule and
+   * carries the reasoning for reading the identity as a `bigint`.
+   */
+  function fileIdentityKey(stat: fs.BigIntStats, realpath: string): string {
+    return FileSystemIdentity.identityKey(stat, realpath);
   }
 
   function formatDiagnostics(diagnostics: ITtscCompilerDiagnostic[]): string {

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/_ProtobufReader.ts

@@ -110,15 +110,19 @@ export class _ProtobufReader {
    * Advance by exactly one varint, which carries no length prefix.
    *
    * A varint terminates at its first byte without the continuation bit, and may
-   * occupy no more than {@link VARINT_MAX_BYTES}. Reading past that limit would
-   * accept a varint that `varint32` and `varint64` could not, making the limit
-   * depend on which method happens to consume the value.
+   * occupy no more than {@link VARINT_MAX_BYTES}. Its tenth byte is bounded
+   * twice over, by {@link lastVarintByte}: it may neither continue into an
+   * eleventh byte nor carry payload above bit 63. Skipping is where that is
+   * easiest to get wrong, because this path discards the bytes it reads and so
+   * never notices a value it could not have represented. Relaxing either bound
+   * here would accept a varint that `varint32` and `varint64` reject, making
+   * the limit depend on which method happens to consume the value.
    */
   public skipVarint(): void {
     this.atomic(() => {
-      for (let i: number = 0; i < VARINT_MAX_BYTES; ++i)
+      for (let i: number = 1; i < VARINT_MAX_BYTES; ++i)
         if ((this.u8() & 0x80) === 0) return;
-      throw error(`varint exceeds ${VARINT_MAX_BYTES} bytes.`);
+      this.lastVarintByte();
     });
   }
 
@@ -172,8 +176,7 @@ export class _ProtobufReader {
     if (this.u8() < 0x80) return value;
     if (this.u8() < 0x80) return value;
     if (this.u8() < 0x80) return value;
-    if (this.u8() < 0x80) return value;
-
+    this.lastVarintByte();
     return value;
   }
 
@@ -208,10 +211,28 @@ export class _ProtobufReader {
     value |= ((loaded = this.u8n()) & BigInt(0x7f)) << BigInt(56);
     if (loaded < BigInt(0x80)) return value;
 
-    value |= (this.u8n() & BigInt(0x01)) << BigInt(63);
+    value |= BigInt(this.lastVarintByte()) << BigInt(63);
     return BigInt.asUintN(64, value);
   }
 
+  /**
+   * Read the only byte whose varint payload is limited to bit 63.
+   *
+   * Two distinct faults meet on this byte, and each is named for what it is. A
+   * continuation bit means the varint would occupy an eleventh byte, which no
+   * 64-bit value can reach. Any other payload bit means the varint terminates
+   * within its ten bytes but carries a value bit above 63. Reporting the second
+   * as a length fault would tell the caller something untrue about a payload
+   * that is exactly ten bytes long.
+   */
+  private lastVarintByte(): number {
+    const loaded: number = this.u8();
+    if ((loaded & 0x80) !== 0)
+      throw error(`varint exceeds ${VARINT_MAX_BYTES} bytes.`);
+    if (loaded > 0x01) throw error(`varint exceeds ${VARINT_MAX_BITS} bits.`);
+    return loaded;
+  }
+
   private u8(): number {
     return this.view.getUint8(this.take(1));
   }
@@ -262,12 +283,20 @@ const error = (message: string): Error =>
 /**
  * The most bytes a varint may occupy: a 64-bit value in seven-bit groups.
  *
- * `varint32` and `varint64` hold this same limit structurally, by reading no
- * further than their tenth byte. This constant is what a loop-driven consumer
- * holds it by.
+ * Every path reads no further than its tenth byte and accepts only bit 63 from
+ * that byte. This constant keeps the loop-driven skip path on the same limit.
  */
 const VARINT_MAX_BYTES = 10;
 
+/**
+ * The widest value a varint may carry: the 64-bit Protocol Buffer wire domain.
+ *
+ * The tenth byte reaches only bit 63, so a payload bit above it belongs to no
+ * representable value. This names the overflow fault apart from the length
+ * one.
+ */
+const VARINT_MAX_BITS = 64;
+
 const utf8 = new Singleton(
   () => new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }),
 );

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/_jsonStringifyArray.ts

@@ -0,0 +1,50 @@
+/**
+ * Serializes the elements of an array the way ECMAScript `JSON.stringify` does.
+ *
+ * `SerializeJSONArray` walks index `0` to `LengthOfArrayLike(value) - 1` and
+ * writes `null` wherever the element serializes to `undefined`. Neither
+ * `Array.prototype.map` nor `Array.prototype.join` reproduces that:
+ *
+ * - `map` never visits a hole and leaves one behind, and `join` renders a hole as
+ *   empty text, so a sparse array joined into malformed text such as `[,1]`. A
+ *   hole exists at runtime whatever the element type declares, so this is not
+ *   an `any` concern.
+ * - `join` renders a mapped `undefined` as empty text too, which is what an `any`
+ *   or `unknown` element holding a function, a symbol, or a `toJSON` that
+ *   returns nothing serializes to.
+ *
+ * The length is converted with `ToLength` and read once, which is both what
+ * `JSON.stringify` does and what `Array.prototype.every` - the traversal
+ * typia's own array checkers emit - does, so the checker and the serializer
+ * walk one index range rather than two that merely usually coincide.
+ *
+ * @param elements Array being serialized.
+ * @param mapper Serializer of one element, emitted by the transform.
+ * @returns Comma separated element text, without the enclosing brackets.
+ * @internal
+ */
+export const _jsonStringifyArray = <T>(
+  elements: ArrayLike<T>,
+  mapper: (elem: T, index: number) => string,
+): string => {
+  const length: number = Math.min(
+    Math.max(Math.trunc(elements.length) || 0, 0),
+    Number.MAX_SAFE_INTEGER,
+  );
+  let output: string = "";
+  for (let i: number = 0; i < length; ++i) {
+    const elem: T | undefined = elements[i];
+    // A hole and an explicit `undefined` are answered without calling the
+    // mapper, because the mapper is the element type's own serializer and a
+    // typed one has no answer for a missing value. Everything else is answered
+    // from the mapper's *result*: an element that is present but serializes to
+    // nothing — a function, a symbol, or a `toJSON` returning nothing in an
+    // `any` slot — is `null` in an array position, exactly as
+    // SerializeJSONArray specifies, and testing the input instead would let its
+    // text become the literal `undefined`.
+    const text: string | undefined =
+      elem === undefined ? undefined : mapper(elem, i);
+    output += (i === 0 ? "" : ",") + (text === undefined ? "null" : text);
+  }
+  return output;
+};

package/src/internal/_jsonStringifyElement.ts

@@ -0,0 +1,19 @@
+/**
+ * Writes one array or tuple element the way ECMAScript `JSON.stringify` writes
+ * it.
+ *
+ * `SerializeJSONArray` writes `null` wherever an element serializes to
+ * `undefined`, because an array position cannot be omitted without shifting
+ * every element after it. A present value with no serialization — a function, a
+ * symbol, or a `toJSON` returning nothing — is therefore `null`, not the
+ * literal text `undefined` and not an empty slot.
+ *
+ * This is the fixed-position counterpart of `_jsonStringifyArray`, which
+ * answers the same question while walking an array's own index range.
+ *
+ * @param text Serialized element value, or `undefined` when it has none.
+ * @returns Element text, or `null` when the element has no serialization.
+ * @internal
+ */
+export const _jsonStringifyElement = (text: string | undefined): string =>
+  text === undefined ? "null" : text;

package/src/internal/_jsonStringifyProperty.ts

@@ -0,0 +1,30 @@
+/**
+ * Writes one object member the way ECMAScript `JSON.stringify` writes it.
+ *
+ * `SerializeJSONObject` serializes each member first and drops the member
+ * entirely when that result is `undefined`. Deciding omission from the _input_
+ * instead cannot reach the same answer: a symbol and a `toJSON` returning
+ * nothing are both present, non-`undefined`, non-function values whose
+ * serialization is `undefined`, so the member's text became the literal
+ * `"k":undefined` — output that is not JSON at all.
+ *
+ * The serialized text is passed in already evaluated, so the member's value is
+ * serialized exactly once. Testing the input and then serializing would
+ * evaluate a `toJSON` twice, and a `toJSON` is free to answer differently each
+ * call.
+ *
+ * The trailing separator belongs to the member because a dropped member must
+ * take its comma with it; `_jsonStringifyTail` removes the one that is left
+ * behind when the last written member is the one that dropped.
+ *
+ * @param head Quoted key and colon, emitted by the transform.
+ * @param text Serialized member value, or `undefined` when it has none.
+ * @param tail Separator following this member, empty for the last one.
+ * @returns Member text, or an empty string when the member is omitted.
+ * @internal
+ */
+export const _jsonStringifyProperty = (
+  head: string,
+  text: string | undefined,
+  tail: string,
+): string => (text === undefined ? "" : head + text + tail);

package/src/internal/_llmApplicationFinalize.ts

@@ -7,7 +7,12 @@ export const _llmApplicationFinalize = <Class extends object = any>(
 ): ILlmApplication<Class> => ({
   ...app,
   config: {
-    ...LlmSchemaConverter.getConfig(),
+    // The schema configuration comes from the emitted application, which is
+    // where the `Config` generic was resolved. Rebuilding it from the
+    // converter's defaults reported `strict: false` for a strict build, and
+    // `@typia/mcp` then inverted a strict output schema without strict, which
+    // drops every constraint it carries as a description tag (issue #2293).
+    ...LlmSchemaConverter.getConfig(app.config),
     validate: config?.validate ?? null,
   },
   functions: app.functions.map((func) => ({

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,6 +1,38 @@
-import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import { _randomInteger } from "./_randomInteger";
+import {
+  _ILengthProps,
+  _RANDOM_LENGTH_ERROR,
+  _randomLengthPick,
+  _randomLengthWindow,
+} from "./_randomStringLength";
+import { __randomBase64 } from "./private/__randomComposition";
 
-export const _randomFormatByte = (props?: _ILengthProps): string =>
-  _randomFormatLength(props, () => FIXED);
+export const _randomFormatByte = (props?: _ILengthProps): string => {
+  // Base64 encodes three bytes as four characters, so a valid length is always
+  // 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);
+  const length: number =
+    low +
+    4 *
+      _randomLengthPick({
+        low: 0,
+        high: Math.floor((window.high - low) / 4),
+      });
+  return __randomBase64(length);
+};
 
-const FIXED = "vt7ekz4lIoNTTS9sDQYdWKharxIFAR54+z/umIxSgUM=";
+const DEFAULT_GROUP_MIN = 4;
+const DEFAULT_GROUP_MAX = 12;

package/src/internal/_randomFormatDate.ts

@@ -1,23 +1,7 @@
-import { _randomInteger } from "./_randomInteger";
-import { _randomFormatLength } from "./_randomStringLength";
+import { _ILengthProps, _randomFormatLength } from "./_randomStringLength";
+import { __IEpochProps, __randomEpoch } from "./private/__randomEpoch";
 
-export const _randomFormatDate = (props?: {
-  minimum?: number;
-  maximum?: number;
-  minLength?: number;
-  maxLength?: number;
-}) =>
+export const _randomFormatDate = (props?: __IEpochProps & _ILengthProps) =>
   _randomFormatLength(props, () =>
-    new Date(
-      _randomInteger({
-        type: "integer",
-        minimum: props?.minimum ?? 0,
-        maximum:
-          (props?.maximum ?? props?.minimum === undefined)
-            ? Date.now()
-            : props.minimum + 365 * 24 * 60 * 60 * 1_000,
-      }),
-    )
-      .toISOString()
-      .substring(0, 10),
+    new Date(__randomEpoch(props)).toISOString().substring(0, 10),
   );