@nextera.one/tps-standard 0.5.33 → 0.6.0

package/src/index.ts

@@ -2,10 +2,18 @@
  * TPS: Temporal Positioning System
  * The Universal Protocol for Space-Time Coordinates.
  * @packageDocumentation
- * @version 0.5.2
+ * @version 0.6.0
  * @license Apache-2.0
  * @copyright 2026 TPS Standards Working Group
  *
+ * v0.5.35 Changes:
+ * - Added TPS.now(), TPS.diff(), TPS.add() convenience methods
+ * - Added Chinese Lunisolar (chin) calendar driver
+ * - Added DriverManager (driver registry separated from TPS class)
+ * - Added timezone utility (src/utils/timezone.ts) with IANA + offset support
+ * - TPS.toDate() now respects ;tz= extensions when present
+ * - ESM dual-mode exports + browser IIFE bundle
+ *
  * v0.5.0 Changes:
  * - Added Actor anchor (A:) for provenance tracking
  * - Added Signature (!) for cryptographic verification
@@ -22,278 +30,36 @@ import { PersianDriver } from "./drivers/persian";
 import { HijriDriver } from "./drivers/hijri";
 import { JulianDriver } from "./drivers/julian";
 import { HoloceneDriver } from "./drivers/holocene";
-
-// Calendar codes are plain strings to allow arbitrary user-defined
-// calendars.  The library still exports constants for the built-in values but
-// callers may also supply their own codes.
-export const DefaultCalendars = {
-  TPS: "tps",
-  GREG: "greg",
-  HIJ: "hij",
-  PER: "per",
-  JUL: "jul",
-  HOLO: "holo",
-  UNIX: "unix",
-} as const;
-
-/**
- * Specifies the direction of the time-component hierarchy when serializing or
- * deserializing a TPS string.  The default is `'descending'` (millennium → … →
- * second), but `'ascending'` produces the reverse order.
- */
-export enum TimeOrder {
-  DESC = "desc",
-  ASC = "asc",
-}
-
-export interface TPSComponents {
-  // --- TEMPORAL ---
-  calendar: string;
-  // --- REQUIRED TEMPORAL FIELDS ---
-  // All of the traditional Gregorian components are now mandatory.  This
-  // reflects the fact that a valid TPS time object must contain a complete
-  // timestamp when using the canonical calendar formats.
-  millennium: number;
-  century: number;
-  year: number;
-  month: number;
-  day: number;
-  hour: number;
-  minute: number;
-  second: number;
-  /** Sub-second precision (0–999).  Encoded as the last `m` token. */
-  millisecond: number;
-  // --- OPTIONAL UNIX BACKUP ---
-  // `unixSeconds` remains optional to support the Unix driver and other
-  // cases where a simple epoch value is preferred.
-  unixSeconds?: number;
-
-  // --- SPATIAL: GPS Coordinates ---
-  latitude?: number;
-  longitude?: number;
-  altitude?: number;
-
-  // --- SPATIAL: Geospatial Cells ---
-  /** Google S2 cell ID (hierarchical, prefix-searchable) */
-  s2Cell?: string;
-  /** Uber H3 cell ID (hexagonal grid) */
-  h3Cell?: string;
-  /** Open Location Code / Plus Code */
-  plusCode?: string;
-  /** what3words address (e.g. "filled.count.soap") */
-  what3words?: string;
-
-  // --- SPATIAL: Structural Anchors ---
-  /** Physical building identifier */
-  building?: string;
-  /** Vertical division (level) */
-  floor?: string;
-  /** Enclosed space identifier */
-  room?: string;
-  /** Logical area within building */
-  zone?: string;
-
-  /** Raw pre-@ space anchor (e.g. adm:city:SA:riyadh, node:api-1, net:ip4:203.0.113.10) */
-  spaceAnchor?: string;
-
-  // --- SPATIAL: Privacy Markers ---
-  /** Technical missing data (e.g. server log without GPS) */
-  isUnknownLocation?: boolean;
-  /** Removed for legal/security reasons (e.g. GDPR) */
-  isRedactedLocation?: boolean;
-  /** Masked by user preference (e.g. "Don't show my location") */
-  isHiddenLocation?: boolean;
-
-  // --- PROVENANCE ---
-  /** Actor anchor - identifies observer/witness (e.g. "did:web:sensor.example.com", "node:gateway-01") */
-  actor?: string;
-  /** Verification hash appended to time (e.g. "sha256:8f3e2a...") */
-  signature?: string;
-
-  // --- CONTEXT ---
-  extensions?: Record<string, string>;
-
-  order?: TimeOrder;
-}
-
-// --- PLUGIN ARCHITECTURE ---
-
-/**
- * Interface for Calendar Driver plugins.
- * Implementations provide conversion logic to/from Gregorian and support for
- * external calendar libraries.
- *
- * @example Using a driver to parse a Hijri date string
- * ```ts
- * const driver = TPS.getDriver('hij');
- * if (driver?.parseDate) {
- *   const components = driver.parseDate('1447-07-21');
- *   const gregDate = driver.toGregorian(components);
- *   const tpsString = TPS.fromDate(gregDate, 'hij');
- * }
- * ```
- *
- * @example Wrapping an external library (moment-hijri)
- * ```ts
- * import moment from 'moment-hijri';
- *
- * class HijriDriver implements CalendarDriver {
- *   readonly code = 'hij';
- *
- *   parseDate(input: string, format?: string): Partial<TPSComponents> {
- *     const m = moment(input, format || 'iYYYY-iMM-iDD');
- *     return {
- *       calendar: 'hij',
- *       year: m.iYear(),
- *       month: m.iMonth() + 1,
- *       day: m.iDate()
- *     };
- *   }
- *
- *   fromGregorian(date: Date): Partial<TPSComponents> {
- *     const m = moment(date);
- *     return {
- *       calendar: 'hij',
- *       year: m.iYear(),
- *       month: m.iMonth() + 1,
- *       day: m.iDate(),
- *       hour: m.hour(),
- *       minute: m.minute(),
- *       second: m.second()
- *     };
- *   }
- *
- *   // ... other methods
- * }
- * ```
- */
-export interface CalendarDriver {
-  /** The calendar code this driver handles (e.g., 'hij', 'jul'). */
-  readonly code: string;
-
-  /**
-   * Human-readable name for this calendar (optional).
-   * @example "Hijri (Islamic)"
-   */
-  readonly name?: string;
-
-  /**
-   * Converts a Date to this calendar's components.
-   * @param date - The Gregorian Date object.
-   * @returns Partial TPS components for year, month, day, etc.
-   */
-  getComponentsFromDate(date: Date): Partial<TPSComponents>;
-
-  /**
-   * Converts this calendar's components to a Date.
-   * @param components - Partial TPS components (year, month, day, etc.).
-   * @returns A JavaScript Date object.
-   */
-  getDateFromComponents(components: Partial<TPSComponents>): Date;
-
-  /**
-   * Generates a TPS time string for this calendar from a Date.
-   * @param date - The Gregorian Date object.
-   * @returns A TPS time string (e.g., "T:hij.y1447.m07.d21...").
-   */
-  getFromDate(date: Date): string;
-
-  // --- NEW ENHANCED METHODS (Optional) ---
-
-  /**
-   * Parse a calendar-specific date string into TPS components.
-   * This allows drivers to handle native date formats from external libraries.
-   *
-   * @param input - Date string in calendar-native format (e.g., '1447-07-21' for Hijri)
-   * @param format - Optional format string (driver-specific, e.g., 'iYYYY-iMM-iDD')
-   * @returns Partial TPS components
-   *
-   * @example
-   * ```ts
-   * // Hijri driver
-   * driver.parseDate('1447-07-21'); // → { year: 1447, month: 7, day: 21, calendar: 'hij' }
-   *
-   * // With time
-   * driver.parseDate('1447-07-21 14:30:00'); // → { year: 1447, month: 7, day: 21, hour: 14, ... }
-   * ```
-   */
-  parseDate(input: string, format?: string): Partial<TPSComponents>;
-
-  /**
-   * Format TPS components to a calendar-specific date string.
-   * Inverse of parseDate().
-   *
-   * @param components - TPS components to format
-   * @param format - Optional format string (driver-specific)
-   * @returns Formatted date string in calendar-native format
-   *
-   * @example
-   * ```ts
-   * driver.format({ year: 1447, month: 7, day: 21 }); // → '1447-07-21'
-   * driver.format({ year: 1447, month: 7, day: 21 }, 'short'); // → '21/7/1447'
-   * ```
-   */
-  format(components: Partial<TPSComponents>, format?: string): string;
-
-  /**
-   * Validate a calendar-specific date string or components.
-   *
-   * @param input - Date string or components to validate
-   * @returns true if valid for this calendar
-   *
-   * @example
-   * ```ts
-   * driver.validate('1447-13-01'); // → false (month 13 invalid)
-   * driver.validate({ year: 1447, month: 7, day: 31 }); // → false (Rajab has 30 days)
-   * ```
-   */
-  validate(input: string | Partial<TPSComponents>): boolean;
-
-  /**
-   * Get calendar metadata (month names, day names, etc.).
-   * Useful for UI rendering.
-   *
-   * @example
-   * ```ts
-   * driver.getMetadata().monthNames
-   * // → ['Muharram', 'Safar', 'Rabi I', ...]
-   * ```
-   */
-  getMetadata(): CalendarMetadata;
-}
-
-/**
- * Metadata about a calendar system.
- */
-export interface CalendarMetadata {
-  /** Human-readable calendar name */
-  name: string;
-  /** Month names in order (1-12 or 1-13) */
-  monthNames?: string[];
-  /** Short month names */
-  monthNamesShort?: string[];
-  /** Day of week names (Sunday=0 or locale-specific) */
-  dayNames?: string[];
-  /** Short day names */
-  dayNamesShort?: string[];
-  /** Whether this calendar is lunar-based */
-  isLunar?: boolean;
-  /** Number of months per year */
-  monthsPerYear?: number;
-  /** Epoch year (for reference) */
-  epochYear?: number;
-}
+import { ChineseDriver } from "./drivers/chinese";
+
+export * from "./types";
+export * from "./uid";
+export * from "./date";
+export { Env } from "./utils/env";
+export { DriverManager } from "./driver-manager";
+export { utcToLocal, localToUtc, getOffsetString } from "./utils/timezone";
+import { DriverManager } from "./driver-manager";
+import { buildTimePart, parseTimeString } from "./utils/tps-string";
+import { localToUtc } from "./utils/timezone";
+
+import {
+  CalendarDriver,
+  TPSComponents,
+  TimeOrder,
+  DefaultCalendars,
+} from "./types";
 
 export class TPS {
   // --- PLUGIN REGISTRY ---
-  private static readonly drivers: Map<string, CalendarDriver> = new Map();
+  /** Shared DriverManager instance — use TPS.driverManager for direct access. */
+  static readonly driverManager = new DriverManager();
 
   /**
    * Registers a calendar driver plugin.
    * @param driver - The driver instance to register.
    */
   static registerDriver(driver: CalendarDriver): void {
-    this.drivers.set(driver.code, driver);
+    this.driverManager.register(driver);
   }
 
   /**
@@ -302,41 +68,44 @@ export class TPS {
    * @returns The driver or undefined.
    */
   static getDriver(code: string): CalendarDriver | undefined {
-    return this.drivers.get(code);
-  }
-
-  // --- REGEX ---
-  // Updated for v0.5.0: supports L: anchors, A: actor, ! signature, structural & geospatial anchors
-  // Tokens may appear in any order; actual semantic parsing happens in
-  // `parseTimeString()` so these patterns are intentionally permissive.
-  // regex simply ensures prefix, space, calendar, and token characters;
-  // token order is not enforced (parseTimeString handles semantics).
+    return this.driverManager.get(code);
+  }
+
+  // --- REGEX (v0.6.0) ---
+  // The URI and time regexes are intentionally permissive in the location &
+  // extension sections — detailed semantic parsing happens in
+  // _mapGroupsToComponents() and the layer parsers below.
+  //
+  // Structure:
+  //   tps://[location]/A:[actor]@T:[cal].[tokens];[ext];...#C:[ctx];...
+  //
+  // The `;` separator is used consistently:
+  //   - between location layers (before @T:)
+  //   - between extensions (after T: tokens, before #)
+  //   - between context key=val pairs (after #C:)
   private static readonly REGEX_URI = new RegExp(
     "^tps://" +
-      // Location part (preserve named captures for space subfields)
-      "(?:L:)?(?<space>" +
-      "~|-|unknown|redacted|hidden|" +
-      "s2=(?<s2>[a-fA-F0-9]+)|" +
-      "h3=(?<h3>[a-fA-F0-9]+)|" +
-      "plus=(?<plus>[A-Z0-9+]+)|" +
-      "w3w=(?<w3w>[a-z]+\\.[a-z]+\\.[a-z]+)|" +
-      "bldg=(?<bldg>[\\w-]+)(?:\\.floor=(?<floor>[\\w-]+))?(?:\\.room=(?<room>[\\w-]+))?(?:\\.zone=(?<zone>[\\w-]+))?|" +
-      "(?<lat>-?\\d+(?:\\.\\d+)?),(?<lon>-?\\d+(?:\\.\\d+)?)(?:,(?<alt>-?\\d+(?:\\.\\d+)?)m?)?|" +
-      "(?<generic>[^@/?#]+)" +
-      ")" +
-      "(?:/A:(?<actor>[^/@]+))?" +
+      // Location: everything up to optional /A: actor and then @T:
+      "(?<location>[^@]+?)" +
+      // Optional actor overlay
+      "(?:/A:(?<actor>[^@]+))?" +
+      // Time section
       "@T:(?<calendar>[a-z]{3,4})" +
-      "(?:\\.(?:m-?\\d+|c\\d+|y\\d+|d\\d{1,2}|h\\d{1,2}|s\\d+(?:\\.\\d+)?))*" +
-      "(?:![^;?#]+)?" +
-      "(?:;(?<extensions>[^?#]+))?" +
-      "(?:\\?[^#]+)?" +
-      "(?:#.+)?$",
+      "(?<tokens>(?:\\.[a-z]-?[\\d.]+)*)" +
+      // Optional signature
+      "(?:!(?<signature>[^;#]+))?" +
+      // Optional extensions (;KEY:val;key=val;...)
+      "(?:;(?<extensions>[^#]+))?" +
+      // Optional context fragment (#C:key=val;...)
+      "(?:#C:(?<context>.+))?$",
   );
 
   private static readonly REGEX_TIME = new RegExp(
     "^T:(?<calendar>[a-z]{3,4})" +
-      "(?:\\.(?:m-?\\d+|c\\d+|y\\d+|d\\d{1,2}|h\\d{1,2}|s\\d+(?:\\.\\d+)?))*" +
-      "(?:![^;?#]+)?$",
+      "(?<tokens>(?:\\.[a-z]-?[\\d.]+)*)" +
+      "(?:!(?<signature>[^;#]+))?" +
+      "(?:;(?<extensions>[^#]+))?" +
+      "(?:#C:(?<context>.+))?$",
   );
 
   // --- CORE METHODS ---
