@llblab/pi-telegram 0.11.1 → 0.12.0

package/lib/menu-settings.ts

@@ -7,7 +7,7 @@
 import {
   getTelegramExtensionSettingsRows,
   type TelegramSectionRegistry,
-} from "./extension-sections.ts";
+} from "./sections.ts";
 import type { TelegramTimeMode } from "./config.ts";
 import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
 import type { TelegramModelMenuState } from "./menu-model.ts";
@@ -115,7 +115,8 @@ export interface TelegramSettingsMenuRuntimeDeps<
 
 export const SETTINGS_MENU_TITLE = "<b>⚙️ Settings:</b>";
 export const PROACTIVE_PUSH_SETTINGS_TITLE = "<b>📌 Proactive push:</b>";
-export const TIME_INJECTION_MODE_SETTINGS_TITLE = "<b>🕒 Time injection mode:</b>";
+export const TIME_INJECTION_MODE_SETTINGS_TITLE =
+  "<b>🕒 Time injection mode:</b>";
 export const VOICE_REPLY_MODE_SETTINGS_TITLE = "<b>👄 Voice reply mode:</b>";
 
 type TelegramVoiceReplyModeSetting = TelegramVoiceReplyMode | "hidden";
@@ -124,6 +125,10 @@ function getVoiceReplyModeLabel(mode: TelegramVoiceReplyModeSetting): string {
   return mode;
 }
 
