ts-fortress 9.2.1 → 11.0.0

package/README.md

@@ -1042,10 +1042,10 @@ type ValidationError = Readonly<{
 - `t.array(elementType)` - Array validation
 - `t.nonEmptyArray(elementType)` - Non-empty array validation
 - `t.tuple([t1, t2, ..., tN])` - Fixed-length tuple validation
-- `t.arrayOfLength(size, elementType)` - Fixed-length array validation
-- `t.arrayAtLeastLength(size, elementType)` - Array validation with a minimum length
-- `t.arrayAtMostLength(size, elementType)` - Array validation with a maximum length
-- `t.arrayBoundedLength(min, max, elementType)` - Array validation with a length between `min` and `max` (inclusive)
+- `t.fixedLengthTuple(size, elementType)` - Fixed-length array validation
+- `t.minLengthTuple(size, elementType)` - Array validation with a minimum length
+- `t.maxLengthTuple(size, elementType)` - Array validation with a maximum length
+- `t.boundedLengthTuple(min, max, elementType)` - Array validation with a length between `min` and `max` (inclusive)
 
 ### Objects
 

package/dist/array/bounded-length-array.d.mts

@@ -0,0 +1,29 @@
+import { type BoundedLengthArray, type MaxLengthArray, type MinLengthArray, type SupportedLength } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { BoundedLengthArray } from 'ts-type-forge';
+/**
+ * Creates a `Type` for a readonly array whose length is within the inclusive
+ * range `[min, max]`, typed as the branded {@link BoundedLengthArray} instead
+ * of the union of tuple types produced by `boundedLengthTuple`.
+ *
+ * Because the length constraint lives only in the brand, no union of tuples
+ * of the element type is ever constructed, which keeps type-checking cheap
+ * even when `A` is a large type.
+ */
+export declare function boundedLengthArray<A, Min extends SupportedLength, Max extends SupportedLength>(min: Min, max: Max, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: BoundedLengthArray<Min, Max, A>;
+}>>): Type<BoundedLengthArray<Min, Max, A>>;
+export declare function boundedLengthArray<A, Min extends SupportedLength>(min: Min, max: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MinLengthArray<Min, A>;
+}>>): Type<MinLengthArray<Min, A>>;
+export declare function boundedLengthArray<A, Max extends SupportedLength>(min: number, max: Max, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MaxLengthArray<Max, A>;
+}>>): Type<MaxLengthArray<Max, A>>;
+export declare function boundedLengthArray<A>(min: number, max: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+//# sourceMappingURL=bounded-length-array.d.mts.map

package/dist/array/bounded-length-array.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-length-array.d.mts","sourceRoot":"","sources":["../../src/array/bounded-length-array.mts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAOxC,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EACD,GAAG,SAAS,eAAe,EAC3B,GAAG,SAAS,eAAe,EAE3B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;CAC/C,CAAC,CACH,GACA,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAIzC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,SAAS,eAAe,EAC/D,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;CACtC,CAAC,CACH,GACA,IAAI,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAIhC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,SAAS,eAAe,EAC/D,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;CACtC,CAAC,CACH,GACA,IAAI,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAGhC,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,CAAC,EAAE,CAAC;CAC5B,CAAC,CACH,GACA,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC"}

package/dist/array/bounded-length-array.mjs

@@ -0,0 +1,54 @@
+import { memoizeFunction, Arr, asUint32, Result } from 'ts-data-forge';
+import { createPrimitiveValidationError } from '../utils/validation-error.mjs';
+import { buildType, validateElements } from './build-type.mjs';
+
+function boundedLengthArray(min, max, elementType, options) {
+  const typeName = options?.typeName ?? `BoundedLengthArray<${min}, ${max}, ${elementType.typeName}>`;
+  const getDefaultValue = memoizeFunction(
+    () => options?.defaultValue ?? // An array of the minimum length is the shortest value within the range.
+    Arr.create(asUint32(min), elementType.defaultValue)
+  );
+  const validate = (a) => {
+    if (!Arr.isArray(a)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: "array",
+          typeName,
+          details: void 0
+        })
+      ]);
+    }
+    if (a.length < min || max < a.length) {
+      return Result.err([
+        {
+          path: [],
+          actualValue: a,
+          expectedType: typeName,
+          typeName,
+          details: {
+            kind: "array-range-length",
+            minLength: min,
+            maxLength: max,
+            actualLength: a.length
+          }
+        }
+      ]);
+    }
+    return validateElements(a, elementType);
+  };
+  const fill = (a) => {
+    if (!Arr.isArray(a)) {
+      return getDefaultValue();
+    }
+    const capped = Arr.take(a, asUint32(max));
+    return capped.length >= min ? Arr.map(capped, (el) => elementType.fill(el)) : Arr.map(
+      Arr.seq(asUint32(min)),
+      (i) => elementType.fill(capped[i])
+    );
+  };
+  return buildType({ typeName, getDefaultValue, validate, fill, elementType });
+}
+
+export { boundedLengthArray };
+//# sourceMappingURL=bounded-length-array.mjs.map

package/dist/array/bounded-length-array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-length-array.mjs","sources":["../../src/array/bounded-length-array.mts"],"sourcesContent":["import { Arr, asUint32, memoizeFunction, Result } from 'ts-data-forge';\nimport {\n  type BoundedLengthArray,\n  type MaxLengthArray,\n  type MinLengthArray,\n  type SupportedLength,\n} from 'ts-type-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createPrimitiveValidationError,\n  type ValidationError,\n} from '../utils/index.mjs';\nimport { buildType, validateElements } from './build-type.mjs';\n\nexport type { BoundedLengthArray } from 'ts-type-forge';\n\n/**\n * Creates a `Type` for a readonly array whose length is within the inclusive\n * range `[min, max]`, typed as the branded {@link BoundedLengthArray} instead\n * of the union of tuple types produced by `boundedLengthTuple`.\n *\n * Because the length constraint lives only in the brand, no union of tuples\n * of the element type is ever constructed, which keeps type-checking cheap\n * even when `A` is a large type.\n */\nexport function boundedLengthArray<\n  A,\n  Min extends SupportedLength,\n  Max extends SupportedLength,\n>(\n  min: Min,\n  max: Max,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: BoundedLengthArray<Min, Max, A>;\n    }>\n  >,\n): Type<BoundedLengthArray<Min, Max, A>>;\n\n// Only the lower bound is in `SupportedLength`, so the upper bound is dropped from\n// the result type and only the \"at least `min`\" guarantee is kept.\nexport function boundedLengthArray<A, Min extends SupportedLength>(\n  min: Min,\n  max: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: MinLengthArray<Min, A>;\n    }>\n  >,\n): Type<MinLengthArray<Min, A>>;\n\n// Only the upper bound is in `SupportedLength`, so the lower bound is dropped from\n// the result type and only the \"at most `max`\" guarantee is kept.\nexport function boundedLengthArray<A, Max extends SupportedLength>(\n  min: number,\n  max: Max,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: MaxLengthArray<Max, A>;\n    }>\n  >,\n): Type<MaxLengthArray<Max, A>>;\n\n// Neither bound is in `SupportedLength`, so the result length is left unconstrained.\nexport function boundedLengthArray<A>(\n  min: number,\n  max: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]>;\n\nexport function boundedLengthArray<A>(\n  min: number,\n  max: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]> {\n  type T = readonly A[];\n\n  const typeName =\n    options?.typeName ??\n    `BoundedLengthArray<${min}, ${max}, ${elementType.typeName}>`;\n\n  const getDefaultValue = memoizeFunction(\n    (): T =>\n      options?.defaultValue ??\n      // An array of the minimum length is the shortest value within the range.\n      Arr.create(asUint32(min), elementType.defaultValue),\n  );\n\n  const validate: Type<T>['validate'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return Result.err([\n        createPrimitiveValidationError({\n          actualValue: a,\n          expectedType: 'array',\n          typeName,\n          details: undefined,\n        }),\n      ]);\n    }\n\n    if (a.length < min || max < a.length) {\n      return Result.err([\n        {\n          path: [],\n          actualValue: a,\n          expectedType: typeName,\n          typeName,\n          details: {\n            kind: 'array-range-length',\n            minLength: min,\n            maxLength: max,\n            actualLength: a.length,\n          },\n        } satisfies ValidationError,\n      ]);\n    }\n\n    return validateElements(a, elementType);\n  };\n\n  const fill: Type<T>['fill'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return getDefaultValue();\n    }\n\n    // Trim down to at most `max`, then pad up to at least `min`.\n    const capped = Arr.take(a, asUint32(max));\n\n    return capped.length >= min\n      ? Arr.map(capped, (el) => elementType.fill(el) satisfies A)\n      : Arr.map(\n          Arr.seq(asUint32(min)),\n          (i) => elementType.fill(capped[i]) satisfies A,\n        );\n  };\n\n  return buildType({ typeName, getDefaultValue, validate, fill, elementType });\n}\n"],"names":[],"mappings":";;;;AAkFO,SAAS,kBAAA,CACd,GAAA,EACA,GAAA,EACA,WAAA,EACA,OAAA,EAMoB;AAGpB,EAAA,MAAM,QAAA,GACJ,SAAS,QAAA,IACT,CAAA,mBAAA,EAAsB,GAAG,CAAA,EAAA,EAAK,GAAG,CAAA,EAAA,EAAK,WAAA,CAAY,QAAQ,CAAA,CAAA,CAAA;AAE5D,EAAA,MAAM,eAAA,GAAkB,eAAA;AAAA,IACtB,MACE,OAAA,EAAS,YAAA;AAAA,IAET,IAAI,MAAA,CAAO,QAAA,CAAS,GAAG,CAAA,EAAG,YAAY,YAAY;AAAA,GACtD;AAEA,EAAA,MAAM,QAAA,GAAgC,CAAC,CAAA,KAAM;AAC3C,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB,8BAAA,CAA+B;AAAA,UAC7B,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,OAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,SACV;AAAA,OACF,CAAA;AAAA,IACH;AAEA,IAAA,IAAI,CAAA,CAAE,MAAA,GAAS,GAAA,IAAO,GAAA,GAAM,EAAE,MAAA,EAAQ;AACpC,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB;AAAA,UACE,MAAM,EAAC;AAAA,UACP,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,QAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,YACP,IAAA,EAAM,oBAAA;AAAA,YACN,SAAA,EAAW,GAAA;AAAA,YACX,SAAA,EAAW,GAAA;AAAA,YACX,cAAc,CAAA,CAAE;AAAA;AAClB;AACF,OACD,CAAA;AAAA,IACH;AAEA,IAAA,OAAO,gBAAA,CAAiB,GAAG,WAAW,CAAA;AAAA,EACxC,CAAA;AAEA,EAAA,MAAM,IAAA,GAAwB,CAAC,CAAA,KAAM;AACnC,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,eAAA,EAAgB;AAAA,IACzB;AAGA,IAAA,MAAM,SAAS,GAAA,CAAI,IAAA,CAAK,CAAA,EAAG,QAAA,CAAS,GAAG,CAAC,CAAA;AAExC,IAAA,OAAO,MAAA,CAAO,MAAA,IAAU,GAAA,GACpB,GAAA,CAAI,GAAA,CAAI,MAAA,EAAQ,CAAC,EAAA,KAAO,WAAA,CAAY,IAAA,CAAK,EAAE,CAAa,IACxD,GAAA,CAAI,GAAA;AAAA,MACF,GAAA,CAAI,GAAA,CAAI,QAAA,CAAS,GAAG,CAAC,CAAA;AAAA,MACrB,CAAC,CAAA,KAAM,WAAA,CAAY,IAAA,CAAK,MAAA,CAAO,CAAC,CAAC;AAAA,KACnC;AAAA,EACN,CAAA;AAEA,EAAA,OAAO,UAAU,EAAE,QAAA,EAAU,iBAAiB,QAAA,EAAU,IAAA,EAAM,aAAa,CAAA;AAC7E;;;;"}

