Investigate if `Temporal` could replace `ms`

[styfle]

Now that Temporal has been standardized and ships in most browsers and will likely ship in a future version of Node.js, we should see if it could replace ms.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal#browser_compatibility

A few examples:

Temporal.Duration.from({ seconds: 5 }).total({ unit: 'milliseconds' });  // 5000
Temporal.Duration.from({ minutes: 3 }).total({ unit: 'milliseconds' });  // 180000
Temporal.Duration.from({ hours: 2 }).total({ unit: 'milliseconds' }); // 7200000
Temporal.Duration.from({ days: 1 }).total({ unit: 'milliseconds' }); // 86400000

There is even short hand string syntax (ISO 8601) such as:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/Duration#iso_8601_duration_format

Temporal.Duration.from('PT5S').total({ unit: 'milliseconds' });  // 5000
Temporal.Duration.from('PT3M').total({ unit: 'milliseconds' });  // 180000
Temporal.Duration.from('PT2H').total({ unit: 'milliseconds' }); // 7200000
Temporal.Duration.from('P1D').total({ unit: 'milliseconds' }); // 86400000

There are still other features to consider and it only makes sense if we can make ms smaller than it already is.

In an ideal world, you wouldn't need to install ms at all 😄

[artahir-dev]

This is a great conversation to have, especially now that we've reached the early 2026 landscape where the native platform has matured significantly. After conducting a deep dive into the current status of Temporal and Intl.DurationFormat, here is the technical breakdown of how it affects the ms library.

1. The State of the Platform (Feb 2026)

As of today, we have reached Baseline Wide Support for the Temporal API:

• Browsers: Native support is standard in Chrome 130+, Firefox 135+, and Safari 19+. The API is no longer behind flags in evergreen browsers.
• Node.js: Temporal is stable and enabled by default in Node.js v24 (LTS) and v26.
• Formatting: Intl.DurationFormat has also reached wide browser support, providing a localized way to format durations (e.g., "1 hour") natively.

2. The Parsing Gap: Why ms is Still Relevant

While Temporal is a powerful engine for time math, its parsing capabilities are strictly compliant with ISO 8601 (e.g., PT5S, P1D) and property objects (e.g., { seconds: 5 }).

Native Temporal does not support the human-readable shorthands that define ms:

• ms: 1h, 2 days, 5m, 1.5 hrs, -1.5s
• Temporal: PT1H, P2D, PT5M, PT1H30M, -PT1.5S

For configuration files, environment variables, and developer-facing APIs, the ms shorthand is significantly more ergonomic. To replace ms with raw Temporal, every developer would have to write their own regex wrapper or move to more verbose ISO strings.

3. Size and Optimization

ms is a ~0.6 KB utility. While native Temporal is "free" once it's in the runtime, using it for simple string parsing still requires code.

If we were to ship a Temporal-based ms, the core parsing logic that handles these "non-standard" strings would still constitute most of the library's weight. However, we could potentially delete all the internal math logic and approximation factors (like the 365.25 day year constant) and delegate that to the native Temporal.Duration engine.

4. Precision vs. Intent

Temporal is a high-precision, calendar-aware engine. ms is a developer utility for application timing (timeouts, TTLs). For standard application logic, the "fixed" year/month lengths used by ms are often preferred over calendar-aware durations because they provide a predictable millisecond count that doesn't vary based on the current date (e.g., Leap Year issues).

Conclusion

In an ideal world, you wouldn't need to install ms, but as long as we value human-readable shorthand over ISO-8601 strictly, ms serves as the necessary interface layer.

The Roadmap for ms v5:
We are looking at refactoring ms to be a pure parser/interface layer.

1. It will continue to provide the friendliest parsing API in the ecosystem.
2. It will offload the actual degree of conversion and mathematical heavy lifting to native Temporal objects under the hood.
3. This will allow us to shrink the library even further while improving its accuracy by using platform-native constants.

[tj-commits]

@artahir-dev Your response is AI generated. Also if Temporal could replace ms, still Temporal is new, so backwards compatibility would break if switching to Temporal. Also using a Temporal polyfill would be unnecessary larger than just using ms