diff --git a/CHANGELOG.md b/CHANGELOG.md
index a32dbe01..3ba36c13 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,15 @@ 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.10.0] - 2026-07-19
+
+### Added
+- **Format Token Modifiers**: Introduced new capabilities for chained formatting modifiers.
+- **Custom Format Tokens**: Completed the Custom Format Tokens implementation, allowing developers to build custom zero-overhead logic evaluators (like native Intl bridges).
+
+### Changed
+- **Documentation Architecture**: Architectural deep-dives (Localized Parsing, Slick Mutations, Custom Tokens) have been extracted from the Cookbook into specialized Core Concepts guides (e.g. `tempo.parse.md`, `tempo.mutate.md`, `tempo.format.md`) to provide a punchier onboarding experience.
+
 ## [3.9.0] - 2026-07-14
 
 ### Added
diff --git a/package.json b/package.json
index 2d91086e..955787b2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "tempo-monorepo",
-  "version": "3.9.3",
+  "version": "3.10.0",
   "private": true,
   "engines": {
     "node": ">=20.0.0"
@@ -22,6 +22,7 @@
     "clean": "node node_modules/typescript-7/bin/tsc -b --clean",
     "version:bump": "node bin/version-bump.mjs",
     "version:sync": "node bin/version-sync.mjs",
+    "catalog:sync": "node packages/plugins/.bin/catalog-sync.mjs",
     "repl": "npm run repl --workspace=@magmacomputing/tempo",
     "repl:plugins": "tsx --import ./packages/plugins/.bin/temporal-polyfill.mts ./packages/plugins/.bin/repl.mts",
     "repl:dist": "npm run repl:dist --workspace=@magmacomputing/tempo",
diff --git a/packages/library/package.json b/packages/library/package.json
index 7a441e35..5cd0e264 100644
--- a/packages/library/package.json
+++ b/packages/library/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@magmacomputing/library",
-  "version": "3.9.3",
+  "version": "3.10.0",
   "description": "Shared utility library for Tempo",
   "author": "Magma Computing Solutions",
   "license": "MIT",
diff --git a/packages/plugins/.bin/README.md b/packages/plugins/.bin/README.md
index cf6ac9df..cd815ea0 100644
--- a/packages/plugins/.bin/README.md
+++ b/packages/plugins/.bin/README.md
@@ -5,6 +5,7 @@ This directory (`packages/plugins/bin/`) contains internal support scripts and u
 It includes:
 - **REPL Environment (`repl.mts`)**: Scripts to initialize an interactive Node.js REPL session with Tempo and Temporal pre-loaded, making it easy to experiment with plugins from the CLI.
 - **Polyfill Setup (`temporal-polyfill.mts`)**: Initialization scripts to ensure the `@js-temporal/polyfill` is correctly loaded into the global scope during testing or REPL sessions, allowing plugins to work with native `Temporal` APIs before they are officially adopted by all runtimes.
+- **Catalog Synchronization (`catalog-sync.mjs`)**: A developer utility that scans all local and external plugin `package.json` files and extracts their metadata into a centralized `catalog.json` file. Run via `npm run catalog:sync`.
 - **TypeScript Configuration (`tsconfig.json`)**: Specific compiler options for running these support scripts directly via tools like `tsx`.
 
 These files are meant for local monorepo development and testing purposes only. They are not published or distributed with any NPM packages.
diff --git a/packages/plugins/.bin/catalog-sync.mjs b/packages/plugins/.bin/catalog-sync.mjs
new file mode 100644
index 00000000..1d624c70
--- /dev/null
+++ b/packages/plugins/.bin/catalog-sync.mjs
@@ -0,0 +1,81 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const catalogPath = path.resolve(__dirname, '../.setup/catalog.json');
+const pluginsDir = path.resolve(__dirname, '../../plugins');
+const nodeModulesDir = path.resolve(__dirname, '../../../node_modules/@magmacomputing');
+
+let catalog = [];
+if (fs.existsSync(catalogPath)) {
+	try {
+		catalog = JSON.parse(fs.readFileSync(catalogPath, 'utf8'));
+	} catch (e) {
+		console.error('Failed to parse catalog.json, starting fresh.', e);
+	}
+}
+
+const catalogMap = new Map();
+catalog.forEach(p => catalogMap.set(p.id, p));
+
+function processPlugin(pluginDir, isExternal) {
+	const pkgPath = path.join(pluginDir, 'package.json');
+	if (!fs.existsSync(pkgPath)) return;
+
+	const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+	// Extract id from directory name, replacing leading dots for VitePress safety
+	let id = path.basename(pluginDir).replace(/^\./, '_');
+	if (isExternal) {
+		id = id.replace('tempo-plugin-', '');
+	}
+
+	// Use the human-readable displayName if we have one, otherwise create a titleized version of the ID
+	const humanName = id.charAt(0).toUpperCase() + id.slice(1) + ' Plugin';
+
+	const entry = catalogMap.get(id) || { id };
+
+	// Update fields from package.json
+	entry.name = entry.name || humanName; // allow manual override of human name
+	entry.description = pkg.description || entry.description || '';
+	entry.packageName = pkg.name;
+	entry.plan = pkg.tempo?.plan || entry.plan || 'community';
+	entry.status = entry.status || 'active';
+	// Note: we do NOT store version here, as build-catalog.mjs injects it dynamically!
+
+	catalogMap.set(id, entry);
+	console.log(`Synced plugin metadata for: ${id} (${isExternal ? 'external' : 'local'})`);
+}
+
+// 1. Process Local Plugins
+if (fs.existsSync(pluginsDir)) {
+	const plugins = fs.readdirSync(pluginsDir);
+	for (const plugin of plugins) {
+		// Skip hidden files/dirs like .setup or .bin unless we want to document them
+		// But we know .setup isn't a plugin, so let's skip it if it doesn't have a package.json
+		const fullPath = path.join(pluginsDir, plugin);
+		if (fs.statSync(fullPath).isDirectory()) {
+			processPlugin(fullPath, false);
+		}
+	}
+}
+
+// 2. Process Node Modules Plugins
+if (fs.existsSync(nodeModulesDir)) {
+	const modules = fs.readdirSync(nodeModulesDir);
+	for (const mod of modules) {
+		if (mod.startsWith('tempo-plugin-')) {
+			const fullPath = path.join(nodeModulesDir, mod);
+			if (fs.statSync(fullPath).isDirectory()) {
+				processPlugin(fullPath, true);
+			}
+		}
+	}
+}
+
+// Write back to catalog.json
+fs.writeFileSync(catalogPath, JSON.stringify(Array.from(catalogMap.values()), null, 2) + '\n');
+console.log(`\nSuccessfully updated ${catalogPath}`);
diff --git a/packages/plugins/.setup/catalog.json b/packages/plugins/.setup/catalog.json
new file mode 100644
index 00000000..3b4938f7
--- /dev/null
+++ b/packages/plugins/.setup/catalog.json
@@ -0,0 +1,50 @@
+[
+  {
+    "id": "astro",
+    "name": "Astro Plugin",
+    "description": "Tempo plugin that calculates precise astronomical seasons (solstices & equinoxes) using the Jean Meeus algorithm — hemisphere-aware, sub-minute accuracy",
+    "packageName": "@magmacomputing/tempo-plugin-astro",
+    "plan": "community",
+    "status": "active"
+  },
+  {
+    "id": "batch",
+    "name": "Batch Plugin",
+    "description": "Tempo community plugin bringing C-level parallelization to massive date arrays via SharedArrayBuffer and Worker Threads.",
+    "packageName": "@magmacomputing/tempo-plugin-batch",
+    "plan": "community",
+    "status": "active"
+  },
+  {
+    "id": "finance",
+    "name": "Finance Plugin",
+    "description": "Tempo Community Plugin: Finance namespace and fiscal year utilities",
+    "packageName": "@magmacomputing/tempo-plugin-finance",
+    "plan": "community",
+    "status": "active"
+  },
+  {
+    "id": "snap",
+    "name": "Snap Plugin",
+    "description": "Snap time to blocks",
+    "packageName": "@magmacomputing/tempo-plugin-snap",
+    "plan": "community",
+    "status": "active"
+  },
+  {
+    "id": "sync",
+    "name": "Sync Plugin",
+    "description": "Tempo community plugin providing lock-free, highly precise cross-thread synchronization via SharedArrayBuffer and Atomics.",
+    "packageName": "@magmacomputing/tempo-plugin-sync",
+    "plan": "community",
+    "status": "active"
+  },
+  {
+    "id": "ticker",
+    "name": "Ticker Plugin",
+    "description": "Tempo plugin that provides a high-performance continuous execution loop (Ticker) based on temporal mathematics.",
+    "packageName": "@magmacomputing/tempo-plugin-ticker",
+    "plan": "pro",
+    "status": "active"
+  }
+]
diff --git a/packages/plugins/.setup/community-plugin-template.md b/packages/plugins/.setup/community-plugin-template.md
index 88659ffb..863e26fe 100644
--- a/packages/plugins/.setup/community-plugin-template.md
+++ b/packages/plugins/.setup/community-plugin-template.md
@@ -8,6 +8,33 @@ Ensure the plugin's `package.json` contains the correct community configuration:
 
 - **Version**: Set to a fresh semantic version (e.g., `"1.0.0"` for the first release).
 - **License**: Must strictly be `"MIT"`.
+- **Type**: Set `"type": "module"`.
+- **Files**: Include the published files array:
+  ```json
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ]
+  ```
+- **PublishConfig**: Configure public npm publishing:
+  ```json
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+  ```
+- **Exports**: Define exports with types and import entrypoints:
+  ```json
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  }
+  ```
 - **Scripts**: 
   - Ensure `"build": "tsup && tsc"` and `"postbuild": "rm -rf dist/src"` are present.
   - Include the prepublish safeguard: `"prepublishOnly": "if [ $(git rev-parse --abbrev-ref HEAD) != main ]; then echo 'ERROR: Must be on main branch to publish.'; exit 1; fi && npm run build"`.
diff --git a/packages/plugins/finance/README.md b/packages/plugins/finance/README.md
index 5a236ed0..e084c42f 100644
--- a/packages/plugins/finance/README.md
+++ b/packages/plugins/finance/README.md
@@ -18,10 +18,10 @@ npm install @magmacomputing/tempo-plugin-finance
 
 ```typescript
 import { Tempo } from '@magmacomputing/tempo';
-import { FinancePlugin } from '@magmacomputing/tempo-plugin-finance';
+import { FinanceNamespace } from '@magmacomputing/tempo-plugin-finance';
 
 // Register the namespace
-Tempo.extend(FinancePlugin);
+Tempo.extend(FinanceNamespace);
 
 const t = new Tempo('2024-07-01');
 
diff --git a/packages/plugins/finance/doc/index.md b/packages/plugins/finance/doc/index.md
index 067a7f14..c1c7f285 100644
--- a/packages/plugins/finance/doc/index.md
+++ b/packages/plugins/finance/doc/index.md
@@ -16,10 +16,10 @@ npm install @magmacomputing/tempo-plugin-finance
 
 ```typescript
 import { Tempo } from '@magmacomputing/tempo';
-import { FinancePlugin } from '@magmacomputing/tempo-plugin-finance';
+import { FinanceNamespace } from '@magmacomputing/tempo-plugin-finance';
 
 // Register the namespace
-Tempo.extend(FinancePlugin);
+Tempo.extend(FinanceNamespace);
 
 const t = new Tempo('2024-07-01');
 
diff --git a/packages/plugins/finance/src/index.ts b/packages/plugins/finance/src/index.ts
index 59906f5d..93da7411 100644
--- a/packages/plugins/finance/src/index.ts
+++ b/packages/plugins/finance/src/index.ts
@@ -15,7 +15,7 @@ export const isFiscalYearStart = (tempo: Tempo) => () => tempo.mm === 1 && tempo
 // Wrap the functions in a Namespace Plugin so they can be injected directly 
 // onto the Tempo instance (e.g., `t.finance.taxYear`) for a fluent experience.
 // -----------------------------------------------------------------------------
-export const FinancePlugin: TempoPlugin = defineNamespace({
+export const FinanceNamespace: TempoPlugin = defineNamespace({
 	name: 'finance',
 	resolvers: {
 		fiscalQuarter,
diff --git a/packages/plugins/finance/test/finance.test.ts b/packages/plugins/finance/test/finance.test.ts
index 7a4686db..0a2f51af 100644
--- a/packages/plugins/finance/test/finance.test.ts
+++ b/packages/plugins/finance/test/finance.test.ts
@@ -1,9 +1,9 @@
 import { Tempo } from '@magmacomputing/tempo';
-import { FinancePlugin } from '../src/index.js';
+import { FinanceNamespace } from '../src/index.js';
 
 describe('Finance Namespace', () => {
 	it('should lazy load the finance properties', () => {
-		Tempo.extend(FinancePlugin);
+		Tempo.extend(FinanceNamespace);
 
 		const t1 = new Tempo('2024-02-15');
 		expect(t1.finance.fiscalQuarter).toBe(1);
diff --git a/packages/plugins/snap/README.md b/packages/plugins/snap/README.md
index f21653a8..52d6d0aa 100644
--- a/packages/plugins/snap/README.md
+++ b/packages/plugins/snap/README.md
@@ -6,7 +6,7 @@
   <a href="https://www.npmjs.com/package/@magmacomputing/tempo-plugin-snap"><img src="https://img.shields.io/npm/v/@magmacomputing/tempo-plugin-snap?style=flat-square" alt="npm version" style="display: inline-block; margin: 0 4px;"></a> <a href="https://www.npmjs.com/package/@magmacomputing/tempo"><img src="https://img.shields.io/npm/dependency-version/@magmacomputing/tempo-plugin-snap/peer/@magmacomputing/tempo?style=flat-square" alt="npm peer dependency version" style="display: inline-block; margin: 0 4px;"></a> <a href="https://www.npmjs.com/package/@magmacomputing/tempo-plugin-snap"><img src="https://img.shields.io/npm/l/@magmacomputing/tempo-plugin-snap?style=flat-square" alt="License" style="display: inline-block; margin: 0 4px;"></a> <a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/TypeScript-Ready-blue?logo=typescript&style=flat-square" alt="TypeScript Ready" style="display: inline-block; margin: 0 4px;"></a> <a href="https://magmacomputing.github.io/magma/doc/9-plugins/snap.index.html"><img src="https://img.shields.io/badge/Docs-VitePress-brightgreen?logo=vitepress&style=flat-square" alt="Documentation" style="display: inline-block; margin: 0 4px;"></a>
 </p>
 
-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.
+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-minute or 1-hour block) for calendar and scheduling applications.
 
 👉 **[View the full documentation on our GitHub Pages](https://magmacomputing.github.io/magma/doc/9-plugins/snap.index.html)**
 
diff --git a/packages/tempo/.vitepress/theme/components/CatalogList.vue b/packages/tempo/.vitepress/theme/components/CatalogList.vue
index 5f519a1e..0016f77c 100644
--- a/packages/tempo/.vitepress/theme/components/CatalogList.vue
+++ b/packages/tempo/.vitepress/theme/components/CatalogList.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref, onMounted, computed } from 'vue';
+import { ref, computed } from 'vue';
 
 interface Plugin {
   id: string;
@@ -12,51 +12,30 @@ interface Plugin {
   version: string;
 }
 
-const plugins = ref<Plugin[]>([])
-const loading = ref(true)
+import catalogData from '../data/catalog.json';
 
-onMounted(async () => {
-  try {
-    const res = await fetch('https://firestore.googleapis.com/v1/projects/tempo-registry/databases/(default)/documents/catalog');
-    const data = await res.json();
-    
-    if (data.documents) {
-      plugins.value = data.documents.map((doc: any) => {
-        const id = doc.name.split('/').pop();
-        const fields = doc.fields;
-        return {
-          id,
-          name: fields.name?.stringValue || '',
-          description: fields.description?.stringValue || '',
-          packageName: fields.packageName?.stringValue || '',
-          price: parseInt(fields.price?.integerValue || '0'),
-          status: fields.status?.stringValue || 'active',
-          plan: fields.plan?.stringValue || 'community',
-          version: fields.release?.mapValue?.fields?.version?.stringValue || '',
-        }
-      })
-    }
-  } catch (e) {
-    console.error('Failed to fetch catalog', e);
-  } finally {
-    loading.value = false;
-  }
-})
+const plugins = ref<Plugin[]>(catalogData as unknown as Plugin[]);
 
 const communityPlugins = computed(() => plugins.value.filter(p => p.plan === 'community' && p.status === 'active'));
 const premiumPlugins = computed(() => plugins.value.filter(p => p.plan !== 'community' && p.status === 'active'));
 const comingSoonPlugins = computed(() => plugins.value.filter(p => p.status === 'coming_soon'));
 
+const copiedPkg = ref<string | null>(null);
+
 const copyInstall = (pkgName: string) => {
   navigator.clipboard.writeText(`npm install ${pkgName}`);
+  copiedPkg.value = pkgName;
+  setTimeout(() => {
+    if (copiedPkg.value === pkgName) {
+      copiedPkg.value = null;
+    }
+  }, 2000);
 }
 </script>
 
 <template>
   <div class="catalog-container">
-    <div v-if="loading" class="loading">Loading catalog...</div>
-    
-    <div v-else>
+    <div>
       <h2 id="community">Community Plugins</h2>
       <p>These plugins are free, open-source extensions that do not require a license token.</p>
       <div class="grid">
@@ -68,9 +47,13 @@ const copyInstall = (pkgName: string) => {
           <p>{{ plugin.description }}</p>
           <div class="actions" style="display: flex; gap: 0.5rem; align-items: center;">
             <code>npm install {{ plugin.packageName }}</code>
-            <button @click="copyInstall(plugin.packageName)" class="btn icon-btn" title="Copy install command">
-              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>
-            </button>
+            <div style="position: relative; display: flex;">
+              <button @click="copyInstall(plugin.packageName)" class="btn icon-btn" title="Copy install command">
+                <svg v-if="copiedPkg === plugin.packageName" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="#10b981" stroke-width="2"><polyline points="20 6 9 17 4 12"></polyline></svg>
+                <svg v-else width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>
+              </button>
+              <span v-if="copiedPkg === plugin.packageName" class="copy-tooltip">Copied!</span>
+            </div>
             <a :href="`../9-plugins/${plugin.id}.index`" class="btn btn-secondary icon-btn" title="View Documentation">
               <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path><polyline points="15 3 21 3 21 9"></polyline><line x1="10" y1="14" x2="21" y2="3"></line></svg>
             </a>
@@ -101,9 +84,13 @@ const copyInstall = (pkgName: string) => {
           <p>{{ plugin.description }}</p>
           <div class="actions" style="display: flex; gap: 0.5rem; align-items: center;">
             <code>npm install {{ plugin.packageName }}</code>
-            <button @click="copyInstall(plugin.packageName)" class="btn icon-btn" title="Copy install command">
-              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>
-            </button>
+            <div style="position: relative; display: flex;">
+              <button @click="copyInstall(plugin.packageName)" class="btn icon-btn" title="Copy install command">
+                <svg v-if="copiedPkg === plugin.packageName" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="#10b981" stroke-width="2"><polyline points="20 6 9 17 4 12"></polyline></svg>
+                <svg v-else width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>
+              </button>
+              <span v-if="copiedPkg === plugin.packageName" class="copy-tooltip">Copied!</span>
+            </div>
             <a :href="`../9-plugins/${plugin.id}.index`" class="btn btn-secondary icon-btn" title="View Documentation">
               <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path><polyline points="15 3 21 3 21 9"></polyline><line x1="10" y1="14" x2="21" y2="3"></line></svg>
             </a>
@@ -238,4 +225,35 @@ const copyInstall = (pkgName: string) => {
   font-size: 1.2rem;
   color: var(--vp-c-text-2);
 }
+.copy-tooltip {
+  position: absolute;
+  bottom: calc(100% + 4px);
+  left: 50%;
+  transform: translateX(-50%);
+  background-color: var(--vp-c-text-1);
+  color: var(--vp-c-bg);
+  padding: 4px 8px;
+  border-radius: 4px;
+  font-size: 0.75rem;
+  font-weight: bold;
+  white-space: nowrap;
+  pointer-events: none;
+  animation: tooltipFadeIn 0.15s ease-out;
+  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+  z-index: 10;
+}
+.copy-tooltip::after {
+  content: '';
+  position: absolute;
+  top: 100%;
+  left: 50%;
+  transform: translateX(-50%);
+  border-width: 4px;
+  border-style: solid;
+  border-color: var(--vp-c-text-1) transparent transparent transparent;
+}
+@keyframes tooltipFadeIn {
+  from { opacity: 0; transform: translateX(-50%) translateY(4px); }
+  to { opacity: 1; transform: translateX(-50%) translateY(0); }
+}
 </style>
diff --git a/packages/tempo/.vitepress/theme/data/catalog.json b/packages/tempo/.vitepress/theme/data/catalog.json
new file mode 100644
index 00000000..b52b08a1
--- /dev/null
+++ b/packages/tempo/.vitepress/theme/data/catalog.json
@@ -0,0 +1,56 @@
+[
+  {
+    "id": "astro",
+    "name": "Astro Plugin",
+    "description": "Tempo plugin that calculates precise astronomical seasons (solstices & equinoxes) using the Jean Meeus algorithm — hemisphere-aware, sub-minute accuracy",
+    "packageName": "@magmacomputing/tempo-plugin-astro",
+    "plan": "community",
+    "status": "active",
+    "version": "2.1.3"
+  },
+  {
+    "id": "batch",
+    "name": "Batch Plugin",
+    "description": "Tempo community plugin bringing C-level parallelization to massive date arrays via SharedArrayBuffer and Worker Threads.",
+    "packageName": "@magmacomputing/tempo-plugin-batch",
+    "plan": "community",
+    "status": "active",
+    "version": "1.0.1"
+  },
+  {
+    "id": "finance",
+    "name": "Finance Plugin",
+    "description": "Tempo Community Plugin: Finance namespace and fiscal year utilities",
+    "packageName": "@magmacomputing/tempo-plugin-finance",
+    "plan": "community",
+    "status": "active",
+    "version": "1.0.1"
+  },
+  {
+    "id": "snap",
+    "name": "Snap Plugin",
+    "description": "Snap time to blocks",
+    "packageName": "@magmacomputing/tempo-plugin-snap",
+    "plan": "community",
+    "status": "active",
+    "version": "1.3.2"
+  },
+  {
+    "id": "sync",
+    "name": "Sync Plugin",
+    "description": "Tempo community plugin providing lock-free, highly precise cross-thread synchronization via SharedArrayBuffer and Atomics.",
+    "packageName": "@magmacomputing/tempo-plugin-sync",
+    "plan": "community",
+    "status": "active",
+    "version": "1.0.2"
+  },
+  {
+    "id": "ticker",
+    "name": "Ticker Plugin",
+    "description": "Tempo plugin that provides a high-performance continuous execution loop (Ticker) based on temporal mathematics.",
+    "packageName": "@magmacomputing/tempo-plugin-ticker",
+    "plan": "pro",
+    "status": "active",
+    "version": "2.2.3"
+  }
+]
diff --git a/packages/tempo/CHANGELOG.md b/packages/tempo/CHANGELOG.md
index 58a142d0..4a2fa792 100644
--- a/packages/tempo/CHANGELOG.md
+++ b/packages/tempo/CHANGELOG.md
@@ -40,7 +40,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Auto-Meridiem Spacing**: Implemented the `:space` modifier for the `{h12}` formatting token (e.g., `{h12:space:dots}`). This enables typographically correct spacing before automatically injected meridiems (e.g., `"10:30 a.m."`).
 
 ### Changed
-- **Documentation Alignment**: Cleaned up `tempo.config.md` to remove deprecated module references, perfectly aligning examples with the `tempo-workspace` ecosystem (`FinancePlugin` and `AstroTerm`).
+- **Documentation Alignment**: Cleaned up `tempo.config.md` to remove deprecated module references, perfectly aligning examples with the `tempo-workspace` ecosystem (`FinanceNamespace` and `AstroTerm`).
 - **Getter Documentation**: Created `tempo.getters.md` as the definitive, educational conceptual guide for utilizing Tempo's zero-cost evaluation getters.
 
 ### Fixed
diff --git a/packages/tempo/bin/build-catalog.mjs b/packages/tempo/bin/build-catalog.mjs
new file mode 100644
index 00000000..2c48c601
--- /dev/null
+++ b/packages/tempo/bin/build-catalog.mjs
@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const sourceCatalogPath = path.resolve(__dirname, '../../../packages/plugins/.setup/catalog.json');
+const targetDir = path.resolve(__dirname, '../.vitepress/theme/data');
+const targetCatalogPath = path.join(targetDir, 'catalog.json');
+
+const pluginsDir = path.resolve(__dirname, '../../../packages/plugins');
+const nodeModulesDir = path.resolve(__dirname, '../../../node_modules');
+
+if (!fs.existsSync(sourceCatalogPath)) {
+	console.error('build-catalog: source catalog.json not found!');
+	process.exit(1);
+}
+
+const catalog = JSON.parse(fs.readFileSync(sourceCatalogPath, 'utf8'));
+
+for (const entry of catalog) {
+	let version = '';
+
+	// 1. Try resolving from local monorepo source (Community Plugins)
+	// Note: Local plugins use the original un-mangled folder name, but our entry.id has leading dots replaced with underscores.
+	// We can just check the dir directly if we kept the original name, but let's just search the dirs.
+	// Actually, wait, community plugins match `entry.id`.
+	const localPkgPath = path.join(pluginsDir, entry.id, 'package.json');
+
+	if (fs.existsSync(localPkgPath)) {
+		const pkg = JSON.parse(fs.readFileSync(localPkgPath, 'utf8'));
+		version = pkg.version;
+	} else {
+		// 2. Try resolving from node_modules (Premium Plugins installed by Dependabot)
+		const externalPkgPath = path.join(nodeModulesDir, entry.packageName, 'package.json');
+		if (fs.existsSync(externalPkgPath)) {
+			const pkg = JSON.parse(fs.readFileSync(externalPkgPath, 'utf8'));
+			version = pkg.version;
+		}
+	}
+
+	if (!version) {
+		console.warn(`build-catalog: Could not resolve installed version for plugin ${entry.id}`);
+	}
+
+	entry.version = version;
+}
+
+if (!fs.existsSync(targetDir)) {
+	fs.mkdirSync(targetDir, { recursive: true });
+}
+
+fs.writeFileSync(targetCatalogPath, JSON.stringify(catalog, null, 2) + '\n');
+console.log(`Successfully generated VitePress catalog JSON with live local versions (${catalog.length} plugins).`);
diff --git a/packages/tempo/doc/1-getting-started/installation.md b/packages/tempo/doc/1-getting-started/installation.md
index 4740415e..8bf64aac 100644
--- a/packages/tempo/doc/1-getting-started/installation.md
+++ b/packages/tempo/doc/1-getting-started/installation.md
@@ -119,7 +119,7 @@ The easiest way to use Tempo natively in the browser is via the pre-optimized ES
 
 ### 2. Smart CDNs (The "Best-of-Both-Worlds")
 
-If you want the absolute easiest setup for **Tempo Premium Plugins** natively in the browser, use an on-the-fly bundling CDN like [esm.sh](https://esm.sh). Smart CDNs act like a Node environment—they read the package resolution rules and resolve nested dependencies automatically, meaning you don't have to map any internal subpaths.
+If you want the absolute easiest setup for **Tempo Plugins** natively in the browser, use an on-the-fly bundling CDN like [esm.sh](https://esm.sh). Smart CDNs act like a Node environment—they read the package resolution rules and resolve nested dependencies automatically, meaning you don't have to map any internal subpaths.
 
 While you *could* import directly from the URL everywhere, the best practice is to use a tiny import map for your top-level packages to keep your application code clean:
 
@@ -141,9 +141,10 @@ While you *could* import directly from the URL everywhere, the best practice is
   // esm.sh handles all the complex internal plugin routing behind the scenes!
   import '@js-temporal/polyfill';
   import { Tempo } from '@magmacomputing/tempo';
-  import { TickerModule } from '@magmacomputing/tempo-plugin-ticker';
+  import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
 
-  Tempo.extend(TickerModule);
+  Tempo.init({ license: 'YOUR_JWT_KEY' });
+  Tempo.extend(TickerPlugin);
 </script>
 ```
 
@@ -164,7 +165,7 @@ While `esm.sh` is fantastic for prototyping and reducing import map complexity,
 
 For production environments where uptime and load speeds are critical, you should use a static file CDN (like jsdelivr). Because static CDNs serve raw files without compiling them on the fly, they are significantly faster and more reliable than Smart CDNs.
 
-To use **Tempo Premium Plugins** via a static CDN, you simply need to explicitly map the unified `plugin-api` subpath so the browser knows how to resolve the internal connections:
+To use **Tempo Plugins** via a static CDN, you simply need to explicitly map the unified `plugin-api` subpath so the browser knows how to resolve the internal connections:
 
 ```html
 <script type="importmap">
diff --git a/packages/tempo/doc/1-getting-started/tempo.cookbook.md b/packages/tempo/doc/1-getting-started/tempo.cookbook.md
index f032b996..9468ae68 100644
--- a/packages/tempo/doc/1-getting-started/tempo.cookbook.md
+++ b/packages/tempo/doc/1-getting-started/tempo.cookbook.md
@@ -75,25 +75,7 @@ new Tempo('2 weeks ago');
 new Tempo('tomorrow afternoon');
 ```
 
-### Localized Parsing Modifiers
-Tempo allows you to localize term modifiers (like `next`, `last`, `this`) by defining them in the `registry.modifiers` configuration. This lets you seamlessly mix localized terms into your relative string parsing and even use them in the `#` shorthand navigation engine!
-
-```typescript
-Tempo.init({
-  locale: 'fr-FR',                // Natively translates months & weekdays
-  registry: {
-    modifiers: {
-      '>': ['prochain', 'suivant'],
-      '<': ['dernier', 'passé'],
-      '=': ['ce', 'cette']
-    }
-  }
-});
-
-new Tempo('next Friday');         // English always works natively
-new Tempo('vendredi prochain');   // Pure French localized string!
-new Tempo('#qtr.dernier');        // Localized shorthand navigation
-```
+👉 **Learn More:** You can seamlessly localize relative phrases (e.g. `next` to `prochain`) by reading the [Internationalized Parsing Guide](../2-core-concepts/tempo.parse.md#internationalized-parsing-locales).
 
 ### Parsing Unix Timestamps
 Tempo handles both milliseconds (Number) and nanoseconds (BigInt).
@@ -131,42 +113,15 @@ const qtrMid = new Tempo().set({ mid: '#quarter' });
 ```
 
 ### Slick Object Mutations
-You can navigate relative to your current date by using Slick Shorthand operators inside `.set()`. Use the snippet shorthand keys (`yy`, `mm`, `ww`, `dd`, `wkd`, etc.) and provide a string payload containing a directional modifier:
+You can navigate relative to your current date by using Slick Shorthand operators directly inside `.set()`. Use the snippet shorthand keys (`yy`, `mm`, `ww`, `dd`, `wkd`, etc.) and provide a string payload containing a directional modifier:
 
 ```typescript
 const t = new Tempo('2024-05-20'); // Monday
-
-// Jump forward two months
-t.set({ mm: '>2' }); // July 20th
-
-// Jump to the next Friday
-t.set({ wkd: '>Fri' }); // May 24th
-
-// Jump to the previous Wednesday
-t.set({ wkd: '<Wed' }); // May 15th
+t.set({ mm: '>2' });               // July 20th
+t.set({ wkd: '>Fri' });            // May 24th
 ```
 
-Because `.set()` processes keys in insertion order, you can now effortlessly combine **absolute assignments** and **Slick shifts** in a single pass to build complex boundaries:
-
-```typescript
-// Jump 2 months forward, find the next Friday, and set the time to 10:30 AM
-const t2 = t.set({ 
-  mm: '>2', 
-  wkd: '>Fri', 
-  hour: 10, 
-  minute: 30 
-});
-```
-
-::: warning ⚠️ ESLint `sort-keys` Warning
-Because mixed object payloads execute strictly in the order they are defined, you must be careful if you use aggressive automated linters (like ESLint's `sort-keys` auto-fixer). If your linter alphabetically re-orders your properties, your math will execute in the wrong order! If your codebase forces alphabetical object keys, stick to chaining: `t.set({ mm: '>2' }).set({ wkd: '>Fri' })`.
-:::
-
-This syntax fully supports advanced shifting (e.g. `<=`, `>=`), double-negations (`>-2`), and localized modifier aliases, providing a clean programmatic interface for date construction.
-
-::: info 💡 Why can't I use Slick modifiers on timezones (`tzd`)?
-Changing a timezone (`tzd` or `timeZone`) does not traverse the timeline—it merely changes the local representation of the exact same absolute moment in time. Because no temporal displacement occurs, applying directional Slick modifiers (like `>`) to a timezone is logically invalid and unsupported.
-:::
+👉 **Learn More:** To read about advanced chaining, order-of-operations, and architectural limitations, see the [Slick Object Mutations Deep Dive](../2-core-concepts/tempo.mutate.md#slick-object-mutations).
 
 ### How long until a deadline? (`until`)
 ```typescript
@@ -244,21 +199,21 @@ Format strings support chained colon-modifiers (e.g., `:upper`, `:locale`, `:ord
 const t = new Tempo('2024-05-15 15:30', { locale: 'fr-FR' });
 
 t.format('{mon:upper}');             // "MAY" (English Default -> UpperCase)
-t.format('{mon:locale}');            // "mai" (Native French Intl output)
-t.format('{mon:locale:upper} {dd}'); // "MAI 15" (Native French Intl output)
+t.format('{mon:long}');              // "mai" (Native French Intl output via styling bridge)
+t.format('{mon:long:upper} {dd}');   // "MAI 15" (Native French Intl output)
 ```
 
 👉 **Learn More:** See the [Smart Formatting Guide](../2-core-concepts/tempo.format.md) for the complete list of available modifiers.
 
 ::: tip
-**Tired of typing `:locale`?**  
-If you find yourself repeatedly writing `:locale` for the same date structure, save it to the global **FORMATS** registry! This creates a clean, reusable shortcut:
+**Tired of typing styling modifiers?**  
+If you find yourself repeatedly writing `:long` or `:short` for the same localized date structure, save it to the global **FORMATS** registry! This creates a clean, reusable shortcut:
 ```typescript
 Tempo.init({
     locale: 'fr-FR',
     registry: {
         formats: {
-            'ui-date': '{wkd:locale}, {dd:raw} {mon:locale} {yyyy}'
+            'ui-date': '{wkd:long}, {dd:raw} {mon:long} {yyyy}'
         }
     }
 });
@@ -266,33 +221,10 @@ Tempo.init({
 t.format('ui-date'); // Resolved with all modifiers intact!
 ```
 
-*Note: Format keys are resolved case-sensitively from the global `registry.formats` object. An error will be thrown if the requested key is not found in the registry.*
+*Note: Format keys are resolved case-sensitively from the global `registry.formats` object. If the requested key is not found, Tempo will simply treat the provided string as a literal layout string rather than throwing an error.*
 :::
 
-### Custom Format Tokens
-Need a completely custom format behavior? You can define dynamic token evaluators in the registry that receive the `zdt` (Temporal.ZonedDateTime) instance and a context object, giving you full native access to `Intl` formatting or custom logic.
-
-```typescript
-Tempo.init({
-    locale: 'fr-FR',
-    registry: {
-        tokens: {
-            // A simple math-based token
-            'myDay': (zdt) => zdt.day - 1,
-            
-            // A deeply localized custom token using native Intl
-            'wkd-fr': (zdt, { config }) => {
-                const dtOptions = config?.intl?.dateTimeFormat ?? {};
-                return zdt.toLocaleString(config?.locale ?? 'en', { ...dtOptions, weekday: 'long' });
-            }
-        }
-    }
-});
-
-const t = new Tempo('2024-05-20');
-t.format('{myDay}');  // "19"
-t.format('{wkd-fr}'); // "lundi"
-```
+👉 **Learn More:** To build custom zero-overhead logic evaluators (like Fiscal Years or native Intl bridges), read the [Custom Format Tokens Deep Dive](../2-core-concepts/tempo.format.md#custom-format-tokens).
 
 👉 **Learn More:** 
 - [Smart Formatting Guide](../2-core-concepts/tempo.format.md)
@@ -301,29 +233,11 @@ t.format('{wkd-fr}'); // "lundi"
 
 ---
 
-::: info
-The examples below use the `using` and `await using` syntax, which require **TypeScript 5.2+** and a runtime that supports **TC39 Explicit Resource Management**.
-:::
-
 ### Ticker Plugin
-The Ticker engine is a premium feature. 
-👉 **Learn More:** [Ticker Plugin Documentation](../../../plugins/ticker/doc/index.md)
-
-
-### Interval-Based Ticker (Recurring Billing)
-Use a `seed` to anchor your ticker to a specific day, then use a month-based interval:
-
-```typescript
-await using billing = Tempo.ticker({ 
-  months: 1, 
-  seed: '2024-01-15' 
-}, (t) => processPayment(t));
-```
-
-### Term-Driven Ticker (Fiscal Quarter Reporting)
-Drive internal reporting cycles precisely when a new quarter begins:
+The Ticker engine is a premium plugin for precisely driving business logic (like recurring billing or reporting cycles) on specific date boundaries.
 
 ```typescript
+// Drive internal reporting precisely when a new quarter begins
 await using quarterly = Tempo.ticker({ '#quarter': 1 });
 
 for await (const t of quarterly) {
@@ -331,6 +245,8 @@ for await (const t of quarterly) {
 }
 ```
 
+👉 **Learn More:** See the [Ticker Plugin Documentation](../../../plugins/ticker/doc/index.md) for detailed configuration, term-driven intervals, and `await using` syntax requirements.
+
 
 ---
 
diff --git a/packages/tempo/doc/2-core-concepts/tempo.config.md b/packages/tempo/doc/2-core-concepts/tempo.config.md
index af27dc52..7a65ccc5 100644
--- a/packages/tempo/doc/2-core-concepts/tempo.config.md
+++ b/packages/tempo/doc/2-core-concepts/tempo.config.md
@@ -27,13 +27,13 @@ This mirrors modern ecosystem standards (like `vite.config.ts` or `tailwind.conf
 ```typescript
 // tempo.config.ts
 import { defineConfig } from '@magmacomputing/tempo';
-import { FinancePlugin } from '@magmacomputing/tempo-plugin-finance';
-import { AstroTerm } from '@magmacomputing/tempo-plugin-astro';
+import { FinanceNamespace } from '@magmacomputing/tempo-plugin-finance';
+import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
 
 export default defineConfig({
   timeZone: 'Australia/Sydney',     // Set your baseline timezone
-  license: 'eyJhbGciOiJIUzI1...',   // JWT Commercial License for Premium Plugins
-  plugins: [FinancePlugin, AstroTerm], // Register plugins
+  license: 'eyJhbGciOiJIUzI1...',   // JWT License Key for Premium Plugins
+  plugins: [FinanceNamespace, TickerPlugin], // Register plugins
   registry: {
     periods: { 
       'market-open': '09:30',
diff --git a/packages/tempo/doc/2-core-concepts/tempo.format.md b/packages/tempo/doc/2-core-concepts/tempo.format.md
index fee703cd..c61391bd 100644
--- a/packages/tempo/doc/2-core-concepts/tempo.format.md
+++ b/packages/tempo/doc/2-core-concepts/tempo.format.md
@@ -131,12 +131,17 @@ You can append modifiers to any token using a colon (`:`) to transform its outpu
 | `:dots` | String | Injects periods (useful for abbreviations) | `{mer:lower:dots}` → `a.m.` |
 | `:space`| String | Injects a leading space (used by `{h12}` auto-meridiem) | `{h12:space:dots}` → `03:30 a.m.` |
 | `:locale` | String | Resolves term via localization dictionary | `{mon:locale}` → `octobre` |
+| `:short` | String | Yields a short or abbreviated style | `{mon:short}` → `Oct` |
+| `:long` | String | Yields a full-length style | `{mon:long}` → `October` |
 | `:yy` | Compound Date | Truncates the internal year component to 2 digits | `{dmy:yy}` → `241026` |
-| `:z` | `{tz}` | Narrow timezone offset | `{tz:z}` → `+10` |
-| `:zz` | `{tz}` | Short timezone offset | `{tz:zz}` → `+10:00` |
-| `:zzz` | `{tz}` | Techie timezone offset | `{tz:zzz}` → `+1000` |
-| `:zzzz` | `{tz}` | Short localized timezone name (fallback: ID) | `{tz:zzzz}` → `AEST` |
-| `:zzzzz` | `{tz}` | Long localized timezone name (fallback: ID) | `{tz:zzzzz}` → `Australian Eastern Standard Time` |
+| `:offset` | `{tz}` | Full numeric timezone offset | `{tz:offset}` → `+10:00` |
+| `:offsetShort` | `{tz}` | Narrow numeric timezone offset | `{tz:offsetShort}` → `+10` |
+| `:offsetCompact` | `{tz}` | Compact numeric timezone offset | `{tz:offsetCompact}` → `+1000` |
+
+> [!TIP]
+> **Implicit Localization Bridge**
+> The `:short` and `:long` styling modifiers act as an automatic bridge to the browser's native `Intl` API! 
+> By default, core tokens like `{mon}` or `{wkd}` run at zero-cost using Tempo's lightning-fast internal enums (yielding English results). If you want a localized string, you don't need to explicitly chain the `:locale` modifier. Simply using a styling modifier like `{mon:long}` will automatically translate the string using the instance's configured locale!
 
 ### 🔄 Automatic Meridiem
 If your format string contains `{h12}` (12-hour clock) but lacks a `{mer}` token, Tempo will automatically append a `{mer}` token with the same modifiers as the `{h12}` token after the last time component to ensure the time remains unambiguous.
@@ -246,3 +251,34 @@ const japaneseConfig = {
 console.log(t.format(japaneseConfig));
 // Output: "令和6年12月25日"
 ```
+
+---
+
+## 🛠️ Custom Format Tokens
+Need a completely custom format behavior? You can define dynamic token evaluators in the global registry that receive the `zdt` (`Temporal.ZonedDateTime`) instance and a context object, giving you full native access to `Intl` formatting or custom logic.
+
+> [!NOTE]
+> **Why native `ZonedDateTime` instead of a `Tempo` instance?**
+> The formatting engine is highly modular and designed to be tree-shakable via the standalone `format()` utility. By injecting native Temporal objects, custom tokens remain extremely fast, portable, and zero-overhead. If you absolutely need access to Tempo's syntactic sugar inside your token evaluator, you can simply re-wrap the object on the fly: `const t = new Tempo(zdt);`
+
+```typescript
+Tempo.init({
+    locale: 'fr-FR',
+    registry: {
+        tokens: {
+            // A simple math-based token
+            'myDay': (zdt) => String(zdt.day - 1),
+            
+            // A deeply localized custom token using native Intl
+            'wkd-fr': (zdt, { config }) => {
+                const dtOptions = config?.intl?.dateTimeFormat ?? {};
+                return zdt.toLocaleString(config?.locale ?? 'en', { ...dtOptions, weekday: 'long' });
+            }
+        }
+    }
+});
+
+const t = new Tempo('2024-05-20');
+t.format('{myDay}');  // "19"
+t.format('{wkd-fr}'); // "lundi"
+```
diff --git a/packages/tempo/doc/2-core-concepts/tempo.mutate.md b/packages/tempo/doc/2-core-concepts/tempo.mutate.md
index b88c4e4a..aa7d45c1 100644
--- a/packages/tempo/doc/2-core-concepts/tempo.mutate.md
+++ b/packages/tempo/doc/2-core-concepts/tempo.mutate.md
@@ -50,6 +50,40 @@ t.set('start.month');         // Start of the current month
 t.set('end.year');            // End of the current year
 ```
 
+### Slick Object Mutations
+
+You can also navigate relative to your current date by using Slick Shorthand operators directly inside the `.set()` object payload. Use the snippet shorthand keys (`yy`, `mm`, `ww`, `dd`, `wkd`, etc.) and provide a string payload containing a directional modifier:
+
+```typescript
+const t = new Tempo('2024-05-20'); // Monday
+
+// Jump forward two months
+t.set({ mm: '>2' }); // July 20th
+
+// Jump to the next Friday
+t.set({ wkd: '>Fri' }); // May 24th
+```
+
+Because `.set()` processes keys in insertion order, you can now effortlessly combine **absolute assignments** and **Slick shifts** in a single pass to build complex boundaries:
+
+```typescript
+// Jump 2 months forward, find the next Friday, and set the time to 10:30 AM
+const t2 = t.set({ 
+  mm: '>2', 
+  wkd: '>Fri', 
+  hour: 10, 
+  minute: 30 
+});
+```
+
+::: warning ⚠️ ESLint `sort-keys` Warning
+Because mixed object payloads execute strictly in the order they are defined, you must be careful if you use aggressive automated linters (like ESLint's `sort-keys` auto-fixer). If your linter alphabetically re-orders your properties, your math will execute in the wrong order! If your codebase forces alphabetical object keys, stick to chaining: `t.set({ mm: '>2' }).set({ wkd: '>Fri' })`.
+:::
+
+::: info 💡 Why can't I use Slick modifiers on timezones (`tzd`)?
+Changing a timezone (`tzd` or `timeZone`) does not traverse the timeline—it merely changes the local representation of the exact same absolute moment in time. Because no temporal displacement occurs, applying directional Slick modifiers (like `>`) to a timezone is logically invalid and unsupported.
+:::
+
 ## Chainability
 
 Because all mutations return a new instance, you can safely chain `.add()` and `.set()` methods together to perform complex temporal logic in a single, readable line.
diff --git a/packages/tempo/doc/2-core-concepts/tempo.parse.md b/packages/tempo/doc/2-core-concepts/tempo.parse.md
index 36d5d3c9..713288b4 100644
--- a/packages/tempo/doc/2-core-concepts/tempo.parse.md
+++ b/packages/tempo/doc/2-core-concepts/tempo.parse.md
@@ -195,6 +195,26 @@ While `Intl` provides a robust foundation for month and weekday translations, th
 
 To bridge these gaps, you can register **Custom Aliases** (see below) or define custom localized keywords in `registry.modifiers`.
 
+### Localized Parsing Modifiers
+Tempo allows you to localize term modifiers (like `next`, `last`, `this`) by defining them in the `registry.modifiers` configuration. This lets you seamlessly mix localized terms into your relative string parsing and even use them in the `#` shorthand navigation engine!
+
+```typescript
+Tempo.init({
+  locale: 'fr-FR',                // Natively translates months & weekdays
+  registry: {
+    modifiers: {
+      '>': ['prochain', 'suivant'],
+      '<': ['dernier', 'passé'],
+      '=': ['ce', 'cette']
+    }
+  }
+});
+
+new Tempo('next Friday');         // English always works natively
+new Tempo('vendredi prochain');   // Pure French localized string!
+new Tempo('#qtr.dernier');        // Localized shorthand navigation
+```
+
 ### Custom Aliases (Events & Periods)
 You can teach the parser new words or entire foreign phrases to bridge translation gaps:
 
diff --git a/packages/tempo/doc/3-extending-tempo/tempo.namespace.md b/packages/tempo/doc/3-extending-tempo/tempo.namespace.md
index 954ef51a..fb4dde5c 100644
--- a/packages/tempo/doc/3-extending-tempo/tempo.namespace.md
+++ b/packages/tempo/doc/3-extending-tempo/tempo.namespace.md
@@ -18,7 +18,7 @@ Let's build a `finance` plugin. We want to add a `.finance` namespace that provi
 import { defineNamespace } from '@magmacomputing/tempo/plugin-api';
 import type { Tempo } from '@magmacomputing/tempo/core';
 
-export const FinancePlugin = defineNamespace({
+export const FinanceNamespace = defineNamespace({
   // 1. Define the property name where this namespace will live on the Tempo instance
   name: 'finance',
   
@@ -77,7 +77,7 @@ Just like standard plugins, you must inform TypeScript about your new namespace
 // finance.ts
 import { defineNamespace } from '@magmacomputing/tempo/plugin-api';
 
-// ... (FinancePlugin implementation) ...
+// ... (FinanceNamespace implementation) ...
 
 declare module '@magmacomputing/tempo/core' {
   interface Tempo {
@@ -96,10 +96,10 @@ Developers can now import your plugin, register it once, and enjoy your clean, i
 
 ```typescript
 import { Tempo } from '@magmacomputing/tempo/core';
-import { FinancePlugin } from './finance.js';
+import { FinanceNamespace } from './finance.js';
 
-// Register the namespace
-Tempo.extend(FinancePlugin);
+// Extend the core Tempo engine
+Tempo.extend(FinanceNamespace);
 
 const t = new Tempo('2024-07-01');
 
@@ -134,7 +134,7 @@ export function isFiscalYearStart(t: Tempo, startMonth: number = 1): boolean {
 export function nextTaxYear(t: Tempo): Tempo { ... }
 
 // 2. The Namespace Wrapper (The OOP layer)
-export const FinancePlugin = defineNamespace({
+export const FinanceNamespace = defineNamespace({
     name: 'finance',
     resolvers: {
         // We simply wrap our pure functions and inject the 'tempo' context!
diff --git a/packages/tempo/doc/3-extending-tempo/tempo.plugin.md b/packages/tempo/doc/3-extending-tempo/tempo.plugin.md
index bbd8759b..89d7fcfa 100644
--- a/packages/tempo/doc/3-extending-tempo/tempo.plugin.md
+++ b/packages/tempo/doc/3-extending-tempo/tempo.plugin.md
@@ -8,6 +8,14 @@ In the Tempo ecosystem, a **Plugin** is the universal overarching term for any f
 2. **`defineTerm`**: A specialized factory exclusively for defining temporal vocabulary constraints (a "Term" is technically just a highly-opinionated "Plugin" focused on date ranges and schedules).
 3. **`defineNamespace`**: A factory for creating lazily-evaluated property landing pads (e.g., `Tempo().finance.taxYear`).
 
+## Naming Convention Standard
+To provide a consistent and intuitive developer experience, the exported symbol of your plugin should use a suffix that directly matches the factory used to construct it. This makes it instantly obvious to consumers how the extension will attach to the Tempo core:
+- Built with `definePlugin` ➡️ **`[Name]Plugin`** (e.g., `TickerPlugin`)
+- Built with `defineTerm` ➡️ **`[Name]Term`** (e.g., `AstroTerm`)
+- Built with `defineNamespace` ➡️ **`[Name]Namespace`** (e.g., `FinanceNamespace`)
+
+*(Note: The `Module` suffix and `defineModule` factory are strictly reserved for Tempo's core internal injection APIs like `ParseModule` and should not be used by external plugins.)*
+
 To manually register a plugin, use the static `extend` method. This is typically used for "opt-in" features or when you need to provide specific configuration to a plugin factory.
 
 ```typescript
@@ -70,7 +78,7 @@ declare module '@magmacomputing/tempo/core' {
 Modern Tempo plugins are designed to be "plug-and-play." By using the `definePlugin` factory, a plugin registers itself with the global Tempo registry as soon as it's imported.
 
 ::: warning
-**Premium Plugin Example**: The example below uses the `@magmacomputing/tempo-plugin-ticker` plugin, which is a commercial plugin. You must provide a valid `license` key during initialization to activate it.
+**Premium Plugin Example**: The example below uses the `@magmacomputing/tempo-plugin-ticker` plugin, which is a premium plugin. You must provide a valid `license` key during initialization to activate it.
 
 <div style="display: flex; align-items: center; gap: 16px; margin: 16px 0;">
   <a href="https://registry.magmacomputing.com.au" target="_blank" rel="noopener noreferrer" style="display: flex; flex-shrink: 0;">
@@ -158,10 +166,10 @@ If your plugin requires its own configuration, export a **factory function** tha
 
 ```typescript
 // tempo-plugin-holiday/index.ts
-import { defineModule } from '@magmacomputing/tempo/plugin-api';
+import { definePlugin } from '@magmacomputing/tempo/plugin-api';
 
 export const HolidayPlugin = (pluginOptions = {}) => {
-  return defineModule((TempoClass, tempoOptions, factory) => {
+  return definePlugin((TempoClass, tempoOptions, factory) => {
     // ... use pluginOptions here ...
   });
 };
@@ -172,24 +180,24 @@ If your plugin provides multiple related components, wrap them in an aggregator
 
 ```typescript
 // index.ts
-import { defineModule } from '@magmacomputing/tempo/plugin-api';
+import { definePlugin } from '@magmacomputing/tempo/plugin-api';
 import { PluginA } from './plugin.a.js';
 import { PluginB } from './plugin.b.js';
 
-export const MyFeaturePlugin = defineModule((TempoClass, options) => {
+export const MyFeaturePlugin = definePlugin((TempoClass, options) => {
   TempoClass.extend([PluginA, PluginB]);
 });
 ```
 
-### Commercial & Premium Plugins
+### Premium Plugins
 
-If you have built a powerful plugin and wish to distribute it commercially, you do not need to implement your own licensing engine. Build your plugin using the standard `definePlugin` wrappers.
+If you wish to distribute a Premium Plugin, you do not need to implement your own licensing engine. Build your plugin using the standard `definePlugin` wrappers.
 
 Once your plugin is ready for the marketplace, **[Contact Magma Computing Solutions](https://github.com/magmacomputing)**. We can inject our proprietary licensing and cryptographic verification engine directly into your build pipeline, ensuring your plugin is securely gated and protected from unauthorized use.
 
 ### Safely Loading Premium Plugins
 
-When using a commercially licensed premium plugin, the cryptographic verification of your license key happens securely in the background. Because of this, you should always wait for the validation engine to settle before executing premium features, especially during application boot.
+When using a licensed premium plugin, the cryptographic verification of your license key happens securely in the background. Because of this, you should always wait for the validation engine to settle before executing premium features, especially during application boot.
 
 Use `Tempo.ready()` to safely wait for the cryptographic engine:
 
diff --git a/packages/tempo/doc/8-project-and-support/commercial.md b/packages/tempo/doc/8-project-and-support/commercial.md
index a0343abe..3c2c6aa1 100644
--- a/packages/tempo/doc/8-project-and-support/commercial.md
+++ b/packages/tempo/doc/8-project-and-support/commercial.md
@@ -33,7 +33,7 @@ For mission-critical applications, we provide priority support, security auditin
 
 ## 💎 Premium Extensions
 
-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.
+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 cryptographic License Key. These extensions provide advanced, proprietary logic for enterprise-scale requirements.
 
 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/8-project-and-support/migration-guide.md b/packages/tempo/doc/8-project-and-support/migration-guide.md
index 7615b232..898fc25d 100644
--- a/packages/tempo/doc/8-project-and-support/migration-guide.md
+++ b/packages/tempo/doc/8-project-and-support/migration-guide.md
@@ -4,7 +4,7 @@ Tempo v3.x finalizes the plugin ecosystem by extracting advanced features into s
 
 ## 🔁 Migrating from version 2.x to 3.0.0 (Ticker Extraction)
 
-The `TickerModule` has been extracted from the core open-source repository into a standalone premium plugin.
+The `TickerPlugin` has been extracted from the core open-source repository into a standalone premium plugin.
 
 **Action Required**:
 1. If you use `Tempo.ticker()`, you must now install `@magmacomputing/tempo-plugin-ticker` alongside `@magmacomputing/tempo`.
@@ -21,10 +21,10 @@ The `TickerModule` has been extracted from the core open-source repository into
 3. Import and register the plugin in your application initialization:
    ```javascript
    import { Tempo } from '@magmacomputing/tempo';
-   import { TickerModule } from '@magmacomputing/tempo-plugin-ticker';
+   import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
 
    Tempo.init({ license: 'YOUR_JWT_KEY' });
-   Tempo.extend(TickerModule);
+   Tempo.extend(TickerPlugin);
    ```
 
 # ⚠️ Migrating to Tempo v2.x
diff --git a/packages/tempo/doc/8-project-and-support/releases/v3.x.md b/packages/tempo/doc/8-project-and-support/releases/v3.x.md
index a70214ee..a5727034 100644
--- a/packages/tempo/doc/8-project-and-support/releases/v3.x.md
+++ b/packages/tempo/doc/8-project-and-support/releases/v3.x.md
@@ -1,5 +1,17 @@
 # 📜 Version 3.x History
 
+## [v3.10.0] - 2026-07-19
+
+### ✨ What's New
+
+**Format Token Modifiers & Custom Tokens**
+Introduced new capabilities for chained formatting modifiers and finalized the complete architecture for Custom Format Tokens. Developers can now register custom zero-overhead logic evaluators (like Fiscal Years or native `Intl` bridges) that seamlessly hook into the `t.format()` engine.
+
+### 📚 Documentation Enhancements
+- **Cookbook Refactoring**: Trimmed architectural "bloat" from the Cookbook (including Localized Parsing, Slick Mutations, and Custom Tokens). This content has been moved into dedicated Core Concepts guides (`tempo.parse.md`, `tempo.mutate.md`, `tempo.format.md`) to provide a much punchier, fast-paced onboarding experience for new users, while keeping deep-dive details just one click away.
+
+---
+
 ## [v3.9.0] - 2026-07-14
 
 ### ✨ What's New
@@ -12,7 +24,7 @@ Expanded the `{h12}` token modifiers with a new `:space` option. When chaining m
 
 ### 📚 Documentation Enhancements
 - **Educational Guides**: Created a brand new `tempo.getters.md` document in the Core Concepts section, serving as the definitive guide to Tempo's zero-cost lazy-evaluation properties.
-- **Ecosystem Alignment**: Updated `tempo.config.md` to remove deprecated plugin references, replacing them with accurate examples from the current `tempo-workspace` (`FinancePlugin` and `AstroTerm`).
+- **Ecosystem Alignment**: Updated `tempo.config.md` to remove deprecated plugin references, replacing them with accurate examples from the current `tempo-workspace` (`FinanceNamespace` and `AstroTerm`).
 
 ### 🪲 Bug Fixes & Stability
 - **Core Typings**: Resolved `any` leakage in `Tempo` core methods by injecting strict overloads for `until()` and `since()` directly into `tempo.class.ts`, ensuring full IDE type-inference flows through to `.format()`.
@@ -299,7 +311,7 @@ This mirrors how `next Friday` works: from any non-Friday you get the very next
     - `relativeTime` shorthand has been removed; use `intl.relativeTime` instead.
     - `term` shorthand has been removed; use `terms` instead.
 - **Strict Parsing Mode**: The parser now enforces a stricter `guard` check by default, reducing the likelihood of "false positive" matches on ambiguous strings.
-- **Ticker Module Extraction**: To lighten the core bundle, the `TickerModule` has been extracted into its own standalone premium plugin (`@magmacomputing/tempo-plugin-ticker`). It is protected by a License Key via the Tempo Registry.
+- **Ticker Module Extraction**: To lighten the core bundle, the `TickerPlugin` has been extracted into its own standalone premium plugin (`@magmacomputing/tempo-plugin-ticker`). It is protected by a License Key via the Tempo Registry.
 
 ### ✨ What's New
 - **Formatting Module Additions**: Added new compact date tokens (`{dmy}`, `{mdy}`, `{ymd}`) for generating 8-digit compact date strings (e.g. `24102026`). `{hhmiss}` has been renamed to `{hms}` for consistency.
@@ -321,14 +333,16 @@ If you are upgrading from v2.x and your application relies on `Tempo.ticker()`,
 3. **Register the Plugin**: Wire the key into your application and extend Tempo:
     ```javascript
     import { Tempo } from '@magmacomputing/tempo';
-    import { TickerModule } from '@magmacomputing/tempo-plugin-ticker';
-
+    import { TickerPlugin } from '@magmacomputing/tempo-plugin-ticker';
+    
+    // Wire your license key
     Tempo.init({ license: 'YOUR_JWT_KEY' });
-    Tempo.extend(TickerModule);
+    
+    // Register the extracted plugin
+    Tempo.extend(TickerPlugin);
     ```
 
 ### 🏗️ Internal Refactoring
 - **Zero-Fallback Initialization**: Cleaned up the `Tempo.init()` bootstrap logic to remove legacy compatibility layers, resulting in a cleaner internal state and reduced bundle size.
 - **Build Pipelines**: Fully synchronized build pipelines and TS declarations to ensure `vitest` and `tsc` operate seamlessly across local and premium workspaces.
-- **ISO Getter Precision**: Upgraded the `.iso` property getter from native `Date.toISOString()` to Temporal's `Instant.toString()`. This provides full ISO 8601 nanosecond precision and conforms to RFC 3339 by gracefully omitting fractional seconds when they evaluate to exactly zero.
 
diff --git a/packages/tempo/package.json b/packages/tempo/package.json
index 4a08ad19..1250171e 100644
--- a/packages/tempo/package.json
+++ b/packages/tempo/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@magmacomputing/tempo",
-  "version": "3.9.3",
+  "version": "3.10.0",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -210,8 +210,8 @@
     "clean": "magma-cli rm dist && (node ../../node_modules/typescript-7/bin/tsc -b --clean || true)",
     "prepublishOnly": "if [ $(git rev-parse --abbrev-ref HEAD) != main ]; then echo 'ERROR: Must be on main branch to publish.'; exit 1; fi && if [ -z \"$TEMPO_LICENSE_PATH\" ] || [ ! -f \"$TEMPO_LICENSE_PATH\" ]; then echo '🚨 ERROR: TEMPO_LICENSE_PATH is missing or invalid. Cannot publish Premium build.'; exit 1; fi && npm run build",
     "docs:api": "typedoc",
-    "docs:dev": "npm run build && npm run docs:api && node bin/harvest-plugins.mjs && vitepress dev",
-    "docs:build": "npm run build && npm run docs:api && node bin/harvest-plugins.mjs && vitepress build",
+    "docs:dev": "npm run build && npm run docs:api && node bin/build-catalog.mjs && node bin/harvest-plugins.mjs && vitepress dev",
+    "docs:build": "npm run build && npm run docs:api && node bin/build-catalog.mjs && node bin/harvest-plugins.mjs && vitepress build",
     "docs:preview": "vitepress preview",
     "docs:push": "bash ./bin/push-docs.sh"
   },
diff --git a/packages/tempo/src/module/module.format.ts b/packages/tempo/src/module/module.format.ts
index 66ba7dd8..49669712 100644
--- a/packages/tempo/src/module/module.format.ts
+++ b/packages/tempo/src/module/module.format.ts
@@ -361,6 +361,38 @@ export function format(obj?: any, fmt?: any, options?: any): any {
 					}
 					break;
 				}
+				case 'short':
+				case 'long':
+				case 'shortoffset':
+				case 'longoffset':
+				case 'shortgeneric':
+				case 'longgeneric': {
+					const modKey = mod.toLowerCase();
+					if (token === 'tz') {
+						const styleMap: Record<string, any> = { short: 'short', long: 'long', shortoffset: 'shortOffset', longoffset: 'longOffset', shortgeneric: 'shortGeneric', longgeneric: 'longGeneric' };
+						const parts = getDTF(config?.locale, { ...dtOptions, timeZone: zdt.timeZoneId, timeZoneName: styleMap[modKey] }).formatToParts(zdt.epochMilliseconds);
+						res = parts.find(p => p.type === 'timeZoneName')?.value ?? zdt.timeZoneId;
+					} else if (token === 'mon' || token === 'mmm') {
+						if (modKey === 'short' || modKey === 'long') res = getDTF(config?.locale, { ...dtOptions, timeZone: zdt.timeZoneId, calendar: zdt.calendarId, month: modKey }).format(zdt.epochMilliseconds);
+					} else if (token === 'wkd' || token === 'www') {
+						if (modKey === 'short' || modKey === 'long') res = getDTF(config?.locale, { ...dtOptions, timeZone: zdt.timeZoneId, calendar: zdt.calendarId, weekday: modKey }).format(zdt.epochMilliseconds);
+					} else if (token === 'era') {
+						if (modKey === 'short' || modKey === 'long') {
+							const parts = getDTF(config?.locale, { ...dtOptions, timeZone: zdt.timeZoneId, calendar: zdt.calendarId, era: modKey }).formatToParts(zdt.epochMilliseconds);
+							res = parts.find(p => p.type === 'era')?.value ?? res;
+						}
+					}
+					break;
+				}
+				case 'offset':
+					if (token === 'tz') res = zdt.offset;
+					break;
+				case 'offsetshort':
+					if (token === 'tz') res = zdt.offset.endsWith(':00') ? zdt.offset.slice(0, -3) : zdt.offset;
+					break;
+				case 'offsetcompact':
+					if (token === 'tz') res = zdt.offset.replace(':', '');
+					break;
 				case 'z':
 					if (token === 'tz') res = zdt.offset.endsWith(':00') ? zdt.offset.slice(0, -3) : zdt.offset;
 					break;
diff --git a/packages/tempo/src/support/support.init.ts b/packages/tempo/src/support/support.init.ts
index e7d6cb9d..34d4d841 100644
--- a/packages/tempo/src/support/support.init.ts
+++ b/packages/tempo/src/support/support.init.ts
@@ -252,6 +252,10 @@ export function extendState(state: t.Internal.State, options: t.Options): boolea
 
 						setProperty(state.config.registry, 'modifiers', merged);
 					}
+					if (arg.value.tokens) {
+						const existing = state.config.registry.tokens ?? {};
+						setProperty(state.config.registry, 'tokens', { ...existing, ...arg.value.tokens });
+					}
 
 					const parseMap: Record<string, 'snippet' | 'layout' | 'event' | 'period' | 'ignore'> = {
 						snippets: 'snippet',
diff --git a/packages/tempo/src/tempo.version.ts b/packages/tempo/src/tempo.version.ts
index 61466281..ed002595 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.3';
+export const TEMPO_VERSION = '3.10.0';
diff --git a/packages/tempo/test/discrete/format.test.ts b/packages/tempo/test/discrete/format.test.ts
index 6a5154a6..57065172 100644
--- a/packages/tempo/test/discrete/format.test.ts
+++ b/packages/tempo/test/discrete/format.test.ts
@@ -152,6 +152,25 @@ describe('Tempo.format() refinements', () => {
       expect(t.format('{#timeOfDay:locale}')).toBe('Milieu de la matinée');
     })
   })
+
+  describe('styling-modifiers', () => {
+    const t = new Tempo('2024-05-20T10:00:00[America/New_York]', { locale: 'fr-FR' });
+
+    it('should implicitly localize natively formatted tokens', () => {
+      expect(t.format('{mon:short}')).toBe('mai'); // fr-FR short month
+      expect(t.format('{mon:long}')).toBe('mai');  // fr-FR long month
+      expect(t.format('{mon:long}')).toBe(t.format('{mon:locale}')); // Proves redundancy
+      expect(t.format('{wkd:long}')).toBe('lundi'); // fr-FR long weekday
+      expect(t.format('{wkd:long}')).toBe(t.format('{wkd:locale}'));
+    })
+
+    it('should resolve timezone styling correctly', () => {
+      expect(t.format('{tz:short}')).toBe('UTC−4'); 
+      expect(t.format('{tz:long}')).toBe('heure d’été de l’Est nord-américain'); 
+      expect(t.format('{tz:offset}')).toBe('-04:00');
+      expect(t.format('{tz:offsetcompact}')).toBe('-0400');
+    })
+  })
   
   describe('era-formatting', () => {
     it('supports the {era} token with BCE dates', () => {
@@ -164,4 +183,20 @@ describe('Tempo.format() refinements', () => {
       expect(ce.format('{era}')).toMatch(/AD|CE/i);
     })
   })
+  
+  describe('custom-format-tokens', () => {
+    it('supports registering and evaluating custom tokens via configuration', () => {
+      const t = new Tempo('2024-05-20', {
+        registry: {
+          tokens: {
+            myCustomDay: (zdt: any) => String(zdt.day + 100)
+          }
+        }
+      });
+      expect(t.format('{myCustomDay}' as any)).toBe('120');
+      
+      // Fallback behavior for non-existent custom tokens
+      expect(t.format('{nonExistent}' as any)).toBe('{nonExistent}');
+    })
+  })
 })