package/dist/array/bounded-length-tuple.d.mts

@@ -0,0 +1,20 @@
+import { type BoundedLengthTuple, type MaxLengthTuple, type MinLengthTuple, type StructuralPrefixLength } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { BoundedLengthTuple } from 'ts-type-forge';
+export declare function boundedLengthTuple<A, Min extends StructuralPrefixLength, Max extends StructuralPrefixLength>(min: Min, max: Max, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: BoundedLengthTuple<Min, Max, A>;
+}>>): Type<BoundedLengthTuple<Min, Max, A>>;
+export declare function boundedLengthTuple<A, Min extends StructuralPrefixLength>(min: Min, max: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MinLengthTuple<Min, A>;
+}>>): Type<MinLengthTuple<Min, A>>;
+export declare function boundedLengthTuple<A, Max extends StructuralPrefixLength>(min: number, max: Max, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MaxLengthTuple<Max, A>;
+}>>): Type<MaxLengthTuple<Max, A>>;
+export declare function boundedLengthTuple<A>(min: number, max: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+//# sourceMappingURL=bounded-length-tuple.d.mts.map

package/dist/array/bounded-length-tuple.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-length-tuple.d.mts","sourceRoot":"","sources":["../../src/array/bounded-length-tuple.mts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC5B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAUxC,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,wBAAgB,kBAAkB,CAChC,CAAC,EACD,GAAG,SAAS,sBAAsB,EAClC,GAAG,SAAS,sBAAsB,EAElC,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;CAC/C,CAAC,CACH,GACA,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAIzC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,SAAS,sBAAsB,EACtE,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;CACtC,CAAC,CACH,GACA,IAAI,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAIhC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,SAAS,sBAAsB,EACtE,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;CACtC,CAAC,CACH,GACA,IAAI,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAGhC,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,CAAC,EAAE,CAAC;CAC5B,CAAC,CACH,GACA,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC"}

package/dist/array/{array-bounded-length.mjs → bounded-length-tuple.mjs}

@@ -4,8 +4,8 @@ import { createCastFn } from '../utils/create-cast-fn.mjs';
 import { createIsFn } from '../utils/create-is-fn.mjs';
 import { createPrimitiveValidationError, prependIndexToValidationErrors } from '../utils/validation-error.mjs';
 
-function arrayBoundedLength(min, max, elementType, options) {
-  const typeName = options?.typeName ?? `ArrayBoundedLen<${min}, ${max}, ${elementType.typeName}>`;
+function boundedLengthTuple(min, max, elementType, options) {
+  const typeName = options?.typeName ?? `BoundedLengthTuple<${min}, ${max}, ${elementType.typeName}>`;
   const getDefaultValue = memoizeFunction(
     () => options?.defaultValue ?? // An array of the minimum length is the shortest value within the range.
     Arr.create(asUint32(min), elementType.defaultValue)
@@ -75,5 +75,5 @@ function arrayBoundedLength(min, max, elementType, options) {
   };
 }
 
-export { arrayBoundedLength };
-//# sourceMappingURL=array-bounded-length.mjs.map
+export { boundedLengthTuple };
+//# sourceMappingURL=bounded-length-tuple.mjs.map

package/dist/array/bounded-length-tuple.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-length-tuple.mjs","sources":["../../src/array/bounded-length-tuple.mts"],"sourcesContent":["import { Arr, asUint32, memoizeFunction, Result } from 'ts-data-forge';\nimport {\n  type BoundedLengthTuple,\n  type MaxLengthTuple,\n  type MinLengthTuple,\n  type StructuralPrefixLength,\n} from 'ts-type-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createAssertFn,\n  createCastFn,\n  createIsFn,\n  createPrimitiveValidationError,\n  prependIndexToValidationErrors,\n  type ValidationError,\n} from '../utils/index.mjs';\n\nexport type { BoundedLengthTuple } from 'ts-type-forge';\n\nexport function boundedLengthTuple<\n  A,\n  Min extends StructuralPrefixLength,\n  Max extends StructuralPrefixLength,\n>(\n  min: Min,\n  max: Max,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: BoundedLengthTuple<Min, Max, A>;\n    }>\n  >,\n): Type<BoundedLengthTuple<Min, Max, A>>;\n\n// Only the lower bound is in `StructuralPrefixLength` (`0..10`), so the upper bound is dropped from the\n// result type and only the \"at least `min`\" guarantee is kept.\nexport function boundedLengthTuple<A, Min extends StructuralPrefixLength>(\n  min: Min,\n  max: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: MinLengthTuple<Min, A>;\n    }>\n  >,\n): Type<MinLengthTuple<Min, A>>;\n\n// Only the upper bound is in `StructuralPrefixLength` (`0..10`), so the lower bound is dropped from the\n// result type and only the \"at most `max`\" guarantee is kept.\nexport function boundedLengthTuple<A, Max extends StructuralPrefixLength>(\n  min: number,\n  max: Max,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: MaxLengthTuple<Max, A>;\n    }>\n  >,\n): Type<MaxLengthTuple<Max, A>>;\n\n// Neither bound is in `StructuralPrefixLength` (`0..10`), so the result length is left unconstrained.\nexport function boundedLengthTuple<A>(\n  min: number,\n  max: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]>;\n\nexport function boundedLengthTuple<A>(\n  min: number,\n  max: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]> {\n  type T = readonly A[];\n\n  const typeName =\n    options?.typeName ??\n    `BoundedLengthTuple<${min}, ${max}, ${elementType.typeName}>`;\n\n  const getDefaultValue = memoizeFunction(\n    (): T =>\n      options?.defaultValue ??\n      // An array of the minimum length is the shortest value within the range.\n      Arr.create(asUint32(min), elementType.defaultValue),\n  );\n\n  const validate: Type<T>['validate'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return Result.err([\n        createPrimitiveValidationError({\n          actualValue: a,\n          expectedType: 'array',\n          typeName,\n          details: undefined,\n        }),\n      ]);\n    }\n\n    if (a.length < min || max < a.length) {\n      return Result.err([\n        {\n          path: [],\n          actualValue: a,\n          expectedType: typeName,\n          typeName,\n          details: {\n            kind: 'array-range-length',\n            minLength: min,\n            maxLength: max,\n            actualLength: a.length,\n          },\n        } satisfies ValidationError,\n      ]);\n    }\n\n    const errors: readonly ValidationError[] = Arr.generate(function* () {\n      for (const [index, el] of a.entries()) {\n        const res = elementType.validate(el);\n\n        if (Result.isErr(res)) {\n          yield* prependIndexToValidationErrors(res.value, index);\n        }\n      }\n    });\n\n    if (Arr.isNonEmpty(errors)) {\n      return Result.err(errors);\n    }\n\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return Result.ok(a as unknown as T);\n  };\n\n  const fill: Type<T>['fill'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return getDefaultValue();\n    }\n\n    // Trim down to at most `max`, then pad up to at least `min`.\n    const capped = Arr.take(a, asUint32(max));\n\n    return capped.length >= min\n      ? Arr.map(capped, (el) => elementType.fill(el) satisfies A)\n      : Arr.map(\n          Arr.seq(asUint32(min)),\n          (i) => elementType.fill(capped[i]) satisfies A,\n        );\n  };\n\n  const prune = (a: T): T => a.map((el) => elementType.prune(el));\n\n  return {\n    typeName,\n    get defaultValue() {\n      return getDefaultValue();\n    },\n    fill,\n    prune,\n    validate,\n    is: createIsFn(validate),\n    cast: createCastFn(validate),\n    assertIs: createAssertFn(validate),\n  };\n}\n"],"names":[],"mappings":";;;;;;AA4EO,SAAS,kBAAA,CACd,GAAA,EACA,GAAA,EACA,WAAA,EACA,OAAA,EAMoB;AAGpB,EAAA,MAAM,QAAA,GACJ,SAAS,QAAA,IACT,CAAA,mBAAA,EAAsB,GAAG,CAAA,EAAA,EAAK,GAAG,CAAA,EAAA,EAAK,WAAA,CAAY,QAAQ,CAAA,CAAA,CAAA;AAE5D,EAAA,MAAM,eAAA,GAAkB,eAAA;AAAA,IACtB,MACE,OAAA,EAAS,YAAA;AAAA,IAET,IAAI,MAAA,CAAO,QAAA,CAAS,GAAG,CAAA,EAAG,YAAY,YAAY;AAAA,GACtD;AAEA,EAAA,MAAM,QAAA,GAAgC,CAAC,CAAA,KAAM;AAC3C,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB,8BAAA,CAA+B;AAAA,UAC7B,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,OAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,SACV;AAAA,OACF,CAAA;AAAA,IACH;AAEA,IAAA,IAAI,CAAA,CAAE,MAAA,GAAS,GAAA,IAAO,GAAA,GAAM,EAAE,MAAA,EAAQ;AACpC,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB;AAAA,UACE,MAAM,EAAC;AAAA,UACP,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,QAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,YACP,IAAA,EAAM,oBAAA;AAAA,YACN,SAAA,EAAW,GAAA;AAAA,YACX,SAAA,EAAW,GAAA;AAAA,YACX,cAAc,CAAA,CAAE;AAAA;AAClB;AACF,OACD,CAAA;AAAA,IACH;AAEA,IAAA,MAAM,MAAA,GAAqC,GAAA,CAAI,QAAA,CAAS,aAAa;AACnE,MAAA,KAAA,MAAW,CAAC,KAAA,EAAO,EAAE,CAAA,IAAK,CAAA,CAAE,SAAQ,EAAG;AACrC,QAAA,MAAM,GAAA,GAAM,WAAA,CAAY,QAAA,CAAS,EAAE,CAAA;AAEnC,QAAA,IAAI,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA,EAAG;AACrB,UAAA,OAAO,8BAAA,CAA+B,GAAA,CAAI,KAAA,EAAO,KAAK,CAAA;AAAA,QACxD;AAAA,MACF;AAAA,IACF,CAAC,CAAA;AAED,IAAA,IAAI,GAAA,CAAI,UAAA,CAAW,MAAM,CAAA,EAAG;AAC1B,MAAA,OAAO,MAAA,CAAO,IAAI,MAAM,CAAA;AAAA,IAC1B;AAGA,IAAA,OAAO,MAAA,CAAO,GAAG,CAAiB,CAAA;AAAA,EACpC,CAAA;AAEA,EAAA,MAAM,IAAA,GAAwB,CAAC,CAAA,KAAM;AACnC,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,eAAA,EAAgB;AAAA,IACzB;AAGA,IAAA,MAAM,SAAS,GAAA,CAAI,IAAA,CAAK,CAAA,EAAG,QAAA,CAAS,GAAG,CAAC,CAAA;AAExC,IAAA,OAAO,MAAA,CAAO,MAAA,IAAU,GAAA,GACpB,GAAA,CAAI,GAAA,CAAI,MAAA,EAAQ,CAAC,EAAA,KAAO,WAAA,CAAY,IAAA,CAAK,EAAE,CAAa,IACxD,GAAA,CAAI,GAAA;AAAA,MACF,GAAA,CAAI,GAAA,CAAI,QAAA,CAAS,GAAG,CAAC,CAAA;AAAA,MACrB,CAAC,CAAA,KAAM,WAAA,CAAY,IAAA,CAAK,MAAA,CAAO,CAAC,CAAC;AAAA,KACnC;AAAA,EACN,CAAA;AAEA,EAAA,MAAM,KAAA,GAAQ,CAAC,CAAA,KAAY,CAAA,CAAE,GAAA,CAAI,CAAC,EAAA,KAAO,WAAA,CAAY,KAAA,CAAM,EAAE,CAAC,CAAA;AAE9D,EAAA,OAAO;AAAA,IACL,QAAA;AAAA,IACA,IAAI,YAAA,GAAe;AACjB,MAAA,OAAO,eAAA,EAAgB;AAAA,IACzB,CAAA;AAAA,IACA,IAAA;AAAA,IACA,KAAA;AAAA,IACA,QAAA;AAAA,IACA,EAAA,EAAI,WAAW,QAAQ,CAAA;AAAA,IACvB,IAAA,EAAM,aAAa,QAAQ,CAAA;AAAA,IAC3B,QAAA,EAAU,eAAe,QAAQ;AAAA,GACnC;AACF;;;;"}

package/dist/array/build-type.d.mts

@@ -0,0 +1,28 @@
+import { Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import { type ValidationError } from '../utils/index.mjs';
+/**
+ * Validates each element of `a` against `elementType`, collecting any element
+ * errors with their index prepended. Shared by the length-constrained array
+ * validators.
+ *
+ * @internal Not part of the public package API.
+ */
+export declare const validateElements: <A>(a: readonly unknown[], elementType: Type<A>) => Result<readonly A[], readonly ValidationError[]>;
+/**
+ * Assembles a structural `Type<readonly A[]>` from the length-specific pieces
+ * (`typeName` / `getDefaultValue` / `validate` / `fill`). Shared internally by
+ * the length-constrained array validators (`fixedLengthArray` etc.) and the
+ * `nonEmptyArray` validator; their outer signatures narrow the structural
+ * result to the branded array type.
+ *
+ * @internal Not part of the public package API.
+ */
+export declare const buildType: <Elm, T extends readonly Elm[] = readonly Elm[]>({ typeName, getDefaultValue, validate, fill, elementType, }: Readonly<{
+    typeName: string;
+    getDefaultValue: () => readonly Elm[];
+    validate: (a: unknown) => Result<readonly Elm[], readonly ValidationError[]>;
+    fill: (a: unknown) => readonly Elm[];
+    elementType: Type<Elm>;
+}>) => Type<T>;
+//# sourceMappingURL=build-type.d.mts.map

package/dist/array/build-type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-type.d.mts","sourceRoot":"","sources":["../../src/array/build-type.mts"],"names":[],"mappings":"AAAA,OAAO,EAAO,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,KAC7B,SAAS,OAAO,EAAE,eACR,IAAI,CAAC,CAAC,CAAC,KACnB,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,SAAS,eAAe,EAAE,CAiBjD,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,GAAI,GAAG,EAAE,CAAC,SAAS,SAAS,GAAG,EAAE,GAAG,SAAS,GAAG,EAAE,+DAMrE,QAAQ,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,SAAS,GAAG,EAAE,CAAC;IACtC,QAAQ,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC,SAAS,GAAG,EAAE,EAAE,SAAS,eAAe,EAAE,CAAC,CAAC;IAC7E,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,SAAS,GAAG,EAAE,CAAC;IACrC,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;CACxB,CAAC,KAAG,IAAI,CAAC,CAAC,CAqBV,CAAC"}

package/dist/array/build-type.mjs

@@ -0,0 +1,44 @@
+import { Arr, Result } from 'ts-data-forge';
+import { createAssertFn } from '../utils/create-assert-fn.mjs';
+import { createCastFn } from '../utils/create-cast-fn.mjs';
+import { createIsFn } from '../utils/create-is-fn.mjs';
+import { prependIndexToValidationErrors } from '../utils/validation-error.mjs';
+
+const validateElements = (a, elementType) => {
+  const errors = Arr.generate(function* () {
+    for (const [index, el] of a.entries()) {
+      const res = elementType.validate(el);
+      if (Result.isErr(res)) {
+        yield* prependIndexToValidationErrors(res.value, index);
+      }
+    }
+  });
+  if (Arr.isNonEmpty(errors)) {
+    return Result.err(errors);
+  }
+  return Result.ok(a);
+};
+const buildType = ({
+  typeName,
+  getDefaultValue,
+  validate,
+  fill,
+  elementType
+}) => {
+  const base = {
+    typeName,
+    get defaultValue() {
+      return getDefaultValue();
+    },
+    fill,
+    prune: (a) => a.map((el) => elementType.prune(el)),
+    validate,
+    is: createIsFn(validate),
+    cast: createCastFn(validate),
+    assertIs: createAssertFn(validate)
+  };
+  return base;
+};
+
+export { buildType, validateElements };
+//# sourceMappingURL=build-type.mjs.map

package/dist/array/build-type.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-type.mjs","sources":["../../src/array/build-type.mts"],"sourcesContent":["import { Arr, Result } from 'ts-data-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createAssertFn,\n  createCastFn,\n  createIsFn,\n  prependIndexToValidationErrors,\n  type ValidationError,\n} from '../utils/index.mjs';\n\n/**\n * Validates each element of `a` against `elementType`, collecting any element\n * errors with their index prepended. Shared by the length-constrained array\n * validators.\n *\n * @internal Not part of the public package API.\n */\nexport const validateElements = <A,>(\n  a: readonly unknown[],\n  elementType: Type<A>,\n): Result<readonly A[], readonly ValidationError[]> => {\n  const errors: readonly ValidationError[] = Arr.generate(function* () {\n    for (const [index, el] of a.entries()) {\n      const res = elementType.validate(el);\n\n      if (Result.isErr(res)) {\n        yield* prependIndexToValidationErrors(res.value, index);\n      }\n    }\n  });\n\n  if (Arr.isNonEmpty(errors)) {\n    return Result.err(errors);\n  }\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return Result.ok(a as readonly A[]);\n};\n\n/**\n * Assembles a structural `Type<readonly A[]>` from the length-specific pieces\n * (`typeName` / `getDefaultValue` / `validate` / `fill`). Shared internally by\n * the length-constrained array validators (`fixedLengthArray` etc.) and the\n * `nonEmptyArray` validator; their outer signatures narrow the structural\n * result to the branded array type.\n *\n * @internal Not part of the public package API.\n */\nexport const buildType = <Elm, T extends readonly Elm[] = readonly Elm[]>({\n  typeName,\n  getDefaultValue,\n  validate,\n  fill,\n  elementType,\n}: Readonly<{\n  typeName: string;\n  getDefaultValue: () => readonly Elm[];\n  validate: (a: unknown) => Result<readonly Elm[], readonly ValidationError[]>;\n  fill: (a: unknown) => readonly Elm[];\n  elementType: Type<Elm>;\n}>): Type<T> => {\n  const base: Type<readonly Elm[]> = {\n    typeName,\n    get defaultValue() {\n      return getDefaultValue();\n    },\n    fill,\n    prune: (a) => a.map((el) => elementType.prune(el)),\n    validate,\n    is: createIsFn(validate),\n    cast: createCastFn(validate),\n    assertIs: createAssertFn(validate),\n  } as const;\n\n  // The branded output type `T` (e.g. `NonEmptyArray` / `FixedLengthArray`) is\n  // a subtype of the structural `readonly Elm[]` the validator actually\n  // produces. The brand is guaranteed by the caller's `validate` / `fill` but\n  // cannot be proven structurally, so it is asserted here once, on behalf of\n  // every length-constrained array validator, instead of at each call site.\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return base as Type<T>;\n};\n"],"names":[],"mappings":";;;;;;AAiBO,MAAM,gBAAA,GAAmB,CAC9B,CAAA,EACA,WAAA,KACqD;AACrD,EAAA,MAAM,MAAA,GAAqC,GAAA,CAAI,QAAA,CAAS,aAAa;AACnE,IAAA,KAAA,MAAW,CAAC,KAAA,EAAO,EAAE,CAAA,IAAK,CAAA,CAAE,SAAQ,EAAG;AACrC,MAAA,MAAM,GAAA,GAAM,WAAA,CAAY,QAAA,CAAS,EAAE,CAAA;AAEnC,MAAA,IAAI,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA,EAAG;AACrB,QAAA,OAAO,8BAAA,CAA+B,GAAA,CAAI,KAAA,EAAO,KAAK,CAAA;AAAA,MACxD;AAAA,IACF;AAAA,EACF,CAAC,CAAA;AAED,EAAA,IAAI,GAAA,CAAI,UAAA,CAAW,MAAM,CAAA,EAAG;AAC1B,IAAA,OAAO,MAAA,CAAO,IAAI,MAAM,CAAA;AAAA,EAC1B;AAGA,EAAA,OAAO,MAAA,CAAO,GAAG,CAAiB,CAAA;AACpC;AAWO,MAAM,YAAY,CAAiD;AAAA,EACxE,QAAA;AAAA,EACA,eAAA;AAAA,EACA,QAAA;AAAA,EACA,IAAA;AAAA,EACA;AACF,CAAA,KAMgB;AACd,EAAA,MAAM,IAAA,GAA6B;AAAA,IACjC,QAAA;AAAA,IACA,IAAI,YAAA,GAAe;AACjB,MAAA,OAAO,eAAA,EAAgB;AAAA,IACzB,CAAA;AAAA,IACA,IAAA;AAAA,IACA,KAAA,EAAO,CAAC,CAAA,KAAM,CAAA,CAAE,GAAA,CAAI,CAAC,EAAA,KAAO,WAAA,CAAY,KAAA,CAAM,EAAE,CAAC,CAAA;AAAA,IACjD,QAAA;AAAA,IACA,EAAA,EAAI,WAAW,QAAQ,CAAA;AAAA,IACvB,IAAA,EAAM,aAAa,QAAQ,CAAA;AAAA,IAC3B,QAAA,EAAU,eAAe,QAAQ;AAAA,GACnC;AAQA,EAAA,OAAO,IAAA;AACT;;;;"}

package/dist/array/fixed-length-array.d.mts

@@ -0,0 +1,23 @@
+import { type FixedLengthArray, type SupportedLength } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { FixedLengthArray } from 'ts-type-forge';
+/**
+ * Creates a `Type` for a readonly array with exactly `size` elements, typed as
+ * the branded {@link FixedLengthArray} instead of the structural tuple type
+ * produced by `fixedLengthTuple`.
+ *
+ * Because the length constraint lives only in the brand, the element type is
+ * never expanded into tuple positions, which keeps type-checking cheap even
+ * when `A` is a large type. Prefer this over `fixedLengthTuple` when `A` is
+ * large; prefer `fixedLengthTuple` when positional element types or a literal
+ * `length` are needed.
+ */
+export declare function fixedLengthArray<A, N extends SupportedLength>(size: N, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: FixedLengthArray<N, A>;
+}>>): Type<FixedLengthArray<N, A>>;
+export declare function fixedLengthArray<A>(size: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+//# sourceMappingURL=fixed-length-array.d.mts.map

package/dist/array/fixed-length-array.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-length-array.d.mts","sourceRoot":"","sources":["../../src/array/fixed-length-array.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAOxC,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,EAC3D,IAAI,EAAE,CAAC,EACP,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACtC,CAAC,CACH,GACA,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAIhC,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,CAAC,EAAE,CAAC;CAC5B,CAAC,CACH,GACA,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC"}

package/dist/array/fixed-length-array.mjs

@@ -0,0 +1,46 @@
+import { memoizeFunction, Arr, asUint32, Result } from 'ts-data-forge';
+import { createPrimitiveValidationError } from '../utils/validation-error.mjs';
+import { buildType, validateElements } from './build-type.mjs';
+
+function fixedLengthArray(size, elementType, options) {
+  const typeName = options?.typeName ?? `FixedLengthArray<${size}, ${elementType.typeName}>`;
+  const getDefaultValue = memoizeFunction(
+    () => options?.defaultValue ?? Arr.create(asUint32(size), elementType.defaultValue)
+  );
+  const validate = (a) => {
+    if (!Arr.isArray(a)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: "array",
+          typeName,
+          details: void 0
+        })
+      ]);
+    }
+    if (a.length !== size) {
+      return Result.err([
+        {
+          path: [],
+          actualValue: a,
+          expectedType: typeName,
+          typeName,
+          details: {
+            kind: "array-length",
+            expectedLength: size,
+            actualLength: a.length
+          }
+        }
+      ]);
+    }
+    return validateElements(a, elementType);
+  };
+  const fill = (a) => Arr.isArray(a) ? Arr.map(
+    Arr.seq(asUint32(size)),
+    (i) => elementType.fill(a[i])
+  ) : getDefaultValue();
+  return buildType({ typeName, getDefaultValue, validate, fill, elementType });
+}
+
+export { fixedLengthArray };
+//# sourceMappingURL=fixed-length-array.mjs.map

