ts-fortress 7.0.6 → 7.1.0

package/README.md

@@ -1040,6 +1040,8 @@ type ValidationError = Readonly<{
 - `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)
 
 ### Objects
 

package/dist/array/array-at-most-length.d.mts

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

package/dist/array/array-at-most-length.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-at-most-length.d.mts","sourceRoot":"","sources":["../../src/array/array-at-most-length.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAUxC,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,CAAC,SAAS,SAAS,EACtD,MAAM,CAAC,EACP,aAAa,IAAI,CAAC,CAAC,CAAC,EACpB,UAAU,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACpC,CAAC,CACH,KACA,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAkF3B,CAAC"}

package/dist/array/array-at-most-length.mjs

@@ -0,0 +1,73 @@
+import { memoizeFunction, 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 { createPrimitiveValidationError, prependIndexToValidationErrors } from '../utils/validation-error.mjs';
+
+const arrayAtMostLength = (size, elementType, options) => {
+    const typeName = options?.typeName ?? `ArrayAtMostLen<${size}, ${elementType.typeName}>`;
+    const getDefaultValue = memoizeFunction(() => options?.defaultValue ??
+        // The empty array is the shortest value satisfying `length <= size`.
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        Arr.create(0, elementType.defaultValue));
+    const validate = (a) => {
+        if (!Arr.isArray(a)) {
+            return Result.err([
+                createPrimitiveValidationError({
+                    actualValue: a,
+                    expectedType: 'array',
+                    typeName,
+                    details: undefined,
+                }),
+            ]);
+        }
+        if (a.length > size) {
+            return Result.err([
+                {
+                    path: [],
+                    actualValue: a,
+                    expectedType: typeName,
+                    typeName,
+                    details: {
+                        kind: 'array-max-length',
+                        maxLength: size,
+                        actualLength: a.length,
+                    },
+                },
+            ]);
+        }
+        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);
+        }
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        return Result.ok(a);
+    };
+    const fill = (a) => Arr.isArray(a)
+        ? // Keep the input but trim down to at most `size` elements.
+            // TODO: remove as
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            Arr.map(Arr.take(a, size), (el) => elementType.fill(el))
+        : getDefaultValue();
+    return {
+        typeName,
+        get defaultValue() {
+            return getDefaultValue();
+        },
+        fill,
+        validate,
+        is: createIsFn(validate),
+        cast: createCastFn(validate),
+        assertIs: createAssertFn(validate),
+    };
+};
+
+export { arrayAtMostLength };
+//# sourceMappingURL=array-at-most-length.mjs.map

package/dist/array/array-at-most-length.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-at-most-length.mjs","sources":["../../src/array/array-at-most-length.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAcO,MAAM,iBAAiB,GAAG,CAC/B,IAAO,EACP,WAAoB,EACpB,OAKC,KAC6B;AAG9B,IAAA,MAAM,QAAQ,GACZ,OAAO,EAAE,QAAQ,IAAI,CAAA,eAAA,EAAkB,IAAI,CAAA,EAAA,EAAK,WAAW,CAAC,QAAQ,GAAG;IAEzE,MAAM,eAAe,GAAG,eAAe,CACrC,MACE,OAAO,EAAE,YAAY;;;QAGpB,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,WAAW,CAAC,YAAY,CAAO,CACjD;AAED,IAAA,MAAM,QAAQ,GAAwB,CAAC,CAAC,KAAI;QAC1C,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YACnB,OAAO,MAAM,CAAC,GAAG,CAAC;AAChB,gBAAA,8BAA8B,CAAC;AAC7B,oBAAA,WAAW,EAAE,CAAC;AACd,oBAAA,YAAY,EAAE,OAAO;oBACrB,QAAQ;AACR,oBAAA,OAAO,EAAE,SAAS;iBACnB,CAAC;AACH,aAAA,CAAC;QACJ;AAEA,QAAA,IAAI,CAAC,CAAC,MAAM,GAAG,IAAI,EAAE;YACnB,OAAO,MAAM,CAAC,GAAG,CAAC;AAChB,gBAAA;AACE,oBAAA,IAAI,EAAE,EAAE;AACR,oBAAA,WAAW,EAAE,CAAC;AACd,oBAAA,YAAY,EAAE,QAAQ;oBACtB,QAAQ;AACR,oBAAA,OAAO,EAAE;AACP,wBAAA,IAAI,EAAE,kBAAkB;AACxB,wBAAA,SAAS,EAAE,IAAI;wBACf,YAAY,EAAE,CAAC,CAAC,MAAM;AACvB,qBAAA;AACwB,iBAAA;AAC5B,aAAA,CAAC;QACJ;AAEA,QAAA,MAAM,MAAM,GAA+B,GAAG,CAAC,QAAQ,CAAC,aAAS;AAC/D,YAAA,KAAK,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;gBACrC,MAAM,GAAG,GAAG,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;AAEpC,gBAAA,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;oBACrB,OAAO,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC;gBACzD;YACF;AACF,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;AAC1B,YAAA,OAAO,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC;QAC3B;;AAGA,QAAA,OAAO,MAAM,CAAC,EAAE,CAAC,CAAiB,CAAC;AACrC,IAAA,CAAC;AAED,IAAA,MAAM,IAAI,GAAoB,CAAC,CAAC,KAC9B,GAAG,CAAC,OAAO,CAAC,CAAC;AACX;;;YAGG,GAAG,CAAC,GAAG,CACN,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,EACjB,CAAC,EAAE,KAAK,WAAW,CAAC,IAAI,CAAC,EAAE,CAAa;UAE1C,eAAe,EAAE;IAEvB,OAAO;QACL,QAAQ;AACR,QAAA,IAAI,YAAY,GAAA;YACd,OAAO,eAAe,EAAE;QAC1B,CAAC;QACD,IAAI;QACJ,QAAQ;AACR,QAAA,EAAE,EAAE,UAAU,CAAC,QAAQ,CAAC;AACxB,QAAA,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC;AAC5B,QAAA,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;KACnC;AACH;;;;"}

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

@@ -0,0 +1,8 @@
+import { type ArrayBoundedLen, type SmallUint } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { ArrayBoundedLen } from 'ts-type-forge';
+export declare const arrayBoundedLength: <A, Min extends SmallUint, Max extends SmallUint>(min: Min, max: Max, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: ArrayBoundedLen<Min, Max, A>;
+}>>) => Type<ArrayBoundedLen<Min, Max, A>>;
+//# sourceMappingURL=array-bounded-length.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array-bounded-length.d.mts","sourceRoot":"","sources":["../../src/array/array-bounded-length.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAUxC,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,eAAO,MAAM,kBAAkB,GAC7B,CAAC,EACD,GAAG,SAAS,SAAS,EACrB,GAAG,SAAS,SAAS,EAErB,KAAK,GAAG,EACR,KAAK,GAAG,EACR,aAAa,IAAI,CAAC,CAAC,CAAC,EACpB,UAAU,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;CAC5C,CAAC,CACH,KACA,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAyFnC,CAAC"}

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

@@ -0,0 +1,80 @@
+import { memoizeFunction, 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 { createPrimitiveValidationError, prependIndexToValidationErrors } from '../utils/validation-error.mjs';
+
+const arrayBoundedLength = (min, max, elementType, options) => {
+    const typeName = options?.typeName ??
+        `ArrayBoundedLen<${min}, ${max}, ${elementType.typeName}>`;
+    const getDefaultValue = memoizeFunction(() => options?.defaultValue ??
+        // An array of the minimum length is the shortest value within the range.
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        Arr.create(min, elementType.defaultValue));
+    const validate = (a) => {
+        if (!Arr.isArray(a)) {
+            return Result.err([
+                createPrimitiveValidationError({
+                    actualValue: a,
+                    expectedType: 'array',
+                    typeName,
+                    details: undefined,
+                }),
+            ]);
+        }
+        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,
+                    },
+                },
+            ]);
+        }
+        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);
+        }
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        return Result.ok(a);
+    };
+    const fill = (a) => {
+        if (!Arr.isArray(a)) {
+            return getDefaultValue();
+        }
+        // Trim down to at most `max`, then pad up to at least `min`.
+        const capped = Arr.take(a, max);
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        return (capped.length >= min
+            ? Arr.map(capped, (el) => elementType.fill(el))
+            : Arr.map(Arr.seq(min), (i) => elementType.fill(capped[i])));
+    };
+    return {
+        typeName,
+        get defaultValue() {
+            return getDefaultValue();
+        },
+        fill,
+        validate,
+        is: createIsFn(validate),
+        cast: createCastFn(validate),
+        assertIs: createAssertFn(validate),
+    };
+};
+
+export { arrayBoundedLength };
+//# sourceMappingURL=array-bounded-length.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array-bounded-length.mjs","sources":["../../src/array/array-bounded-length.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/array/index.d.mts

@@ -1,4 +1,6 @@
 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 './non-empty-array.mjs';

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,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,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"}

package/dist/array/index.mjs

@@ -1,4 +1,6 @@
 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 { nonEmptyArray } from './non-empty-array.mjs';

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/entry-point.mjs

@@ -1,5 +1,7 @@
 export { FiniteNumber, Int, Int16, Int32, Int8, NonNegativeFiniteNumber, NonNegativeInt16, NonNegativeInt32, NonZeroFiniteNumber, NonZeroInt, NonZeroInt16, NonZeroInt32, NonZeroSafeInt, NonZeroUint16, NonZeroUint32, PositiveFiniteNumber, PositiveInt, PositiveInt16, PositiveInt32, PositiveSafeInt, PositiveUint16, PositiveUint32, Result, SafeInt, SafeUint, Uint, Uint16, Uint32, Uint8, asFiniteNumber, asInt, asInt16, asInt32, asInt8, asNonNegativeFiniteNumber, asNonNegativeInt16, asNonNegativeInt32, asNonZeroFiniteNumber, asNonZeroInt, asNonZeroInt16, asNonZeroInt32, asNonZeroSafeInt, asNonZeroUint16, asNonZeroUint32, asPositiveFiniteNumber, asPositiveInt, asPositiveInt16, asPositiveInt32, asPositiveSafeInt, asPositiveUint16, asPositiveUint32, asSafeInt, asSafeUint, asUint, asUint16, asUint32, asUint8, isBigint, isFiniteNumber, isInt, isInt16, isInt32, isInt8, isNonNegativeFiniteNumber, isNonNegativeInt16, isNonNegativeInt32, isNonZeroFiniteNumber, isNonZeroInt, isNonZeroInt16, isNonZeroInt32, isNonZeroSafeInt, isNonZeroUint16, isNonZeroUint32, isPositiveFiniteNumber, isPositiveInt, isPositiveInt16, isPositiveInt32, isPositiveSafeInt, isPositiveUint16, isPositiveUint32, isSafeInt, isSafeUint, isUint, isUint16, isUint32, isUint8 } from 'ts-data-forge';
 export { arrayAtLeastLength } from './array/array-at-least-length.mjs';
+export { arrayAtMostLength } from './array/array-at-most-length.mjs';
+export { arrayBoundedLength } from './array/array-bounded-length.mjs';
 export { arrayOfLength } from './array/array-of-length.mjs';
 export { array } from './array/array.mjs';
 export { nonEmptyArray } from './array/non-empty-array.mjs';

package/dist/entry-point.mjs.map

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

package/dist/index.mjs

@@ -1,4 +1,6 @@
 export { arrayAtLeastLength } from './array/array-at-least-length.mjs';
+export { arrayAtMostLength } from './array/array-at-most-length.mjs';
+export { arrayBoundedLength } from './array/array-bounded-length.mjs';
 export { arrayOfLength } from './array/array-of-length.mjs';
 export { array } from './array/array.mjs';
 export { nonEmptyArray } from './array/non-empty-array.mjs';

package/dist/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/utils/validation-error.d.mts

@@ -22,6 +22,15 @@ export type ValidationErrorDetails = Readonly<{
     kind: 'array-min-length';
     minLength: number;
     actualLength: number;
+} | {
+    kind: 'array-max-length';
+    maxLength: number;
+    actualLength: number;
+} | {
+    kind: 'array-range-length';
+    minLength: number;
+    maxLength: number;
+    actualLength: number;
 } | {
     kind: 'non-empty-array';
 } | {

package/dist/utils/validation-error.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"validation-error.d.mts","sourceRoot":"","sources":["../../src/utils/validation-error.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"validation-error.d.mts","sourceRoot":"","sources":["../../src/utils/validation-error.mts"],"names":[],"mappings":"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"}

package/dist/utils/validation-error.mjs

@@ -41,6 +41,10 @@ const createDetailsMessage = (error, maxLengthToPrintActualValue) => {
             return `expected array of length ${error.details.expectedLength} but length ${error.details.actualLength} was passed.`;
         case 'array-min-length':
             return `expected array of length ${error.details.minLength} or more but length ${error.details.actualLength} was passed.`;
+        case 'array-max-length':
+            return `expected array of length ${error.details.maxLength} or less but length ${error.details.actualLength} was passed.`;
+        case 'array-range-length':
+            return `expected array of length between ${error.details.minLength} and ${error.details.maxLength} but length ${error.details.actualLength} was passed.`;
         case 'non-empty-array':
             return 'expected non-empty array but empty array was passed.';
         case 'missing-key':

package/dist/utils/validation-error.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"validation-error.mjs","sources":["../../src/utils/validation-error.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"validation-error.mjs","sources":["../../src/utils/validation-error.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-fortress",
-  "version": "7.0.6",
+  "version": "7.1.0",
   "private": false,
   "keywords": [
     "typescript"
@@ -75,9 +75,9 @@
     "z:vitest:node": "pnpm run z:vitest --project='Node.js'"
   },
   "dependencies": {
-    "@sindresorhus/is": "8.0.0",
-    "ts-data-forge": "6.9.4",
-    "ts-type-forge": "3.0.0"
+    "@sindresorhus/is": "^8.0.0",
+    "ts-data-forge": "^6.9.6",
+    "ts-type-forge": "^3.1.0"
   },
   "devDependencies": {
     "@rollup/plugin-replace": "6.0.3",
@@ -98,10 +98,10 @@
     "cspell": "10.0.0",
     "dedent": "1.7.2",
     "eslint": "9.39.4",
-    "eslint-config-typed": "4.9.6",
+    "eslint-config-typed": "4.9.8",
     "fast-glob": "3.3.3",
     "fp-ts": "2.16.11",
-    "github-settings-as-code": "1.2.7",
+    "github-settings-as-code": "1.2.9",
     "io-ts": "2.2.22",
     "jiti": "2.6.1",
     "markdownlint": "0.40.0",
@@ -113,8 +113,8 @@
     "prettier-plugin-packagejson": "3.0.2",
     "rollup": "4.60.2",
     "semantic-release": "25.0.3",
-    "ts-codemod-lib": "2.1.4",
-    "ts-repo-utils": "10.0.1",
+    "ts-codemod-lib": "2.1.7",
+    "ts-repo-utils": "10.0.3",
     "tslib": "2.8.1",
     "tsx": "4.21.0",
     "typedoc": "0.28.19",
@@ -122,9 +122,9 @@
     "typescript": "5.9.3",
     "vite": "8.0.10",
     "vitest": "4.1.5",
-    "zod": "4.3.6"
+    "zod": "4.4.3"
   },
-  "packageManager": "pnpm@10.33.2",
+  "packageManager": "pnpm@10.33.4",
   "engines": {
     "node": ">=22.18.0",
     "pnpm": ">=9.0.0"

package/src/array/array-at-most-length.mts

@@ -0,0 +1,106 @@
+import { Arr, memoizeFunction, Result } from 'ts-data-forge';
+import { type ArrayAtMostLen, type SmallUint } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+  prependIndexToValidationErrors,
+  type ValidationError,
+} from '../utils/index.mjs';
+
+export type { ArrayAtMostLen } from 'ts-type-forge';
+
+export const arrayAtMostLength = <A, N extends SmallUint>(
+  size: N,
+  elementType: Type<A>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+      defaultValue: ArrayAtMostLen<N, A>;
+    }>
+  >,
+): Type<ArrayAtMostLen<N, A>> => {
+  type T = ArrayAtMostLen<N, A>;
+
+  const typeName =
+    options?.typeName ?? `ArrayAtMostLen<${size}, ${elementType.typeName}>`;
+
+  const getDefaultValue = memoizeFunction(
+    (): T =>
+      options?.defaultValue ??
+      // The empty array is the shortest value satisfying `length <= size`.
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      (Arr.create(0, elementType.defaultValue) as T),
+  );
+
+  const validate: Type<T>['validate'] = (a) => {
+    if (!Arr.isArray(a)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: 'array',
+          typeName,
+          details: undefined,
+        }),
+      ]);
+    }
+
+    if (a.length > size) {
+      return Result.err([
+        {
+          path: [],
+          actualValue: a,
+          expectedType: typeName,
+          typeName,
+          details: {
+            kind: 'array-max-length',
+            maxLength: size,
+            actualLength: a.length,
+          },
+        } satisfies ValidationError,
+      ]);
+    }
+
+    const errors: readonly ValidationError[] = 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);
+    }
+
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return Result.ok(a as unknown as T);
+  };
+
+  const fill: Type<T>['fill'] = (a) =>
+    Arr.isArray(a)
+      ? // Keep the input but trim down to at most `size` elements.
+        // TODO: remove as
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        (Arr.map(
+          Arr.take(a, size),
+          (el) => elementType.fill(el) satisfies A,
+        ) as T)
+      : getDefaultValue();
+
+  return {
+    typeName,
+    get defaultValue() {
+      return getDefaultValue();
+    },
+    fill,
+    validate,
+    is: createIsFn(validate),
+    cast: createCastFn(validate),
+    assertIs: createAssertFn(validate),
+  };
+};

package/src/array/array-at-most-length.test.mts

@@ -0,0 +1,206 @@
+import { expectType, Result } from 'ts-data-forge';
+import { type ArrayAtMostLen } from 'ts-type-forge';
+import { number } from '../primitives/index.mjs';
+import { type TypeOf } from '../type.mjs';
+import {
+  type ValidationError,
+  validationErrorsToMessages,
+} from '../utils/index.mjs';
+import { arrayAtMostLength } from './array-at-most-length.mjs';
+
+describe(arrayAtMostLength, () => {
+  describe('arg patterns', () => {
+    test('without explicit default value', () => {
+      assert.deepStrictEqual(arrayAtMostLength(3, number()).defaultValue, []);
+    });
+
+    test('with explicit default value override', () => {
+      assert.deepStrictEqual(
+        arrayAtMostLength(3, number(), {
+          typeName: 'ys',
+          defaultValue: [1, 2, 3],
+        }).defaultValue,
+        [1, 2, 3],
+      );
+    });
+  });
+
+  const xs = arrayAtMostLength(3, number(), {
+    typeName: 'xs',
+    defaultValue: [1, 2, 3],
+  });
+
+  type Xs = TypeOf<typeof xs>;
+
+  expectType<Xs, ArrayAtMostLen<3, number>>('=');
+
+  expectType<typeof xs.defaultValue, Xs>('=');
+
+  describe('is', () => {
+    test('truthy case (max length)', () => {
+      const ys: unknown = [4, 5, 6] as const;
+
+      if (xs.is(ys)) {
+        expectType<typeof ys, Xs>('=');
+      } else {
+        expectType<typeof ys, unknown>('=');
+      }
+
+      assert.isTrue(xs.is(ys));
+    });
+
+    test('truthy case (empty)', () => {
+      const ys: unknown = [] as const;
+
+      assert.isTrue(xs.is(ys));
+    });
+
+    test('falsy case 1 (too long)', () => {
+      const ys: unknown = [1, 2, 3, 4] as const;
+
+      assert.isFalse(xs.is(ys));
+    });
+
+    test('falsy case 2 (wrong element type)', () => {
+      const ys: unknown = [1, '2', 3] as const;
+
+      assert.isFalse(xs.is(ys));
+    });
+
+    test('falsy case 3 (not an array)', () => {
+      const ys: unknown = 'foo';
+
+      assert.isFalse(xs.is(ys));
+    });
+  });
+
+  describe('validate', () => {
+    test('truthy case', () => {
+      const ys: unknown = [4, 5] as const;
+
+      const result = xs.validate(ys);
+
+      expectType<typeof result, Result<Xs, readonly ValidationError[]>>('=');
+
+      assert.isTrue(Result.isOk(result));
+
+      const resultValue = Result.unwrapThrow(result);
+
+      assert.deepStrictEqual(resultValue, [4, 5]);
+    });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = [4, 5, 6] as const;
+
+      const result = xs.validate(input);
+
+      assert.isTrue(Result.isOk(result));
+
+      const resultValue1 = Result.unwrapThrow(result);
+
+      expect(resultValue1).toBe(input); // ✅ same reference
+    });
+
+    test('falsy case 1 (not an array)', () => {
+      const ys: unknown = 'foo';
+
+      const result = xs.validate(ys);
+
+      assert.isTrue(Result.isErr(result));
+
+      const resultError = Result.unwrapErrThrow(result);
+
+      assert.deepStrictEqual(resultError, [
+        {
+          path: [],
+          actualValue: ys,
+          expectedType: 'array',
+          typeName: 'xs',
+          details: undefined,
+        },
+      ]);
+
+      assert.deepStrictEqual(validationErrorsToMessages(resultError), [
+        'Error: expected <array> type but <string> type value "foo" was passed.',
+      ]);
+    });
+
+    test('falsy case 2 (too long)', () => {
+      const ys: unknown = [1, 2, 3, 4] as const;
+
+      const result = xs.validate(ys);
+
+      assert.isTrue(Result.isErr(result));
+
+      const resultError = Result.unwrapErrThrow(result);
+
+      assert.deepStrictEqual(resultError, [
+        {
+          path: [],
+          actualValue: ys,
+          expectedType: 'xs',
+          typeName: 'xs',
+          details: {
+            kind: 'array-max-length',
+            maxLength: 3,
+            actualLength: 4,
+          },
+        },
+      ]);
+
+      assert.deepStrictEqual(validationErrorsToMessages(resultError), [
+        'Error: expected array of length 3 or less but length 4 was passed.',
+      ]);
+    });
+
+    test('falsy case 3 (wrong element type)', () => {
+      const ys: unknown = [1, '2', 3] as const;
+
+      const result = xs.validate(ys);
+
+      assert.isTrue(Result.isErr(result));
+
+      const resultError = Result.unwrapErrThrow(result);
+
+      assert.deepStrictEqual(resultError, [
+        {
+          path: ['1'],
+          actualValue: '2',
+          expectedType: 'number',
+          typeName: 'number',
+          details: undefined,
+        },
+      ]);
+
+      assert.deepStrictEqual(validationErrorsToMessages(resultError), [
+        'Error at 1: expected <number> type but <string> type value "2" was passed.',
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('keeps numeric entries and trims extras to max', () => {
+      const ys: unknown = [4, 5, 6, 7] as const;
+
+      assert.deepStrictEqual(xs.fill(ys), [4, 5, 6]);
+    });
+
+    test('keeps shorter arrays as-is and fills invalid entries', () => {
+      const ys: unknown = [4, '5'] as const;
+
+      assert.deepStrictEqual(xs.fill(ys), [4, 0]);
+    });
+
+    test('keeps the empty array', () => {
+      const ys: unknown = [] as const;
+
+      assert.deepStrictEqual(xs.fill(ys), []);
+    });
+
+    test('fill with the default value for non-array input', () => {
+      const ys: unknown = null;
+
+      assert.deepStrictEqual(xs.fill(ys), [1, 2, 3]);
+    });
+  });
+});

package/src/array/array-bounded-length.mts

@@ -0,0 +1,118 @@
+import { Arr, memoizeFunction, Result } from 'ts-data-forge';
+import { type ArrayBoundedLen, type SmallUint } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+  prependIndexToValidationErrors,
+  type ValidationError,
+} from '../utils/index.mjs';
+
+export type { ArrayBoundedLen } from 'ts-type-forge';
+
+export const arrayBoundedLength = <
+  A,
+  Min extends SmallUint,
+  Max extends SmallUint,
+>(
+  min: Min,
+  max: Max,
+  elementType: Type<A>,
+  options?: Partial<
+    Readonly<{
+      typeName: string;
+      defaultValue: ArrayBoundedLen<Min, Max, A>;
+    }>
+  >,
+): Type<ArrayBoundedLen<Min, Max, A>> => {
+  type T = ArrayBoundedLen<Min, Max, A>;
+
+  const typeName =
+    options?.typeName ??
+    `ArrayBoundedLen<${min}, ${max}, ${elementType.typeName}>`;
+
+  const getDefaultValue = memoizeFunction(
+    (): T =>
+      options?.defaultValue ??
+      // An array of the minimum length is the shortest value within the range.
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      (Arr.create(min, elementType.defaultValue) as T),
+  );
+
+  const validate: Type<T>['validate'] = (a) => {
+    if (!Arr.isArray(a)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: 'array',
+          typeName,
+          details: undefined,
+        }),
+      ]);
+    }
+
+    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,
+          },
+        } satisfies ValidationError,
+      ]);
+    }
+
+    const errors: readonly ValidationError[] = 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);
+    }
+
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return Result.ok(a as unknown as T);
+  };
+
+  const fill: Type<T>['fill'] = (a) => {
+    if (!Arr.isArray(a)) {
+      return getDefaultValue();
+    }
+
+    // Trim down to at most `max`, then pad up to at least `min`.
+    const capped = Arr.take(a, max);
+
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return (
+      capped.length >= min
+        ? Arr.map(capped, (el) => elementType.fill(el) satisfies A)
+        : Arr.map(Arr.seq(min), (i) => elementType.fill(capped[i]) satisfies A)
+    ) as T;
+  };
+
+  return {
+    typeName,
+    get defaultValue() {
+      return getDefaultValue();
+    },
+    fill,
+    validate,
+    is: createIsFn(validate),
+    cast: createCastFn(validate),
+    assertIs: createAssertFn(validate),
+  };
+};

package/src/array/array-bounded-length.test.mts

@@ -0,0 +1,252 @@
+import { expectType, Result } from 'ts-data-forge';
+import { type ArrayBoundedLen } from 'ts-type-forge';
+import { number } from '../primitives/index.mjs';
+import { type TypeOf } from '../type.mjs';
+import {
+  type ValidationError,
+  validationErrorsToMessages,
+} from '../utils/index.mjs';
+import { arrayBoundedLength } from './array-bounded-length.mjs';
+
+describe(arrayBoundedLength, () => {
+  describe('arg patterns', () => {
+    test('without explicit default value', () => {
+      assert.deepStrictEqual(
+        arrayBoundedLength(2, 4, number()).defaultValue,
+        [0, 0],
+      );
+    });
+
+    test('with explicit element default value', () => {
+      assert.deepStrictEqual(
+        arrayBoundedLength(2, 4, number(5)).defaultValue,
+        [5, 5],
+      );
+    });
+
+    test('with explicit default value override', () => {
+      assert.deepStrictEqual(
+        arrayBoundedLength(2, 4, number(), {
+          typeName: 'ys',
+          defaultValue: [1, 2, 3],
+        }).defaultValue,
+        [1, 2, 3],
+      );
+    });
+  });
+
+  const xs = arrayBoundedLength(2, 4, number(), {
+    typeName: 'xs',
+    defaultValue: [1, 2, 3],
+  });
+
+  type Xs = TypeOf<typeof xs>;
+
+  expectType<Xs, ArrayBoundedLen<2, 4, number>>('=');
+
+  expectType<typeof xs.defaultValue, Xs>('=');
+
+  describe('is', () => {
+    test('truthy case (min length)', () => {
+      const ys: unknown = [4, 5] as const;
+
+      if (xs.is(ys)) {
+        expectType<typeof ys, Xs>('=');
+      } else {
+        expectType<typeof ys, unknown>('=');
+      }
+
+      assert.isTrue(xs.is(ys));
+    });
+
+    test('truthy case (max length)', () => {
+      const ys: unknown = [4, 5, 6, 7] as const;
+
+      assert.isTrue(xs.is(ys));
+    });
+
+    test('falsy case 1 (too short)', () => {
+      const ys: unknown = [4] as const;
+
+      assert.isFalse(xs.is(ys));
+    });
+
+    test('falsy case 2 (too long)', () => {
+      const ys: unknown = [1, 2, 3, 4, 5] as const;
+
+      assert.isFalse(xs.is(ys));
+    });
+
+    test('falsy case 3 (wrong element type)', () => {
+      const ys: unknown = [1, '2'] as const;
+
+      assert.isFalse(xs.is(ys));
+    });
+
+    test('falsy case 4 (not an array)', () => {
+      const ys: unknown = 'foo';
+
+      assert.isFalse(xs.is(ys));
+    });
+  });
+
+  describe('validate', () => {
+    test('truthy case', () => {
+      const ys: unknown = [4, 5, 6] as const;
+
+      const result = xs.validate(ys);
+
+      expectType<typeof result, Result<Xs, readonly ValidationError[]>>('=');
+
+      assert.isTrue(Result.isOk(result));
+
+      const resultValue = Result.unwrapThrow(result);
+
+      assert.deepStrictEqual(resultValue, [4, 5, 6]);
+    });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = [4, 5, 6] as const;
+
+      const result = xs.validate(input);
+
+      assert.isTrue(Result.isOk(result));
+
+      const resultValue1 = Result.unwrapThrow(result);
+
+      expect(resultValue1).toBe(input); // ✅ same reference
+    });
+
+    test('falsy case 1 (not an array)', () => {
+      const ys: unknown = 'foo';
+
+      const result = xs.validate(ys);
+
+      assert.isTrue(Result.isErr(result));
+
+      const resultError = Result.unwrapErrThrow(result);
+
+      assert.deepStrictEqual(resultError, [
+        {
+          path: [],
+          actualValue: ys,
+          expectedType: 'array',
+          typeName: 'xs',
+          details: undefined,
+        },
+      ]);
+
+      assert.deepStrictEqual(validationErrorsToMessages(resultError), [
+        'Error: expected <array> type but <string> type value "foo" was passed.',
+      ]);
+    });
+
+    test('falsy case 2 (too short)', () => {
+      const ys: unknown = [4] as const;
+
+      const result = xs.validate(ys);
+
+      assert.isTrue(Result.isErr(result));
+
+      const resultError = Result.unwrapErrThrow(result);
+
+      assert.deepStrictEqual(resultError, [
+        {
+          path: [],
+          actualValue: ys,
+          expectedType: 'xs',
+          typeName: 'xs',
+          details: {
+            kind: 'array-range-length',
+            minLength: 2,
+            maxLength: 4,
+            actualLength: 1,
+          },
+        },
+      ]);
+
+      assert.deepStrictEqual(validationErrorsToMessages(resultError), [
+        'Error: expected array of length between 2 and 4 but length 1 was passed.',
+      ]);
+    });
+
+    test('falsy case 3 (too long)', () => {
+      const ys: unknown = [1, 2, 3, 4, 5] as const;
+
+      const result = xs.validate(ys);
+
+      assert.isTrue(Result.isErr(result));
+
+      const resultError = Result.unwrapErrThrow(result);
+
+      assert.deepStrictEqual(resultError, [
+        {
+          path: [],
+          actualValue: ys,
+          expectedType: 'xs',
+          typeName: 'xs',
+          details: {
+            kind: 'array-range-length',
+            minLength: 2,
+            maxLength: 4,
+            actualLength: 5,
+          },
+        },
+      ]);
+
+      assert.deepStrictEqual(validationErrorsToMessages(resultError), [
+        'Error: expected array of length between 2 and 4 but length 5 was passed.',
+      ]);
+    });
+
+    test('falsy case 4 (wrong element type)', () => {
+      const ys: unknown = [1, '2'] as const;
+
+      const result = xs.validate(ys);
+
+      assert.isTrue(Result.isErr(result));
+
+      const resultError = Result.unwrapErrThrow(result);
+
+      assert.deepStrictEqual(resultError, [
+        {
+          path: ['1'],
+          actualValue: '2',
+          expectedType: 'number',
+          typeName: 'number',
+          details: undefined,
+        },
+      ]);
+
+      assert.deepStrictEqual(validationErrorsToMessages(resultError), [
+        'Error at 1: expected <number> type but <string> type value "2" was passed.',
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('trims extras down to max', () => {
+      const ys: unknown = [4, 5, 6, 7, 8] as const;
+
+      assert.deepStrictEqual(xs.fill(ys), [4, 5, 6, 7]);
+    });
+
+    test('pads up to min and fills invalid entries', () => {
+      const ys: unknown = [4] as const;
+
+      assert.deepStrictEqual(xs.fill(ys), [4, 0]);
+    });
+
+    test('keeps in-range arrays and fills invalid entries', () => {
+      const ys: unknown = [4, '5', 6] as const;
+
+      assert.deepStrictEqual(xs.fill(ys), [4, 0, 6]);
+    });
+
+    test('fill with the default value for non-array input', () => {
+      const ys: unknown = null;
+
+      assert.deepStrictEqual(xs.fill(ys), [1, 2, 3]);
+    });
+  });
+});

package/src/array/index.mts

@@ -1,4 +1,6 @@
 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 './non-empty-array.mjs';

package/src/utils/validation-error.mts

@@ -32,6 +32,17 @@ export type ValidationErrorDetails = Readonly<
       minLength: number;
       actualLength: number;
     }
+  | {
+      kind: 'array-max-length';
+      maxLength: number;
+      actualLength: number;
+    }
+  | {
+      kind: 'array-range-length';
+      minLength: number;
+      maxLength: number;
+      actualLength: number;
+    }
   | {
       kind: 'non-empty-array';
     }
@@ -156,6 +167,12 @@ const createDetailsMessage = (
     case 'array-min-length':
       return `expected array of length ${error.details.minLength} or more but length ${error.details.actualLength} was passed.`;
 
+    case 'array-max-length':
+      return `expected array of length ${error.details.maxLength} or less but length ${error.details.actualLength} was passed.`;
+
+    case 'array-range-length':
+      return `expected array of length between ${error.details.minLength} and ${error.details.maxLength} but length ${error.details.actualLength} was passed.`;
+
     case 'non-empty-array':
       return 'expected non-empty array but empty array was passed.';