npm install {{ plugin.packageName }}
@@ -106,7 +114,10 @@ const copyInstall = (pkgName: string) => {
Coming Soon
-
{{ plugin.name }}
+
+
{{ plugin.name }}
+ v{{ plugin.version }}
+
{{ plugin.description }}
@@ -133,11 +144,25 @@ const copyInstall = (pkgName: string) => {
display: flex;
flex-direction: column;
}
+.card-title {
+ display: flex;
+ align-items: baseline;
+ justify-content: space-between;
+ gap: 0.5rem;
+ margin-bottom: 0.5rem;
+}
.card h3 {
margin-top: 0;
- margin-bottom: 0.5rem;
+ margin-bottom: 0;
font-size: 1.25rem;
}
+.card-version {
+ font-size: 0.75rem;
+ font-weight: 500;
+ color: var(--vp-c-text-3);
+ white-space: nowrap;
+ flex-shrink: 0;
+}
.card p {
flex-grow: 1;
font-size: 0.95rem;
diff --git a/packages/tempo/CHANGELOG.md b/packages/tempo/CHANGELOG.md
index 28ad2857..ddea1533 100644
--- a/packages/tempo/CHANGELOG.md
+++ b/packages/tempo/CHANGELOG.md
@@ -6,7 +6,20 @@ All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-## [3.9.0] - 2026-07-14
+## [3.9.1] - 2026-07-17
+
+### Added
+- **Format Type Validation**: Implemented compile-time IDE validation for Tempo's `.format()` string templates using a recursive template literal type validator (`ValidateFormat`). Augmented this with an extensible `TempoFormatTokens` interface, allowing plugins to register custom tokens (like `{term.quarter}`) without core modifications or type errors.
+
+### Changed
+- **Documentation Navigation**: Restructured the VitePress navigation sidebar to include a dedicated **License Key Guide** section, prominently surfacing the guide for premium plugins.
+- **Plugin Harvesting Pipeline**: Refactored the `harvest-plugins.mjs` build script to support modular multi-file plugin documentation. Implemented a robust `_` prefixing strategy (e.g., `.setup` -> `_setup`) and explicit directory collision detection to prevent silent overwrites in the flattened `9-plugins/` VitePress routing namespace.
+
+### Fixed
+- **CI Workspace Resolution**: Fixed a critical build failure in the GitHub Actions CI where isolated test runners (`plugins`, `functions`) failed with `Failed to resolve entry for package "@magmacomputing/tempo"`. The CI now explicitly builds the core packages (`npm run build:tempo`) prior to executing downstream workspace tests.
+- **CI Security Hardening**: Upgraded `.github/workflows/ci.yml` by explicitly setting `persist-credentials: false` on all checkout steps and implementing strict top-level `permissions` blocks following the principle of least privilege.
+
+## [3.9.0] - 2026-07-16
### Added
- **Era Parsing Engine**: Upgraded the `ParseModule` and Lexer to natively support parsing historical and future era dates with explicit markers (e.g. `200 BC`, `BC 200`, `2026 CE`). Supports both leading and trailing formats and flawlessly converts to the astronomical ISO 8601 year.
diff --git a/packages/tempo/README.md b/packages/tempo/README.md
index 23603de7..7955dba4 100644
--- a/packages/tempo/README.md
+++ b/packages/tempo/README.md
@@ -97,7 +97,7 @@ While the native Temporal API gives you perfect primitives (`ZonedDateTime`, `Pl
### The Missing Domain Layer
* **๐๏ธ Future Standard**: Built natively on the TC39 `Temporal` proposal. Inherit the reliability of the future standard.
-* **๐งฉ Premium Ecosystem**: Don't build temporal math from scratch. Drop in our cryptographically-secured plugins for Astronomical seasons (`astro`) and atomic state syncing (`sync`).
+* **๐งฉ Premium Ecosystem**: Don't build temporal math from scratch. Drop in our plugins for Astronomical seasons (`astro`) and atomic state syncing (`sync`).
* **๐ Zero-Bundle Localization**: Best-in-class multi-language parsing and formatting powered natively by the `Intl` APIโno massive static locale dictionaries required.
* **๐ฃ๏ธ Natural Language**: Resolve complex terms like "two days ago" with zero configuration.
* **๐ง Functional Aliases**: Extend the parser with custom logic using a powerful resolution context for relative date math.
@@ -115,6 +115,19 @@ For a deeper dive into the API, architecture, and advanced features:
* **[Official Documentation Website](https://magmacomputing.github.io/magma/)** โ Tutorials, interactive demos, and "Getting Started" guides.
* **[Full API Reference Guide](https://magmacomputing.github.io/magma/doc/api/)** โ Detailed technical documentation for every class and method.
+---
+
+## ๐งฐ The Tempo Ecosystem
+
+Tempo is the core library, but the ecosystem extends further:
+
+| Package | Description |
+| :--- | :--- |
+| **[`@magmacomputing/tempo`](https://www.npmjs.com/package/@magmacomputing/tempo)** | Core library โ parsing, formatting, natural-language engine |
+| **[`@magmacomputing/tempo-fns`](https://www.npmjs.com/package/@magmacomputing/tempo-fns)** | Pure functional utilities built on native Temporal & Tempo โ tree-shakeable helpers for calendars, business logic, and scheduling [](https://magmacomputing.github.io/magma/functions/) |
+| **[`@magmacomputing/tempo-plugin-*`](https://www.npmjs.com/search?q=%40magmacomputing%2Ftempo-plugin)** | Premium & community plugins โ Ticker, Astro, Finance, Sync, Snap and more [](./doc/3-extending-tempo/ecosystem.md) |
+
+
---
## ๐ฌ Contact & Support
diff --git a/packages/tempo/bin/harvest-plugins.mjs b/packages/tempo/bin/harvest-plugins.mjs
index ee59b9f4..35a4576f 100644
--- a/packages/tempo/bin/harvest-plugins.mjs
+++ b/packages/tempo/bin/harvest-plugins.mjs
@@ -8,16 +8,49 @@ const __dirname = path.dirname(__filename);
const pluginsDir = path.resolve(__dirname, '../../../packages/plugins');
const targetDir = path.resolve(__dirname, '../doc/9-plugins');
-if (!fs.existsSync(targetDir)) {
- fs.mkdirSync(targetDir, { recursive: true });
-}
+fs.rmSync(targetDir, { recursive: true, force: true });
+fs.mkdirSync(targetDir, { recursive: true });
+
+// Track normalised plugin IDs to detect collisions early (e.g. both '.setup/' and 'setup/' present)
+const usedPluginIds = new Map(); // pluginId -> original directory name
const plugins = fs.readdirSync(pluginsDir);
for (const plugin of plugins) {
- const docPath = path.join(pluginsDir, plugin, 'doc', 'index.md');
- if (fs.existsSync(docPath)) {
- let content = fs.readFileSync(docPath, 'utf8');
- fs.writeFileSync(path.join(targetDir, `${plugin}.md`), content);
- console.log(`Harvested docs for plugin: ${plugin}`);
+ const docDir = path.join(pluginsDir, plugin, 'doc');
+ if (!fs.existsSync(docDir)) continue;
+
+ const files = fs.readdirSync(docDir).filter(f => f.endsWith('.md'));
+ if (files.length === 0) continue;
+
+ // Normalise plugin directory name for use as a VitePress-safe filename segment:
+ // Leading dots are replaced with underscores to avoid router issues and prevent
+ // silent collision between e.g. '.setup/' and 'setup/' (would both strip to 'setup').
+ const pluginId = plugin.replace(/^\./, '_');
+
+ if (usedPluginIds.has(pluginId)) {
+ const conflict = usedPluginIds.get(pluginId);
+ throw new Error(
+ `harvest-plugins: name collision detected!\n` +
+ ` Both '${conflict}' and '${plugin}' normalise to pluginId '${pluginId}'.\n` +
+ ` Rename one of the plugin directories to resolve the conflict.`
+ );
+ }
+ usedPluginIds.set(pluginId, plugin);
+
+ for (const file of files) {
+ let content = fs.readFileSync(path.join(docDir, file), 'utf8');
+
+ // Rewrite internal sibling links within the same plugin's doc/ folder
+ // Maps: ./other.md -> ./[pluginId].other.md
+ content = content.replace(/\]\(\.\/([^/]+)\.md(?:([#?][^)]*))?\)/g, `](./${pluginId}.$1.md$2)`);
+
+ // Rewrite cross-plugin relative links so they work in VitePress
+ // Maps: ../../[plugin-dir]/doc/[filename].md -> ./[normalised-pluginId].[filename].md
+ content = content.replace(/\]\(\.\.\/\.\.\/([^/]+)\/doc\/([^/]+)\.md(?:([#?][^)]*))?\)/g, (_m, p, f, q) => `](./${p.replace(/^\./, '_')}.${f}.md${q || ''})`);
+
+ const basename = path.basename(file, '.md');
+ const outName = `${pluginId}.${basename}.md`;
+ fs.writeFileSync(path.join(targetDir, outName), content);
+ console.log(`Harvested docs for plugin: ${plugin} (${file} -> ${outName})`);
}
}
diff --git a/packages/tempo/doc/1-getting-started/tempo.cookbook.md b/packages/tempo/doc/1-getting-started/tempo.cookbook.md
index f01fe452..f032b996 100644
--- a/packages/tempo/doc/1-getting-started/tempo.cookbook.md
+++ b/packages/tempo/doc/1-getting-started/tempo.cookbook.md
@@ -307,7 +307,7 @@ The examples below use the `using` and `await using` syntax, which require **Typ
### Ticker Plugin
The Ticker engine is a premium feature.
-๐ **Learn More:** [Ticker Plugin Documentation](../9-plugins/ticker.md)
+๐ **Learn More:** [Ticker Plugin Documentation](../../../plugins/ticker/doc/index.md)
### Interval-Based Ticker (Recurring Billing)
diff --git a/packages/tempo/doc/3-extending-tempo/tempo.extension.md b/packages/tempo/doc/3-extending-tempo/tempo.extension.md
index 7d6ad407..de181c5d 100644
--- a/packages/tempo/doc/3-extending-tempo/tempo.extension.md
+++ b/packages/tempo/doc/3-extending-tempo/tempo.extension.md
@@ -147,4 +147,4 @@ const nextBiz = t.addBusinessDays(2);
---
> [!TIP] Need something more complex?
-> If you need to build advanced scheduling engines, AsyncGenerators, or precision arithmetic tools that you plan to distribute commercially, check out our **[Premium Plugin Registry โ](https://magmacomputing.github.io/tempo-plugin-docs/)** for inspiration, or contact Magma Computing Solutions for professional plugin development.
+> If you need to build advanced scheduling engines, AsyncGenerators, or precision arithmetic tools that you plan to distribute commercially, check out our **[Plugin Ecosystem โ](./ecosystem.html)** for inspiration, or contact Magma Computing Solutions for professional plugin development.
diff --git a/packages/tempo/doc/3-extending-tempo/tempo.plugin.md b/packages/tempo/doc/3-extending-tempo/tempo.plugin.md
index 4a219aba..bbd8759b 100644
--- a/packages/tempo/doc/3-extending-tempo/tempo.plugin.md
+++ b/packages/tempo/doc/3-extending-tempo/tempo.plugin.md
@@ -133,21 +133,21 @@ if (errorCondition) {
This pattern ensures that Tempo remains robust in production environments while providing strict validation during development.
-## Alternative: Standalone Functions (`tempo-fns`)
+## Alternative: Standalone Functions (`functions`)
The JavaScript ecosystem is divided between two architectural preferences: **Chained Fluent APIs** (like Tempo Plugins) and **Pure Standalone Functions** (for aggressive tree-shaking).
-To support teams that mandate strict 0kb bundle-impacts and functional programming paradigms, Magma Computing provides the **`@magmacomputing/tempo-fns`** library.
+To support teams that mandate strict 0kb bundle-impacts and functional programming paradigms, Magma Computing provides the **`@magmacomputing/functions`** library.
```typescript
// The Pure, Tree-shakeable approach:
-import { isFirstDayOfMonth } from '@magmacomputing/tempo-fns';
+import { isFirstDayOfMonth } from '@magmacomputing/functions';
import { Tempo } from '@magmacomputing/tempo/core';
if (isFirstDayOfMonth(new Tempo('2024-01-01'))) { ... }
```
-When building complex logic, consider whether it belongs as a core Plugin extension, or as a standalone utility in `tempo-fns` (or a hybrid wrapper of both!).
+When building complex logic, consider whether it belongs as a core Plugin extension, or as a standalone utility in `functions` (or a hybrid wrapper of both!).
## Distributing Your Plugin
diff --git a/packages/tempo/doc/8-project-and-support/commercial.md b/packages/tempo/doc/8-project-and-support/commercial.md
index 2145dc00..a0343abe 100644
--- a/packages/tempo/doc/8-project-and-support/commercial.md
+++ b/packages/tempo/doc/8-project-and-support/commercial.md
@@ -35,9 +35,7 @@ For mission-critical applications, we provide priority support, security auditin
In addition to our open-source core, we offer a suite of **Premium Plugins** published directly to the standard public NPM registry (`npmjs.com`), secured by a commercial License Key. These extensions provide advanced, proprietary logic for enterprise-scale requirements.
-More details on browsing the 'Tempo Store' will be provided soon...
-
-For details on how to unlock and use these features, see our [License Key Guide](https://magmacomputing.github.io/tempo-plugin-docs/).
+For details on how to unlock and use these features, see our [License Key Guide](../../../plugins/.setup/doc/index.md).
---
diff --git a/packages/tempo/doc/9-plugins/astro.md b/packages/tempo/doc/9-plugins/astro.md
deleted file mode 100644
index d8371908..00000000
--- a/packages/tempo/doc/9-plugins/astro.md
+++ /dev/null
@@ -1,77 +0,0 @@
-
-
-# @magmacomputing/tempo-plugin-astro
-
-
- 
-
-
-This is a Community plugin for the [Tempo](https://github.com/magmacomputing/magma) library that calculates the exact astronomical season (Equinoxes and Solstices) for any date using the **Jean Meeus polynomial algorithm**.
-
-> [!NOTE]
-> **Mean-Polynomial Approximation (Ch. 27)**
-> This plugin specifically implements the mean-polynomial calculation from Chapter 27 of Meeus' *Astronomical Algorithms*. To keep the library extremely lightweight, it omits the massive periodic correction tables required for exact apparent calculations. It is strictly enforced to support the mathematical range of **-1000 to +3000 AD**.
-
-Because it is a true astronomical calculation rather than a fixed calendar date, it precisely determines the exact minute the sun crosses the celestial equator. It is also **hemisphere-aware**: by configuring your Tempo instance with a `sphere` (e.g., `sphere: 'south'`), the plugin accurately flips the Vernal Equinox from Spring to Autumn.
-
-::: info Meteorological vs Astronomical
-Unlike Tempo's built-in **Meteorological** `season` Term โ which rigidly snaps to the 1st day of calendar months โ this **Astronomical** plugin calculates the dynamic, true solar boundaries that shift slightly year-over-year.
-:::
-## Installation
-
-```bash
-npm install @magmacomputing/tempo-plugin-astro
-```
-
-## Usage
-
-```typescript
-import { Tempo } from '@magmacomputing/tempo';
-import { AstroTerm } from '@magmacomputing/tempo-plugin-astro';
-
-// Pass the plugin to `Tempo.init` to register it into the runtime.
-Tempo.init({
- plugins: [AstroTerm]
-});
-
-const t = new Tempo('2026-03-20');
-
-// Get the Astronomical Event mapping
-console.log(t.term.astro);
-// Output: 'Vernal'
-```
-
-### Response Payload
-
-When resolving the term, the plugin intelligently returns the correct astronomical event and its corresponding traditional season based on your configured hemisphere (`sphere`):
-
-```javascript
-{
- key: 'Vernal', // Flips to 'Autumnal' if sphere is set to 'south'
- season: 'Spring', // Flips to 'Autumn' if sphere is set to 'south'
- sphere: 'north', // Flips to 'south' if sphere is set to 'south'
- event: 'Equinox',
- group: 'astronomy',
- year: 2026,
- month: 3,
- day: 20,
- hour: 14,
- minute: 45,
- second: 0
-}
-```
-
-You can also access the full metadata object containing the sub-second precision fields via the `astronomy` term:
-
-```typescript
-console.log(t.term.astronomy);
-// Output: { key: 'Vernal', group: 'astronomy', year: 2026, month: 3, day: 20, hour: 14, minute: 45, ... }
-```
-
-::: tip Did you know?
-**Seasons:** `t.term.astronomy.season` returns the *Astronomical* season calculated by the precise timing of solstices and equinoxes. This will often differ from `t.term.season.key` in the core library, which uses standard Meteorological/Civil calendar boundaries (e.g., 1st of the month).
-:::
-
-## Licensing
-
-This is a **Community** plugin. It is completely free and open-source for personal and commercial use. No license token is required.
diff --git a/packages/tempo/doc/9-plugins/batch.md b/packages/tempo/doc/9-plugins/batch.md
deleted file mode 100644
index 628f2c69..00000000
--- a/packages/tempo/doc/9-plugins/batch.md
+++ /dev/null
@@ -1,58 +0,0 @@
-
-
-# @magmacomputing/tempo-plugin-batch
-
-
- 
-
-
-This is a Community plugin for the [Tempo](https://github.com/magmacomputing/magma) library that parallelizes massive epoch mutation tasks across worker threads utilizing lock-free `SharedArrayBuffer` architecture for extreme throughput.
-
-::: tip Perfect For
-Heavy data ETL pipelines, massive IoT telemetry ingestion, financial ledger chronometrics, and any parallel bulk date-processing workloads.
-:::
-
-## Installation
-
-```bash
-npm install @magmacomputing/tempo-plugin-batch
-```
-
-## Usage
-
-```typescript
-import { Tempo } from '@magmacomputing/tempo';
-import { BatchPlugin } from '@magmacomputing/tempo-plugin-batch';
-
-Tempo.init({
- plugins: [BatchPlugin]
-});
-
-// Assume `epochs` is a massive array of integers representing timestamps
-const epochs = [1700000000000, 1700000001000, /* ... millions more ... */];
-
-// Mutate millions of dates concurrently using the worker pool
-// The engine automatically splits the payload and offloads to workers!
-const batchResult = await Tempo.batch(epochs, { weeks: 1 });
-
-console.log(batchResult); // Returns an array of mutated timestamp integers
-```
-
-### Rehydration
-
-By default, `Tempo.batch` returns an array of primitive `number` timestamps to maximize throughput over the thread boundary. If you need fully-fledged `Tempo` objects back, pass `{ rehydrate: true }`:
-
-```typescript
-// Returns an array of Tempo instances instead of integers
-const tempoInstances = await Tempo.batch(epochs, { weeks: 1 }, { rehydrate: true });
-```
-
-### Graceful Degradation
-
-If the host environment does not support `SharedArrayBuffer` (or if it is blocked by CORS/COOP headers in the browser), the orchestrator intelligently and transparently falls back to using traditional `postMessage` structural cloning chunks to ensure execution never halts.
-
-## Licensing
-
-This is a **Community** plugin. It is completely free and open-source for personal and commercial use. No license token is required.
-
-For commercial licensing options, please contact Magma Computing.
diff --git a/packages/tempo/doc/9-plugins/finance.md b/packages/tempo/doc/9-plugins/finance.md
deleted file mode 100644
index 067a7f14..00000000
--- a/packages/tempo/doc/9-plugins/finance.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# @magmacomputing/tempo-plugin-finance
-
-
- 
-
-
-A specialized namespace plugin for Tempo that provides fiscal year and financial date utilities.
-
-## Installation
-
-```bash
-npm install @magmacomputing/tempo-plugin-finance
-```
-
-## Usage
-
-```typescript
-import { Tempo } from '@magmacomputing/tempo';
-import { FinancePlugin } from '@magmacomputing/tempo-plugin-finance';
-
-// Register the namespace
-Tempo.extend(FinancePlugin);
-
-const t = new Tempo('2024-07-01');
-
-// Evaluate static properties
-console.log(t.finance.fiscalQuarter); // 3
-console.log(t.finance.taxYear); // 2024
-
-// Evaluate functional closures
-console.log(t.finance.isFiscalYearStart()); // false
-```
-
-## Licensing
-
-This is a **Community** plugin. It is completely free and open-source for personal and commercial use. No license token is required.
diff --git a/packages/tempo/doc/9-plugins/snap.md b/packages/tempo/doc/9-plugins/snap.md
deleted file mode 100644
index d167810a..00000000
--- a/packages/tempo/doc/9-plugins/snap.md
+++ /dev/null
@@ -1,55 +0,0 @@
-
-
-# @magmacomputing/tempo-plugin-snap
-
-
- 
-
-
-A Community plugin for the [Tempo](https://github.com/magmacomputing/magma) library that provides robust time rounding and snapping functionality (e.g., snapping to the nearest 15 minutes or 1 hour block) for calendar and scheduling applications.
-
-By default, the plugin effortlessly snaps dates to a configurable minute-interval. This is particularly useful when building UI components like time-pickers, ensuring data boundaries align perfectly with application logic.
-
-### ๐ก User Notes: Why Sub-Second Snapping?
-While `hours` and `minutes` cover most UI use cases, sub-second precision (`ms`, `us`, `ns`) is invaluable for:
-1. **Telemetry & Log Aggregation**: Snapping high-frequency jittery timestamps to the nearest `100ms` or `500ms` bucket for cleaner charts and analysis.
-2. **Video & Audio Synchronization**: Multimedia frame rates require precise timing. Snap to the nearest `16ms` (approx 60fps) or `40ms` (25fps) to align data points with visual boundaries.
-3. **Database & API Normalization**: Truncating or snapping Tempo's native nanosecond precision to the nearest `ms` before sending payloads ensures your local application state perfectly matches remote databases that don't support microseconds.
-4. **Performance Benchmarking**: Grouping execution times into buckets (e.g., nearest `10ms`) for histograms.
-
-## Installation
-
-```bash
-npm install @magmacomputing/tempo-plugin-snap
-```
-
-## Usage
-
-```typescript
-import { Tempo } from '@magmacomputing/tempo';
-import { SnapPlugin } from '@magmacomputing/tempo-plugin-snap';
-
-// Pass the plugin to `Tempo.init` to register it into the runtime.
-Tempo.init({
- plugins: [SnapPlugin]
-});
-
-const t = new Tempo('2026-06-01T14:08:00Z');
-
-// Snaps to the nearest 15 minutes by default
-const snapped = t.snap();
-console.log(snapped.format('{hh}:{mi}')); // "14:15"
-
-// Or explicitly provide units and intervals
-const snapHour = t.snap({ hh: 1 });
-const snapSecond = t.snap({ ss: 30 });
-const snapMs = t.snap({ ms: 100 });
-
-// Force snapping direction instead of standard rounding
-const snapUp = t.snap({ mi: 15, direction: 'up' });
-const snapDown = t.snap({ mi: 15, direction: 'down' });
-```
-
-## Licensing
-
-This is a **Community** plugin. It is completely free and open-source for personal and commercial use. No license token is required.
diff --git a/packages/tempo/doc/9-plugins/sync.md b/packages/tempo/doc/9-plugins/sync.md
deleted file mode 100644
index 7cea6e96..00000000
--- a/packages/tempo/doc/9-plugins/sync.md
+++ /dev/null
@@ -1,62 +0,0 @@
-
-
-# @magmacomputing/tempo-plugin-sync
-
-
- 
-
-
-This is a Community plugin for the [Tempo](https://github.com/magmacomputing/magma) library that provides lock-free, nanosecond-accurate cross-thread time synchronization using `SharedArrayBuffer` and `Atomics`.
-
-::: tip Perfect For
-High-frequency trading platforms, real-time multiplayer game servers, distributed microservice tracing, and extreme-precision scientific telemetry.
-:::
-
-## Installation
-
-```bash
-npm install @magmacomputing/tempo-plugin-sync
-```
-
-## Usage
-
-```typescript
-import { Tempo } from '@magmacomputing/tempo';
-import { SyncPlugin } from '@magmacomputing/tempo-plugin-sync';
-
-Tempo.init({
- plugins: [SyncPlugin]
-});
-
-// Master Thread: Start the clock
-const clock = Tempo.sync.startClock({ updateIntervalMs: 1 });
-const buffer = clock.buffer; // Pass this SharedArrayBuffer to your workers
-```
-
-### Reading from Worker Threads
-
-To read the synchronized time from inside a worker thread, pass the `SharedArrayBuffer` via `workerData` and instantiate an `AtomicReader`.
-
-```typescript
-// worker.ts
-import { workerData } from 'node:worker_threads';
-import { AtomicReader } from '@magmacomputing/tempo-plugin-sync';
-
-// Hydrate the reader using the master buffer
-const reader = new AtomicReader(workerData.buffer);
-
-// 1. Get raw milliseconds (O(1) Atomic Read)
-const ms = reader.now();
-
-// 2. Get high-precision BigInt nanoseconds
-const ns = reader.nowNano();
-
-// 3. Hydrate a brand new Tempo instance with exact precision
-const t = reader.getTempo();
-```
-
-## Licensing
-
-This is a **Community** plugin. It is completely free and open-source for personal and commercial use. No license token is required.
-
-For commercial licensing options, please contact Magma Computing.
diff --git a/packages/tempo/doc/9-plugins/ticker.md b/packages/tempo/doc/9-plugins/ticker.md
deleted file mode 100644
index daf5c54a..00000000
--- a/packages/tempo/doc/9-plugins/ticker.md
+++ /dev/null
@@ -1,351 +0,0 @@
-
-
-# @magmacomputing/tempo-plugin-ticker
-
-
- 
-
-
-This is a premium plugin for the [Tempo](https://github.com/magmacomputing/magma) library that provides a high-performance continuous execution loop (Ticker) based on temporal mathematics.
-
-::: info High Performance Loop
-Unlike standard `setInterval` or `requestAnimationFrame`, the Ticker plugin leverages Tempo's robust temporal core to ensure exact sub-millisecond precision, making it ideal for games, complex UI animations, and accurate state synchronization.
-:::
-
-## Installation
-
-```bash
-npm install @magmacomputing/tempo-plugin-ticker
-```
-
-## Usage
-
-To use the Ticker, pass the plugin to `Tempo.init` to ensure it registers securely alongside your license.
-
-```typescript
-import { Tempo } from '@magmacomputing/tempo';
-import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
-
-// A valid premium license token is required to use this plugin
-Tempo.init({
- license: 'YOUR_LICENSE_TOKEN',
- plugins: [TickerPlugin]
-});
-
-// You can now access Ticker-based execution loops through the Tempo API:
-const ticker = Tempo.ticker({ seconds: 1 });
-```
-
-### Direct Access
-If you need to access the [Reporting & Registry](#reporting-registry) API (like `Ticker.active`), you should import the `Ticker` namespace:
-
-```typescript
-import { Ticker } from '@magmacomputing/tempo-plugin-ticker';
-
-console.log(Ticker.active);
-```
-
-## ๐ Key Features
-
-The Ticker supports a unified **Options** object, enabling professional resource management and semantic duration-based intervals.
-
-### 1. Semantic Intervals (Duration Objects)
-Instead of raw numeric seconds, you can use `DurationLike` objects or shorthand keys for clarity. This is especially powerful for variable-length intervals like **months**.
-
-```typescript
-// Pulse exactly once a month
-await using monthly = Tempo.ticker({ months: 1 });
-
-// You can also use highly compact shorthand keys
-await using concise = Tempo.ticker({ hh: 1, mi: 30 }); // every 1h 30m
-
-// Pulse every time a new #quarter begins
-await using quarterly = Tempo.ticker({ '#quarter': 1 });
-```
-
-### 2. Term-Based Intervals
-Ticker intervals can now be driven by any registered **Term**. This is powerful for syncing with business cycles or daily shifts.
-
-```typescript
-// Pulse at the start of every 'morning', 'afternoon', etc.
-using shiftTicker = Tempo.ticker({ '#period': 1 }, (t) => {
- console.log(`New period started: ${t.term.per}`);
-});
-```
-
-### 3. Stop Conditions (Resource Management)
-Prevent memory leaks and runaway processes by setting a built-in termination condition.
-
-```typescript
-// Pattern A: Stop after exactly 5 ticks (defaults to 1-second interval)
-using tickerA = Tempo.ticker({ limit: 5 }, (t) => console.log(t));
-
-// Pattern B: Stop when a specific virtual time is reached (Inclusive)
-using tickerB = Tempo.ticker({
- seconds: 10, // Plural DurationLike property
- until: '2024-12-25T12:00:00'
-}, (t) => console.log(t));
-
-// Pattern C: Stop immediately (Limit: 0 is strictly honored)
-using tickerC = Tempo.ticker({ limit: 0 });
-```
-
-### 4. Virtual Clock (Seeding)
-To create a **Virtual Clock** that increments from a specific point rather than using the system time, use the `seed` option:
-
-```typescript
-// Starts at '2024-01-01', then increments by 1 day per pulse
-await using daily = Tempo.ticker({
- days: 1,
- seed: '2024-01-01'
-});
-```
-
-### 5. Backwards Tickers (Countdowns)
-By providing a **negative** interval, you can create a Ticker that moves backwards in time.
-
-```typescript
-// Count down from 10 seconds, moving backwards 1s at a time
-using countdown = Tempo.ticker({ seconds: -1, seed: "00:00:10" }, (t, stop) => {
- console.log(t.format('{ss}'));
- if (t.ss === 0) stop();
-});
-```
-
-## Usage Patterns
-
-### 1. Resource Management (Recommended)
-
-Using the `using` and `await using` keywords ensures that Tickers are automatically stopped when they go out of scope.
-
-```typescript
-// Pattern A: Automatic cleanup for callback-based ticker
-{
- using ticker = Tempo.ticker((t) => render(t)); // Defaults to a 1-second pulse
-} // interval stops automatically here
-
-// Pattern B: Automatic cleanup for async generator
-{
- await using ticker = Tempo.ticker(1);
- for await (const t of ticker) {
- if (done) break;
- }
-} // generator is closed and interval stops here
-```
-
-### 2. Manual Control (Programmatic Stop)
-
-If you are not using the `using` or `await using` keywords, or if you need to stop the Ticker from outside its own loop (e.g., in a separate event handler), you can manually call the `stop()` method on the Ticker object.
-
-```typescript
-// Pattern A: Stop a callback-based ticker
-const tickerA = Tempo.ticker(1, (t) => console.log(t));
-// ... later
-tickerA.stop();
-
-// Pattern B: Stop an async generator externally
-const tickerB = Tempo.ticker(1);
-
-(async () => {
- for await (const t of tickerB) {
- console.log(t.toString());
- }
- console.log('Ticker has been gracefully stopped.');
-})();
-
-// Close the generator from somewhere else
-setTimeout(() => {
- tickerB.stop();
-}, 5000);
-```
-### 3. Event Listeners (.on)
-Instead of (or in addition to) the constructor callback, you can register listeners for the `'pulse'`, `'stop'`, and `'catch'` events.
-All listeners use the same callback signature: `(t, stop) => {}`.
-
-```typescript
-const ticker = Tempo.ticker(1);
-ticker.on('pulse', (t) => console.log('Listener A:', t.fmt.weekTime));
-ticker.on('pulse', (t) => console.log('Listener B:', t.fmt.weekTime));
-ticker.on('stop', (t) => console.log('Ticker stopped at:', t.fmt.weekTime));
-```
-For `'stop'` listeners, the `stop` callback argument is included for signature consistency; however, invoking it after stop has already occurred is a no-op.
-
-### 4. Manual Pulsing (.pulse)
-In some scenarios, you may want to drive a Ticker manually (e.g., from a UI event or a WebSocket message) while still benefiting from the Ticker's internal state management and listeners.
-
-```typescript
-const ticker = Tempo.ticker({ seconds: 1 }); // Still has a 1s duration logic
-// ...
-ticker.pulse(); // Manually advance and notify listeners
-```
-
-## ๐ง Zombie Tickers (Warning) {#zombie-tickers-warning}
-
-In a Node.js environment, `Tempo.ticker()` uses background timers (`setTimeout`) to drive its pulses. If you do not explicitly stop a Ticker, it becomes a **"Zombie Ticker"** that continues to run indefinitely, even if the variable that created it has gone out of scope.
-
-### The Risks:
-- **Process Hangs**: Node.js will not exit a process if there are active timers. Undisposed Tickers are a common cause of "mysterious hangs" at the end of test runs.
-- **Test Inconsistency**: Leaked Tickers can continue to fire while subsequent tests are running, leading to flaky assertions and "impossible" state changes.
-- **Memory Leaks**: Each active Ticker maintains closures that prevent garbage collection of the `Tempo` instance and its listeners.
-
-### The Solution:
-Always use the **Disposer Pattern** (`using` or `await using`) or a `try...finally` block to guarantee cleanup:
-
-```typescript
-// โ
โ
BEST: Automatic cleanup via 'using'
-{
- using ticker = Tempo.ticker(1);
- // ... logic ...
-} // Stays clean: ticker stopped automatically here
-
-// โ
GOOD: Manual cleanup in finally block (Required for captured variables)
-let ticker;
-try {
- ticker = Tempo.ticker(1, (t) => { ... });
- // ... assertions ...
-} finally {
- ticker?.stop(); // Prevents "Zombie Tickers" even if assertions fail
-}
-```
-
-::: warning
-If you are using `const` or `let` without a `finally` block, an assertion failure will skip the `stop()` call, leaving a live timer in the event loop. Always prefer the `using` keyword or `try...finally` for industrial-grade resource management.
-:::
-
-### `Ticker` Object
-The object returned by `Tempo.ticker()` (or an instance of the `Ticker` class) implements the following interface:
-
-| Method / Property | Description |
-| :--- | :--- |
-| `on(event, cb)` | Registers a listener for the `'pulse'`, `'stop'`, or `'catch'` events. |
-| `pulse()` | Manually triggers a pulse, advances state, and notifies listeners. Returns the new `Tempo`. |
-| `info` | Read-only getter returning `{ next, ticks, limit, interval, stopped }`. |
-| `stop()` | Stops the Ticker, clears active timers, and immediately resolves any pending async iteration Promises. |
-| `[Symbol.dispose]` | Standard cleanup for `using` blocks. |
-| `[Symbol.asyncDispose]` | Standard async cleanup for `await using` blocks. |
-| `[Symbol.asyncIterator]` | Standard async iteration support (for `for await` loops). |
-
-## Reporting & Registry {#reporting-registry}
-
-The `Ticker` class maintains a static registry of all currently active Tickers. This is useful for debugging, monitoring, or cleanup checks.
-
-### `Ticker.active`
-A static getter that returns an array of [`Ticker.Snapshot`](#tickersnapshot) objects for all active (non-stopped) Tickers.
-
-```typescript
-import { Ticker } from '@magmacomputing/tempo-plugin-ticker';
-
-// Get a report of all running tickers
-const reports = Ticker.active;
-
-reports.forEach(({ ticker, next, ticks }) => {
- console.log(`Ticker ${ticker} next pulse: ${next}, ticks so far: ${ticks}`);
-});
-```
-
-#### `Ticker.Snapshot`
-```typescript
-type Snapshot = {
- ticker: Instance; // The Ticker instance (Proxy) itself
- next: Tempo; // The next Tempo value to be emitted
- ticks: number; // Number of pulses emitted so far
- limit?: number; // The configured limit (if any)
- interval: object; // The duration-based interval
- stopped: boolean; // Whether the ticker is stopped
-}
-```
-
-## ๐ฏ One-Shot Ticker (Meeting Alerts)
-
-You can use the Ticker as a "one-shot" timer for specific events by simply specifying a **seed** value. This is perfect for setting up a single alert (e.g., for a meeting) that cleans itself up immediately after firing.
-
-::: tip
-**Seed-Only Logic**: Providing a `seed` (as a string or in an options object) without any other duration-based keys (`seconds`, `minutes`, etc.) or a `limit` implies a `limit: 1`.
-
-Effectively, `Tempo.ticker('Fri 10am')` and `Tempo.ticker({ seed: 'Fri 10am' })` and `Tempo.ticker({ seed: 'Fri 10am', limit: 1 })` are all treated as one-shot Tickers.
-
-**Inclusive Boundaries**: Termination conditions (`limit` and `until`) are **inclusive**. A Ticker with `limit: 1` will pulse exactly once before stopping.
-:::
-
-```typescript
-// Pattern A: Implicit one-shot via string seed
-Tempo.ticker('Friday 10am', (t) => {
- console.log(`Meeting alert: ${t.format('{hh}:{mi}')}`);
-});
-
-// Pattern B: Explicit one-shot via options
-const event = { meeting: 'Friday 10am' };
-
-Tempo.ticker({
- seed: { value: 'meeting', event }
-}, (t) => {
- console.log(`Meeting alert: ${t.format('{hh}:{mi}')}`);
-});
-```
-
-::: warning
-**Future Seeds**: If the `seed` is in the future, the Ticker will remain dormant (waiting) until that time is reached. **Most Tickers emit an initial pulse immediately** (at the `seed` time or "now"), but a future seed will delay that first pulse until the specified time.
-:::
-
-::: danger
-**Persistence**: Ticker timers exist only **in-memory**. If the driving process (e.g., Node.js) terminates, any scheduled future pulses (including those from future seeds) are lost. For critical long-term scheduling, consider an external persistent job runner.
-:::
-
-::: warning
-While `limit: 1` handles the stop condition automatically, always remember that if you are using long-running Tickers without a limit, you **must** use the [Disposer Pattern](#zombie-tickers-warning) or manual `stop()` to avoid memory leaks and zombie processes.
-:::
-
-## ๐งญ Advanced: Syncing Multiple Clocks
-
-If you need to show multiple timezones on a dashboard, avoid creating multiple Tickers. Instead, use a single **Master Ticker** to drive all views. This prevents "drift" between the clocks and is much more efficient.
-
-### Using Signals (Recommended)
-
-Signals (from Preact, Solid, or Vue) are perfect for this "one source, many views" pattern.
-
-```typescript
-// 1. Master source of truth
-const now = signal(new Tempo());
-
-// 2. Drive the master from a single ticker
-using _ = Tempo.ticker(1, (t) => now.value = t);
-
-// 3. Derived timezones update automatically and stay 100% in sync
-const sydney = computed(() => now.value.set({ timeZone: 'Australia/Sydney' }));
-const london = computed(() => now.value.set({ timeZone: 'Europe/London' }));
-```
-
-### Using Async Generators (Framework-Agnostic)
-
-If you are not using a reactive framework, you can use the same pattern with an `AsyncGenerator` to derive all clocks from a single pulse.
-
-```typescript
-// One generator, one interval, zero drift.
-await using master = Tempo.ticker(1);
-
-for await (const t of master) {
- const clocks = {
- sydney: t.set({ timeZone: 'Australia/Sydney' }),
- ny: t.set({ timeZone: 'America/New_York' }),
- london: t.set({ timeZone: 'Europe/London' })
- };
-
- renderDashboard(clocks);
-}
-```
-
-## Licensing
-
-This is a **Premium** plugin. Usage requires an active, cryptographically signed Tempo license token with the `ticker` scope enabled.
-
-::: tip
-
-:::
diff --git a/packages/tempo/package.json b/packages/tempo/package.json
index 28f1f51a..b9161d23 100644
--- a/packages/tempo/package.json
+++ b/packages/tempo/package.json
@@ -1,6 +1,6 @@
{
"name": "@magmacomputing/tempo",
- "version": "3.9.0",
+ "version": "3.9.1",
"engines": {
"node": ">=20.0.0"
},
@@ -46,7 +46,9 @@
"dist/engine/engine.*.js",
"src/engine/engine.*.ts",
"dist/module/module.*.js",
- "src/module/module.*.ts"
+ "src/module/module.*.ts",
+ "dist/lib/temporal.polyfill.js",
+ "dist/lib/temporal.library.js"
],
"main": "dist/tempo.index.js",
"types": "dist/tempo.index.d.ts",
diff --git a/packages/tempo/plan/refactor-path-terms.md b/packages/tempo/plan/refactor-path-terms.md
new file mode 100644
index 00000000..de7831d5
--- /dev/null
+++ b/packages/tempo/plan/refactor-path-terms.md
@@ -0,0 +1,296 @@
+# Plan: Refactor Built-in Terms into `packages/plugins/.std/`
+
+> **Status: DEFERRED** โ agreed design, awaiting execution after other work is complete.
+
+## Overview
+
+Move the four built-in data Terms (Quarter, Season, Zodiac, Timeline) from
+`packages/tempo/src/plugin/term/` into a new hidden directory
+`packages/plugins/.std/`.
+
+**Delivery:** Rollup inlines the `.std` source into `dist/term/` inside
+`@magmacomputing/tempo` at build time โ mirroring how `@magmacomputing/library`
+is inlined into `dist/lib/`.
+**No separate npm publish is required.**
+
+---
+
+## Naming: `.std` (hidden directory)
+
+The existing plugins workspace uses hidden directories for workspace infrastructure
+(`.app/`) and visible directories for published plugins (`snap/`, `batch/` etc.).
+`.std` inherits that convention: clearly internal, non-publishable, self-documenting.
+
+| Name | Problem | Verdict |
+|---|---|---|
+| `standard` | Contributor thinks it's publishable; user tries `npm i @magmacomputing/tempo-plugin-standard` โ 404 | โ |
+| `.std` | Mirrors `.app`, clearly non-publishable | โ
|
+
+---
+
+## Key Design Decisions (all resolved)
+
+### Option B โ `TermsModule` stays in `tempo.index.ts`
+
+`TermsModule` remains in `packages/tempo/src/tempo.index.ts`.
+`.std` exports **only** `StandardTerms` (the array of four terms) and the individual
+term exports. This means `.std` has **no need** for `getRuntime` or `onRegistryReset`,
+and `plugin-api` needs no new lifecycle surface exposure.
+
+If a Premium plugin author needs runtime lifecycle access in future, a dedicated
+mechanism will be designed at that time.
+
+### `plugin-api` additions (minimal)
+
+Only two pure utilities are added โ no runtime singleton exposure:
+- `resolveCycleWindow` (pure calculation function, already in `term.util.ts`)
+- `logWarn` (simple console wrapper)
+
+### Auto-loading safety
+
+A user dropping a custom term file into `.std/src/` will **not** have it
+auto-loaded. Rollup only bundles files reachable through the import graph.
+Un-imported files are tree-shaken away. The `StandardTerms` array in
+`.std/src/index.ts` is the sole entry gate.
+
+### `dist/term/` modification risk
+
+No greater than editing `dist/tempo.class.js`. Standard npm social contract applies.
+A `/* Generated โ do not edit */` header is sufficient deterrent.
+
+---
+
+## Proposed Changes
+
+### 1 โ New package: `packages/plugins/.std/`
+
+#### `packages/plugins/.std/package.json`
+
+```json
+{
+ "name": "@magmacomputing/tempo-std",
+ "version": "1.0.0",
+ "private": true,
+ "description": "Standard built-in Terms for @magmacomputing/tempo (showcase implementation โ not published separately)",
+ "type": "module",
+ "peerDependencies": {
+ "@magmacomputing/tempo": "^3.9.x"
+ }
+}
+```
+
+`"private": true` โ hard guard against accidental `npm publish`; also self-documents intent.
+
+#### `packages/plugins/.std/src/index.ts`
+
+```ts
+export { QuarterTerm } from './term.quarter.js';
+export { SeasonTerm } from './term.season.js';
+export { ZodiacTerm } from './term.zodiac.js';
+export { TimelineTerm } from './term.timeline.js';
+
+export const StandardTerms = [QuarterTerm, SeasonTerm, ZodiacTerm, TimelineTerm];
+```
+
+`TermsModule` is **not** here โ it stays in `tempo.index.ts`.
+
+#### `packages/plugins/.std/src/term.quarter.ts` / `term.season.ts` / `term.zodiac.ts` / `term.timeline.ts`
+
+Move verbatim from `packages/tempo/src/plugin/term/`. Update imports:
+
+```diff
+- import { defineTerm, getTermRange, defineRange, resolveCycleWindow } from './term.util.js';
+- import { logWarn } from '../../support/support.util.js';
+- import { COMPASS } from '../../support/support.enum.js';
+- import { isNumber } from '#library/assertion.library.js';
+- import type { Tempo } from '../../tempo.class.js';
+
++ import { defineTerm, getTermRange, defineRange, resolveCycleWindow, logWarn, COMPASS, isNumber } from '@magmacomputing/tempo/plugin-api';
++ import type { Tempo } from '@magmacomputing/tempo';
+```
+
+Module augmentation target:
+
+```diff
+- declare module '../../tempo.class.js' {
++ declare module '@magmacomputing/tempo' {
+ interface TempoTermRegistry { ... }
+ }
+```
+
+#### `packages/plugins/.std/README.md`
+
+Content must include:
+- โ ๏ธ Banner: "Not published separately"
+- Why it exists (source organization, Rollup-inlined delivery)
+- The four terms table (key, scope, description)
+- How end-users access them (`import '@magmacomputing/tempo'` or `/term/quarter` sub-path)
+- Clear instruction: **do not add custom terms here** โ create a new `packages/plugins/
/` instead
+- Build notes: source โ `packages/plugins/.std/src/`, output โ `packages/tempo/dist/term/`
+
+#### `packages/plugins/.std/test/`
+
+Move term tests from `packages/tempo/test/` (term-related files) alongside the source.
+
+---
+
+### 2 โ `packages/tempo/src/tsconfig.json`
+
+```diff
+ "paths": {
+ ...
++ "#tempo/std": [ "../../plugins/.std/src/index.ts" ],
+ }
+```
+
+No project reference needed โ `.std` is consumed as source (same pattern as `@magmacomputing/library`).
+
+---
+
+### 3 โ `packages/tempo/src/tempo.index.ts`
+
+`TermsModule` body unchanged. Only the import source changes:
+
+```diff
+- import { QuarterTerm } from './plugin/term/term.quarter.js';
+- import { SeasonTerm } from './plugin/term/term.season.js';
+- import { ZodiacTerm } from './plugin/term/term.zodiac.js';
+- import { TimelineTerm } from './plugin/term/term.timeline.js';
+
++ import { StandardTerms } from '#tempo/std';
+```
+
+And simplify the StandardTerms reference inside `TermsModule.install()`:
+
+```diff
+- TempoClass.extend([QuarterTerm, SeasonTerm, ZodiacTerm, TimelineTerm]);
++ TempoClass.extend(StandardTerms);
+```
+
+---
+
+### 4 โ `packages/tempo/src/plugin/term/term.index.ts` (slimmed)
+
+Remove all data term imports, `StandardTerms`, and `TermsModule`. Retain framework only:
+
+```ts
+// Framework utilities for external Term plugin authors
+export { defineTerm, defineRange, getTermRange, resolveCycleWindow } from './term.util.js';
+export type { TermPlugin, Range, ResolvedRange } from './term.type.js';
+```
+
+**Delete:**
+- `packages/tempo/src/plugin/term/term.quarter.ts`
+- `packages/tempo/src/plugin/term/term.season.ts`
+- `packages/tempo/src/plugin/term/term.zodiac.ts`
+- `packages/tempo/src/plugin/term/term.timeline.ts`
+
+---
+
+### 5 โ `packages/tempo/rollup.config.js`
+
+Extend the `entryFileNames` routing hook (after the existing `dist/lib/` branch):
+
+```diff
+ if (id.includes('magma/packages/library') || rel.startsWith('../library')) {
+ ...
+ return `lib/${dir}${name}.js`;
+ }
+
++ if (id.includes('magma/packages/plugins/.std') || rel.startsWith('../plugins/.std')) {
++ const match = normalizedRel.match(/plugins\/\.std\/src\/(.*)$/);
++ const modulePath = match ? path.dirname(match[1]) : '.';
++ const dir = modulePath === '.' ? '' : modulePath + '/';
++ return `term/${dir}${name}.js`;
++ }
+```
+
+Output: `dist/term/index.js`, `dist/term/term.quarter.js` โฆ `dist/term/term.timeline.js`
+
+---
+
+### 6 โ `packages/tempo/src/plugin-api.index.ts`
+
+Add two pure utilities (no runtime exposure):
+
+```diff
+- export { defineTerm, defineRange, getTermRange } from './plugin/term/term.index.js';
++ export { defineTerm, defineRange, getTermRange, resolveCycleWindow } from './plugin/term/term.index.js';
++ export { logWarn } from './support/support.util.js';
+```
+
+---
+
+### 7 โ `packages/tempo/package.json`
+
+#### `imports` โ one addition
+
+```diff
++ "#tempo/std": { "default": "./dist/term/index.js" },
+```
+
+#### `exports` โ additive only
+
+```diff
++ "./term/standard": { "types": "./dist/term/index.d.ts", "import": "./dist/term/index.js" },
++ "./term/quarter": { "types": "./dist/term/term.quarter.d.ts", "import": "./dist/term/term.quarter.js" },
++ "./term/season": { "types": "./dist/term/term.season.d.ts", "import": "./dist/term/term.season.js" },
++ "./term/zodiac": { "types": "./dist/term/term.zodiac.d.ts", "import": "./dist/term/term.zodiac.js" },
++ "./term/timeline": { "types": "./dist/term/term.timeline.d.ts", "import": "./dist/term/term.timeline.js" },
+```
+
+#### `sideEffects` โ two removals
+
+```diff
+- "**/plugin/term/term.index.js",
+- "**/plugin/term/term.index.ts",
+```
+
+#### `dependencies` โ no change
+
+`.std` source is inlined at build time. No new runtime npm dependency.
+
+---
+
+## Documentation Trawl
+
+Run after code changes are complete. Files requiring review:
+
+| File | Change |
+|---|---|
+| `doc/3-extending-tempo/tempo.term.md` L153 | `@magmacomputing/tempo/term/quarter` is now a **real** sub-path โ confirm/add note |
+| `doc/3-extending-tempo/tempo.modularity.md` L74 | Same โ confirm `/term/quarter` sub-path validity |
+| `doc/3-extending-tempo/tempo.term.md` (augmentation example) | Ensure `declare module '@magmacomputing/tempo'` (not `/core`) |
+| `doc/9-plugins/` | Consider adding `.std.md` entry or expanding `tempo.term.md` with "Built-in Standard Terms" section |
+| `doc/api/Variable.StandardTerms.md` | Delete stale file; regenerate via `npm run docs:api` |
+| `doc/api/Variable.TermsModule.md` | Regenerate |
+| `doc/api/Function.define*.md` + `getTermRange.md` | Regenerate |
+| `doc/api/Interface.TempoTermRegistry.md` | Regenerate |
+
+---
+
+## Verification Plan
+
+```bash
+# 1. Build
+cd packages/tempo && npm run build
+
+# Confirm dist/term/ has 5 files
+ls dist/term/
+# โ index.js term.quarter.js term.season.js term.zodiac.js term.timeline.js
+
+# Confirm dist/plugin/term/ has only framework files
+ls dist/plugin/term/
+# โ term.index.js term.util.js term.type.js
+
+# 2. Full test suite
+npm test
+
+# 3. REPL smoke test
+npm run repl
+# tempo.quarter / tempo.season / tempo.zodiac / tempo.timeOfDay all resolve
+# import { StandardTerms } from '@magmacomputing/tempo/term/standard' โ [4 terms]
+
+# 4. Plugin compat
+cd ../plugins/snap && npm run build # must still pass against updated plugin-api
+```
diff --git a/packages/tempo/plan/typescript-format-template.md b/packages/tempo/plan/typescript-format-template.md
new file mode 100644
index 00000000..07ca10d7
--- /dev/null
+++ b/packages/tempo/plan/typescript-format-template.md
@@ -0,0 +1,70 @@
+The goal of this step is to introduce 'IDE confirmation' on a User's .format() string.
+
+
+``` typescript
+// Define your allowed tokens
+type ValidToken = 'dd' | 'mm' | 'yy' | 'yyyy' | 'mon' | 'dd:ord';
+
+// A type helper that ensures the string contains a valid pattern
+type ValidFormatString = S extends `${string}{${infer Token}}${infer Rest}`
+ ? Token extends ValidToken
+ ? ValidFormatString // Valid token, recursively check the rest of the string
+ : never // Illegal token found!
+ : string; // Base case: no more tokens found
+
+// Apply it directly to your class method
+class Tempo {
+ format(formatStr: S & ValidFormatString): string {
+ // Runtime parsing logic goes here...
+ return '';
+ }
+}
+```
+ If a developer types new Tempo().format('{mon} {dy}'), their IDE will immediately highlight {dy} in red with a compilation error, preventing runtime failures before their code even hits production.
+
+Do we see value in doing this for parsing input ?
+You can do the same thing for anchoring or parsing formats. If your anchor configuration option accepts an ISO date, you can strictly validate the YYYY-MM-DD shape at compile time
+``` typescript
+type ISODateFormat = `${number}${number}${number}${number}-${number}${number}-${number}${number}`;
+
+interface TempoOptions {
+ anchor?: ISODateFormat; // Will reject '2026/10/15' or 'tomorrow'
+}
+```
+
+---
+
+## Shipped in 3.9.0
+
+The following was implemented in `packages/tempo/src/`:
+
+- **`TempoFormatTokens` interface** (`tempo.type.ts`) โ an open, augmentable interface listing
+ every built-in `{token}` key. Plugins can extend it via declaration merging:
+ ```ts
+ declare module '@magmacomputing/tempo' {
+ interface TempoFormatTokens { 'fiscal.quarter': true }
+ }
+ ```
+
+- **`ValidateFormat` type** (`tempo.type.ts`) โ a recursive template-literal type that walks
+ every `{โฆ}` pair and checks it against `TempoFormatTokens`. Key design decisions:
+ - `string extends S ? string : โฆ` โ skips validation when a variable (not a literal) is passed.
+ - `${_CoreToken}:${string}` โ all modifier suffixes (`{dd:ord}`, `{tz:zzzzz}`) are accepted.
+ - `#${string}` โ term-plugin keys (`{#season.key}`) are always accepted (dynamic, unknowable statically).
+ - Returns `โ '{bad}' is not a valid Tempo format token` as the error type (not `never`) so the
+ bad token name is visible in the IDE tooltip.
+
+- **`format()` overload** (`module.format.ts`) โ a new generic overload is inserted before the
+ `any` catch-all so string literals are resolved against `ValidateFormat` at call-site.
+
+---
+
+## Excluded โ future work
+
+| Feature | Reason excluded | Suggested PR |
+|---|---|---|
+| **`anchor` option validation** | The plan's `ISODateFormat` pattern (`${number}${number}โฆ`) accepts any 8-digit sequence (e.g. `9999-99-99`). True ISO validation requires calendar-aware logic that can't be expressed purely in template literal types. Needs its own design. | 3.10.x |
+| **Constructor `value` / parse-input validation** | Parse input is intentionally flexible (strings, numbers, Dates, Temporal objects). Constraining it at the type level would be too narrow and break valid use cases. | Not planned |
+| **`registry.tokens` keys in `TempoFormatTokens`** | Custom tokens registered via `Tempo.init({ registry: { tokens: { myKey: fn } } })` are runtime values โ TypeScript has no way to reflect them into the type system without explicit manual augmentation. Document the augmentation pattern instead. | 3.10.x (docs) |
+| **Modifier validation** (`{dd:badModifier}`) | The modifier space (`:ord`, `:lower`, `:upper`, `:title`, `:locale`, `:z` โฆ `:zzzzz`, etc.) varies per token. Per-token modifier unions would be possible but complex โ a separate dedicated type work item. | 4.0 |
+| **`Tempo.FORMAT` alias strings** | `tempo.format('display')` (a pre-registered alias key) works at runtime but the format alias string expands to a template containing tokens โ validating the *expanded* alias at compile time would require inlining all `FORMAT` values into the type, which duplicates state and risks drift. | 4.0 |
\ No newline at end of file
diff --git a/packages/tempo/src/module/module.format.ts b/packages/tempo/src/module/module.format.ts
index a4a17d78..d7907c39 100644
--- a/packages/tempo/src/module/module.format.ts
+++ b/packages/tempo/src/module/module.format.ts
@@ -12,13 +12,26 @@ import { defineInterpreterModule } from '../plugin/plugin.util.js';
import { findTermPlugin } from '../plugin/term/term.util.js';
import type { Tempo } from '../tempo.class.js';
-
declare module '../tempo.class.js' {
interface Tempo {
- /** applies a format to the instance. */ format(options: Intl.DateTimeFormatOptions & { timeZone?: string; calendar?: string }): string;
- /** applies a format to the instance. */ format(fmt: BigIntPattern, options?: any): bigint;
- /** applies a format to the instance. */ format(fmt: NumericPattern, options?: any): number;
- /** applies a format to the instance. */ format(fmt?: any, options?: any): any;
+ /** applies a format to the instance. */ format(options: import('../tempo.type.js').FormatOptions): string;
+ /** applies a format to the instance. */ format(fmt: BigIntPattern, options?: any): bigint;
+ /** applies a format to the instance. */ format(fmt: NumericPattern, options?: any): number;
+ /**
+ * Applies a format to the instance.
+ * Format strings are validated at compile time โ any unrecognised `{token}`
+ * will produce an IDE error showing the bad token name.
+ * @see {@link import('../tempo.type.js').TempoFormatTokens} to extend the token set.
+ */
+ format(
+ fmt: string extends S
+ ? S // variable string โ no validation, accept as-is
+ : string extends import('../tempo.type.js').ValidateFormat
+ ? S // ValidateFormat is `string` โ all tokens valid, accept
+ : import('../tempo.type.js').ValidateFormat, // ValidateFormat is an error literal โ mismatch forces IDE error
+ options?: any
+ ): string | number | bigint;
+ /** applies a format to the instance (zero-argument โ returns a pre-built format proxy). */ format(): string | number | bigint;
}
}
@@ -35,7 +48,7 @@ declare module '../tempo.class.js' {
* const stamp = format().logStamp; // defaults to 'Now'
*/
export function format(obj?: any): any;
-export function format(obj: any, options: Intl.DateTimeFormatOptions & { timeZone?: string; calendar?: string }): string;
+export function format(obj: any, options: import('../tempo.type.js').FormatOptions): string;
export function format(obj: any, fmt: BigIntPattern, options?: any): bigint;
export function format(obj: any, fmt: NumericPattern, options?: any): number;
export function format(obj: any, fmt: string | symbol, options?: any): string;
diff --git a/packages/tempo/src/tempo.class.ts b/packages/tempo/src/tempo.class.ts
index bfb9f7ad..c9d2aae1 100644
--- a/packages/tempo/src/tempo.class.ts
+++ b/packages/tempo/src/tempo.class.ts
@@ -1625,8 +1625,7 @@ export class Tempo {
*/
/** @internal */ get #Tempo() { return this.constructor as typeof Tempo; }
- /** apply a custom format. */ format(fmt?: any, options?: any): any { return this.#resolve(() => interpret(this, 'FormatModule', () => `{${String(fmt)}}`, false, fmt, options)); }
-
+ /** apply a custom format. */ format(fmt?: any, options?: any): string | number | bigint { return this.#resolve(() => interpret(this, 'FormatModule', () => `{${String(fmt)}}`, false, fmt, options)); }
/** time duration until another date-time */
until(dateTimeOrOpts?: t.DateTime | t.Options, opts?: t.Options): t.Duration;
until(unit: t.Unit, opts?: t.Options): number;
@@ -1808,6 +1807,7 @@ export namespace Tempo {
export interface BaseOptions extends t.Internal.BaseOptions { }
export type Options = t.Options;
+ export interface FormatOptions extends t.FormatOptions { }
/** Configuration to use for #until() and #since() argument */
export type Unit = t.Unit;
@@ -1854,4 +1854,4 @@ export namespace Tempo {
export type Element = t.Element;
export interface Params extends t.Params { }
-}
+}
\ No newline at end of file
diff --git a/packages/tempo/src/tempo.type.ts b/packages/tempo/src/tempo.type.ts
index c67eff45..197df1a0 100644
--- a/packages/tempo/src/tempo.type.ts
+++ b/packages/tempo/src/tempo.type.ts
@@ -187,6 +187,81 @@ export type Format = enums.Format;
export type FormatRegistry = enums.FormatEnum;
export type FormatType = enums.FormatType;
+/**
+ * Augment this interface in your plugin or app to register additional
+ * format tokens for compile-time validation via `ValidateFormat`.
+ *
+ * @example
+ * // In a plugin's .d.ts:
+ * declare module '@magmacomputing/tempo' {
+ * interface TempoFormatTokens {
+ * 'fiscal.quarter': true;
+ * }
+ * }
+ */
+export interface TempoFormatTokens {
+ // โโ year / week โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ yyyy: true; yy: true; yw: true;
+ // โโ week-of-year โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ ww: true; wy: true; yywy: true; yyww: true;
+ // โโ era / eon โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ era: true; eon: true;
+ // โโ month โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ mm: true; mon: true; mmm: true;
+ // โโ day โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ dd: true; day: true; dow: true; wkd: true; www: true;
+ // โโ hour / minute / second โโโโโโโโโโโโโโโโโโโโโโโโ
+ hh: true; h24: true; h12: true; mer: true;
+ mi: true; ss: true;
+ // โโ sub-second โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ ms: true; us: true; ns: true; ff: true;
+ // โโ composite date/time โโโโโโโโโโโโโโโโโโโโโโโโโโโ
+ ymd: true; dmy: true; mdy: true; hms: true;
+ // โโ legacy composites (deprecated, still supported) โโ
+ ymd6: true; dmy6: true; mdy6: true;
+ // โโ timestamp / zone / calendar โโโโโโโโโโโโโโโโโโโ
+ ts: true; nano: true; tz: true; cal: true;
+}
+
+/** All statically-known base token names (derived from TempoFormatTokens). */
+type _CoreToken = keyof TempoFormatTokens;
+
+/**
+ * Accepted token shapes inside a `{โฆ}` brace pair:
+ * - a core token alone: `{yyyy}`
+ * - a core token with one or more modifiers: `{dd:ord}`, `{tz:zzzzz}`
+ * - a term-plugin key (always accepted, cannot be statically known): `{#season.key}`
+ */
+type _ValidToken = _CoreToken | `${_CoreToken}:${string}` | `#${string}` | `term.${string}`;
+
+/**
+ * Compile-time validator for Tempo format strings.
+ *
+ * - Recursively walks every `{token}` brace-pair in the string.
+ * - Accepts any token in `TempoFormatTokens`, modifier suffixes (`{dd:ord}`),
+ * and term-plugin keys (`{#season.key}`).
+ * - When `S` is a plain `string` variable (not a literal) validation is skipped
+ * to avoid false positives.
+ * - Returns a descriptive error literal when an unknown token is found, which
+ * surfaces as a readable type error in the IDE.
+ *
+ * @example
+ * // Valid โ no IDE error
+ * tempo.format('{www}, {dd} {mmm} {yyyy}');
+ *
+ * // Invalid โ IDE highlights the bad token
+ * tempo.format('{mon} {dy}');
+ * // ^^ Type '"โ '{dy}' is not a valid Tempo format token"'
+ */
+export type ValidateFormat =
+ string extends S ? string // S widened to string (variable) โ skip
+ : S extends `${string}\\${string}` ? string // escaped braces present โ skip validation
+ : S extends `${string}{${infer T}}${infer Rest}`
+ ? T extends _ValidToken
+ ? ValidateFormat // valid token, recurse into tail
+ : `โ '{${T}}' is not a valid Tempo format token` // bad token โ surfaced as IDE error
+ : string; // no more braces โ valid
+
export type WEEKDAY = enums.WEEKDAY
export type WEEKDAYS = enums.WEEKDAYS
export type MONTH = enums.MONTH
@@ -212,6 +287,12 @@ export interface RelativeTime {
/** Default style for relative time */ style?: Intl.RelativeTimeFormatStyle;
}
+export interface FormatOptions extends Intl.DateTimeFormatOptions {
+ timeZone?: string;
+ calendar?: string;
+ locale?: string | string[];
+}
+
export interface IntlOptions {
/** relative time formatting configuration */ relativeTimeFormat?: RelativeTime | ((value: number, unit: any) => string);
/** multi-unit duration formatting configuration */ durationFormat?: any | ((duration: any) => string);
diff --git a/packages/tempo/src/tempo.version.ts b/packages/tempo/src/tempo.version.ts
index 0e940446..bcd131b2 100644
--- a/packages/tempo/src/tempo.version.ts
+++ b/packages/tempo/src/tempo.version.ts
@@ -5,4 +5,4 @@
* โ ๏ธ This file is auto-updated by `npm run build:version` (see `bin/update-version.mjs`).
* Do NOT edit manually โ your changes will be overwritten on the next build.
*/
-export const TEMPO_VERSION = '3.9.0';
+export const TEMPO_VERSION = '3.9.1';
diff --git a/packages/tempo/test/instance/instance.format.test.ts b/packages/tempo/test/instance/instance.format.test.ts
index 9c3ee940..00cfeb15 100644
--- a/packages/tempo/test/instance/instance.format.test.ts
+++ b/packages/tempo/test/instance/instance.format.test.ts
@@ -1,5 +1,12 @@
import { Tempo } from '#tempo';
+declare module '../../src/tempo.type.js' {
+ export interface TempoFormatTokens {
+ myDay: string;
+ }
+}
+
+
const label = 'instance.format:';
describe(`${label} format method`, () => {
@@ -7,7 +14,7 @@ describe(`${label} format method`, () => {
test('formats with standard tokens', () => {
const t = new Tempo('2024-05-20 15:30:00');
expect(t.format('{yyyy}-{mm}-{dd}')).toBe('2024-05-20');
- // hh is 24-hour hour. h12 is 12-hour hour.
+ // hh is 24-hour. h12 is 12-hour.
expect(t.format('{hh}:{mi}')).toBe('15:30');
});
@@ -56,7 +63,7 @@ describe(`${label} format method`, () => {
month: 'long',
day: 'numeric',
numberingSystem: 'arab'
- };
+ } as Tempo.FormatOptions;
// The format module should extract locale, shift the ZonedDateTime, and gracefully
// fallback or pass through the options without crashing on the Temporal timeZone mismatch constraint.
@@ -75,7 +82,7 @@ describe(`${label} format method`, () => {
year: 'numeric',
month: 'long',
day: 'numeric'
- }
+ } as Tempo.FormatOptions
const result = t.format(japaneseConfig);
expect(result).toBe('ไปคๅ6ๅนด12ๆ25ๆฅ');
diff --git a/packages/tempo/vitest.config.ts b/packages/tempo/vitest.config.ts
index 2733b855..2c2b0cf9 100644
--- a/packages/tempo/vitest.config.ts
+++ b/packages/tempo/vitest.config.ts
@@ -65,17 +65,15 @@ export default defineConfig({
{ find: /^#tempo\/license$/, replacement: resolve(__dirname, './dist/plugin/license/license.validator.js') },
{ find: /^#tempo\/core$/, replacement: resolve(__dirname, './dist/core.index.js') },
{ find: /^#tempo\/term$/, replacement: resolve(__dirname, './dist/plugin/term/term.index.js') },
- { find: /^#tempo\/duration$/, replacement: resolve(__dirname, './dist/module/module.duration.js') },
- { find: /^#tempo\/(parse|format)$/, replacement: resolve(__dirname, './dist/module/module.$1.js') },
+ { find: /^#tempo\/(parse|format|mutate|duration)$/, replacement: resolve(__dirname, './dist/module/module.$1.js') },
{ find: /^#tempo\/module$/, replacement: resolve(__dirname, './dist/module/module.index.js') },
- { find: /^#tempo\/mutate$/, replacement: resolve(__dirname, './dist/module/module.mutate.js') },
+ { find: /^#tempo\/support$/, replacement: resolve(__dirname, './dist/support/support.index.js') },
{ find: /^#tempo\/scripts\/(.*)\.js$/, replacement: resolve(__dirname, './scripts/$1.js') },
{ find: /^#tempo\/plugin\/plugin\.(.*)\.js$/, replacement: resolve(__dirname, './dist/plugin/plugin.$1.js') },
{ find: /^#tempo\/plugin\/extend\/(.*)\.js$/, replacement: resolve(__dirname, './dist/plugin/extend/$1.js') },
{ find: /^#tempo\/engine\/(.*)\.js$/, replacement: resolve(__dirname, './dist/engine/$1.js') },
{ find: /^#tempo\/module\/(.*)\.js$/, replacement: resolve(__dirname, './dist/module/$1.js') },
{ find: /^#tempo\/plugin\/term\/(.*)\.js$/, replacement: resolve(__dirname, './dist/plugin/term/$1.js') },
- { find: /^#tempo\/support$/, replacement: resolve(__dirname, './dist/support/support.index.js') },
{ find: /^#tempo\/(.*)\.js$/, replacement: resolve(__dirname, './dist/$1.js') },
{ find: /^#tempo$/, replacement: resolve(__dirname, './dist/tempo.index.js') },
{ find: /^#library\/(.*)\.js$/, replacement: resolve(__dirname, '../library/dist/common/$1.js') },
@@ -100,17 +98,15 @@ export default defineConfig({
{ find: /^#tempo\/core$/, replacement: resolve(__dirname, './src/core.index.ts') },
{ find: /^#tempo\/term$/, replacement: resolve(__dirname, './src/plugin/term/term.index.ts') },
{ find: /^#tempo\/term\/(.*)$/, replacement: resolve(__dirname, './src/plugin/term/$1') },
- { find: /^#tempo\/duration$/, replacement: resolve(__dirname, './src/module/module.duration.ts') },
- { find: /^#tempo\/(parse|format)$/, replacement: resolve(__dirname, './src/module/module.$1.ts') },
+ { find: /^#tempo\/(parse|format|mutate|duration)$/, replacement: resolve(__dirname, './src/module/module.$1.ts') },
{ find: /^#tempo\/module$/, replacement: resolve(__dirname, './src/module/module.index.ts') },
- { find: /^#tempo\/mutate$/, replacement: resolve(__dirname, './src/module/module.mutate.ts') },
+ { find: /^#tempo\/support$/, replacement: resolve(__dirname, './src/support/support.index.ts') },
{ find: /^#tempo\/scripts\/(.*)\.js$/, replacement: resolve(__dirname, './scripts/$1.ts') },
{ find: /^#tempo\/plugin\/plugin\.(.*)\.js$/, replacement: resolve(__dirname, './src/plugin/plugin.$1.ts') },
{ find: /^#tempo\/plugin\/extend\/(.*)\.js$/, replacement: resolve(__dirname, './src/plugin/extend/$1.ts') },
{ find: /^#tempo\/engine\/(.*)\.js$/, replacement: resolve(__dirname, './src/engine/$1.ts') },
{ find: /^#tempo\/module\/(.*)\.js$/, replacement: resolve(__dirname, './src/module/$1.ts') },
{ find: /^#tempo\/plugin\/term\/(.*)\.js$/, replacement: resolve(__dirname, './src/plugin/term/$1.ts') },
- { find: /^#tempo\/support$/, replacement: resolve(__dirname, './src/support/support.index.ts') },
{ find: /^#tempo\/(.*)\.js$/, replacement: resolve(__dirname, './src/$1.ts') },
{ find: /^#tempo$/, replacement: resolve(__dirname, './src/tempo.index.ts') },
{ find: /^#library\/(.*)\.js$/, replacement: resolve(__dirname, '../library/src/common/$1.ts') },
diff --git a/vitest.config.ts b/vitest.config.ts
index 8ca9d92c..b0bf6da8 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -1,6 +1,6 @@
-import { defineConfig } from 'vitest/config'
import path, { dirname } from 'node:path'
import { fileURLToPath } from 'node:url'
+import { defineConfig } from 'vitest/config'
import swc from 'unplugin-swc'
const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -61,14 +61,13 @@ export default defineConfig({
alias: [
{ find: /^#library\/(browser|server|common)\/(.*)\.js$/, replacement: path.resolve(__dirname, './packages/library/src/$1/$2.ts') },
{ find: /^#library\/(.*)\.js$/, replacement: path.resolve(__dirname, './packages/library/src/common/$1.ts') },
- { find: /^#tempo\/plugins\/plugin\.util\.js$/, replacement: path.resolve(__dirname, './packages/tempo/src/plugins/plugin.util.ts') },
- { find: /^#tempo\/plugins\/plugin\.type\.js$/, replacement: path.resolve(__dirname, './packages/tempo/src/plugins/plugin.type.ts') },
- { find: /^#tempo\/plugins\/plugin\.(.*)\.js$/, replacement: path.resolve(__dirname, './packages/tempo/src/plugins/extend/plugin.$1.ts') },
+ { find: /^#tempo\/plugin\.(util|type)\.js$/, replacement: path.resolve(__dirname, './packages/tempo/src/plugin/plugin.$1.ts') },
+ { find: /^#tempo\/plugin\.(.*)\.js$/, replacement: path.resolve(__dirname, './packages/tempo/src/plugin/extend/plugin.$1.ts') },
{ find: /^#tempo\/core$/, replacement: path.resolve(__dirname, './packages/tempo/src/core.index.ts') },
- { find: /^#tempo\/(parse|format)$/, replacement: path.resolve(__dirname, './packages/tempo/src/discrete/discrete.$1.ts') },
- { find: /^#tempo\/discrete$/, replacement: path.resolve(__dirname, './packages/tempo/src/discrete/discrete.index.ts') },
- { find: /^#tempo\/tempo\.class\.js$/, replacement: path.resolve(__dirname, './packages/tempo/src/tempo.index.ts') },
+ { find: /^#tempo\/(parse|format|mutate|duration)$/, replacement: path.resolve(__dirname, './packages/tempo/src/module/module.$1.ts') },
{ find: /^#tempo\/support$/, replacement: path.resolve(__dirname, './packages/tempo/src/support/support.index.ts') },
+ { find: /^#tempo\/module$/, replacement: path.resolve(__dirname, './packages/tempo/src/module/module.index.ts') },
+ { find: /^#tempo\/tempo\.class\.js$/, replacement: path.resolve(__dirname, './packages/tempo/src/tempo.index.ts') },
{ find: /^#tempo\/(.*)\.js$/, replacement: path.resolve(__dirname, './packages/tempo/src/$1.ts') },
{ find: /^#tempo\/(.*)$/, replacement: path.resolve(__dirname, './packages/tempo/src/$1.ts') }
]
+ 
+
+