package/dist/array/fixed-length-array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-length-array.mjs","sources":["../../src/array/fixed-length-array.mts"],"sourcesContent":["import { Arr, asUint32, memoizeFunction, Result } from 'ts-data-forge';\nimport { type FixedLengthArray, type SupportedLength } from 'ts-type-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createPrimitiveValidationError,\n  type ValidationError,\n} from '../utils/index.mjs';\nimport { buildType, validateElements } from './build-type.mjs';\n\nexport type { FixedLengthArray } from 'ts-type-forge';\n\n/**\n * Creates a `Type` for a readonly array with exactly `size` elements, typed as\n * the branded {@link FixedLengthArray} instead of the structural tuple type\n * produced by `fixedLengthTuple`.\n *\n * Because the length constraint lives only in the brand, the element type is\n * never expanded into tuple positions, which keeps type-checking cheap even\n * when `A` is a large type. Prefer this over `fixedLengthTuple` when `A` is\n * large; prefer `fixedLengthTuple` when positional element types or a literal\n * `length` are needed.\n */\nexport function fixedLengthArray<A, N extends SupportedLength>(\n  size: N,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: FixedLengthArray<N, A>;\n    }>\n  >,\n): Type<FixedLengthArray<N, A>>;\n\n// For sizes outside `SupportedLength` (`0..2048`) the length cannot be encoded in the brand,\n// so the result length is left unconstrained (`readonly A[]`).\nexport function fixedLengthArray<A>(\n  size: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]>;\n\nexport function fixedLengthArray<A>(\n  size: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]> {\n  type T = readonly A[];\n\n  const typeName =\n    options?.typeName ?? `FixedLengthArray<${size}, ${elementType.typeName}>`;\n\n  const getDefaultValue = memoizeFunction(\n    (): T =>\n      options?.defaultValue ??\n      Arr.create(asUint32(size), elementType.defaultValue),\n  );\n\n  const validate: Type<T>['validate'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return Result.err([\n        createPrimitiveValidationError({\n          actualValue: a,\n          expectedType: 'array',\n          typeName,\n          details: undefined,\n        }),\n      ]);\n    }\n\n    if (a.length !== size) {\n      return Result.err([\n        {\n          path: [],\n          actualValue: a,\n          expectedType: typeName,\n          typeName,\n          details: {\n            kind: 'array-length',\n            expectedLength: size,\n            actualLength: a.length,\n          },\n        } satisfies ValidationError,\n      ]);\n    }\n\n    return validateElements(a, elementType);\n  };\n\n  const fill: Type<T>['fill'] = (a) =>\n    Arr.isArray(a)\n      ? Arr.map(\n          Arr.seq(asUint32(size)),\n          (i) => elementType.fill(a[i]) satisfies A,\n        )\n      : getDefaultValue();\n\n  return buildType({ typeName, getDefaultValue, validate, fill, elementType });\n}\n"],"names":[],"mappings":";;;;AA8CO,SAAS,gBAAA,CACd,IAAA,EACA,WAAA,EACA,OAAA,EAMoB;AAGpB,EAAA,MAAM,WACJ,OAAA,EAAS,QAAA,IAAY,oBAAoB,IAAI,CAAA,EAAA,EAAK,YAAY,QAAQ,CAAA,CAAA,CAAA;AAExE,EAAA,MAAM,eAAA,GAAkB,eAAA;AAAA,IACtB,MACE,SAAS,YAAA,IACT,GAAA,CAAI,OAAO,QAAA,CAAS,IAAI,CAAA,EAAG,WAAA,CAAY,YAAY;AAAA,GACvD;AAEA,EAAA,MAAM,QAAA,GAAgC,CAAC,CAAA,KAAM;AAC3C,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB,8BAAA,CAA+B;AAAA,UAC7B,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,OAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,SACV;AAAA,OACF,CAAA;AAAA,IACH;AAEA,IAAA,IAAI,CAAA,CAAE,WAAW,IAAA,EAAM;AACrB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB;AAAA,UACE,MAAM,EAAC;AAAA,UACP,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,QAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,YACP,IAAA,EAAM,cAAA;AAAA,YACN,cAAA,EAAgB,IAAA;AAAA,YAChB,cAAc,CAAA,CAAE;AAAA;AAClB;AACF,OACD,CAAA;AAAA,IACH;AAEA,IAAA,OAAO,gBAAA,CAAiB,GAAG,WAAW,CAAA;AAAA,EACxC,CAAA;AAEA,EAAA,MAAM,OAAwB,CAAC,CAAA,KAC7B,IAAI,OAAA,CAAQ,CAAC,IACT,GAAA,CAAI,GAAA;AAAA,IACF,GAAA,CAAI,GAAA,CAAI,QAAA,CAAS,IAAI,CAAC,CAAA;AAAA,IACtB,CAAC,CAAA,KAAM,WAAA,CAAY,IAAA,CAAK,CAAA,CAAE,CAAC,CAAC;AAAA,MAE9B,eAAA,EAAgB;AAEtB,EAAA,OAAO,UAAU,EAAE,QAAA,EAAU,iBAAiB,QAAA,EAAU,IAAA,EAAM,aAAa,CAAA;AAC7E;;;;"}