+function getTelegramSettingsStateValueLabel(value: string): string {
+  return value.length > 0 ? value[0]!.toUpperCase() + value.slice(1) : value;
+}
+
 function getVoiceReplyModeSetting(
   mode: TelegramVoiceReplyMode,
   configured: boolean,
@@ -135,17 +140,24 @@ export function buildTelegramSettingsMenuText(): string {
   return SETTINGS_MENU_TITLE;
 }
 
-export function buildProactivePushSettingsText(): string {
+export function buildProactivePushSettingsText(
+  proactivePushEnabled: boolean,
+): string {
   return [
-    PROACTIVE_PUSH_SETTINGS_TITLE,
+    `${PROACTIVE_PUSH_SETTINGS_TITLE} <code>${proactivePushEnabled ? "on" : "off"}</code>`,
     "",
     "Send successful local π task results to Telegram when the bridge is connected.",
   ].join("\n");
 }
 
-export function buildVoiceReplyModeSettingsText(): string {
+export function buildVoiceReplyModeSettingsText(
+  mode: TelegramVoiceReplyMode,
+  configured = true,
+): string {
   return [
-    VOICE_REPLY_MODE_SETTINGS_TITLE,
+    `${VOICE_REPLY_MODE_SETTINGS_TITLE} <code>${getVoiceReplyModeLabel(
+      getVoiceReplyModeSetting(mode, configured),
+    )}</code>`,
     "",
     "Controls when pi-telegram converts assistant text replies into Telegram voice messages.",
     "",
@@ -156,13 +168,15 @@ export function buildVoiceReplyModeSettingsText(): string {
   ].join("\n");
 }
 
-export function buildTimeInjectionModeSettingsText(): string {
+export function buildTimeInjectionModeSettingsText(
+  mode: TelegramTimeMode,
+): string {
   return [
-    TIME_INJECTION_MODE_SETTINGS_TITLE,
+    `${TIME_INJECTION_MODE_SETTINGS_TITLE} <code>${mode}</code>`,
     "",
     "Controls whether Telegram-originated prompts include a compact wall-clock [time] line.",
     "",
-    "<code>-</code> <code>off</code> (default): no time line is added.",
+    "<code>-</code> <code>hidden</code> (default): no time line is added to prompt context.",
     "<code>-</code> <code>always</code>: add time to every Telegram turn.",
     "<code>-</code> <code>interval</code>: add time at most once per chat interval (default: 1 hour).",
   ].join("\n");
@@ -188,21 +202,23 @@ export function buildTelegramSettingsMenuReplyMarkup(
   rows.push(
     [
       {
-        text: `👄 Voice reply: ${getVoiceReplyModeLabel(
-          getVoiceReplyModeSetting(voiceReplyMode, voiceReplyModeConfigured),
+        text: `👄 Voice reply: ${getTelegramSettingsStateValueLabel(
+          getVoiceReplyModeLabel(
+            getVoiceReplyModeSetting(voiceReplyMode, voiceReplyModeConfigured),
+          ),
         )}`,
         callback_data: "settings:open:voice-reply",
       },
     ],
     [
       {
-        text: `🕒 Time injection: ${timeInjectionMode}`,
+        text: `🕒 Time injection: ${getTelegramSettingsStateValueLabel(timeInjectionMode)}`,
         callback_data: "settings:open:time-injection",
       },
     ],
     [
       {
-        text: `📌 Proactive push: ${proactivePushEnabled ? "on" : "off"}`,
+        text: `📌 Proactive push: ${proactivePushEnabled ? "On" : "Off"}`,
         callback_data: "settings:open:proactive",
       },
     ],
@@ -242,11 +258,11 @@ export function buildProactivePushSettingsReplyMarkup(
       [{ text: "⬆️ Back", callback_data: "settings:list" }],
       [
         {
-          text: proactivePushEnabled ? "🟢 on" : "⚫️ on",
+          text: proactivePushEnabled ? "🟢 On" : "⚫️ On",
           callback_data: "settings:set:proactive:on",
         },
         {
-          text: proactivePushEnabled ? "⚫️ off" : "🟡 off",
+          text: proactivePushEnabled ? "⚫️ Off" : "🟡 Off",
           callback_data: "settings:set:proactive:off",
         },
       ],
@@ -257,7 +273,7 @@ export function buildProactivePushSettingsReplyMarkup(
 export function buildTimeInjectionModeSettingsReplyMarkup(
   mode: TelegramTimeMode,
 ): TelegramSettingsMenuReplyMarkup {
-  const modes: TelegramTimeMode[] = ["off", "always", "interval"];
+  const modes: TelegramTimeMode[] = ["hidden", "always", "interval"];
   return {
     inline_keyboard: [
       [{ text: "⬆️ Back", callback_data: "settings:list" }],
@@ -314,30 +330,31 @@ export async function updateTelegramSettingsMenuMessage(
 export async function updateProactivePushSettingsMessage(
   deps: TelegramSettingsMenuCallbackDeps,
 ): Promise<void> {
+  const proactivePushEnabled = deps.isProactivePushEnabled();
   await deps.updateSettingsMessage(
-    buildProactivePushSettingsText(),
-    buildProactivePushSettingsReplyMarkup(deps.isProactivePushEnabled()),
+    buildProactivePushSettingsText(proactivePushEnabled),
+    buildProactivePushSettingsReplyMarkup(proactivePushEnabled),
   );
 }
 
 export async function updateTimeInjectionModeSettingsMessage(
   deps: TelegramSettingsMenuCallbackDeps,
 ): Promise<void> {
+  const mode = deps.getTimeInjectionMode();
   await deps.updateSettingsMessage(
-    buildTimeInjectionModeSettingsText(),
-    buildTimeInjectionModeSettingsReplyMarkup(deps.getTimeInjectionMode()),
+    buildTimeInjectionModeSettingsText(mode),
+    buildTimeInjectionModeSettingsReplyMarkup(mode),
   );
 }
 
 export async function updateVoiceReplyModeSettingsMessage(
   deps: TelegramSettingsMenuCallbackDeps,
 ): Promise<void> {
+  const mode = deps.getVoiceReplyMode();
+  const configured = deps.isVoiceReplyModeConfigured();
   await deps.updateSettingsMessage(
-    buildVoiceReplyModeSettingsText(),
-    buildVoiceReplyModeSettingsReplyMarkup(
-      deps.getVoiceReplyMode(),
-      deps.isVoiceReplyModeConfigured(),
-    ),
+    buildVoiceReplyModeSettingsText(mode, configured),
+    buildVoiceReplyModeSettingsReplyMarkup(mode, configured),
   );
 }
 
@@ -362,7 +379,10 @@ export async function handleTelegramSettingsMenuCallbackAction(
     await deps.answerCallbackQuery(callbackQueryId);
     return true;
   }
-  if (data === "settings:open:time-injection" || data === "settings:open:time") {
+  if (
+    data === "settings:open:time-injection" ||
+    data === "settings:open:time"
+  ) {
     await updateTimeInjectionModeSettingsMessage(deps);
     await deps.answerCallbackQuery(callbackQueryId);
     return true;
@@ -391,10 +411,18 @@ export async function handleTelegramSettingsMenuCallbackAction(
     const mode = data.startsWith("settings:set:time-injection:")
       ? data.slice("settings:set:time-injection:".length)
       : data.slice("settings:set:time:".length);
-    if (mode === "off" || mode === "always" || mode === "interval") {
-      await deps.setTimeInjectionMode(mode);
+    const normalizedMode = mode === "off" ? "hidden" : mode;
+    if (
+      normalizedMode === "hidden" ||
+      normalizedMode === "always" ||
+      normalizedMode === "interval"
+    ) {
+      await deps.setTimeInjectionMode(normalizedMode);
       await updateTimeInjectionModeSettingsMessage(deps);
-      await deps.answerCallbackQuery(callbackQueryId, `Time injection: ${mode}`);
+      await deps.answerCallbackQuery(
+        callbackQueryId,
+        `Time injection: ${normalizedMode}`,
+      );
       return true;
     }
   }
@@ -488,15 +516,18 @@ export function createTelegramSettingsMenuRuntime<
           ? query.data.slice("settings:set:time-injection:".length)
           : query.data.slice("settings:set:time:".length);
         if (
-          (hasTimeInjectionPrefix || query.data.startsWith("settings:set:time:")) &&
+          (hasTimeInjectionPrefix ||
+            query.data.startsWith("settings:set:time:")) &&
           (timeMode === "off" ||
+            timeMode === "hidden" ||
             timeMode === "always" ||
             timeMode === "interval")
         ) {
-          await deps.setTimeInjectionMode(timeMode);
+          const normalizedMode = timeMode === "off" ? "hidden" : timeMode;
+          await deps.setTimeInjectionMode(normalizedMode);
           await deps.answerCallbackQuery(
             query.id,
-            `Time injection: ${timeMode}`,
+            `Time injection: ${normalizedMode}`,
           );
           return true;
         }

package/lib/menu-status.ts

@@ -8,7 +8,7 @@ import { formatTelegramCommandEmojiPrefix } from "./commands.ts";
 import {
   getTelegramSectionMainMenuRows,
   type TelegramSectionRegistry,
-} from "./extension-sections.ts";
+} from "./sections.ts";
 import {
   formatStatusButtonLabel,
   type TelegramMenuMessageRuntimeDeps,

package/lib/menu.ts

@@ -10,7 +10,7 @@ import {
   handleTelegramSectionSettingsOpen,
   parseTelegramSectionCallback,
   type TelegramSectionRegistry,
-} from "./extension-sections.ts";
+} from "./sections.ts";
 import {
   createTelegramModelMenuStateBuilder,
   handleTelegramModelMenuCallbackAction,

package/lib/{outbound-handlers.ts → outbound.ts}

@@ -1,7 +1,7 @@
 /**
- * Telegram outbound handler helpers
+ * Telegram outbound surface helpers
  * Zones: telegram outbound, assistant markup, command templates, callback routing
- * Owns assistant-authored outbound markup extraction, configured artifact generation, callback actions, and Telegram outbound delivery
+ * Owns assistant-authored outbound markup extraction, configured artifact generation, callback actions, runtime-event bridge, and Telegram outbound delivery
  */
 
 import { randomUUID } from "node:crypto";
@@ -61,6 +61,18 @@ const DEFAULT_VOICE_TIMEOUT_MS = 120_000;
  * diagnostics alongside pi-telegram's own events. Events are silently dropped
  * when pi-telegram is not loaded.
  */
+export type TelegramRuntimeEventRecorder = (
+  category: string,
+  error: unknown,
+  details?: Record<string, unknown>,
+) => void;
+
+export function bindTelegramRuntimeEventRecorder(
+  recorder: TelegramRuntimeEventRecorder,
+): void {
+  (globalThis as Record<string, unknown>)[VOICE_EVENT_RECORDER_KEY] = recorder;
+}
+
 export function recordTelegramRuntimeEvent(
   category: string,
   error: unknown,
@@ -70,13 +82,7 @@ export function recordTelegramRuntimeEvent(
     VOICE_EVENT_RECORDER_KEY
   ];
   if (typeof recorder === "function") {
-    (
-      recorder as (
-        category: string,
-        error: unknown,
-        details?: Record<string, unknown>,
-      ) => void
-    )(category, error, details);
+    (recorder as TelegramRuntimeEventRecorder)(category, error, details);
   }
 }
 
@@ -1028,7 +1034,9 @@ export function createTelegramVoiceReplySender(
         });
         return;
       } catch (error) {
-        deps.recordRuntimeEvent?.("voice", error, { phase: "template-handler-send" });
+        deps.recordRuntimeEvent?.("voice", error, {
+          phase: "template-handler-send",
+        });
       }
     }
 
@@ -1045,7 +1053,9 @@ export function createTelegramVoiceReplySender(
         });
         return;
       } catch (error) {
-        deps.recordRuntimeEvent?.("voice", error, { phase: "programmatic-handler-send" });
+        deps.recordRuntimeEvent?.("voice", error, {
+          phase: "programmatic-handler-send",
+        });
       }
     }
 

package/lib/pi.ts

@@ -11,6 +11,8 @@ import {
   type ExtensionAPI,
   type ExtensionCommandContext,
   type ExtensionContext,
+  type SessionBeforeCompactEvent,
+  type SessionCompactEvent,
   type SessionShutdownEvent,
   type SessionStartEvent,
   type SlashCommandInfo,
@@ -24,6 +26,8 @@ export type {
   ExtensionAPI,
   ExtensionCommandContext,
   ExtensionContext,
+  SessionBeforeCompactEvent,
+  SessionCompactEvent,
   SessionShutdownEvent,
   SessionStartEvent,
   SlashCommandInfo,

package/lib/polling.ts

@@ -1,5 +1,5 @@
 /**
- * Telegram polling domain helpers
+ * Telegram polling runtime domain helpers
  * Zones: telegram transport, polling runtime
  * Owns polling request builders, stop conditions, and the long-poll loop runtime for Telegram updates
  */
@@ -91,8 +91,9 @@ export function createTelegramPollingActivityReader(
   return () => isTelegramPollingControllerActive(state);
 }
 
-export interface TelegramPollingRuntimeDeps<TContext>
-  extends TelegramRuntimeEventRecorderPort {
+export interface TelegramPollingRuntimeDeps<
+  TContext,
+> extends TelegramRuntimeEventRecorderPort {
   hasBotToken: () => boolean;
   getPollingPromise: () => Promise<void> | undefined;
   setPollingPromise: (promise: Promise<void> | undefined) => void;

package/lib/preview.ts

@@ -22,7 +22,7 @@ import {
 } from "./rendering.ts";
 
 import { buildTelegramReplyParameters } from "./replies.ts";
-import { stripTelegramCommentMarkupForPreview } from "./outbound-handlers.ts";
+import { stripTelegramCommentMarkupForPreview } from "./outbound.ts";
 import { shouldSuppressPreviewForVoice } from "./voice.ts";
 
 const TELEGRAM_PREVIEW_THROTTLE_MS = 750;

package/lib/routing.ts

@@ -7,12 +7,12 @@
 import { readFile } from "node:fs/promises";
 import * as Commands from "./commands.ts";
 import type { TelegramConfigStore } from "./config.ts";
-import type { TelegramSectionRegistry } from "./extension-sections.ts";
-import type { TelegramInboundHandlerRuntime } from "./inbound-handlers.ts";
+import type { TelegramSectionRegistry } from "./sections.ts";
+import type { TelegramInboundHandlerRuntime } from "./inbound.ts";
 import * as Media from "./media.ts";
 import * as Menu from "./menu.ts";
 import * as Model from "./model.ts";
-import * as OutboundHandlers from "./outbound-handlers.ts";
+import * as OutboundHandlers from "./outbound.ts";
 import * as PromptTemplates from "./prompt-templates.ts";
 import * as Queue from "./queue.ts";
 import type { TelegramBridgeRuntime } from "./runtime.ts";
@@ -138,6 +138,7 @@ export interface TelegramInboundRouteRuntimeDeps<
 }
 
 const TELEGRAM_OWNED_CALLBACK_PREFIXES = [
+  "compact:",
   "menu:",
   "model:",
   "queue:",
@@ -262,6 +263,45 @@ export function createTelegramInboundRouteRuntime<
       );
       if (handled) return;
     }
+    const handledByCompact =
+      await Commands.handleTelegramCompactConfirmationCallback(query, {
+        ctx,
+        answerCallbackQuery: deps.answerCallbackQuery,
+        editInteractiveMessage: deps.editInteractiveMessage ?? (async () => {}),
+        runCompact: async (compactCtx, chatId, replyToMessageId) => {
+          await Commands.handleTelegramCompactCommand({
+            isIdle: () => deps.isIdle(compactCtx),
+            hasPendingMessages: () => deps.hasPendingMessages(compactCtx),
+            hasActiveTelegramTurn: deps.activeTurnRuntime.has,
+            hasDispatchPending: deps.bridgeRuntime.lifecycle.hasDispatchPending,
+            hasQueuedTelegramItems: deps.telegramQueueStore.hasQueuedItems,
+            isCompactionInProgress:
+              deps.bridgeRuntime.lifecycle.isCompactionInProgress,
+            setCompactionInProgress:
+              deps.bridgeRuntime.lifecycle.setCompactionInProgress,
+            updateStatus: () => deps.updateStatus(compactCtx),
+            dispatchNextQueuedTelegramTurn: () =>
+              deps.dispatchNextQueuedTelegramTurn(compactCtx),
+            requestDeferredDispatchNextQueuedTelegramTurn:
+              deps.requestDeferredDispatchNextQueuedTelegramTurn
+                ? (dispatch) =>
+                    deps.requestDeferredDispatchNextQueuedTelegramTurn?.(() =>
+                      dispatch(),
+                    )
+                : undefined,
+            compact: (callbacks) => deps.compact(compactCtx, callbacks),
+            startTypingLoop: deps.startTypingLoop
+              ? () => deps.startTypingLoop?.(compactCtx, chatId)
+              : undefined,
+            stopTypingLoop: deps.stopTypingLoop,
+            sendTextReply: (text) =>
+              deps.sendTextReply(chatId, replyToMessageId, text).then(() => {}),
+            suppressStartNotice: true,
+            recordRuntimeEvent: deps.recordRuntimeEvent,
+          });
+        },
+      });
+    if (handledByCompact) return;
     const handledByQueue = await deps.queueMenuCallbackHandler(query, ctx);
     if (handledByQueue) return;
     const handledBySettings = await deps.settingsMenuCallbackHandler?.(
@@ -302,28 +342,19 @@ export function createTelegramInboundRouteRuntime<
     message: TMessage,
     ctx: TContext,
   ): Promise<void> => {
-    const enqueuePlan = Queue.planTelegramPromptEnqueue(
-      deps.telegramQueueStore.getQueuedItems(),
-      deps.bridgeRuntime.lifecycle.shouldPreserveQueuedTurnsAsHistory(),
-    );
     deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory(false);
     const continueMessage = {
       ...message,
       text: "continue",
       caption: undefined,
     } as TMessage;
-    const turn = await promptTurnBuilder(
-      [continueMessage],
-      enqueuePlan.historyTurns,
-      ctx,
-    );
+    const turn = await promptTurnBuilder([continueMessage], [], ctx);
     const continueTurn = {
       ...turn,
       queueLane: "priority" as const,
       laneOrder: Number.MIN_SAFE_INTEGER + turn.queueOrder,
       statusSummary: "continue",
     };
-    deps.telegramQueueStore.setQueuedItems(enqueuePlan.remainingItems);
     deps.queueMutationRuntime.append(continueTurn, ctx);
     deps.dispatchNextQueuedTelegramTurn(ctx);
   };
@@ -381,6 +412,7 @@ export function createTelegramInboundRouteRuntime<
     getPromptTemplateCommands,
     persistConfig: deps.configStore.persist,
     sendTextReply: deps.sendTextReply,
+    sendInteractiveMessage: deps.sendInteractiveMessage,
     recordRuntimeEvent: deps.recordRuntimeEvent,
   });
   const promptEnqueue = Queue.createTelegramPromptEnqueueController<

package/lib/{extension-sections.ts → sections.ts}

@@ -1,12 +1,13 @@
 /**
  * Telegram Extension Sections registry and callback routing
  * Zones: telegram ui, extension platform, callback routing
- * Owns section registration, token mapping, main-menu/settings row injection, and section callback dispatch
+ * Owns section registration, global registry binding, token mapping, main-menu/settings row injection, and section callback dispatch
  */
 
 import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
 
 const SECTION_REGISTRY_KEY = "__piTelegramSectionRegistry__";
+const TELEGRAM_CALLBACK_DATA_MAX_BYTES = 64;
 
 // --- Core Types ---
 
@@ -181,9 +182,7 @@ function buildTelegramSectionContext(
         .then(() => {}),
     enqueuePrompt: deps.enqueuePrompt,
     callbackData: (action, payload) =>
-      payload
-        ? `section:${token}:${action}:${payload}`
-        : `section:${token}:${action}`,
+      buildTelegramSectionCallbackData(token, action, payload),
     deleteMessage: () =>
       messageId !== undefined
         ? deps.deleteMessage(chatId, messageId)
@@ -231,9 +230,7 @@ function buildTelegramSectionCallbackContext(
         .then(() => {}),
     enqueuePrompt: deps.enqueuePrompt,
     callbackData: (action, payload) =>
-      payload
-        ? `section:${token}:${action}:${payload}`
-        : `section:${token}:${action}`,
+      buildTelegramSectionCallbackData(token, action, payload),
     deleteMessage: () =>
       messageId !== undefined
         ? deps.deleteMessage(chatId, messageId)
@@ -250,6 +247,13 @@ export function setGlobalTelegramSectionRegistry(
   (globalThis as Record<string, unknown>)[SECTION_REGISTRY_KEY] = registry;
 }
 
+/** @internal */
+export function createAndBindTelegramSectionRegistry(): TelegramSectionRegistry {
+  const registry = createTelegramExtensionSectionRegistry();
+  setGlobalTelegramSectionRegistry(registry);
+  return registry;
+}
+
 /**
  * Register a Telegram Extension Section from any pi extension.
  * Returns a disposer. Throws if no section registry is active.
@@ -271,8 +275,8 @@ export function registerTelegramSection(
 
 /**
  * Get current section diagnostics. Returns empty array when registry is absent.
+ * @internal
  */
-/** @internal */
 export function getTelegramSectionDiagnostics(): TelegramSectionDiagnostic[] {
   const registry = (globalThis as Record<string, unknown>)[
     SECTION_REGISTRY_KEY
@@ -291,6 +295,27 @@ const BACK_NAV_ROW = {
   text: "⬆️ Back",
 } as const;
 
+function getUtf8ByteLength(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function buildTelegramSectionCallbackData(
+  token: TelegramSectionToken,
+  action: string,
+  payload?: string,
+): string {
+  const data = payload
+    ? `section:${token}:${action}:${payload}`
+    : `section:${token}:${action}`;
+  const byteLength = getUtf8ByteLength(data);
+  if (byteLength > TELEGRAM_CALLBACK_DATA_MAX_BYTES) {
+    throw new Error(
+      `Telegram section callback_data exceeds ${TELEGRAM_CALLBACK_DATA_MAX_BYTES} bytes (${byteLength}). Use a shorter action/payload or store state behind a compact key.`,
+    );
+  }
+  return data;
+}
+
 function prependBackRow(
   replyMarkup: TelegramInlineKeyboardMarkup | undefined,
   backCallback: string,
@@ -319,6 +344,10 @@ export function createTelegramExtensionSectionRegistry(): TelegramSectionRegistr
   let nextToken = 0;
 
   function register(section: TelegramSectionRegistration): () => void {
+    const duplicate = [...sections.values()].find((s) => s.id === section.id);
+    if (duplicate) {
+      throw new Error(`Telegram section id already registered: ${section.id}`);
+    }
     const token = String(nextToken++);
     const registered: RegisteredTelegramSection = {
       id: section.id,

package/lib/time-injection.ts

@@ -52,7 +52,7 @@ export function createTimeInjectionRuntime(
   return {
     resolveLine: (chatId, now = new Date()) => {
       const config = deps.getConfig();
-      if (config.injectionMode === "off") return null;
+      if (config.injectionMode === "hidden") return null;
       let line: string;
       try {
         line = formatTelegramTimeInjectionLine(now, config.timezone);