@nextera.one/tps-standard 0.6.0 → 0.8.0

package/src/drivers/tps.ts

@@ -2,86 +2,58 @@
  * TPS calendar driver for canonical TPS time strings.
  *
  * TPS Calendar characteristics:
- * - Epoch: August 11, 1999 (00:00 UTC)
- * - Months: Always 28 days (12 months per year = 336 days)
- * - Time offset: 7 hours ahead of Gregorian (00:00 Gregorian = 07:00 TPS)
- *
- * Conversion process:
- * 1. Apply 7-hour offset to Gregorian date
- * 2. Calculate day-of-year in offset date
- * 3. Convert day-of-year to TPS month/day (each month = 28 days)
- * 4. Preserve millennium/century/year structure
+ * - Epoch anchor: 1999-08-11T07:00:00.000Z
+ * - Day boundary: 07:00 Gregorian / UTC
+ * - Year shape: 12 months × 4 weeks × 7 days = 336 days
+ * - Indexed form: `T:tps.iN[.F]`
  */
 import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
 import { buildTimePart } from "../utils/tps-string";
-import { GregorianDriver } from "./gregorian";
+import {
+  buildTpsComponentsFromDayIndex,
+  getTpsFullYear,
+  normalizeTpsComponents,
+  parseTpsIndexedToken,
+  TPS_DAY_MS,
+  TPS_DAYS_PER_MONTH,
+  TPS_EPOCH_START_MS,
+  TPS_MONTHS_PER_YEAR,
+  validateTpsComponents,
+} from "../utils/tps-native";
 
 /**
  * TPS calendar driver for canonical TPS time strings.
  *
  * TPS Calendar characteristics:
- * - Epoch: August 11, 1999 (00:00 UTC)
- * - Months: Always 28 days (12 months per year = 336 days)
- * - Time offset: 7 hours ahead of Gregorian (00:00 Gregorian = 07:00 TPS)
+ * - Epoch anchor: 1999-08-11T07:00:00.000Z
+ * - Day boundary: 07:00 Gregorian / UTC
+ * - Year shape: 12 months × 4 weeks × 7 days = 336 days
  */
 export class TpsDriver implements CalendarDriver {
   readonly code = "tps";
-  readonly name = "TPS Canonical";
-
-  private readonly TPS_OFFSET_HOURS = 7;
-  private readonly TPS_DAYS_PER_MONTH = 28;
-  private readonly TPS_MONTHS_PER_YEAR = 12;
-
-  private readonly gregorian = new GregorianDriver();
+  readonly name = "TPS Indexed";
 
   getComponentsFromDate(date: Date): Partial<TPSComponents> {
-    const offsetMillis = this.TPS_OFFSET_HOURS * 60 * 60 * 1000;
-    const offsetDate = new Date(date.getTime() + offsetMillis);
-
-    const gregComponents = this.gregorian.getComponentsFromDate(offsetDate);
-
-    const yearStart = new Date(Date.UTC(offsetDate.getUTCFullYear(), 0, 1));
-    const dayOfYear = Math.floor(
-      (offsetDate.getTime() - yearStart.getTime()) / (24 * 60 * 60 * 1000),
-    );
+    const deltaMs = date.getTime() - TPS_EPOCH_START_MS;
+    const dayIndex = Math.floor(deltaMs / TPS_DAY_MS);
+    const dayFraction =
+      ((deltaMs % TPS_DAY_MS) + TPS_DAY_MS) % TPS_DAY_MS / TPS_DAY_MS;
 
-    const tpsMonth = Math.floor(dayOfYear / this.TPS_DAYS_PER_MONTH) + 1;
-    const tpsDay = (dayOfYear % this.TPS_DAYS_PER_MONTH) + 1;
-
-    return {
-      calendar: this.code,
-      millennium: gregComponents.millennium,
-      century: gregComponents.century,
-      year: gregComponents.year,
-      month: tpsMonth,
-      day: tpsDay,
-      hour: gregComponents.hour,
-      minute: gregComponents.minute,
-      second: gregComponents.second,
-      millisecond: gregComponents.millisecond,
-    };
+    return buildTpsComponentsFromDayIndex(dayIndex, dayFraction);
   }
 
   getDateFromComponents(components: Partial<TPSComponents>): Date {
-    const tpsMonth = components.month ?? 1;
-    const tpsDay = components.day ?? 1;
-    const dayOfYear = (tpsMonth - 1) * this.TPS_DAYS_PER_MONTH + (tpsDay - 1);
-
-    const m = components.millennium ?? 0;
-    const c = components.century ?? 1;
-    const y = components.year ?? 0;
-    const fullYear = (m - 1) * 1000 + (c - 1) * 100 + y;
-
-    const dateInYear = new Date(Date.UTC(fullYear, 0, 1));
-    dateInYear.setUTCDate(dateInYear.getUTCDate() + dayOfYear);
+    const normalized = normalizeTpsComponents({
+      ...components,
+      calendar: this.code,
+    });
 
-    dateInYear.setUTCHours(components.hour ?? 0);
-    dateInYear.setUTCMinutes(components.minute ?? 0);
-    dateInYear.setUTCSeconds(components.second ?? 0);
-    dateInYear.setUTCMilliseconds(components.millisecond ?? 0);
+    const dayIndex = normalized.dayIndex ?? 0;
+    const subDayMilliseconds = normalized.subDayMilliseconds ?? 0;
 
-    const offsetMillis = this.TPS_OFFSET_HOURS * 60 * 60 * 1000;
-    return new Date(dateInYear.getTime() - offsetMillis);
+    return new Date(
+      TPS_EPOCH_START_MS + dayIndex * TPS_DAY_MS + subDayMilliseconds,
+    );
   }
 
   getFromDate(date: Date): string {
@@ -91,8 +63,16 @@ export class TpsDriver implements CalendarDriver {
 
   parseDate(input: string, _format?: string): Partial<TPSComponents> {
     const s = input.trim();
+    const indexed = parseTpsIndexedToken(s);
+    if (indexed) {
+      return normalizeTpsComponents({
+        calendar: this.code,
+        ...indexed,
+      });
+    }
+
     const m = s.match(
-      /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/,
+      /^(-?\d{1,6})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/,
     );
     if (!m)
       throw new Error(`TpsDriver.parseDate: unsupported format "${input}"`);
@@ -101,12 +81,12 @@ export class TpsDriver implements CalendarDriver {
     const month = parseInt(m[2], 10);
     const day = parseInt(m[3], 10);
 
-    if (month < 1 || month > this.TPS_MONTHS_PER_YEAR) {
+    if (month < 1 || month > TPS_MONTHS_PER_YEAR) {
       throw new Error(
         `TpsDriver.parseDate: invalid TPS month ${month} (expected 1-12)`,
       );
     }
-    if (day < 1 || day > this.TPS_DAYS_PER_MONTH) {
+    if (day < 1 || day > TPS_DAYS_PER_MONTH) {
       throw new Error(
         `TpsDriver.parseDate: invalid TPS day ${day} (expected 1-28)`,
       );
@@ -128,45 +108,50 @@ export class TpsDriver implements CalendarDriver {
     if (minute !== undefined) comp.minute = minute;
     if (second !== undefined) comp.second = second;
     if (millisecond !== undefined) comp.millisecond = millisecond;
-    return comp;
+    return normalizeTpsComponents(comp);
   }
 
   format(components: Partial<TPSComponents>, _format?: string): string {
+    const normalized = normalizeTpsComponents({
+      ...components,
+      calendar: this.code,
+    });
+    const fullYear = getTpsFullYear(normalized);
     const y =
-      components.year !== undefined
-        ? String(components.year).padStart(4, "0")
+      normalized.year !== undefined
+        ? String(fullYear).padStart(4, "0")
         : "0000";
     const mo =
-      components.month !== undefined
-        ? String(components.month).padStart(2, "0")
+      normalized.month !== undefined
+        ? String(normalized.month).padStart(2, "0")
         : "01";
     const d =
-      components.day !== undefined
-        ? String(components.day).padStart(2, "0")
+      normalized.day !== undefined
+        ? String(normalized.day).padStart(2, "0")
         : "01";
     let out = `${y}-${mo}-${d}`;
 
     if (
-      components.hour !== undefined ||
-      components.minute !== undefined ||
-      components.second !== undefined ||
-      components.millisecond !== undefined
+      normalized.hour !== undefined ||
+      normalized.minute !== undefined ||
+      normalized.second !== undefined ||
+      normalized.millisecond !== undefined
     ) {
       const h =
-        components.hour !== undefined
-          ? String(components.hour).padStart(2, "0")
+        normalized.hour !== undefined
+          ? String(normalized.hour).padStart(2, "0")
           : "00";
       const mi =
-        components.minute !== undefined
-          ? String(components.minute).padStart(2, "0")
+        normalized.minute !== undefined
+          ? String(normalized.minute).padStart(2, "0")
           : "00";
       const s =
-        components.second !== undefined
-          ? String(Math.floor(components.second)).padStart(2, "0")
+        normalized.second !== undefined
+          ? String(Math.floor(normalized.second)).padStart(2, "0")
           : "00";
       const ms =
-        components.millisecond !== undefined
-          ? String(components.millisecond).padStart(3, "0")
+        normalized.millisecond !== undefined
+          ? String(normalized.millisecond).padStart(3, "0")
           : "000";
       out += `T${h}:${mi}:${s}.${ms}`;
     }
@@ -175,31 +160,25 @@ export class TpsDriver implements CalendarDriver {
 
   validate(input: string | Partial<TPSComponents>): boolean {
     if (typeof input === "string") {
-      try {
-        this.parseDate(input);
+      if (parseTpsIndexedToken(input.trim())) {
         return true;
+      }
+
+      try {
+        return validateTpsComponents(this.parseDate(input));
       } catch {
         return false;
       }
     }
     if (typeof input === "object") {
-      return (
-        input.year !== undefined &&
-        input.month !== undefined &&
-        input.day !== undefined &&
-        input.year >= 0 &&
-        input.month >= 1 &&
-        input.month <= this.TPS_MONTHS_PER_YEAR &&
-        input.day >= 1 &&
-        input.day <= this.TPS_DAYS_PER_MONTH
-      );
+      return validateTpsComponents(input);
     }
     return false;
   }
 
   getMetadata(): CalendarMetadata {
     return {
-      name: "TPS Canonical (28-day months)",
+      name: "TPS Native (epoch-based 12x4x7)",
       monthNames: [
         "Month 1",
         "Month 2",
@@ -215,15 +194,15 @@ export class TpsDriver implements CalendarDriver {
         "Month 12",
       ],
       dayNames: [
-        "Sunday",
-        "Monday",
-        "Tuesday",
-        "Wednesday",
-        "Thursday",
-        "Friday",
-        "Saturday",
+        "Day 1",
+        "Day 2",
+        "Day 3",
+        "Day 4",
+        "Day 5",
+        "Day 6",
+        "Day 7",
       ],
-      monthsPerYear: this.TPS_MONTHS_PER_YEAR,
+      monthsPerYear: TPS_MONTHS_PER_YEAR,
       epochYear: 1999,
       isLunar: false,
     };

package/src/index.ts

@@ -2,7 +2,7 @@
  * TPS: Temporal Positioning System
  * The Universal Protocol for Space-Time Coordinates.
  * @packageDocumentation
- * @version 0.6.0
+ * @version 0.8.0
  * @license Apache-2.0
  * @copyright 2026 TPS Standards Working Group
  *
@@ -41,12 +41,21 @@ 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 {
+  buildTpsComponentsFromDayIndex,
+  getTpsDayFraction,
+  getTpsDayIndex,
+  getTpsSubDayMilliseconds,
+  isTpsIndexedToken,
+  normalizeTpsComponents,
+} from "./utils/tps-native";
 
 import {
   CalendarDriver,
   TPSComponents,
   TimeOrder,
   DefaultCalendars,
+  TPSTimeOptions,
 } from "./types";
 
 export class TPS {
@@ -196,6 +205,10 @@ export class TPS {
       return `${beforeT}T:${cal}.m0.c0.y0.m0.d0.h0.m0.s0.m0${timeSuffix}`;
     }
 
+    if (/^i/i.test(tokenStr)) {
+      return `${beforeT}T:${cal}.${tokenStr}${timeSuffix}`;
+    }
+
     // ── 5. Tokenise ──────────────────────────────────────────────────────────
     // Each raw token: first char = letter prefix, remainder = numeric value
     type Tok = { p: string; v: string };
@@ -204,8 +217,15 @@ export class TPS {
       .filter((t) => t.length >= 2 && /^[a-z]/.test(t))
       .map((t) => ({ p: t[0], v: t.slice(1) }));
 
-    // ── 6. Detect order from non-m tokens (c=7, y=6, d=4, h=3, s=1) ─────────
-    const nonMRank: Record<string, number> = { c: 7, y: 6, d: 4, h: 3, s: 1 };
+    // ── 6. Detect order from non-m tokens (c=7, y=6, w=4.5, d=4, h=3, s=1) ──
+    const nonMRank: Record<string, number> = {
+      c: 7,
+      y: 6,
+      w: 4.5,
+      d: 4,
+      h: 3,
+      s: 1,
+    };
     const nonMSeq = tokens
       .filter((t) => t.p !== "m" && nonMRank[t.p] !== undefined)
       .map((t) => nonMRank[t.p]);
@@ -235,12 +255,12 @@ export class TPS {
     }
 
     // ── 9. Build complete DESC token string, filling gaps with '0' ───────────
-    // Full DESC slot sequence: m(8) c(7) y(6) m(5) d(4) h(3) m(2) s(1) m(0)
     const descSlots: Array<[string, number]> = [
       ["m", 8],
       ["c", 7],
       ["y", 6],
       ["m", 5],
+      ...(tokens.some((t) => t.p === "w") ? [["w", 4.5] as [string, number]] : []),
       ["d", 4],
       ["h", 3],
       ["m", 2],
@@ -257,10 +277,24 @@ export class TPS {
 
   static validate(input: string): boolean {
     const sanitized = this.sanitizeTimeInput(input);
-    if (sanitized.startsWith("tps://")) {
-      return this.REGEX_URI.test(sanitized);
+    const matchesRegex = sanitized.startsWith("tps://")
+      ? this.REGEX_URI.test(sanitized)
+      : this.REGEX_TIME.test(sanitized);
+
+    if (!matchesRegex) return false;
+
+    const indexedMatch = sanitized.match(/(?:^T:|@T:)([a-z]{3,4})\.(i[^!;?#]+)/i);
+    if (indexedMatch) {
+      if (indexedMatch[1].toLowerCase() !== DefaultCalendars.TPS) {
+        return false;
+      }
+      if (!isTpsIndexedToken(indexedMatch[2])) {
+        return this.parse(sanitized) !== null;
+      }
+      return this.parse(sanitized) !== null;
     }
-    return this.REGEX_TIME.test(sanitized);
+
+    return true;
   }
 
   static parse(input: string): TPSComponents | null {
@@ -339,12 +373,73 @@ export class TPS {
     return comp;
   }
 
+  private static buildTimeString(
+    comp: Partial<TPSComponents>,
+    opts?: TPSTimeOptions,
+  ): string {
+    let time = buildTimePart(comp, opts);
+
+    if (comp.extensions && Object.keys(comp.extensions).length > 0) {
+      const extStrings = Object.entries(comp.extensions).map(([k, v]) => {
+        return `${k.toUpperCase()}:${v}`;
+      });
+      time += `;${extStrings.join(";")}`;
+    }
+
+    if (comp.context && Object.keys(comp.context).length > 0) {
+      const ctxStrings = Object.entries(comp.context).map(([k, v]) => `${k}=${v}`);
+      time += `#C:${ctxStrings.join(";")}`;
+    }
+
+    return time;
+  }
+
+  private static toTpsNativeComponents(
+    input: Date | string | Partial<TPSComponents>,
+  ): Partial<TPSComponents> | null {
+    if (input instanceof Date) {
+      return normalizeTpsComponents({
+        calendar: DefaultCalendars.TPS,
+        ...buildTpsComponentsFromDayIndex(
+          getTpsDayIndex(input),
+          getTpsDayFraction(input),
+        ),
+      });
+    }
+
+    if (typeof input === "string") {
+      const parsed = this.parse(input);
+      if (!parsed || parsed.calendar !== DefaultCalendars.TPS) return null;
+      return normalizeTpsComponents(parsed);
+    }
+
+    if ((input.calendar ?? DefaultCalendars.TPS) !== DefaultCalendars.TPS) {
+      return null;
+    }
+
+    return normalizeTpsComponents({
+      ...input,
+      calendar: DefaultCalendars.TPS,
+    });
+  }
+
+  private static renderTpsLikeInput(
+    originalInput: string,
+    comp: Partial<TPSComponents>,
+    opts?: TPSTimeOptions,
+  ): string {
+    const sanitized = this.sanitizeTimeInput(originalInput);
+    return sanitized.startsWith("tps://")
+      ? this.toURI(comp, opts)
+      : this.buildTimeString(comp, opts);
+  }
+
   /**
    * SERIALIZER: Converts a components object into a full TPS URI.
    * @param comp - The TPS components.
    * @returns Full URI string (e.g. "tps://...").
    */
-  static toURI(comp: TPSComponents): string {
+  static toURI(comp: Partial<TPSComponents>, opts?: TPSTimeOptions): string {
     // ── 1. Location layers (v0.6.0) ──────────────────────────────────────────
     // Build an ordered list of location layer strings, then join with ";"
     const layers: string[] = [];
@@ -406,7 +501,7 @@ export class TPS {
     const actorPart = comp.actor ? `/A:${comp.actor}` : "";
 
     // ── 3. Time (mandatory 9 tokens) ─────────────────────────────────────────
-    const timePart = buildTimePart(comp);
+    const timePart = buildTimePart(comp, opts);
 
     // ── 4. Extensions (;KEY:val;...) ─────────────────────────────────────────
     let extPart = "";
@@ -440,7 +535,7 @@ export class TPS {
   static fromDate(
     date: Date = new Date(),
     calendar: string = DefaultCalendars.TPS,
-    opts?: { order?: TimeOrder },
+    opts?: TPSTimeOptions,
   ): string {
     const normalizedCalendar = calendar.toLowerCase();
     const driver = this.driverManager.get(normalizedCalendar);
@@ -449,11 +544,11 @@ export class TPS {
       // `fromDate` helper and instead generate components ourselves so that
       // order is honoured even if the driver doesn't know about it.  This
       // keeps behaviour identical to the old built-in implementation.
-      if (opts?.order) {
+      if (opts?.order || opts?.timeMode || opts?.indexedPrecision !== undefined) {
         const comp = driver.getComponentsFromDate(date) as TPSComponents;
         comp.calendar = normalizedCalendar;
-        comp.order = opts.order;
-        return buildTimePart(comp);
+        if (opts?.order) comp.order = opts.order;
+        return buildTimePart(comp, opts);
       }
       return driver.getFromDate(date);
     }
@@ -466,7 +561,7 @@ export class TPS {
       const s = (date.getTime() / 1000).toFixed(3);
       comp.unixSeconds = parseFloat(s);
       if (opts?.order) comp.order = opts.order;
-      return buildTimePart(comp);
+      return buildTimePart(comp, opts);
     }
 
     if (normalizedCalendar === DefaultCalendars.GREG) {
@@ -481,7 +576,7 @@ export class TPS {
       comp.second = date.getUTCSeconds();
       comp.millisecond = date.getUTCMilliseconds();
       if (opts?.order) comp.order = opts.order;
-      return buildTimePart(comp);
+      return buildTimePart(comp, opts);
     }
 
     throw new Error(
@@ -537,6 +632,109 @@ export class TPS {
     return date;
   }
 
+  static toDayIndex(
+    input: Date | string | Partial<TPSComponents>,
+  ): number | null {
+    const comp = this.toTpsNativeComponents(input);
+    return comp ? getTpsDayIndex(comp) : null;
+  }
+
+  static fromDayIndex(
+    dayIndex: number,
+    dayFraction: number = 0,
+    opts?: TPSTimeOptions,
+  ): string {
+    if (!Number.isSafeInteger(dayIndex) || dayIndex < 0) {
+      throw new Error("TPS.fromDayIndex: dayIndex must be a non-negative integer");
+    }
+    if (!Number.isFinite(dayFraction) || dayFraction < 0 || dayFraction >= 1) {
+      throw new Error("TPS.fromDayIndex: dayFraction must be in [0, 1)");
+    }
+
+    const comp = buildTpsComponentsFromDayIndex(dayIndex, dayFraction);
+    if (opts?.order) comp.order = opts.order;
+    return buildTimePart(comp, opts);
+  }
+
+  static getDayFraction(
+    input: Date | string | Partial<TPSComponents>,
+  ): number | null {
+    const comp = this.toTpsNativeComponents(input);
+    return comp ? getTpsDayFraction(comp) : null;
+  }
+
+  static getSubDayMilliseconds(
+    input: Date | string | Partial<TPSComponents>,
+  ): number | null {
+    const comp = this.toTpsNativeComponents(input);
+    return comp ? getTpsSubDayMilliseconds(comp) : null;
+  }
+
+  static expandIndexedTime(input: string): string | null {
+    const sanitized = this.sanitizeTimeInput(input);
+    const indexedMatch = sanitized.match(/(?:^T:|@T:)([a-z]{3,4})\.(i[^!;?#]+)/i);
+    if (
+      !indexedMatch ||
+      indexedMatch[1].toLowerCase() !== DefaultCalendars.TPS ||
+      !isTpsIndexedToken(indexedMatch[2])
+    ) {
+      const parsed = this.parse(sanitized);
+      if (!parsed || parsed.calendar !== DefaultCalendars.TPS) return null;
+      return input.trim();
+    }
+
+    const comp = this.toTpsNativeComponents(sanitized);
+    if (!comp) return null;
+    return this.renderTpsLikeInput(sanitized, comp);
+  }
+
+  static expandIndex(input: string): string | null {
+    return this.expandIndexedTime(input);
+  }
+
+  static compactIndexedTime(
+    input: string,
+    opts?: { precision?: number },
+  ): string | null {
+    const comp = this.toTpsNativeComponents(input);
+    if (!comp) return null;
+    return this.renderTpsLikeInput(input, comp, {
+      timeMode: "indexed-fraction",
+      indexedPrecision: opts?.precision,
+    });
+  }
+
+  static compact(
+    input: string,
+    opts?: { precision?: number },
+  ): string | null {
+    return this.compactIndexedTime(input, opts);
+  }
+
+  static toIndexedTime(
+    input: Date | string | Partial<TPSComponents>,
+    opts?: { precision?: number },
+  ): string | null {
+    const comp = this.toTpsNativeComponents(input);
+    if (!comp) return null;
+    return this.buildTimeString(comp, {
+      timeMode: "indexed-fraction",
+      indexedPrecision: opts?.precision,
+    });
+  }
+
+  static toIndexedURI(
+    input: Partial<TPSComponents>,
+    opts?: { precision?: number },
+  ): string | null {
+    const comp = this.toTpsNativeComponents(input);
+    if (!comp) return null;
+    return this.toURI(comp, {
+      timeMode: "indexed-fraction",
+      indexedPrecision: opts?.precision,
+    });
+  }
+
   // --- DRIVER CONVENIENCE METHODS ---
 
   /**

package/src/types.ts

@@ -27,6 +27,14 @@ export enum TimeOrder {
   ASC = "asc",
 }
 
+export type TPSTimeMode = "hierarchical" | "indexed-fraction";
+
+export interface TPSTimeOptions {
+  order?: TimeOrder;
+  timeMode?: TPSTimeMode;
+  indexedPrecision?: number;
+}
+
 export interface TPSComponents {
   // --- TEMPORAL ---
   calendar: string;
@@ -34,11 +42,16 @@ export interface TPSComponents {
   century: number;
   year: number;
   month: number;
+  week?: number;
   day: number;
   hour: number;
   minute: number;
   second: number;
   millisecond: number;
+  dayIndex?: number;
+  dayFraction?: number;
+  subDayMilliseconds?: number;
+  fractionPrecision?: number;
 
   // --- OPTIONAL UNIX BACKUP ---
   unixSeconds?: number;

package/src/uid.ts

@@ -35,6 +35,7 @@ export class TPSUID7RB {
     tps: string,
     opts: TPSUID7RBEncodeOptions = {},
   ): Uint8Array {
+    tps = TPS.expandIndexedTime(tps) ?? tps;
     const compress = opts.compress ?? false;
     const epochMs = opts.epochMs ?? this.epochMsFromTPSString(tps);
 
@@ -155,6 +156,7 @@ export class TPSUID7RB {
     privateKey: any,
     opts?: TPSUID7RBEncodeOptions,
   ): Uint8Array {
+    tps = TPS.expandIndexedTime(tps) ?? tps;
     const compress = opts?.compress ?? false;
     const epochMs = opts?.epochMs ?? this.epochMsFromTPSString(tps);
 
@@ -220,6 +222,7 @@ export class TPSUID7RB {
   }
 
   public static epochMsFromTPSString(tps: string): number {
+    tps = TPS.expandIndexedTime(tps) ?? tps;
     const date = TPS.toDate(tps);
     if (date) return date.getTime();
     const stripped = tps.replace(/;[^?#]*/, "").replace(/[?#].*$/, "");