package/dist/array/fixed-length-tuple.d.mts

@@ -0,0 +1,8 @@
+import { type FixedLengthTuple, type StructuralPrefixLength } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { FixedLengthTuple } from 'ts-type-forge';
+export declare const fixedLengthTuple: <A, N extends StructuralPrefixLength>(size: N, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: FixedLengthTuple<N, A>;
+}>>) => Type<FixedLengthTuple<N, A>>;
+//# sourceMappingURL=fixed-length-tuple.d.mts.map

package/dist/array/fixed-length-tuple.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-length-tuple.d.mts","sourceRoot":"","sources":["../../src/array/fixed-length-tuple.mts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC5B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAUxC,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,SAAS,sBAAsB,QAC5D,CAAC,eACM,IAAI,CAAC,CAAC,CAAC,YACV,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACtC,CAAC,CACH,KACA,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAoF7B,CAAC"}

package/dist/array/{array-of-length.mjs → fixed-length-tuple.mjs}

@@ -4,8 +4,8 @@ import { createCastFn } from '../utils/create-cast-fn.mjs';
 import { createIsFn } from '../utils/create-is-fn.mjs';
 import { createPrimitiveValidationError, prependIndexToValidationErrors } from '../utils/validation-error.mjs';
 
-const arrayOfLength = (size, elementType, options) => {
-  const typeName = options?.typeName ?? `ArrayOfLength<${size}, ${elementType.typeName}>`;
+const fixedLengthTuple = (size, elementType, options) => {
+  const typeName = options?.typeName ?? `FixedLengthTuple<${size}, ${elementType.typeName}>`;
   const getDefaultValue = memoizeFunction(
     () => options?.defaultValue ?? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
     Arr.create(size, elementType.defaultValue)
@@ -21,7 +21,7 @@ const arrayOfLength = (size, elementType, options) => {
         })
       ]);
     }
