@nextera.one/tps-standard 0.5.33 → 0.6.0

package/dist/index.js

@@ -3,18 +3,40 @@
  * 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
  * - Added structural anchors (bldg, floor, room, zone)
  * - Added geospatial cell systems (S2, H3, Plus Code, what3words)
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TpsDate = exports.TPSUID7RB = exports.TPS = exports.TimeOrder = exports.DefaultCalendars = void 0;
+exports.TPS = exports.getOffsetString = exports.localToUtc = exports.utcToLocal = exports.DriverManager = exports.Env = void 0;
 // built-in drivers are registered automatically; importing them here
 // ensures they are included when the library bundler/tree-shaker runs.
 const gregorian_1 = require("./drivers/gregorian");
@@ -24,35 +46,29 @@ const persian_1 = require("./drivers/persian");
 const hijri_1 = require("./drivers/hijri");
 const julian_1 = require("./drivers/julian");
 const holocene_1 = require("./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.
-exports.DefaultCalendars = {
-    TPS: "tps",
-    GREG: "greg",
-    HIJ: "hij",
-    PER: "per",
-    JUL: "jul",
-    HOLO: "holo",
-    UNIX: "unix",
-};
-/**
- * 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.
- */
-var TimeOrder;
-(function (TimeOrder) {
-    TimeOrder["DESC"] = "desc";
-    TimeOrder["ASC"] = "asc";
-})(TimeOrder || (exports.TimeOrder = TimeOrder = {}));
+const chinese_1 = require("./drivers/chinese");
+__exportStar(require("./types"), exports);
+__exportStar(require("./uid"), exports);
+__exportStar(require("./date"), exports);
+var env_1 = require("./utils/env");
+Object.defineProperty(exports, "Env", { enumerable: true, get: function () { return env_1.Env; } });
+var driver_manager_1 = require("./driver-manager");
+Object.defineProperty(exports, "DriverManager", { enumerable: true, get: function () { return driver_manager_1.DriverManager; } });
+var timezone_1 = require("./utils/timezone");
+Object.defineProperty(exports, "utcToLocal", { enumerable: true, get: function () { return timezone_1.utcToLocal; } });
+Object.defineProperty(exports, "localToUtc", { enumerable: true, get: function () { return timezone_1.localToUtc; } });
+Object.defineProperty(exports, "getOffsetString", { enumerable: true, get: function () { return timezone_1.getOffsetString; } });
+const driver_manager_2 = require("./driver-manager");
+const tps_string_1 = require("./utils/tps-string");
+const timezone_2 = require("./utils/timezone");
+const types_1 = require("./types");
 class TPS {
     /**
      * Registers a calendar driver plugin.
      * @param driver - The driver instance to register.
      */
     static registerDriver(driver) {
-        this.drivers.set(driver.code, driver);
+        this.driverManager.register(driver);
     }
     /**
      * Gets a registered calendar driver.
@@ -60,7 +76,7 @@ class TPS {
      * @returns The driver or undefined.
      */
     static getDriver(code) {
-        return this.drivers.get(code);
+        return this.driverManager.get(code);
     }
     // --- CORE METHODS ---
     /**
@@ -76,6 +92,24 @@ 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.
@@ -208,7 +242,7 @@ class TPS {
                 timeStr = timeStr.split(/[!;?#]/)[0];
             }
             if (timeStr) {
-                const parsed = this.parseTimeString(timeStr);
+                const parsed = (0, tps_string_1.parseTimeString)(timeStr);
                 if (!parsed)
                     return null;
                 Object.assign(comp, parsed.components);
@@ -231,13 +265,34 @@ class TPS {
             signature = sigMatch.groups.sig;
             timeOnly = input.split(/[!;?#]/)[0];
         }
-        const parsed = this.parseTimeString(timeOnly);
+        else {
+            // Strip extension/query/fragment suffix so parseTimeString sees only tokens
+            timeOnly = input.split(/[;?#]/)[0];
+        }
+        const parsed = (0, tps_string_1.parseTimeString)(timeOnly);
         if (!parsed)
             return null;
         const comp = parsed.components;
         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 = {
+            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;
     }
     /**
@@ -246,64 +301,99 @@ class TPS {
      * @returns Full URI string (e.g. "tps://...").
      */
     static toURI(comp) {
-        // 1. Build Space Part (L: anchor)
-        let spacePart = "L:-"; // Default: unknown
-        if (comp.spaceAnchor) {
-            spacePart = comp.spaceAnchor;
-        }
-        else if (comp.isHiddenLocation) {
-            spacePart = "L:~";
+        // ── 1. Location layers (v0.6.0) ──────────────────────────────────────────
+        // Build an ordered list of location layer strings, then join with ";"
+        const layers = [];
+        // 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}`;
+            layers.push(`bldg:${comp.building}`);
             if (comp.floor)
-                spacePart += `.floor=${comp.floor}`;
+                layers.push(`floor:${comp.floor}`);
             if (comp.room)
-                spacePart += `.room=${comp.room}`;
+                layers.push(`room:${comp.room}`);
+            if (comp.door)
+                layers.push(`door:${comp.door}`);
             if (comp.zone)
-                spacePart += `.zone=${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);
         }
-        // 2. Build Actor Part (A: anchor) - optional
-        let actorPart = "";
-        if (comp.actor) {
-            actorPart = `/A:${comp.actor}`;
-        }
-        // 3. Build Time Part (handles order & signature)
-        const timePart = this.buildTimePart(comp);
-        // 5. Build Extensions
+        else {
+            layers.push("L:-"); // unknown fallback
+        }
+        // Place layer (P:) — appended after primary location
+        if (comp.placeCountryCode || comp.placeCountryName ||
+            comp.placeCityCode || comp.placeCityName) {
+            const pParts = [];
+            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(",")}`);
+        }
+        const locationStr = layers.join(";");
+        // ── 2. Actor (/A:...) ─────────────────────────────────────────────────────
+        const actorPart = comp.actor ? `/A:${comp.actor}` : "";
+        // ── 3. Time (mandatory 9 tokens) ─────────────────────────────────────────
+        const timePart = (0, tps_string_1.buildTimePart)(comp);
+        // ── 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}`;
     }
     /**
      * CONVERTER: Creates a TPS Time Object string from a JavaScript Date.
@@ -314,9 +404,9 @@ class TPS {
      *   supported key is `order` which may be `'ascending'` or `'descending'`.
      * @returns Canonical string (e.g., "T:tps.m3.c1.y26...").
      */
-    static fromDate(date = new Date(), calendar = exports.DefaultCalendars.TPS, opts) {
+    static fromDate(date = new Date(), calendar = types_1.DefaultCalendars.TPS, opts) {
         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
@@ -326,21 +416,21 @@ class TPS {
                 const comp = driver.getComponentsFromDate(date);
                 comp.calendar = normalizedCalendar;
                 comp.order = opts.order;
-                return this.buildTimePart(comp);
+                return (0, tps_string_1.buildTimePart)(comp);
             }
             return driver.getFromDate(date);
         }
         // Fallback for old built-in calendars (shouldn't happen once drivers are
         // registered, but kept for backwards compatibility).
         const comp = { calendar: normalizedCalendar };
-        if (normalizedCalendar === exports.DefaultCalendars.UNIX) {
+        if (normalizedCalendar === types_1.DefaultCalendars.UNIX) {
             const s = (date.getTime() / 1000).toFixed(3);
             comp.unixSeconds = parseFloat(s);
             if (opts?.order)
                 comp.order = opts.order;
-            return this.buildTimePart(comp);
+            return (0, tps_string_1.buildTimePart)(comp);
         }
-        if (normalizedCalendar === exports.DefaultCalendars.GREG) {
+        if (normalizedCalendar === types_1.DefaultCalendars.GREG) {
             const fullYear = date.getUTCFullYear();
             comp.millennium = Math.floor(fullYear / 1000) + 1;
             comp.century = Math.floor((fullYear % 1000) / 100) + 1;
@@ -353,7 +443,7 @@ class TPS {
             comp.millisecond = date.getUTCMilliseconds();
             if (opts?.order)
                 comp.order = opts.order;
-            return this.buildTimePart(comp);
+            return (0, tps_string_1.buildTimePart)(comp);
         }
         throw new Error(`Calendar driver '${normalizedCalendar}' not implemented. Register a driver.`);
     }
@@ -382,13 +472,22 @@ class TPS {
         const parsed = this.parse(tpsString);
         if (!parsed)
             return null;
-        const cal = parsed.calendar || exports.DefaultCalendars.TPS;
-        const driver = this.drivers.get(cal);
+        const cal = parsed.calendar || types_1.DefaultCalendars.TPS;
+        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 = (0, timezone_2.localToUtc)(localMs, tz);
+            return new Date(utcMs);
+        }
+        return date;
     }
     // --- DRIVER CONVENIENCE METHODS ---
     /**
@@ -410,7 +509,7 @@ class TPS {
      * ```
      */
     static parseCalendarDate(calendar, dateString, format) {
-        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.`);
         }
@@ -471,926 +570,319 @@ class TPS {
      * ```
      */
     static formatCalendarDate(calendar, components, format) {
-        const driver = this.drivers.get(calendar);
+        const driver = this.driverManager.get(calendar);
         if (!driver) {
             throw new Error(`Calendar driver '${calendar}' not found.`);
         }
         // format is guaranteed by the interface, so we can call it directly.
         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)`.
      *
-     * Drivers may ignore this helper and produce their own time strings if they
-     * implement custom ordering logic.
+     * @param calendar - Calendar code. Defaults to 'greg'.
+     * @param opts - Optional `order` (ASC/DESC) parameter.
+     * @returns TPS time string.
+     *
+     * @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"
+     * ```
      */
-    static buildTimePart(comp) {
-        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 === exports.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 = [
-            ["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 = 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 = types_1.DefaultCalendars.GREG, opts) {
+        return this.fromDate(new Date(), calendar, opts);
     }
     /**
-     * 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, t2) {
+        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) {
-        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)
+    static add(tpsStr, duration) {
+        const date = this.toDate(tpsStr);
+        if (!date)
             return null;
-        const calendar = parts[0];
-        const comp = { calendar };
-        // Fixed-rank prefixes (unambiguous regardless of position)
-        const fixedRankMap = {
-            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.DESC;
-        if (calendar !== exports.DefaultCalendars.UNIX) {
-            const nonMRanks = [];
-            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, ord) => {
-            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 = [];
-        let lastAssignedRank = 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 === exports.DefaultCalendars.UNIX && prefix === "s") {
-                comp.unixSeconds = parseFloat(value);
-                ranks.push(9);
-                continue;
-            }
-            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;
-                }
-            }
-        }
-        // ── Step 4: confirm order from the complete rank sequence ────────────────
-        let order = 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
-        }
-        return { components: comp, order };
+        const parsed = this.parse(tpsStr);
+        const calendar = parsed?.calendar ?? types_1.DefaultCalendars.GREG;
+        const order = parsed?.order;
+        const deltaMs = (duration.days ?? 0) * 86400000 +
+            (duration.hours ?? 0) * 3600000 +
+            (duration.minutes ?? 0) * 60000 +
+            (duration.seconds ?? 0) * 1000 +
+            (duration.milliseconds ?? 0);
+        const shifted = new Date(date.getTime() + deltaMs);
+        return this.fromDate(shifted, calendar, order ? { order } : undefined);
     }
+    // --- INTERNAL HELPERS ---
     static _mapGroupsToComponents(g) {
         const components = {};
         components.calendar = g.calendar;
-        // 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 = {};
-            const parts = g.extensions.split(".");
-            parts.forEach((p) => {
-                const eqIdx = p.indexOf("=");
-                if (eqIdx > 0) {
-                    const key = p.substring(0, eqIdx);
-                    const val = p.substring(eqIdx + 1);
-                    if (key && val)
+            g.extensions.split(";").forEach((part) => {
+                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 {
-                    // Legacy format: first char is key
-                    const key = p.charAt(0);
-                    const val = p.substring(1);
-                    if (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;
+            if (Object.keys(extObj).length > 0)
+                components.extensions = extObj;
+        }
+        // ── Context (#C:key=val;key=val) ─────────────────────────────────────────
+        if (g.context) {
+            const ctx = {};
+            g.context.split(";").forEach((part) => {
+                part = part.trim();
+                if (!part)
+                    return;
+                const eqIdx = part.indexOf("=");
+                if (eqIdx > 0) {
+                    ctx[part.substring(0, eqIdx)] = part.substring(eqIdx + 1);
+                }
+            });
+            if (Object.keys(ctx).length > 0)
+                components.context = ctx;
         }
         return components;
     }
-}
-exports.TPS = TPS;
-// --- PLUGIN REGISTRY ---
-TPS.drivers = new Map();
-// --- 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).
-TPS.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>[^/@]+))?" +
-    "@T:(?<calendar>[a-z]{3,4})" +
-    "(?:\\.(?:m-?\\d+|c\\d+|y\\d+|d\\d{1,2}|h\\d{1,2}|s\\d+(?:\\.\\d+)?))*" +
-    "(?:![^;?#]+)?" +
-    "(?:;(?<extensions>[^?#]+))?" +
-    "(?:\\?[^#]+)?" +
-    "(?:#.+)?$");
-TPS.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+)?))*" +
-    "(?:![^;?#]+)?$");
-// register built-in drivers and set default
-// (tps and gregorian provide canonical conversions before unix)
-TPS.registerDriver(new tps_1.TpsDriver());
-TPS.registerDriver(new gregorian_1.GregorianDriver());
-TPS.registerDriver(new unix_1.UnixDriver());
-TPS.registerDriver(new persian_1.PersianDriver());
-TPS.registerDriver(new hijri_1.HijriDriver());
-TPS.registerDriver(new julian_1.JulianDriver());
-TPS.registerDriver(new holocene_1.HoloceneDriver());
-/**
- * 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
- * ```
- */
-class TPSUID7RB {
-    // ---------------------------
-    // 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, opts = {}) {
-        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) {
-        // 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}`);
-        }
-        // 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.
+     * Parses a multi-layer location string (before @T:) into component fields.
+     * Layers are `;`-separated. Each layer is identified by its prefix token.
      *
-     * @param tps - The TPS string to encode
-     * @param opts - Encoding options
-     * @returns Base64url encoded TPS-UID with prefix
+     * 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 encodeBinaryB64(tps, opts) {
-        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) {
-        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) {
-        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) {
-        const now = new Date();
-        const time = TPS.fromDate(now, exports.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`;
+    static _parseLocationLayers(location, components) {
+        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;
             }
-        }
-        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) {
-        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) */
-    static writeU48(epochMs) {
-        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) */
-    static readU48(bytes, offset) {
-        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 */
-    static uvarintEncode(n) {
-        if (!Number.isInteger(n) || n < 0) {
-            throw new Error("uvarint must be non-negative int");
-        }
-        const out = [];
-        let x = n >>> 0;
-        while (x >= 0x80) {
-            out.push((x & 0x7f) | 0x80);
-            x >>>= 7;
-        }
-        out.push(x);
-        return new Uint8Array(out);
-    }
-    /** Decode LEB128 varint */
-    static uvarintDecode(bytes, offset) {
-        let x = 0;
-        let s = 0;
-        let i = 0;
-        while (true) {
-            if (offset + i >= bytes.length) {
-                throw new Error("uvarint overflow");
+            if (l === "L:-" || l === "L:unknown") {
+                components.isUnknownLocation = true;
+                continue;
             }
-            const b = bytes[offset + i];
-            if (b < 0x80) {
-                if (i > 9 || (i === 9 && b > 1)) {
-                    throw new Error("uvarint too large");
+            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) => {
+                    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;
+            }
+            // 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]);
                 }
-                x |= b << s;
-                return { value: x >>> 0, bytesRead: i + 1 };
+                continue;
             }
-            x |= (b & 0x7f) << s;
-            s += 7;
-            i++;
-            if (i > 10) {
-                throw new Error("uvarint too long");
+            // Geospatial cells
+            if (/^S2:/i.test(l)) {
+                components.s2Cell = l.slice(3);
+                continue;
             }
-        }
-    }
-    // ---------------------------
-    // Base64url Helpers
-    // ---------------------------
-    /** Encode bytes to base64url (no padding) */
-    static base64UrlEncode(bytes) {
-        // 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 */
-    static base64UrlDecode(b64url) {
-        // 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 */
-    static deflateRaw(data) {
-        // 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)));
+            if (/^H3:/i.test(l)) {
+                components.h3Cell = l.slice(3);
+                continue;
             }
-            catch {
-                throw new Error("TPSUID7RB: compression not available");
+            if (/^3W:/i.test(l)) {
+                components.what3words = l.slice(3);
+                continue;
             }
-        }
-        // Browser: would need pako or similar library
-        throw new Error("TPSUID7RB: compression not available in browser");
-    }
-    /** Decompress using zlib inflate raw */
-    static inflateRaw(data) {
-        // 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)));
+            if (/^plus:/i.test(l)) {
+                components.plusCode = l.slice(5);
+                continue;
             }
-            catch {
-                throw new Error("TPSUID7RB: decompression failed");
+            // Network
+            if (/^net:ip4:/i.test(l)) {
+                components.ipv4 = l.slice(8);
+                continue;
             }
-        }
-        // 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, privateKey, opts) {
-        // 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");
-        }
-        // 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;
-    }
-    /**
-     * 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
-     */
-    static verifyAndDecode(sealedBytes, publicKey) {
-        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) ---
-    static signEd25519(data, privateKey) {
-        if (typeof require !== "undefined") {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                const crypto = require("crypto");
-                let key;
-                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),
-                        format: "der",
-                        type: "pkcs8",
-                    });
-                }
-                return new Uint8Array(crypto.sign(null, data, key));
+            if (/^net:ip6:/i.test(l)) {
+                components.ipv6 = l.slice(8);
+                continue;
             }
-            catch (e) {
-                throw new Error("TPSUID7RB: signing failed (check key format)");
+            if (/^node:/i.test(l)) {
+                components.nodeName = l.slice(5);
+                continue;
             }
-        }
-        throw new Error("TPSUID7RB: signing not available in browser");
-    }
-    static verifyEd25519(data, signature, publicKey) {
-        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);
+            // Structural
+            if (/^bldg:/i.test(l)) {
+                components.building = l.slice(5);
+                continue;
             }
-            catch {
-                return false;
+            if (/^floor:/i.test(l)) {
+                components.floor = l.slice(6);
+                continue;
             }
-        }
-        throw new Error("TPSUID7RB: verification not available in browser");
-    }
-    // ---------------------------
-    // Random Bytes
-    // ---------------------------
-    /** Generate cryptographically secure random bytes */
-    static randomBytes(length) {
-        // 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));
+            if (/^room:/i.test(l)) {
+                components.room = l.slice(5);
+                continue;
             }
-            catch {
-                // Fallback to crypto.getRandomValues
+            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");
     }
 }
-exports.TPSUID7RB = TPSUID7RB;
-/** Magic bytes: "TPU7" */
-TPSUID7RB.MAGIC = new Uint8Array([0x54, 0x50, 0x55, 0x37]);
-/** Version 1 */
-TPSUID7RB.VER = 0x01;
-/** String prefix for base64url encoded form */
-TPSUID7RB.PREFIX = "tpsuid7rb_";
-/** Regex for validating base64url encoded form */
-TPSUID7RB.REGEX = /^tpsuid7rb_[A-Za-z0-9_-]+$/;
+exports.TPS = TPS;
+// --- PLUGIN REGISTRY ---
+/** Shared DriverManager instance — use TPS.driverManager for direct access. */
+TPS.driverManager = new driver_manager_2.DriverManager();
+// --- 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:)
+TPS.REGEX_URI = new RegExp("^tps://" +
+    // Location: everything up to optional /A: actor and then @T:
+    "(?<location>[^@]+?)" +
+    // Optional actor overlay
+    "(?:/A:(?<actor>[^@]+))?" +
+    // Time section
+    "@T:(?<calendar>[a-z]{3,4})" +
+    "(?<tokens>(?:\\.[a-z]-?[\\d.]+)*)" +
+    // Optional signature
+    "(?:!(?<signature>[^;#]+))?" +
+    // Optional extensions (;KEY:val;key=val;...)
+    "(?:;(?<extensions>[^#]+))?" +
+    // Optional context fragment (#C:key=val;...)
+    "(?:#C:(?<context>.+))?$");
+TPS.REGEX_TIME = new RegExp("^T:(?<calendar>[a-z]{3,4})" +
+    "(?<tokens>(?:\\.[a-z]-?[\\d.]+)*)" +
+    "(?:!(?<signature>[^;#]+))?" +
+    "(?:;(?<extensions>[^#]+))?" +
+    "(?:#C:(?<context>.+))?$");
+// register built-in drivers and set default
+// (tps and gregorian provide canonical conversions before unix)
+TPS.registerDriver(new tps_1.TpsDriver());
+TPS.registerDriver(new gregorian_1.GregorianDriver());
+TPS.registerDriver(new unix_1.UnixDriver());
+TPS.registerDriver(new persian_1.PersianDriver());
+TPS.registerDriver(new hijri_1.HijriDriver());
+TPS.registerDriver(new julian_1.JulianDriver());
+TPS.registerDriver(new holocene_1.HoloceneDriver());
+TPS.registerDriver(new chinese_1.ChineseDriver());
 /**
  * `TpsDate` is a Date-like wrapper with native TPS conversion helpers.
  *
@@ -1401,161 +893,4 @@ TPSUID7RB.REGEX = /^tpsuid7rb_[A-Za-z0-9_-]+$/;
  * - `new TpsDate(tpsString)`
  * - `new TpsDate(year, monthIndex, day?, hour?, minute?, second?, ms?)`
  */
-class TpsDate {
-    getTpsComponents() {
-        const parsed = TPS.parse(this.toTPS(exports.DefaultCalendars.TPS));
-        if (!parsed) {
-            throw new Error("TpsDate: failed to derive TPS components");
-        }
-        return parsed;
-    }
-    getTpsFullYear() {
-        const comp = this.getTpsComponents();
-        return (comp.millennium - 1) * 1000 + (comp.century - 1) * 100 + comp.year;
-    }
-    constructor(...args) {
-        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);
-    }
-    static looksLikeTPS(input) {
-        const s = input.trim();
-        return s.startsWith("tps://") || s.startsWith("T:") || s.startsWith("t:");
-    }
-    static now() {
-        return Date.now();
-    }
-    static parse(input) {
-        if (this.looksLikeTPS(input)) {
-            const d = TPS.toDate(input);
-            return d ? d.getTime() : Number.NaN;
-        }
-        return Date.parse(input);
-    }
-    static UTC(year, monthIndex, day, hours, minutes, seconds, ms) {
-        return Date.UTC(year, monthIndex, day ?? 1, hours ?? 0, minutes ?? 0, seconds ?? 0, ms ?? 0);
-    }
-    static fromTPS(tps) {
-        return new TpsDate(tps);
-    }
-    toGregorianDate() {
-        return new Date(this.internal.getTime());
-    }
-    toDate() {
-        return this.toGregorianDate();
-    }
-    toTPS(calendar = exports.DefaultCalendars.TPS, opts) {
-        return TPS.fromDate(this.internal, calendar, opts);
-    }
-    toTPSURI(calendar = exports.DefaultCalendars.TPS, opts) {
-        const time = this.toTPS(calendar, { order: opts?.order });
-        const comp = TPS.parse(time);
-        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() {
-        return this.internal.getTime();
-    }
-    valueOf() {
-        return this.internal.valueOf();
-    }
-    toString() {
-        return this.toTPS(exports.DefaultCalendars.TPS);
-    }
-    toISOString() {
-        return this.internal.toISOString();
-    }
-    toUTCString() {
-        return this.internal.toUTCString();
-    }
-    toJSON() {
-        return this.internal.toJSON();
-    }
-    getFullYear() {
-        return this.getTpsFullYear();
-    }
-    getUTCFullYear() {
-        return this.getTpsFullYear();
-    }
-    getMonth() {
-        return this.getTpsComponents().month - 1;
-    }
-    getUTCMonth() {
-        return this.getTpsComponents().month - 1;
-    }
-    getDate() {
-        return this.getTpsComponents().day;
-    }
-    getUTCDate() {
-        return this.getTpsComponents().day;
-    }
-    getHours() {
-        return this.getTpsComponents().hour;
-    }
-    getUTCHours() {
-        return this.getTpsComponents().hour;
-    }
-    getMinutes() {
-        return this.getTpsComponents().minute;
-    }
-    getUTCMinutes() {
-        return this.getTpsComponents().minute;
-    }
-    getSeconds() {
-        return this.getTpsComponents().second;
-    }
-    getUTCSeconds() {
-        return this.getTpsComponents().second;
-    }
-    getMilliseconds() {
-        return this.getTpsComponents().millisecond;
-    }
-    getUTCMilliseconds() {
-        return this.getTpsComponents().millisecond;
-    }
-    [Symbol.toPrimitive](hint) {
-        if (hint === "number")
-            return this.valueOf();
-        return this.toString();
-    }
-}
-exports.TpsDate = TpsDate;
 //# sourceMappingURL=index.js.map