@@ -354,6 +123,22 @@ export class TPS {
     let s = input.trim().replace(/\s+/g, "");
     if (!s) return s;
 
+    // ── 1.2 Compact scheme normalization (v0.6.0) ──────────────────────────
+    // TPS:...    → tps://...   (generic compact)
+    // NIP4:x     → tps://net:ip4:x   (IPv4 shorthand)
+    // NIP6:x     → tps://net:ip6:x   (IPv6 shorthand)
+    // NODE:x     → tps://node:x      (logical node shorthand)
+    if (/^TPS:/i.test(s) && !s.toLowerCase().startsWith("tps://")) {
+      // TPS:L:... or TPS:lat,lon... → tps://...
+      s = "tps://" + s.slice(4); // strip 'TPS:'
+    } else if (/^NIP4:/i.test(s)) {
+      s = "tps://net:ip4:" + s.slice(5);
+    } else if (/^NIP6:/i.test(s)) {
+      s = "tps://net:ip6:" + s.slice(5);
+    } else if (/^NODE:/i.test(s)) {
+      s = "tps://node:" + s.slice(5);
+    }
+
     // ── 1.5 Convert legacy "/T:" separators to the new canonical "@T:".
     // The input may contain "/T:" from older versions; we normalise early so
     // subsequent logic can assume only the '@' form.
@@ -504,7 +289,7 @@ export class TPS {
         timeStr = timeStr.split(/[!;?#]/)[0];
       }
       if (timeStr) {
-        const parsed = this.parseTimeString(timeStr);
+        const parsed = parseTimeString(timeStr);
         if (!parsed) return null;
         Object.assign(comp, parsed.components);
         comp.order = parsed.order;
@@ -524,12 +309,33 @@ export class TPS {
     if (sigMatch && sigMatch.groups && sigMatch.groups.sig) {
       signature = sigMatch.groups.sig;
       timeOnly = input.split(/[!;?#]/)[0];
+    } else {
+      // Strip extension/query/fragment suffix so parseTimeString sees only tokens
+      timeOnly = input.split(/[;?#]/)[0];
     }
-    const parsed = this.parseTimeString(timeOnly);
+    const parsed = parseTimeString(timeOnly);
     if (!parsed) return null;
     const comp = parsed.components as TPSComponents;
     if (signature) comp.signature = signature;
     comp.order = parsed.order;
+
+    // Route through the same group mapper used by REGEX_URI for consistency
+    // (handles extensions ;KEY:val and context #C:key=val)
+    const syntheticGroups: Record<string, string> = {
+      calendar: match.groups.calendar ?? "",
+      signature: match.groups.signature ?? "",
+      extensions: match.groups.extensions ?? "",
+      context: match.groups.context ?? "",
+      location: "", // no location in time-only string
+      actor: "",
+    };
+    const mappedComp = this._mapGroupsToComponents(syntheticGroups);
+    // Merge temporal components from parseTimeString with mapped metadata
+    Object.assign(comp, {
+      signature: mappedComp.signature || comp.signature,
+      extensions: mappedComp.extensions || comp.extensions,
+      context: mappedComp.context,
+    });
     return comp;
   }
 
@@ -539,59 +345,87 @@ export class TPS {
    * @returns Full URI string (e.g. "tps://...").
    */
   static toURI(comp: TPSComponents): string {
-    // 1. Build Space Part (L: anchor)
-    let spacePart = "L:-"; // Default: unknown
+    // ── 1. Location layers (v0.6.0) ──────────────────────────────────────────
+    // Build an ordered list of location layer strings, then join with ";"
+    const layers: string[] = [];
 
-    if (comp.spaceAnchor) {
-      spacePart = comp.spaceAnchor;
-    } else if (comp.isHiddenLocation) {
-      spacePart = "L:~";
+    // Privacy shorthand takes priority
+    if (comp.isHiddenLocation) {
+      layers.push("L:~");
     } else if (comp.isRedactedLocation) {
-      spacePart = "L:redacted";
+      layers.push("L:redacted");
     } else if (comp.isUnknownLocation) {
-      spacePart = "L:-";
+      layers.push("L:-");
+    } else if (comp.spaceAnchor) {
+      // Generic / legacy anchor (adm:, planet:, etc.)
+      layers.push(comp.spaceAnchor);
+    } else if (comp.ipv4) {
+      layers.push(`net:ip4:${comp.ipv4}`);
+    } else if (comp.ipv6) {
+      layers.push(`net:ip6:${comp.ipv6}`);
+    } else if (comp.nodeName) {
+      layers.push(`node:${comp.nodeName}`);
     } else if (comp.s2Cell) {
-      spacePart = `L:s2=${comp.s2Cell}`;
+      layers.push(`S2:${comp.s2Cell}`);
     } else if (comp.h3Cell) {
-      spacePart = `L:h3=${comp.h3Cell}`;
-    } else if (comp.plusCode) {
-      spacePart = `L:plus=${comp.plusCode}`;
+      layers.push(`H3:${comp.h3Cell}`);
     } else if (comp.what3words) {
-      spacePart = `L:w3w=${comp.what3words}`;
+      layers.push(`3W:${comp.what3words}`);
+    } else if (comp.plusCode) {
+      layers.push(`plus:${comp.plusCode}`);
     } else if (comp.building) {
-      spacePart = `L:bldg=${comp.building}`;
-      if (comp.floor) spacePart += `.floor=${comp.floor}`;
-      if (comp.room) spacePart += `.room=${comp.room}`;
-      if (comp.zone) spacePart += `.zone=${comp.zone}`;
+      layers.push(`bldg:${comp.building}`);
+      if (comp.floor) layers.push(`floor:${comp.floor}`);
+      if (comp.room) layers.push(`room:${comp.room}`);
+      if (comp.door) layers.push(`door:${comp.door}`);
+      if (comp.zone) layers.push(`zone:${comp.zone}`);
     } else if (comp.latitude !== undefined && comp.longitude !== undefined) {
-      spacePart = `L:${comp.latitude},${comp.longitude}`;
-      if (comp.altitude !== undefined) {
-        spacePart += `,${comp.altitude}m`;
-      }
+      let gps = `L:${comp.latitude},${comp.longitude}`;
+      if (comp.altitude !== undefined) gps += `,${comp.altitude}m`;
+      layers.push(gps);
+    } else {
+      layers.push("L:-"); // unknown fallback
     }
 
-    // 2. Build Actor Part (A: anchor) - optional
-    let actorPart = "";
-    if (comp.actor) {
-      actorPart = `/A:${comp.actor}`;
+    // Place layer (P:) — appended after primary location
+    if (
+      comp.placeCountryCode || comp.placeCountryName ||
+      comp.placeCityCode   || comp.placeCityName
+    ) {
+      const pParts: string[] = [];
+      if (comp.placeCountryCode) pParts.push(`cc=${comp.placeCountryCode}`);
+      if (comp.placeCountryName) pParts.push(`cn=${comp.placeCountryName}`);
+      if (comp.placeCityCode) pParts.push(`ci=${comp.placeCityCode}`);
+      if (comp.placeCityName) pParts.push(`ct=${comp.placeCityName}`);
+      layers.push(`P:${pParts.join(",")}`);
     }
 
-    // 3. Build Time Part (handles order & signature)
-    const timePart = this.buildTimePart(comp);
+    const locationStr = layers.join(";");
+
+    // ── 2. Actor (/A:...) ─────────────────────────────────────────────────────
+    const actorPart = comp.actor ? `/A:${comp.actor}` : "";
+
+    // ── 3. Time (mandatory 9 tokens) ─────────────────────────────────────────
+    const timePart = buildTimePart(comp);
 
-    // 5. Build Extensions
+    // ── 4. Extensions (;KEY:val;...) ─────────────────────────────────────────
     let extPart = "";
     if (comp.extensions && Object.keys(comp.extensions).length > 0) {
-      const extStrings = Object.entries(comp.extensions).map(
-        ([k, v]) => `${k}=${v}`,
-      );
-      extPart = `;${extStrings.join(".")}`;
+      const extStrings = Object.entries(comp.extensions).map(([k, v]) => {
+        // Emit as KEY:val (preferred v0.6.0 style)
+        return `${k.toUpperCase()}:${v}`;
+      });
+      extPart = `;${extStrings.join(";")}`;
+    }
+
+    // ── 5. Context (#C:key=val;...) ──────────────────────────────────────────
+    let contextPart = "";
+    if (comp.context && Object.keys(comp.context).length > 0) {
+      const ctxStrings = Object.entries(comp.context).map(([k, v]) => `${k}=${v}`);
+      contextPart = `#C:${ctxStrings.join(";")}`;
     }
 
-    // timePart already begins with 'T:'.  The new canonical separator is '@'
-    // instead of '/', so we interpolate it accordingly.  Actor anchor (if
-    // present) still uses a leading slash.
-    return `tps://${spacePart}${actorPart}@${timePart}${extPart}`;
+    return `tps://${locationStr}${actorPart}@${timePart}${extPart}${contextPart}`;
   }
 
   /**
@@ -609,7 +443,7 @@ export class TPS {
     opts?: { order?: TimeOrder },
   ): string {
     const normalizedCalendar = calendar.toLowerCase();
-    const driver = this.drivers.get(normalizedCalendar);
+    const driver = this.driverManager.get(normalizedCalendar);
     if (driver) {
       // when caller requested an explicit order we can bypass the driver's
       // `fromDate` helper and instead generate components ourselves so that
@@ -619,7 +453,7 @@ export class TPS {
         const comp = driver.getComponentsFromDate(date) as TPSComponents;
         comp.calendar = normalizedCalendar;
         comp.order = opts.order;
-        return this.buildTimePart(comp);
+        return buildTimePart(comp);
       }
       return driver.getFromDate(date);
     }
@@ -632,7 +466,7 @@ export class TPS {
       const s = (date.getTime() / 1000).toFixed(3);
       comp.unixSeconds = parseFloat(s);
       if (opts?.order) comp.order = opts.order;
-      return this.buildTimePart(comp);
+      return buildTimePart(comp);
     }
 
     if (normalizedCalendar === DefaultCalendars.GREG) {
@@ -647,7 +481,7 @@ export class TPS {
       comp.second = date.getUTCSeconds();
       comp.millisecond = date.getUTCMilliseconds();
       if (opts?.order) comp.order = opts.order;
-      return this.buildTimePart(comp);
+      return buildTimePart(comp);
     }
 
     throw new Error(
@@ -683,13 +517,24 @@ export class TPS {
 
     const cal = parsed.calendar || DefaultCalendars.TPS;
 
-    const driver = this.drivers.get(cal);
+    const driver = this.driverManager.get(cal);
     if (!driver) {
       console.error(`Calendar driver '${cal}' not registered.`);
       return null;
     }
 
-    return driver.getDateFromComponents(parsed);
+    const date = driver.getDateFromComponents(parsed);
+
+    // If the URI has a ;tz= extension, the calendar date was expressed in local
+    // time. Convert from local → UTC using the timezone utility.
+    const tz = parsed.extensions?.["tz"];
+    if (tz && date) {
+      const localMs = date.getTime();
+      const utcMs = localToUtc(localMs, tz);
+      return new Date(utcMs);
+    }
+
+    return date;
   }
 
   // --- DRIVER CONVENIENCE METHODS ---
@@ -717,7 +562,7 @@ export class TPS {
     dateString: string,
     format?: string,
   ): Partial<TPSComponents> | null {
-    const driver = this.drivers.get(calendar);
+    const driver = this.driverManager.get(calendar);
     if (!driver) {
       throw new Error(
         `Calendar driver '${calendar}' not found. Register a driver first.`,
@@ -799,7 +644,7 @@ export class TPS {
     components: Partial<TPSComponents>,
     format?: string,
   ): string {
-    const driver = this.drivers.get(calendar);
+    const driver = this.driverManager.get(calendar);
     if (!driver) {
       throw new Error(`Calendar driver '${calendar}' not found.`);
     }
@@ -807,1033 +652,260 @@ export class TPS {
     return driver.format(components, format);
   }
 
-  // --- INTERNAL HELPERS ---
+  // --- CONVENIENCE METHODS ---
 
   /**
-   * Generate the canonical `T:` time string for a set of components.  The
-   * `order` field (or `comp.order`) controls whether tokens are emitted in
-   * ascending or descending hierarchy; if undefined the default
-   * `'descending'` orientation is used.
+   * Returns a TPS time string for the current moment.
+   * Shorthand for `TPS.fromDate(new Date(), calendar, opts)`.
+   *
+   * @param calendar - Calendar code. Defaults to 'greg'.
+   * @param opts - Optional `order` (ASC/DESC) parameter.
+   * @returns TPS time string.
    *
-   * Drivers may ignore this helper and produce their own time strings if they
-   * implement custom ordering logic.
+   * @example
+   * ```ts
+   * TPS.now(); // "T:greg.m3.c1.y26.m3.d4.h06.m30.s00.m0"
+   * TPS.now('hij'); // "T:hij.y1447.m09.d05.h06.m30.s00"
+   * ```
    */
-  public static buildTimePart(comp: TPSComponents): string {
-    const calendar = (comp.calendar || "").toLowerCase();
-    if (!/^[a-z]{3,4}$/.test(calendar)) {
-      throw new Error(
-        `Invalid calendar code '${comp.calendar}'. Calendar code width must be 3–4 lowercase letters.`,
-      );
-    }
-
-    let time = `T:${calendar}`;
-    if (calendar === DefaultCalendars.UNIX) {
-      if (comp.unixSeconds !== undefined) {
-        time += `.s${comp.unixSeconds}`;
-      }
-      return time;
-    }
-
-    // sequence of [prefix, value, rank]
-    // All four of millennium / month / minute / millisecond share the prefix 'm'.
-    // Position within the ordered sequence disambiguates them during parsing.
-    const tokens: Array<[string, number | undefined, number]> = [
-      ["m", comp.millennium, 8], // m-token rank 8 → millennium
-      ["c", comp.century, 7],
-      ["y", comp.year, 6],
-      ["m", comp.month, 5], // m-token rank 5 → month
-      ["d", comp.day, 4],
-      ["h", comp.hour, 3],
-      ["m", comp.minute, 2], // m-token rank 2 → minute
-      ["s", comp.second, 1],
-      ["m", comp.millisecond, 0], // m-token rank 0 → millisecond
-    ];
-
-    const order: TimeOrder = comp.order || TimeOrder.DESC;
-    if (order === TimeOrder.ASC) tokens.reverse();
-
-    for (const [pref, val] of tokens) {
-      if (val !== undefined) {
-        // seconds may be fractional
-        time += `.${pref}${val}`;
-      }
-    }
-
-    if (comp.signature) {
-      time += `!${comp.signature}`;
-    }
-
-    return time;
+  static now(
+    calendar: string = DefaultCalendars.GREG,
+    opts?: { order?: TimeOrder },
+  ): string {
+    return this.fromDate(new Date(), calendar, opts) as string;
   }
 
   /**
-   * Parse the *time* portion of a TPS string (optionally beginning with
-   * `T:`) into components and determine the component ordering.  This helper
-   * accepts tokens in **any** sequence and will return an `order` value of
-   * `'ascending'` or `'descending'`.
+   * Returns the difference in milliseconds between two TPS strings.
+   * The result is `t2 - t1`; negative if t1 is after t2.
    *
-   * The caller is responsible for stripping off a leading signature or other
-   * trailer characters; this method will drop anything after `!`, `;`, `?` or
-   * `#`.
+   * @param t1 - First TPS string (subtracted from t2).
+   * @param t2 - Second TPS string.
+   * @returns Milliseconds between the two moments, or NaN on parse failure.
    *
-   * ### `m`-token disambiguation
-   * All four of millennium (rank 8), month (rank 5), minute (rank 2) and
-   * millisecond (rank 0) share the single-character prefix `m`.  They are told
-   * apart by their **position relative to the neighbouring tokens**.  The
-   * algorithm is:
+   * @example
+   * ```ts
+   * const ms = TPS.diff('T:greg.m3.c1.y26.m1.d1.h0.m0.s0.m0',
+   *                       'T:greg.m3.c1.y26.m1.d2.h0.m0.s0.m0');
+   * // 86_400_000  (one day)
+   * ```
+   */
+  static diff(t1: string, t2: string): number {
+    const d1 = this.toDate(t1);
+    const d2 = this.toDate(t2);
+    if (!d1 || !d2) return NaN;
+    return d2.getTime() - d1.getTime();
+  }
+
+  /**
+   * Returns a new TPS string shifted by the given duration.
+   * The result is in the same calendar as the original string.
    *
-   * 1. Pre-scan the non-`m` tokens (c, y, d, h, s) whose ranks are fixed to
-   *    determine whether the string is ascending or descending.
-   * 2. While iterating, track `lastAssignedRank` – the rank of the most
-   *    recently processed token (m or non-m).
-   * 3. When an `m` token is encountered, derive its rank from `lastAssignedRank`
-   *    and the detected order:
-   *    - **DESC**  null → 8 (mill) | rank > 5 → 5 (month) | rank > 2 → 2 (min) | else → 0 (ms)
-   *    - **ASC**   null → 0 (ms)   | rank < 2 → 2 (min)   | rank < 5 → 5 (month) | else → 8 (mill)
+   * @param tpsStr - Source TPS string.
+   * @param duration - Object with optional `days`, `hours`, `minutes`, `seconds`, `milliseconds`.
+   * @returns Shifted TPS string, or null if the input is invalid.
    *
-   * @param input - Time fragment (e.g. `"T:greg.m3.c1.y26"` or `"greg.m0.s25.m30"`)
+   * @example
+   * ```ts
+   * const t = 'T:greg.m3.c1.y26.m1.d9.h14.m30.s25.m0';
+   * TPS.add(t, { days: 7 });   // one week later
+   * TPS.add(t, { hours: -2 }); // two hours earlier
+   * ```
    */
-  static parseTimeString(
-    input: string,
-  ): { components: Partial<TPSComponents>; order: TimeOrder } | null {
-    let s = input.trim();
-    // strip off anything after signature or extensions/query/fragment
-    s = s.split(/[!;?#]/)[0];
-    if (s.startsWith("T:")) s = s.slice(2);
-    const parts = s.split(".");
-    if (parts.length === 0) return null;
-    const calendar = parts[0];
-    const comp: Partial<TPSComponents> = { calendar };
-
-    // Fixed-rank prefixes (unambiguous regardless of position)
-    const fixedRankMap: Record<string, number> = {
-      c: 7,
-      y: 6,
-      d: 4,
-      h: 3,
-      s: 1,
-    };
-
-    // ── Step 1: pre-scan non-m tokens to estimate order ─────────────────────
-    // This is only needed to handle the first 'm' token when lastAssignedRank
-    // is still null (nothing has been seen yet).
-    let initialOrder: TimeOrder = TimeOrder.DESC;
-    if (calendar !== DefaultCalendars.UNIX) {
-      const nonMRanks: number[] = [];
-      for (let i = 1; i < parts.length; i++) {
-        const pr = parts[i]?.charAt(0);
-        if (pr && pr in fixedRankMap) nonMRanks.push(fixedRankMap[pr]);
-      }
-      if (nonMRanks.length >= 2) {
-        const isAsc = nonMRanks.every((v, i, a) => i === 0 || a[i - 1] <= v);
-        if (isAsc) initialOrder = TimeOrder.ASC;
-      }
-    }
-
-    // ── Step 2: resolve the semantic rank of an 'm' token ───────────────────
-    const assignMRank = (lastRank: number | null, ord: TimeOrder): number => {
-      if (ord === TimeOrder.DESC) {
-        if (lastRank === null) return 8; // first token → millennium
-        if (lastRank > 5) return 5; // after century / year  → month
-        if (lastRank > 2) return 2; // after day / hour      → minute
-        return 0; // after second          → millisecond
-      } else {
-        if (lastRank === null) return 0; // first token → millisecond
-        if (lastRank < 2) return 2; // after millisecond / second → minute
-        if (lastRank < 5) return 5; // after minute / hour / day  → month
-        return 8; // after month / year / cent  → millennium
-      }
-    };
-
-    // ── Step 3: iterate and build components ────────────────────────────────
-    const ranks: number[] = [];
-    let lastAssignedRank: number | null = null;
-
-    for (let i = 1; i < parts.length; i++) {
-      const token = parts[i];
-      if (!token) continue;
-      const prefix = token.charAt(0);
-      const value = token.slice(1);
-
-      // UNIX calendar: single 's' token carries the full unix timestamp
-      if (calendar === DefaultCalendars.UNIX && prefix === "s") {
-        comp.unixSeconds = parseFloat(value);
-        ranks.push(9);
-        continue;
-      }
+  static add(
+    tpsStr: string,
+    duration: {
+      days?: number;
+      hours?: number;
+      minutes?: number;
+      seconds?: number;
+      milliseconds?: number;
+    },
+  ): string | null {
+    const date = this.toDate(tpsStr);
+    if (!date) return null;
 
-      if (prefix === "m") {
-        const rank = assignMRank(lastAssignedRank, initialOrder);
-        switch (rank) {
-          case 8:
-            comp.millennium = parseInt(value, 10);
-            break;
-          case 5:
-            comp.month = parseInt(value, 10);
-            break;
-          case 2:
-            comp.minute = parseInt(value, 10);
-            break;
-          case 0:
-            comp.millisecond = parseInt(value, 10);
-            break;
-        }
-        ranks.push(rank);
-        lastAssignedRank = rank;
-      } else {
-        switch (prefix) {
-          case "c":
-            comp.century = parseInt(value, 10);
-            ranks.push(7);
-            lastAssignedRank = 7;
-            break;
-          case "y":
-            comp.year = parseInt(value, 10);
-            ranks.push(6);
-            lastAssignedRank = 6;
-            break;
-          case "d":
-            comp.day = parseInt(value, 10);
-            ranks.push(4);
-            lastAssignedRank = 4;
-            break;
-          case "h":
-            comp.hour = parseInt(value, 10);
-            ranks.push(3);
-            lastAssignedRank = 3;
-            break;
-          case "s":
-            comp.second = parseFloat(value);
-            ranks.push(1);
-            lastAssignedRank = 1;
-            break;
-          default:
-            // unknown prefix – ignore
-            break;
-        }
-      }
-    }
+    const parsed = this.parse(tpsStr);
+    const calendar = parsed?.calendar ?? DefaultCalendars.GREG;
+    const order = parsed?.order;
 
-    // ── Step 4: confirm order from the complete rank sequence ────────────────
-    let order: TimeOrder = TimeOrder.DESC;
-    if (ranks.length > 1) {
-      const isAsc = ranks.every((v, i, a) => i === 0 || a[i - 1] <= v);
-      const isDesc = ranks.every((v, i, a) => i === 0 || a[i - 1] >= v);
-      if (isAsc && !isDesc) order = TimeOrder.ASC;
-      // mixed / single direction → defaults to DESC
-    }
+    const deltaMs =
+      (duration.days ?? 0) * 86_400_000 +
+      (duration.hours ?? 0) * 3_600_000 +
+      (duration.minutes ?? 0) * 60_000 +
+      (duration.seconds ?? 0) * 1_000 +
+      (duration.milliseconds ?? 0);
 
-    return { components: comp, order };
+    const shifted = new Date(date.getTime() + deltaMs);
+    return this.fromDate(
+      shifted,
+      calendar,
+      order ? { order } : undefined,
+    ) as string;
   }
 
+  // --- INTERNAL HELPERS ---
+
   private static _mapGroupsToComponents(
     g: Record<string, string>,
   ): TPSComponents {
     const components: any = {};
     components.calendar = g.calendar as string;
 
-    // Signature Mapping
+    // ── Signature ────────────────────────────────────────────────────────────
     if (g.signature) {
       components.signature = g.signature;
     }
 
-    // Actor Mapping
+    // ── Actor (/A:...) ────────────────────────────────────────────────────────
     if (g.actor) {
-      components.actor = g.actor;
+      components.actor = g.actor.trim();
     }
 
-    // Space Mapping
-    if (g.space) {
-      // Privacy markers
-      if (g.space === "unknown" || g.space === "-") {
-        components.isUnknownLocation = true;
-      } else if (g.space === "redacted") {
-        components.isRedactedLocation = true;
-      } else if (g.space === "hidden" || g.space === "~") {
-        components.isHiddenLocation = true;
-      }
-      // Geospatial cells
-      else if (g.s2) {
-        components.s2Cell = g.s2;
-      } else if (g.h3) {
-        components.h3Cell = g.h3;
-      } else if (g.plus) {
-        components.plusCode = g.plus;
-      } else if (g.w3w) {
-        components.what3words = g.w3w;
-      }
-      // Structural anchors
-      else if (g.bldg) {
-        components.building = g.bldg;
-        if (g.floor) components.floor = g.floor;
-        if (g.room) components.room = g.room;
-        if (g.zone) components.zone = g.zone;
-      }
-      // Generic pre-@ anchor (adm/node/net/planet/etc)
-      else if (g.generic) {
-        components.spaceAnchor = g.generic;
-      }
-      // GPS coordinates
-      else {
-        if (g.lat) components.latitude = parseFloat(g.lat);
-        if (g.lon) components.longitude = parseFloat(g.lon);
-        if (g.alt) components.altitude = parseFloat(g.alt);
-      }
+    // ── Location layers (v0.6.0: multi-layer, ;-separated) ───────────────────
+    if (g.location) {
+      this._parseLocationLayers(g.location, components);
     }
 
-    // Extensions Mapping
+    // ── Extensions (;KEY:val or ;key=val after T: tokens) ────────────────────
     if (g.extensions) {
-      const extObj: any = {};
-      const parts = g.extensions.split(".");
-      parts.forEach((p: string) => {
-        const eqIdx = p.indexOf("=");
-        if (eqIdx > 0) {
-          const key = p.substring(0, eqIdx);
-          const val = p.substring(eqIdx + 1);
-          if (key && val) extObj[key] = val;
-        } else {
-          // Legacy format: first char is key
-          const key = p.charAt(0);
-          const val = p.substring(1);
-          if (key && val) extObj[key] = val;
+      const extObj: Record<string, string> = {};
+      g.extensions.split(";").forEach((part: string) => {
+        part = part.trim();
+        if (!part) return;
+        const colonIdx = part.indexOf(":");
+        const eqIdx = part.indexOf("=");
+        if (colonIdx > 0 && (eqIdx < 0 || colonIdx < eqIdx)) {
+          // KEY:val form (e.g. TZ:+03:00)
+          const key = part.substring(0, colonIdx).toLowerCase();
+          const val = part.substring(colonIdx + 1);
+          if (key && val !== undefined) extObj[key] = val;
+        } else if (eqIdx > 0) {
+          // key=val form (e.g. tz=+03:00)
+          const key = part.substring(0, eqIdx).toLowerCase();
+          const val = part.substring(eqIdx + 1);
+          if (key && val !== undefined) extObj[key] = val;
         }
       });
-      components.extensions = extObj;
-    }
-
-    return components as TPSComponents;
-  }
-}
-
-// register built-in drivers and set default
-// (tps and gregorian provide canonical conversions before unix)
-TPS.registerDriver(new TpsDriver());
-TPS.registerDriver(new GregorianDriver());
-TPS.registerDriver(new UnixDriver());
-TPS.registerDriver(new PersianDriver());
-TPS.registerDriver(new HijriDriver());
-TPS.registerDriver(new JulianDriver());
-TPS.registerDriver(new HoloceneDriver());
-
-// --- TPS-UID v1 Types ---
-
-/**
- * Decoded result from TPSUID7RB binary format.
- */
-export type TPSUID7RBDecodeResult = {
-  /** Version identifier */
-  version: "tpsuid7rb";
-  /** Epoch milliseconds (UTC) */
-  epochMs: number;
-  /** Whether the TPS payload was compressed */
-  compressed: boolean;
-  /** 32-bit nonce for collision prevention */
-  nonce: number;
-  /** The original TPS string (exact reconstruction) */
-  tps: string;
-};
-
-/**
- * Encoding options for TPSUID7RB.
- */
-export type TPSUID7RBEncodeOptions = {
-  /** Enable zlib compression of TPS payload */
-  compress?: boolean;
-  /** Override epoch milliseconds (default: parsed from TPS) */
-  epochMs?: number;
-};
-
-/**
- * TPS-UID v1 — Temporal Positioning System Identifier (Binary Reversible)
- *
- * A time-first, reversible identifier that binds an event to a TPS coordinate.
- * Unlike UUIDs, TPS-UID identifies events in spacetime and allows exact
- * reconstruction of the original TPS string.
- *
- * Binary Schema (all integers big-endian):
- * ```
- * MAGIC   4 bytes   "TPU7"
- * VER     1 byte    0x01
- * FLAGS   1 byte    bit0 = compression flag
- * TIME    6 bytes   epoch_ms (48-bit unsigned)
- * NONCE   4 bytes   32-bit random
- * LEN     varint    length of TPS payload
- * TPS     bytes     UTF-8 TPS string (raw or zlib-compressed)
- * ```
- *
- * @example
- * ```ts
- * const tps = 'tps://31.95,35.91@T:greg.m3.c1.y26.m01.d09';
- *
- * // Encode to binary
- * const bytes = TPSUID7RB.encodeBinary(tps);
- *
- * // Encode to base64url string
- * const id = TPSUID7RB.encodeBinaryB64(tps);
- * // → "tpsuid7rb_AFRQV..."
- *
- * // Decode back to original TPS
- * const decoded = TPSUID7RB.decodeBinaryB64(id);
- * console.log(decoded.tps); // exact original TPS
- * ```
- */
-export class TPSUID7RB {
-  /** Magic bytes: "TPU7" */
-  private static readonly MAGIC = new Uint8Array([0x54, 0x50, 0x55, 0x37]);
-  /** Version 1 */
-  private static readonly VER = 0x01;
-  /** String prefix for base64url encoded form */
-  private static readonly PREFIX = "tpsuid7rb_";
-  /** Regex for validating base64url encoded form */
-  public static readonly REGEX = /^tpsuid7rb_[A-Za-z0-9_-]+$/;
-
-  // ---------------------------
-  // Public API
-  // ---------------------------
-
-  /**
-   * Encode TPS string to binary bytes (Uint8Array).
-   * This is the canonical form for hashing, signing, and storage.
-   *
-   * @param tps - The TPS string to encode
-   * @param opts - Encoding options (compress, epochMs override)
-   * @returns Binary TPS-UID as Uint8Array
-   */
-  static encodeBinary(
-    tps: string,
-    opts: TPSUID7RBEncodeOptions = {},
-  ): Uint8Array {
-    const compress = opts.compress ?? false;
-    const epochMs = opts.epochMs ?? this.epochMsFromTPSString(tps);
-
-    if (!Number.isInteger(epochMs) || epochMs < 0) {
-      throw new Error("epochMs must be a non-negative integer");
-    }
-    if (epochMs > 0xffffffffffff) {
-      throw new Error("epochMs exceeds 48-bit range");
-    }
-
-    const flags = compress ? 0x01 : 0x00;
-
-    // Generate 32-bit nonce
-    const nonceBuf = this.randomBytes(4);
-    const nonce =
-      ((nonceBuf[0] << 24) >>> 0) +
-      ((nonceBuf[1] << 16) >>> 0) +
-      ((nonceBuf[2] << 8) >>> 0) +
-      nonceBuf[3];
-
-    // Encode TPS to UTF-8
-    const tpsUtf8 = new TextEncoder().encode(tps);
-
-    // Optionally compress
-    const payload = compress ? this.deflateRaw(tpsUtf8) : tpsUtf8;
-
-    // Encode length as varint
-    const lenVar = this.uvarintEncode(payload.length);
-
-    // Construct binary structure
-    const out = new Uint8Array(
-      4 + 1 + 1 + 6 + 4 + lenVar.length + payload.length,
-    );
-    let offset = 0;
-
-    // MAGIC
-    out.set(this.MAGIC, offset);
-    offset += 4;
-
-    // VER
-    out[offset++] = this.VER;
-
-    // FLAGS
-    out[offset++] = flags;
-
-    // TIME (48-bit big-endian)
-    const timeBytes = this.writeU48(epochMs);
-    out.set(timeBytes, offset);
-    offset += 6;
-
-    // NONCE (32-bit big-endian)
-    out.set(nonceBuf, offset);
-    offset += 4;
-
-    // LEN (varint)
-    out.set(lenVar, offset);
-    offset += lenVar.length;
-
-    // TPS payload
-    out.set(payload, offset);
-
-    return out;
-  }
-
-  /**
-   * Decode binary bytes back to original TPS string.
-   *
-   * @param bytes - Binary TPS-UID
-   * @returns Decoded result with original TPS string
-   */
-  static decodeBinary(bytes: Uint8Array): TPSUID7RBDecodeResult {
-    // Header min size: 4+1+1+6+4 + 1 (at least 1 byte varint) = 17
-    if (bytes.length < 17) {
-      throw new Error("TPSUID7RB: too short");
-    }
-
-    // MAGIC
-    if (
-      bytes[0] !== 0x54 ||
-      bytes[1] !== 0x50 ||
-      bytes[2] !== 0x55 ||
-      bytes[3] !== 0x37
-    ) {
-      throw new Error("TPSUID7RB: bad magic");
-    }
-
-    // VERSION
-    const ver = bytes[4];
-    if (ver !== this.VER) {
-      throw new Error(`TPSUID7RB: unsupported version ${ver}`);
+      if (Object.keys(extObj).length > 0) components.extensions = extObj;
     }
 
-    // FLAGS
-    const flags = bytes[5];
-    const compressed = (flags & 0x01) === 0x01;
-
-    // TIME (48-bit big-endian)
-    const epochMs = this.readU48(bytes, 6);
-
-    // NONCE (32-bit big-endian)
-    const nonce =
-      ((bytes[12] << 24) >>> 0) +
-      ((bytes[13] << 16) >>> 0) +
-      ((bytes[14] << 8) >>> 0) +
-      bytes[15];
-
-    // LEN (varint at offset 16)
-    let offset = 16;
-    const { value: tpsLen, bytesRead } = this.uvarintDecode(bytes, offset);
-    offset += bytesRead;
-
-    if (offset + tpsLen > bytes.length) {
-      throw new Error("TPSUID7RB: length overflow");
-    }
-
-    // TPS payload
-    const payload = bytes.slice(offset, offset + tpsLen);
-    const tpsUtf8 = compressed ? this.inflateRaw(payload) : payload;
-    const tps = new TextDecoder().decode(tpsUtf8);
-
-    return { version: "tpsuid7rb", epochMs, compressed, nonce, tps };
-  }
-
-  /**
-   * Encode TPS to base64url string with prefix.
-   * This is the transport/storage form.
-   *
-   * @param tps - The TPS string to encode
-   * @param opts - Encoding options
-   * @returns Base64url encoded TPS-UID with prefix
-   */
-  static encodeBinaryB64(tps: string, opts?: TPSUID7RBEncodeOptions): string {
-    const bytes = this.encodeBinary(tps, opts ?? {});
-    return `${this.PREFIX}${this.base64UrlEncode(bytes)}`;
-  }
-
-  /**
-   * Decode base64url string back to original TPS string.
-   *
-   * @param id - Base64url encoded TPS-UID with prefix
-   * @returns Decoded result with original TPS string
-   */
-  static decodeBinaryB64(id: string): TPSUID7RBDecodeResult {
-    const s = id.trim();
-    if (!s.startsWith(this.PREFIX)) {
-      throw new Error("TPSUID7RB: missing prefix");
-    }
-    const b64 = s.slice(this.PREFIX.length);
-    const bytes = this.base64UrlDecode(b64);
-    return this.decodeBinary(bytes);
-  }
-
-  /**
-   * Validate base64url encoded TPS-UID format.
-   * Note: This validates shape only; binary decode is authoritative.
-   *
-   * @param id - String to validate
-   * @returns true if format is valid
-   */
-  static validateBinaryB64(id: string): boolean {
-    return this.REGEX.test(id.trim());
-  }
-
-  /**
-   * Generate a TPS-UID from the current time and optional location.
-   *
-   * @param opts - Generation options
-   * @returns Base64url encoded TPS-UID
-   */
-  static generate(opts?: {
-    latitude?: number;
-    longitude?: number;
-    altitude?: number;
-    compress?: boolean;
-    order?: TimeOrder;
-  }): string {
-    const now = new Date();
-    const time = TPS.fromDate(now, DefaultCalendars.TPS, {
-      order: opts?.order,
-    });
-    let space = "unknown";
-
-    if (opts?.latitude !== undefined && opts?.longitude !== undefined) {
-      space = `${opts.latitude},${opts.longitude}`;
-      if (opts.altitude !== undefined) {
-        space += `,${opts.altitude}m`;
-      }
-    }
-
-    const tps = `tps://${space}@${time}`;
-
-    return this.encodeBinaryB64(tps, {
-      compress: opts?.compress,
-      epochMs: now.getTime(),
-    });
-  }
-
-  // ---------------------------
-  // TPS String Helpers
-  // ---------------------------
-
-  /**
-   * Generate a TPS string from a Date and optional location.
-   */
-
-  /**
-   * Parse epoch milliseconds from a TPS string.
-   * Supports both URI format (tps://...) and time-only format (T:greg...)
-   */
-  static epochMsFromTPSString(tps: string): number {
-    const date = TPS.toDate(tps);
-    if (date) return date.getTime();
-
-    // If parse fails due to unsupported/extended extension payloads,
-    // strip extensions/query/fragment and retry. Epoch only depends on time.
-    const stripped = tps.replace(/;[^?#]*/, "").replace(/[?#].*$/, "");
-    const retryDate = TPS.toDate(stripped);
-    if (!retryDate) throw new Error("TPS: unable to parse date for epoch");
-    return retryDate.getTime();
-  }
-
-  // ---------------------------
-  // Binary Helpers
-  // ---------------------------
-
-  /** Write 48-bit unsigned integer (big-endian) */
-  private static writeU48(epochMs: number): Uint8Array {
-    const b = new Uint8Array(6);
-    // Use BigInt for proper 48-bit handling
-    const v = BigInt(epochMs);
-    b[0] = Number((v >> 40n) & 0xffn);
-    b[1] = Number((v >> 32n) & 0xffn);
-    b[2] = Number((v >> 24n) & 0xffn);
-    b[3] = Number((v >> 16n) & 0xffn);
-    b[4] = Number((v >> 8n) & 0xffn);
-    b[5] = Number(v & 0xffn);
-    return b;
-  }
-
-  /** Read 48-bit unsigned integer (big-endian) */
-  private static readU48(bytes: Uint8Array, offset: number): number {
-    const v =
-      (BigInt(bytes[offset]) << 40n) +
-      (BigInt(bytes[offset + 1]) << 32n) +
-      (BigInt(bytes[offset + 2]) << 24n) +
-      (BigInt(bytes[offset + 3]) << 16n) +
-      (BigInt(bytes[offset + 4]) << 8n) +
-      BigInt(bytes[offset + 5]);
-
-    const n = Number(v);
-    if (!Number.isSafeInteger(n)) {
-      throw new Error("TPSUID7RB: u48 not safe integer");
-    }
-    return n;
-  }
-
-  /** Encode unsigned integer as LEB128 varint */
-  private static uvarintEncode(n: number): Uint8Array {
-    if (!Number.isInteger(n) || n < 0) {
-      throw new Error("uvarint must be non-negative int");
-    }
-    const out: number[] = [];
-    let x = n >>> 0;
-    while (x >= 0x80) {
-      out.push((x & 0x7f) | 0x80);
-      x >>>= 7;
-    }
-    out.push(x);
-    return new Uint8Array(out);
-  }
-
-  /** Decode LEB128 varint */
-  private static uvarintDecode(
-    bytes: Uint8Array,
-    offset: number,
-  ): { value: number; bytesRead: number } {
-    let x = 0;
-    let s = 0;
-    let i = 0;
-    while (true) {
-      if (offset + i >= bytes.length) {
-        throw new Error("uvarint overflow");
-      }
-      const b = bytes[offset + i];
-      if (b < 0x80) {
-        if (i > 9 || (i === 9 && b > 1)) {
-          throw new Error("uvarint too large");
+    // ── Context (#C:key=val;key=val) ─────────────────────────────────────────
+    if (g.context) {
+      const ctx: Record<string, string> = {};
+      g.context.split(";").forEach((part: string) => {
+        part = part.trim();
+        if (!part) return;
+        const eqIdx = part.indexOf("=");
+        if (eqIdx > 0) {
+          ctx[part.substring(0, eqIdx)] = part.substring(eqIdx + 1);
         }
-        x |= b << s;
-        return { value: x >>> 0, bytesRead: i + 1 };
-      }
-      x |= (b & 0x7f) << s;
-      s += 7;
-      i++;
-      if (i > 10) {
-        throw new Error("uvarint too long");
-      }
-    }
-  }
-
-  // ---------------------------
-  // Base64url Helpers
-  // ---------------------------
-
-  /** Encode bytes to base64url (no padding) */
-  private static base64UrlEncode(bytes: Uint8Array): string {
-    // Node.js environment
-    if (typeof Buffer !== "undefined") {
-      return Buffer.from(bytes)
-        .toString("base64")
-        .replace(/\+/g, "-")
-        .replace(/\//g, "_")
-        .replace(/=+$/g, "");
-    }
-    // Browser environment
-    let binary = "";
-    for (let i = 0; i < bytes.length; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary)
-      .replace(/\+/g, "-")
-      .replace(/\//g, "_")
-      .replace(/=+$/g, "");
-  }
-
-  /** Decode base64url to bytes */
-  private static base64UrlDecode(b64url: string): Uint8Array {
-    // Add padding
-    const padLen = (4 - (b64url.length % 4)) % 4;
-    const b64 = (b64url + "=".repeat(padLen))
-      .replace(/-/g, "+")
-      .replace(/_/g, "/");
-
-    // Node.js environment
-    if (typeof Buffer !== "undefined") {
-      return new Uint8Array(Buffer.from(b64, "base64"));
-    }
-    // Browser environment
-    const binary = atob(b64);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-  }
-
-  // ---------------------------
-  // Compression Helpers
-  // ---------------------------
-
-  /** Compress using zlib deflate raw */
-  private static deflateRaw(data: Uint8Array): Uint8Array {
-    // Node.js environment
-    if (typeof require !== "undefined") {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const zlib = require("zlib");
-        return new Uint8Array(zlib.deflateRawSync(Buffer.from(data)));
-      } catch {
-        throw new Error("TPSUID7RB: compression not available");
-      }
-    }
-    // Browser: would need pako or similar library
-    throw new Error("TPSUID7RB: compression not available in browser");
-  }
-
-  /** Decompress using zlib inflate raw */
-  private static inflateRaw(data: Uint8Array): Uint8Array {
-    // Node.js environment
-    if (typeof require !== "undefined") {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const zlib = require("zlib");
-        return new Uint8Array(zlib.inflateRawSync(Buffer.from(data)));
-      } catch {
-        throw new Error("TPSUID7RB: decompression failed");
-      }
-    }
-    // Browser: would need pako or similar library
-    throw new Error("TPSUID7RB: decompression not available in browser");
-  }
-
-  // ---------------------------
-  // Cryptographic Sealing (Ed25519)
-  // ---------------------------
-
-  /**
-   * Seal (sign) a TPS string to create a cryptographically verifiable TPS-UID.
-   * This appends an Ed25519 signature to the binary form.
-   *
-   * @param tps - The TPS string to seal
-   * @param privateKey - Ed25519 private key (hex or buffer)
-   * @param opts - Encoding options
-   * @returns Sealed binary TPS-UID
-   */
-  static seal(
-    tps: string,
-    privateKey: string | Buffer | Uint8Array,
-    opts?: TPSUID7RBEncodeOptions,
-  ): Uint8Array {
-    // 1. Create standard binary (unsealed first)
-    // We force the SEAL flag (bit 1) to be 0 initially for the "content to sign"
-    // But wait, we want the signature to cover the header too.
-    // Strategy: Construct the full binary with SEAL flag OFF, sign it, then set SEAL flag ON and append sig.
-    // Actually, the standard way is:
-    // Content = MAGIC + VER + FLAGS(with seal bit set) + TIME + NONCE + LEN + PAYLOAD
-    // Signature = Sign(Content)
-    // Final = Content + SEAL_TYPE + SIGNATURE
-
-    const compress = opts?.compress ?? false;
-    const epochMs = opts?.epochMs ?? this.epochMsFromTPSString(tps);
-
-    // Validate epoch
-    if (!Number.isInteger(epochMs) || epochMs < 0 || epochMs > 0xffffffffffff) {
-      throw new Error("epochMs must be a valid 48-bit non-negative integer");
+      });
+      if (Object.keys(ctx).length > 0) components.context = ctx;
     }
 
-    // Flags: Bit 0 = compress, Bit 1 = sealed
-    const flags = (compress ? 0x01 : 0x00) | 0x02; // Set SEAL bit
-
-    // Generate Nonce
-    const nonceBuf = this.randomBytes(4);
-
-    // Encode Payload
-    const tpsUtf8 = new TextEncoder().encode(tps);
-    const payload = compress ? this.deflateRaw(tpsUtf8) : tpsUtf8;
-    const lenVar = this.uvarintEncode(payload.length);
-
-    // Construct Content (Header + Payload)
-    const contentLen = 4 + 1 + 1 + 6 + 4 + lenVar.length + payload.length;
-    const content = new Uint8Array(contentLen);
-    let offset = 0;
-
-    content.set(this.MAGIC, offset);
-    offset += 4;
-    content[offset++] = this.VER;
-    content[offset++] = flags;
-    content.set(this.writeU48(epochMs), offset);
-    offset += 6;
-    content.set(nonceBuf, offset);
-    offset += 4;
-    content.set(lenVar, offset);
-    offset += lenVar.length;
-    content.set(payload, offset);
-
-    // Sign the content
-    const signature = this.signEd25519(content, privateKey);
-    const sealType = 0x01; // Ed25519
-
-    // Final Output: Content + SealType (1) + Signature (64)
-    const final = new Uint8Array(contentLen + 1 + signature.length);
-    final.set(content, 0);
-    final.set([sealType], contentLen);
-    final.set(signature, contentLen + 1);
-
-    return final;
+    return components as TPSComponents;
   }
 
   /**
-   * Verify a sealed TPS-UID and decode it.
-   * Throws if signature is invalid or not sealed.
-   *
-   * @param sealedBytes - The binary sealed TPS-UID
-   * @param publicKey - Ed25519 public key (hex or buffer) to verify against
-   * @returns Decoded result
+   * Parses a multi-layer location string (before @T:) into component fields.
+   * Layers are `;`-separated. Each layer is identified by its prefix token.
+   *
+   * Supported layers:
+   *   L:lat,lon[,altm]         — GPS
+   *   L:~|L:-|L:redacted       — Privacy markers
+   *   P:cc=JO,ci=AMM,...       — Place (country/city codes and names)
+   *   S2:token                 — S2 cell
+   *   H3:token                 — H3 cell
+   *   3W:word.word.word        — What3Words
+   *   plus:token               — Plus Code
+   *   net:ip4:x.x.x.x          — IPv4
+   *   net:ip6:x::x             — IPv6
+   *   node:name                — Logical node/host
+   *   bldg:name                — Building
+   *   floor:x                  — Floor
+   *   room:x                   — Room
+   *   door:x                   — Door
+   *   zone:x                   — Zone
    */
-  static verifyAndDecode(
-    sealedBytes: Uint8Array,
-    publicKey: string | Buffer | Uint8Array,
-  ): TPSUID7RBDecodeResult {
-    if (sealedBytes.length < 18) throw new Error("TPSUID7RB: too short");
-
-    // Check Magic
-    if (
-      sealedBytes[0] !== 0x54 ||
-      sealedBytes[1] !== 0x50 ||
-      sealedBytes[2] !== 0x55 ||
-      sealedBytes[3] !== 0x37
-    ) {
-      throw new Error("TPSUID7RB: bad magic");
-    }
-
-    // Check Flags for Sealed Bit (bit 1)
-    const flags = sealedBytes[5];
-    if ((flags & 0x02) === 0) {
-      throw new Error("TPSUID7RB: not a sealed UID");
-    }
-
-    // 1. Parse the structure to find where content ends
-    // We need to parse LEN and Payload to find the split point
-    let offset = 16; // Start of LEN
-    // Decode LEN
-    const { value: tpsLen, bytesRead } = this.uvarintDecode(
-      sealedBytes,
-      offset,
-    );
-    offset += bytesRead;
-    const payloadEnd = offset + tpsLen;
-
-    if (payloadEnd > sealedBytes.length) {
-      throw new Error("TPSUID7RB: length overflow (truncated)");
-    }
-
-    // The Content to verify matches exactly [0 ... payloadEnd]
-    const content = sealedBytes.slice(0, payloadEnd);
-
-    // After content: SealType (1 byte) + Signature
-    if (sealedBytes.length <= payloadEnd + 1) {
-      throw new Error("TPSUID7RB: missing signature data");
-    }
-
-    const sealType = sealedBytes[payloadEnd];
-    if (sealType !== 0x01) {
-      throw new Error(
-        `TPSUID7RB: unsupported seal type 0x${sealType.toString(16)}`,
-      );
-    }
-
-    const signature = sealedBytes.slice(payloadEnd + 1);
-    if (signature.length !== 64) {
-      throw new Error(
-        `TPSUID7RB: invalid Ed25519 signature length ${signature.length}`,
-      );
-    }
-
-    // Verify
-    const isValid = this.verifyEd25519(content, signature, publicKey);
-    if (!isValid) {
-      throw new Error("TPSUID7RB: signature verification failed");
-    }
-
-    // Decode (reuse standard logic, but ignoring the extra bytes at end is fine?)
-    // Actually standard logic doesn't expect trailing bytes unless we tell it to.
-    // But since we verified, we can just slice the content and decode that as a strict binary
-    // EXCEPT standard decodeBinary checks strict length.
-    // So we manually decode the components here to be safe and efficient.
-
-    return this.decodeBinary(content); // Reuse strict decoder on the content part
-  }
-
-  // --- Crypto Implementation (Ed25519) ---
-
-  private static signEd25519(
-    data: Uint8Array,
-    privateKey: string | Buffer | Uint8Array,
-  ): Uint8Array {
-    if (typeof require !== "undefined") {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const crypto = require("crypto");
-
-        let key: any;
-        if (typeof privateKey === "string") {
-          if (privateKey.includes("PRIVATE KEY")) {
-            // PEM format — use directly
-            key = privateKey;
-          } else {
-            // Hex-encoded DER/PKCS8
-            key = crypto.createPrivateKey({
-              key: Buffer.from(privateKey, "hex"),
-              format: "der",
-              type: "pkcs8",
-            });
-          }
-        } else if (
-          typeof privateKey === "object" &&
-          privateKey !== null &&
-          "asymmetricKeyType" in privateKey
-        ) {
-          // Node.js KeyObject (e.g. from crypto.generateKeyPairSync)
-          key = privateKey;
-        } else {
-          // Buffer or Uint8Array — assume DER/PKCS8 encoded
-          key = crypto.createPrivateKey({
-            key: Buffer.from(privateKey as Uint8Array),
-            format: "der",
-            type: "pkcs8",
-          });
-        }
-
-        return new Uint8Array(crypto.sign(null, data, key));
-      } catch (e) {
-        throw new Error("TPSUID7RB: signing failed (check key format)");
+  private static _parseLocationLayers(location: string, components: any): void {
+    const layers = location.trim().split(";");
+
+    for (const layer of layers) {
+      const l = layer.trim();
+      if (!l) continue;
+
+      // Privacy shorthand
+      if (l === "L:~" || l === "L:hidden") { components.isHiddenLocation = true; continue; }
+      if (l === "L:-" || l === "L:unknown") { components.isUnknownLocation = true; continue; }
+      if (l === "L:redacted") { components.isRedactedLocation = true; continue; }
+
+      // P: Place layer — P:cc=JO,ci=AMM,cn=Jordan,ct=Amman
+      if (l.startsWith("P:")) {
+        l.slice(2).split(",").forEach((pair: string) => {
+          const eq = pair.indexOf("=");
+          if (eq < 1) return;
+          const k = pair.substring(0, eq).toLowerCase();
+          const v = pair.substring(eq + 1);
+          if (k === "cc") components.placeCountryCode = v;
+          else if (k === "cn") components.placeCountryName = v;
+          else if (k === "ci") components.placeCityCode = v;
+          else if (k === "ct") components.placeCityName = v;
+        });
+        continue;
       }
-    }
-    throw new Error("TPSUID7RB: signing not available in browser");
-  }
 
-  private static verifyEd25519(
-    data: Uint8Array,
-    signature: Uint8Array,
-    publicKey: string | Buffer | Uint8Array,
-  ): boolean {
-    if (typeof require !== "undefined") {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const crypto = require("crypto");
-        return crypto.verify(null, data, publicKey, signature);
-      } catch {
-        return false;
+      // GPS coordinates (L:lat,lon[,alt])
+      if (l.startsWith("L:")) {
+        const coords = l.slice(2);
+        const m = coords.match(/^(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)(?:,(-?\d+(?:\.\d+)?)m?)?$/);
+        if (m) {
+          components.latitude = parseFloat(m[1]);
+          components.longitude = parseFloat(m[2]);
+          if (m[3]) components.altitude = parseFloat(m[3]);
+        }
+        continue;
       }
-    }
-    throw new Error("TPSUID7RB: verification not available in browser");
-  }
 
-  // ---------------------------
-  // Random Bytes
-  // ---------------------------
-
-  /** Generate cryptographically secure random bytes */
-  private static randomBytes(length: number): Uint8Array {
-    // Node.js environment
-    if (typeof require !== "undefined") {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const crypto = require("crypto");
-        return new Uint8Array(crypto.randomBytes(length));
-      } catch {
-        // Fallback to crypto.getRandomValues
+      // Geospatial cells
+      if (/^S2:/i.test(l)) { components.s2Cell = l.slice(3); continue; }
+      if (/^H3:/i.test(l)) { components.h3Cell = l.slice(3); continue; }
+      if (/^3W:/i.test(l)) { components.what3words = l.slice(3); continue; }
+      if (/^plus:/i.test(l)) { components.plusCode = l.slice(5); continue; }
+
+      // Network
+      if (/^net:ip4:/i.test(l)) { components.ipv4 = l.slice(8); continue; }
+      if (/^net:ip6:/i.test(l)) { components.ipv6 = l.slice(8); continue; }
+      if (/^node:/i.test(l)) { components.nodeName = l.slice(5); continue; }
+
+      // Structural
+      if (/^bldg:/i.test(l)) { components.building = l.slice(5); continue; }
+      if (/^floor:/i.test(l)) { components.floor = l.slice(6); continue; }
+      if (/^room:/i.test(l)) { components.room = l.slice(5); continue; }
+      if (/^door:/i.test(l)) { components.door = l.slice(5); continue; }
+      if (/^zone:/i.test(l)) { components.zone = l.slice(5); continue; }
+
+      // Fallback: generic space anchor (adm:, planet:, legacy strings)
+      if (l) {
+        components.spaceAnchor = components.spaceAnchor
+          ? components.spaceAnchor + ";" + l
+          : l;
       }
     }
-    // Browser or fallback
-    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-      const bytes = new Uint8Array(length);
-      crypto.getRandomValues(bytes);
-      return bytes;
-    }
-    throw new Error("TPSUID7RB: no crypto available");
   }
 }
 
+// register built-in drivers and set default
+// (tps and gregorian provide canonical conversions before unix)
+TPS.registerDriver(new TpsDriver());
+TPS.registerDriver(new GregorianDriver());
+TPS.registerDriver(new UnixDriver());
+TPS.registerDriver(new PersianDriver());
+TPS.registerDriver(new HijriDriver());
+TPS.registerDriver(new JulianDriver());
+TPS.registerDriver(new HoloceneDriver());
+TPS.registerDriver(new ChineseDriver());
+
 /**
  * `TpsDate` is a Date-like wrapper with native TPS conversion helpers.
  *
@@ -1844,247 +916,3 @@ export class TPSUID7RB {
  * - `new TpsDate(tpsString)`
  * - `new TpsDate(year, monthIndex, day?, hour?, minute?, second?, ms?)`
  */
-export class TpsDate {
-  private readonly internal: Date;
-
-  private getTpsComponents(): TPSComponents {
-    const parsed = TPS.parse(this.toTPS(DefaultCalendars.TPS));
-    if (!parsed) {
-      throw new Error("TpsDate: failed to derive TPS components");
-    }
-    return parsed;
-  }
-
-  private getTpsFullYear(): number {
-    const comp = this.getTpsComponents();
-    return (comp.millennium - 1) * 1000 + (comp.century - 1) * 100 + comp.year;
-  }
-
-  constructor();
-  constructor(value: string | number | Date | TpsDate);
-  constructor(
-    year: number,
-    monthIndex: number,
-    day?: number,
-    hours?: number,
-    minutes?: number,
-    seconds?: number,
-    ms?: number,
-  );
-  constructor(
-    ...args:
-      | []
-      | [string | number | Date | TpsDate]
-      | [number, number, number?, number?, number?, number?, number?]
-  ) {
-    if (args.length === 0) {
-      this.internal = new Date();
-      return;
-    }
-
-    if (args.length === 1) {
-      const value = args[0];
-      if (value instanceof TpsDate) {
-        this.internal = new Date(value.getTime());
-        return;
-      }
-      if (value instanceof Date) {
-        this.internal = new Date(value.getTime());
-        return;
-      }
-      if (typeof value === "string" && TpsDate.looksLikeTPS(value)) {
-        const parsed = TPS.toDate(value);
-        if (!parsed) {
-          throw new RangeError(`Invalid TPS date string: ${value}`);
-        }
-        this.internal = parsed;
-        return;
-      }
-
-      this.internal = new Date(value);
-      return;
-    }
-
-    const [year, monthIndex, day, hours, minutes, seconds, ms] = args;
-    this.internal = new Date(
-      year,
-      monthIndex,
-      day ?? 1,
-      hours ?? 0,
-      minutes ?? 0,
-      seconds ?? 0,
-      ms ?? 0,
-    );
-  }
-
-  private static looksLikeTPS(input: string): boolean {
-    const s = input.trim();
-    return s.startsWith("tps://") || s.startsWith("T:") || s.startsWith("t:");
-  }
-
-  static now(): number {
-    return Date.now();
-  }
-
-  static parse(input: string): number {
-    if (this.looksLikeTPS(input)) {
-      const d = TPS.toDate(input);
-      return d ? d.getTime() : Number.NaN;
-    }
-    return Date.parse(input);
-  }
-
-  static UTC(
-    year: number,
-    monthIndex: number,
-    day?: number,
-    hours?: number,
-    minutes?: number,
-    seconds?: number,
-    ms?: number,
-  ): number {
-    return Date.UTC(
-      year,
-      monthIndex,
-      day ?? 1,
-      hours ?? 0,
-      minutes ?? 0,
-      seconds ?? 0,
-      ms ?? 0,
-    );
-  }
-
-  static fromTPS(tps: string): TpsDate {
-    return new TpsDate(tps);
-  }
-
-  toGregorianDate(): Date {
-    return new Date(this.internal.getTime());
-  }
-
-  toDate(): Date {
-    return this.toGregorianDate();
-  }
-
-  toTPS(
-    calendar: string = DefaultCalendars.TPS,
-    opts?: { order?: TimeOrder },
-  ): string {
-    return TPS.fromDate(this.internal, calendar, opts);
-  }
-
-  toTPSURI(
-    calendar: string = DefaultCalendars.TPS,
-    opts?: {
-      order?: TimeOrder;
-      latitude?: number;
-      longitude?: number;
-      altitude?: number;
-      isUnknownLocation?: boolean;
-      isHiddenLocation?: boolean;
-      isRedactedLocation?: boolean;
-    },
-  ): string {
-    const time = this.toTPS(calendar, { order: opts?.order });
-    const comp = TPS.parse(time) as TPSComponents;
-
-    if (opts?.latitude !== undefined && opts?.longitude !== undefined) {
-      comp.latitude = opts.latitude;
-      comp.longitude = opts.longitude;
-      if (opts.altitude !== undefined) comp.altitude = opts.altitude;
-    } else if (opts?.isHiddenLocation) {
-      comp.isHiddenLocation = true;
-    } else if (opts?.isRedactedLocation) {
-      comp.isRedactedLocation = true;
-    } else {
-      comp.isUnknownLocation = true;
-    }
-
-    return TPS.toURI(comp);
-  }
-
-  getTime(): number {
-    return this.internal.getTime();
-  }
-
-  valueOf(): number {
-    return this.internal.valueOf();
-  }
-
-  toString(): string {
-    return this.toTPS(DefaultCalendars.TPS);
-  }
-
-  toISOString(): string {
-    return this.internal.toISOString();
-  }
-
-  toUTCString(): string {
-    return this.internal.toUTCString();
-  }
-
-  toJSON(): string | null {
-    return this.internal.toJSON();
-  }
-
-  getFullYear(): number {
-    return this.getTpsFullYear();
-  }
-
-  getUTCFullYear(): number {
-    return this.getTpsFullYear();
-  }
-
-  getMonth(): number {
-    return this.getTpsComponents().month - 1;
-  }
-
-  getUTCMonth(): number {
-    return this.getTpsComponents().month - 1;
-  }
-
-  getDate(): number {
-    return this.getTpsComponents().day;
-  }
-
-  getUTCDate(): number {
-    return this.getTpsComponents().day;
-  }
-
-  getHours(): number {
-    return this.getTpsComponents().hour;
-  }
-
-  getUTCHours(): number {
-    return this.getTpsComponents().hour;
-  }
-
-  getMinutes(): number {
-    return this.getTpsComponents().minute;
-  }
-
-  getUTCMinutes(): number {
-    return this.getTpsComponents().minute;
-  }
-
-  getSeconds(): number {
-    return this.getTpsComponents().second;
-  }
-
-  getUTCSeconds(): number {
-    return this.getTpsComponents().second;
-  }
-
-  getMilliseconds(): number {
-    return this.getTpsComponents().millisecond;
-  }
-
-  getUTCMilliseconds(): number {
-    return this.getTpsComponents().millisecond;
-  }
-
-  [Symbol.toPrimitive](hint: string): string | number {
-    if (hint === "number") return this.valueOf();
-    return this.toString();
-  }
-}