-    if (!Arr.isArrayOfLength(a, size)) {
+    if (!Arr.isFixedLengthTuple(a, size)) {
       return Result.err([
         {
           path: [],
@@ -75,5 +75,5 @@ const arrayOfLength = (size, elementType, options) => {
   };
 };
 
-export { arrayOfLength };
-//# sourceMappingURL=array-of-length.mjs.map
+export { fixedLengthTuple };
+//# sourceMappingURL=fixed-length-tuple.mjs.map

package/dist/array/fixed-length-tuple.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-length-tuple.mjs","sources":["../../src/array/fixed-length-tuple.mts"],"sourcesContent":["import { Arr, memoizeFunction, Result } from 'ts-data-forge';\nimport {\n  type FixedLengthTuple,\n  type StructuralPrefixLength,\n} from 'ts-type-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createAssertFn,\n  createCastFn,\n  createIsFn,\n  createPrimitiveValidationError,\n  prependIndexToValidationErrors,\n  type ValidationError,\n} from '../utils/index.mjs';\n\nexport type { FixedLengthTuple } from 'ts-type-forge';\n\nexport const fixedLengthTuple = <A, N extends StructuralPrefixLength>(\n  size: N,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: FixedLengthTuple<N, A>;\n    }>\n  >,\n): Type<FixedLengthTuple<N, A>> => {\n  type T = FixedLengthTuple<N, A>;\n\n  const typeName =\n    options?.typeName ?? `FixedLengthTuple<${size}, ${elementType.typeName}>`;\n\n  const getDefaultValue = memoizeFunction(\n    (): T =>\n      options?.defaultValue ??\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      (Arr.create(size, elementType.defaultValue) as T),\n  );\n\n  const validate: Type<T>['validate'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return Result.err([\n        createPrimitiveValidationError({\n          actualValue: a,\n          expectedType: 'array',\n          typeName,\n          details: undefined,\n        }),\n      ]);\n    }\n\n    if (!Arr.isFixedLengthTuple(a, size)) {\n      return Result.err([\n        {\n          path: [],\n          actualValue: a,\n          expectedType: typeName,\n          typeName,\n          details: {\n            kind: 'array-length',\n            expectedLength: size,\n            actualLength: a.length,\n          },\n        } satisfies ValidationError,\n      ]);\n    }\n\n    const errors: readonly ValidationError[] = Arr.generate(function* () {\n      for (const [index, el] of a.entries()) {\n        const res = elementType.validate(el);\n\n        if (Result.isErr(res)) {\n          yield* prependIndexToValidationErrors(res.value, index);\n        }\n      }\n    });\n\n    if (Arr.isNonEmpty(errors)) {\n      return Result.err(errors);\n    }\n\n    return Result.ok(a);\n  };\n\n  const fill: Type<T>['fill'] = (a) =>\n    !Arr.isArray(a)\n      ? getDefaultValue()\n      : // TODO: remove as\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        (Arr.map(\n          Arr.seq(size),\n          (i) => elementType.fill(a[i]) satisfies A,\n        ) as T);\n\n  const prune = (a: T): T =>\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    Arr.map(a, (el) => elementType.prune(el)) as T;\n\n  return {\n    typeName,\n    get defaultValue() {\n      return getDefaultValue();\n    },\n    fill,\n    prune,\n    validate,\n    is: createIsFn(validate),\n    cast: createCastFn(validate),\n    assertIs: createAssertFn(validate),\n  };\n};\n"],"names":[],"mappings":";;;;;;AAiBO,MAAM,gBAAA,GAAmB,CAC9B,IAAA,EACA,WAAA,EACA,OAAA,KAMiC;AAGjC,EAAA,MAAM,WACJ,OAAA,EAAS,QAAA,IAAY,oBAAoB,IAAI,CAAA,EAAA,EAAK,YAAY,QAAQ,CAAA,CAAA,CAAA;AAExE,EAAA,MAAM,eAAA,GAAkB,eAAA;AAAA,IACtB,MACE,OAAA,EAAS,YAAA;AAAA,IAER,GAAA,CAAI,MAAA,CAAO,IAAA,EAAM,WAAA,CAAY,YAAY;AAAA,GAC9C;AAEA,EAAA,MAAM,QAAA,GAAgC,CAAC,CAAA,KAAM;AAC3C,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB,8BAAA,CAA+B;AAAA,UAC7B,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,OAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,SACV;AAAA,OACF,CAAA;AAAA,IACH;AAEA,IAAA,IAAI,CAAC,GAAA,CAAI,kBAAA,CAAmB,CAAA,EAAG,IAAI,CAAA,EAAG;AACpC,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB;AAAA,UACE,MAAM,EAAC;AAAA,UACP,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,QAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,YACP,IAAA,EAAM,cAAA;AAAA,YACN,cAAA,EAAgB,IAAA;AAAA,YAChB,cAAc,CAAA,CAAE;AAAA;AAClB;AACF,OACD,CAAA;AAAA,IACH;AAEA,IAAA,MAAM,MAAA,GAAqC,GAAA,CAAI,QAAA,CAAS,aAAa;AACnE,MAAA,KAAA,MAAW,CAAC,KAAA,EAAO,EAAE,CAAA,IAAK,CAAA,CAAE,SAAQ,EAAG;AACrC,QAAA,MAAM,GAAA,GAAM,WAAA,CAAY,QAAA,CAAS,EAAE,CAAA;AAEnC,QAAA,IAAI,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA,EAAG;AACrB,UAAA,OAAO,8BAAA,CAA+B,GAAA,CAAI,KAAA,EAAO,KAAK,CAAA;AAAA,QACxD;AAAA,MACF;AAAA,IACF,CAAC,CAAA;AAED,IAAA,IAAI,GAAA,CAAI,UAAA,CAAW,MAAM,CAAA,EAAG;AAC1B,MAAA,OAAO,MAAA,CAAO,IAAI,MAAM,CAAA;AAAA,IAC1B;AAEA,IAAA,OAAO,MAAA,CAAO,GAAG,CAAC,CAAA;AAAA,EACpB,CAAA;AAEA,EAAA,MAAM,IAAA,GAAwB,CAAC,CAAA,KAC7B,CAAC,IAAI,OAAA,CAAQ,CAAC,IACV,eAAA,EAAgB;AAAA;AAAA;AAAA,IAGf,GAAA,CAAI,GAAA;AAAA,MACH,GAAA,CAAI,IAAI,IAAI,CAAA;AAAA,MACZ,CAAC,CAAA,KAAM,WAAA,CAAY,IAAA,CAAK,CAAA,CAAE,CAAC,CAAC;AAAA;AAC9B,GAAA;AAEN,EAAA,MAAM,QAAQ,CAAC,CAAA;AAAA;AAAA,IAEb,GAAA,CAAI,IAAI,CAAA,EAAG,CAAC,OAAO,WAAA,CAAY,KAAA,CAAM,EAAE,CAAC;AAAA,GAAA;AAE1C,EAAA,OAAO;AAAA,IACL,QAAA;AAAA,IACA,IAAI,YAAA,GAAe;AACjB,MAAA,OAAO,eAAA,EAAgB;AAAA,IACzB,CAAA;AAAA,IACA,IAAA;AAAA,IACA,KAAA;AAAA,IACA,QAAA;AAAA,IACA,EAAA,EAAI,WAAW,QAAQ,CAAA;AAAA,IACvB,IAAA,EAAM,aAAa,QAAQ,CAAA;AAAA,IAC3B,QAAA,EAAU,eAAe,QAAQ;AAAA,GACnC;AACF;;;;"}

package/dist/array/index.d.mts

@@ -1,8 +1,12 @@
-export * from './array-at-least-length.mjs';
-export * from './array-at-most-length.mjs';
-export * from './array-bounded-length.mjs';
-export * from './array-of-length.mjs';
 export * from './array.mjs';
+export * from './bounded-length-array.mjs';
+export * from './bounded-length-tuple.mjs';
+export * from './fixed-length-array.mjs';
+export * from './fixed-length-tuple.mjs';
+export * from './max-length-array.mjs';
+export * from './max-length-tuple.mjs';
+export * from './min-length-array.mjs';
+export * from './min-length-tuple.mjs';
 export * from './non-empty-array.mjs';
 export * from './tuple.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/array/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/array/index.mts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/array/index.mts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}

package/dist/array/index.mjs

@@ -1,8 +1,12 @@
-export { arrayAtLeastLength } from './array-at-least-length.mjs';
-export { arrayAtMostLength } from './array-at-most-length.mjs';
-export { arrayBoundedLength } from './array-bounded-length.mjs';
-export { arrayOfLength } from './array-of-length.mjs';
 export { array } from './array.mjs';
+export { boundedLengthArray } from './bounded-length-array.mjs';
+export { boundedLengthTuple } from './bounded-length-tuple.mjs';
+export { fixedLengthArray } from './fixed-length-array.mjs';
+export { fixedLengthTuple } from './fixed-length-tuple.mjs';
+export { maxLengthArray } from './max-length-array.mjs';
+export { maxLengthTuple } from './max-length-tuple.mjs';
+export { minLengthArray } from './min-length-array.mjs';
+export { minLengthTuple } from './min-length-tuple.mjs';
 export { nonEmptyArray } from './non-empty-array.mjs';
 export { tuple } from './tuple.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/array/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/dist/array/max-length-array.d.mts

@@ -0,0 +1,21 @@
+import { type MaxLengthArray, type SupportedLength } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { MaxLengthArray } from 'ts-type-forge';
+/**
+ * Creates a `Type` for a readonly array with at most `maxLength` elements,
+ * typed as the branded {@link MaxLengthArray} instead of the union of tuple
+ * types produced by `maxLengthTuple`.
+ *
+ * Because the length constraint lives only in the brand, no union of tuples
+ * of the element type is ever constructed, which keeps type-checking cheap
+ * even when `A` is a large type.
+ */
+export declare function maxLengthArray<A, N extends SupportedLength>(maxLength: N, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MaxLengthArray<N, A>;
+}>>): Type<MaxLengthArray<N, A>>;
+export declare function maxLengthArray<A>(maxLength: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+//# sourceMappingURL=max-length-array.d.mts.map

package/dist/array/max-length-array.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-length-array.d.mts","sourceRoot":"","sources":["../../src/array/max-length-array.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAOxC,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,eAAe,EACzD,SAAS,EAAE,CAAC,EACZ,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACpC,CAAC,CACH,GACA,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAI9B,wBAAgB,cAAc,CAAC,CAAC,EAC9B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,CAAC,EAAE,CAAC;CAC5B,CAAC,CACH,GACA,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC"}

package/dist/array/max-length-array.mjs

@@ -0,0 +1,50 @@
+import { memoizeFunction, Arr, Result, asUint32 } from 'ts-data-forge';
+import { createPrimitiveValidationError } from '../utils/validation-error.mjs';
+import { buildType, validateElements } from './build-type.mjs';
+
+function maxLengthArray(maxLength, elementType, options) {
+  const typeName = options?.typeName ?? `MaxLengthArray<${maxLength}, ${elementType.typeName}>`;
+  const getDefaultValue = memoizeFunction(
+    () => options?.defaultValue ?? // The empty array is the shortest value satisfying `length <= maxLength`.
+    Arr.create(0, elementType.defaultValue)
+  );
+  const validate = (a) => {
+    if (!Arr.isArray(a)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: "array",
+          typeName,
+          details: void 0
+        })
+      ]);
+    }
+    if (a.length > maxLength) {
+      return Result.err([
+        {
+          path: [],
+          actualValue: a,
+          expectedType: typeName,
+          typeName,
+          details: {
+            kind: "array-max-length",
+            maxLength,
+            actualLength: a.length
+          }
+        }
+      ]);
+    }
+    return validateElements(a, elementType);
+  };
+  const fill = (a) => Arr.isArray(a) ? (
+    // Keep the input but trim down to at most `maxLength` elements.
+    Arr.map(
+      Arr.take(a, asUint32(maxLength)),
+      (el) => elementType.fill(el)
+    )
+  ) : getDefaultValue();
+  return buildType({ typeName, getDefaultValue, validate, fill, elementType });
+}
+
+export { maxLengthArray };
+//# sourceMappingURL=max-length-array.mjs.map

package/dist/array/max-length-array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-length-array.mjs","sources":["../../src/array/max-length-array.mts"],"sourcesContent":["import { Arr, asUint32, memoizeFunction, Result } from 'ts-data-forge';\nimport { type MaxLengthArray, type SupportedLength } from 'ts-type-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createPrimitiveValidationError,\n  type ValidationError,\n} from '../utils/index.mjs';\nimport { buildType, validateElements } from './build-type.mjs';\n\nexport type { MaxLengthArray } from 'ts-type-forge';\n\n/**\n * Creates a `Type` for a readonly array with at most `maxLength` elements,\n * typed as the branded {@link MaxLengthArray} instead of the union of tuple\n * types produced by `maxLengthTuple`.\n *\n * Because the length constraint lives only in the brand, no union of tuples\n * of the element type is ever constructed, which keeps type-checking cheap\n * even when `A` is a large type.\n */\nexport function maxLengthArray<A, N extends SupportedLength>(\n  maxLength: N,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: MaxLengthArray<N, A>;\n    }>\n  >,\n): Type<MaxLengthArray<N, A>>;\n\n// For bounds outside `SupportedLength` (`0..2048`) the length cannot be encoded in the brand,\n// so the result length is left unconstrained (`readonly A[]`).\nexport function maxLengthArray<A>(\n  maxLength: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]>;\n\nexport function maxLengthArray<A>(\n  maxLength: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]> {\n  type T = readonly A[];\n\n  const typeName =\n    options?.typeName ??\n    `MaxLengthArray<${maxLength}, ${elementType.typeName}>`;\n\n  const getDefaultValue = memoizeFunction(\n    (): T =>\n      options?.defaultValue ??\n      // The empty array is the shortest value satisfying `length <= maxLength`.\n      Arr.create(0, elementType.defaultValue),\n  );\n\n  const validate: Type<T>['validate'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return Result.err([\n        createPrimitiveValidationError({\n          actualValue: a,\n          expectedType: 'array',\n          typeName,\n          details: undefined,\n        }),\n      ]);\n    }\n\n    if (a.length > maxLength) {\n      return Result.err([\n        {\n          path: [],\n          actualValue: a,\n          expectedType: typeName,\n          typeName,\n          details: {\n            kind: 'array-max-length',\n            maxLength,\n            actualLength: a.length,\n          },\n        } satisfies ValidationError,\n      ]);\n    }\n\n    return validateElements(a, elementType);\n  };\n\n  const fill: Type<T>['fill'] = (a) =>\n    Arr.isArray(a)\n      ? // Keep the input but trim down to at most `maxLength` elements.\n        Arr.map(\n          Arr.take(a, asUint32(maxLength)),\n          (el) => elementType.fill(el) satisfies A,\n        )\n      : getDefaultValue();\n\n  return buildType({ typeName, getDefaultValue, validate, fill, elementType });\n}\n"],"names":[],"mappings":";;;;AA4CO,SAAS,cAAA,CACd,SAAA,EACA,WAAA,EACA,OAAA,EAMoB;AAGpB,EAAA,MAAM,WACJ,OAAA,EAAS,QAAA,IACT,kBAAkB,SAAS,CAAA,EAAA,EAAK,YAAY,QAAQ,CAAA,CAAA,CAAA;AAEtD,EAAA,MAAM,eAAA,GAAkB,eAAA;AAAA,IACtB,MACE,OAAA,EAAS,YAAA;AAAA,IAET,GAAA,CAAI,MAAA,CAAO,CAAA,EAAG,WAAA,CAAY,YAAY;AAAA,GAC1C;AAEA,EAAA,MAAM,QAAA,GAAgC,CAAC,CAAA,KAAM;AAC3C,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB,8BAAA,CAA+B;AAAA,UAC7B,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,OAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,SACV;AAAA,OACF,CAAA;AAAA,IACH;AAEA,IAAA,IAAI,CAAA,CAAE,SAAS,SAAA,EAAW;AACxB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB;AAAA,UACE,MAAM,EAAC;AAAA,UACP,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,QAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,YACP,IAAA,EAAM,kBAAA;AAAA,YACN,SAAA;AAAA,YACA,cAAc,CAAA,CAAE;AAAA;AAClB;AACF,OACD,CAAA;AAAA,IACH;AAEA,IAAA,OAAO,gBAAA,CAAiB,GAAG,WAAW,CAAA;AAAA,EACxC,CAAA;AAEA,EAAA,MAAM,IAAA,GAAwB,CAAC,CAAA,KAC7B,GAAA,CAAI,QAAQ,CAAC,CAAA;AAAA;AAAA,IAET,GAAA,CAAI,GAAA;AAAA,MACF,GAAA,CAAI,IAAA,CAAK,CAAA,EAAG,QAAA,CAAS,SAAS,CAAC,CAAA;AAAA,MAC/B,CAAC,EAAA,KAAO,WAAA,CAAY,IAAA,CAAK,EAAE;AAAA;AAC7B,MACA,eAAA,EAAgB;AAEtB,EAAA,OAAO,UAAU,EAAE,QAAA,EAAU,iBAAiB,QAAA,EAAU,IAAA,EAAM,aAAa,CAAA;AAC7E;;;;"}

package/dist/array/max-length-tuple.d.mts

@@ -0,0 +1,12 @@
+import { type MaxLengthTuple, type StructuralPrefixLength } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { MaxLengthTuple } from 'ts-type-forge';
+export declare function maxLengthTuple<A, N extends StructuralPrefixLength>(size: N, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MaxLengthTuple<N, A>;
+}>>): Type<MaxLengthTuple<N, A>>;
+export declare function maxLengthTuple<A>(size: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+//# sourceMappingURL=max-length-tuple.d.mts.map

package/dist/array/max-length-tuple.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-length-tuple.d.mts","sourceRoot":"","sources":["../../src/array/max-length-tuple.mts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC5B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAUxC,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,sBAAsB,EAChE,IAAI,EAAE,CAAC,EACP,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACpC,CAAC,CACH,GACA,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAI9B,wBAAgB,cAAc,CAAC,CAAC,EAC9B,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,CAAC,EAAE,CAAC;CAC5B,CAAC,CACH,GACA,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC"}

package/dist/array/{array-at-most-length.mjs → max-length-tuple.mjs}

@@ -4,8 +4,8 @@ import { createCastFn } from '../utils/create-cast-fn.mjs';
 import { createIsFn } from '../utils/create-is-fn.mjs';
 import { createPrimitiveValidationError, prependIndexToValidationErrors } from '../utils/validation-error.mjs';
 
-function arrayAtMostLength(size, elementType, options) {
-  const typeName = options?.typeName ?? `ArrayAtMostLen<${size}, ${elementType.typeName}>`;
+function maxLengthTuple(size, elementType, options) {
+  const typeName = options?.typeName ?? `MaxLengthTuple<${size}, ${elementType.typeName}>`;
   const getDefaultValue = memoizeFunction(
     () => options?.defaultValue ?? // The empty array is the shortest value satisfying `length <= size`.
     Arr.create(0, elementType.defaultValue)
@@ -71,5 +71,5 @@ function arrayAtMostLength(size, elementType, options) {
   };
 }
 
-export { arrayAtMostLength };
-//# sourceMappingURL=array-at-most-length.mjs.map
+export { maxLengthTuple };
+//# sourceMappingURL=max-length-tuple.mjs.map

package/dist/array/max-length-tuple.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-length-tuple.mjs","sources":["../../src/array/max-length-tuple.mts"],"sourcesContent":["import { Arr, asUint32, memoizeFunction, Result } from 'ts-data-forge';\nimport {\n  type MaxLengthTuple,\n  type StructuralPrefixLength,\n} from 'ts-type-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createAssertFn,\n  createCastFn,\n  createIsFn,\n  createPrimitiveValidationError,\n  prependIndexToValidationErrors,\n  type ValidationError,\n} from '../utils/index.mjs';\n\nexport type { MaxLengthTuple } from 'ts-type-forge';\n\nexport function maxLengthTuple<A, N extends StructuralPrefixLength>(\n  size: N,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: MaxLengthTuple<N, A>;\n    }>\n  >,\n): Type<MaxLengthTuple<N, A>>;\n\n// For sizes outside `StructuralPrefixLength` (`0..10`) the exact length cannot be encoded in the type,\n// so the result length is left unconstrained (`readonly A[]`).\nexport function maxLengthTuple<A>(\n  size: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]>;\n\nexport function maxLengthTuple<A>(\n  size: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]> {\n  type T = readonly A[];\n\n  const typeName =\n    options?.typeName ?? `MaxLengthTuple<${size}, ${elementType.typeName}>`;\n\n  const getDefaultValue = memoizeFunction(\n    (): T =>\n      options?.defaultValue ??\n      // The empty array is the shortest value satisfying `length <= size`.\n      Arr.create(0, elementType.defaultValue),\n  );\n\n  const validate: Type<T>['validate'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return Result.err([\n        createPrimitiveValidationError({\n          actualValue: a,\n          expectedType: 'array',\n          typeName,\n          details: undefined,\n        }),\n      ]);\n    }\n\n    if (a.length > size) {\n      return Result.err([\n        {\n          path: [],\n          actualValue: a,\n          expectedType: typeName,\n          typeName,\n          details: {\n            kind: 'array-max-length',\n            maxLength: size,\n            actualLength: a.length,\n          },\n        } satisfies ValidationError,\n      ]);\n    }\n\n    const errors: readonly ValidationError[] = Arr.generate(function* () {\n      for (const [index, el] of a.entries()) {\n        const res = elementType.validate(el);\n\n        if (Result.isErr(res)) {\n          yield* prependIndexToValidationErrors(res.value, index);\n        }\n      }\n    });\n\n    if (Arr.isNonEmpty(errors)) {\n      return Result.err(errors);\n    }\n\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return Result.ok(a as unknown as T);\n  };\n\n  const fill: Type<T>['fill'] = (a) =>\n    Arr.isArray(a)\n      ? // Keep the input but trim down to at most `size` elements.\n        Arr.map(\n          Arr.take(a, asUint32(size)),\n          (el) => elementType.fill(el) satisfies A,\n        )\n      : getDefaultValue();\n\n  const prune = (a: T): T => a.map((el) => elementType.prune(el));\n\n  return {\n    typeName,\n    get defaultValue() {\n      return getDefaultValue();\n    },\n    fill,\n    prune,\n    validate,\n    is: createIsFn(validate),\n    cast: createCastFn(validate),\n    assertIs: createAssertFn(validate),\n  };\n}\n"],"names":[],"mappings":";;;;;;AAyCO,SAAS,cAAA,CACd,IAAA,EACA,WAAA,EACA,OAAA,EAMoB;AAGpB,EAAA,MAAM,WACJ,OAAA,EAAS,QAAA,IAAY,kBAAkB,IAAI,CAAA,EAAA,EAAK,YAAY,QAAQ,CAAA,CAAA,CAAA;AAEtE,EAAA,MAAM,eAAA,GAAkB,eAAA;AAAA,IACtB,MACE,OAAA,EAAS,YAAA;AAAA,IAET,GAAA,CAAI,MAAA,CAAO,CAAA,EAAG,WAAA,CAAY,YAAY;AAAA,GAC1C;AAEA,EAAA,MAAM,QAAA,GAAgC,CAAC,CAAA,KAAM;AAC3C,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB,8BAAA,CAA+B;AAAA,UAC7B,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,OAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,SACV;AAAA,OACF,CAAA;AAAA,IACH;AAEA,IAAA,IAAI,CAAA,CAAE,SAAS,IAAA,EAAM;AACnB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB;AAAA,UACE,MAAM,EAAC;AAAA,UACP,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,QAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,YACP,IAAA,EAAM,kBAAA;AAAA,YACN,SAAA,EAAW,IAAA;AAAA,YACX,cAAc,CAAA,CAAE;AAAA;AAClB;AACF,OACD,CAAA;AAAA,IACH;AAEA,IAAA,MAAM,MAAA,GAAqC,GAAA,CAAI,QAAA,CAAS,aAAa;AACnE,MAAA,KAAA,MAAW,CAAC,KAAA,EAAO,EAAE,CAAA,IAAK,CAAA,CAAE,SAAQ,EAAG;AACrC,QAAA,MAAM,GAAA,GAAM,WAAA,CAAY,QAAA,CAAS,EAAE,CAAA;AAEnC,QAAA,IAAI,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA,EAAG;AACrB,UAAA,OAAO,8BAAA,CAA+B,GAAA,CAAI,KAAA,EAAO,KAAK,CAAA;AAAA,QACxD;AAAA,MACF;AAAA,IACF,CAAC,CAAA;AAED,IAAA,IAAI,GAAA,CAAI,UAAA,CAAW,MAAM,CAAA,EAAG;AAC1B,MAAA,OAAO,MAAA,CAAO,IAAI,MAAM,CAAA;AAAA,IAC1B;AAGA,IAAA,OAAO,MAAA,CAAO,GAAG,CAAiB,CAAA;AAAA,EACpC,CAAA;AAEA,EAAA,MAAM,IAAA,GAAwB,CAAC,CAAA,KAC7B,GAAA,CAAI,QAAQ,CAAC,CAAA;AAAA;AAAA,IAET,GAAA,CAAI,GAAA;AAAA,MACF,GAAA,CAAI,IAAA,CAAK,CAAA,EAAG,QAAA,CAAS,IAAI,CAAC,CAAA;AAAA,MAC1B,CAAC,EAAA,KAAO,WAAA,CAAY,IAAA,CAAK,EAAE;AAAA;AAC7B,MACA,eAAA,EAAgB;AAEtB,EAAA,MAAM,KAAA,GAAQ,CAAC,CAAA,KAAY,CAAA,CAAE,GAAA,CAAI,CAAC,EAAA,KAAO,WAAA,CAAY,KAAA,CAAM,EAAE,CAAC,CAAA;AAE9D,EAAA,OAAO;AAAA,IACL,QAAA;AAAA,IACA,IAAI,YAAA,GAAe;AACjB,MAAA,OAAO,eAAA,EAAgB;AAAA,IACzB,CAAA;AAAA,IACA,IAAA;AAAA,IACA,KAAA;AAAA,IACA,QAAA;AAAA,IACA,EAAA,EAAI,WAAW,QAAQ,CAAA;AAAA,IACvB,IAAA,EAAM,aAAa,QAAQ,CAAA;AAAA,IAC3B,QAAA,EAAU,eAAe,QAAQ;AAAA,GACnC;AACF;;;;"}