spectrum-ts 1.18.0 → 3.0.0

package/dist/index.js

@@ -1,42 +1,56 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
 import {
-  group,
   richlink
-} from "./chunk-JQN6CRSC.js";
+} from "./chunk-CHY5YLLV.js";
+import {
+  FUSOR_MESSAGES_CHANNEL,
+  fusor,
+  fusorEvent,
+  isFusorClient,
+  isFusorEvent
+} from "./chunk-34FQGGD7.js";
+import {
+  group
+} from "./chunk-MHGCPC2V.js";
 import {
   voice
-} from "./chunk-NNY6LMSC.js";
+} from "./chunk-77U6SH5A.js";
 import {
   option,
   poll
 } from "./chunk-2D27WW5B.js";
 import {
   SpectrumCloudError,
+  cloud
+} from "./chunk-3GEJYGZK.js";
+import {
+  contact
+} from "./chunk-NZ5WCMTY.js";
+import {
   broadcast,
-  cloud,
   createAsyncQueue,
   mergeStreams,
   stream
-} from "./chunk-MC6ZKFSG.js";
+} from "./chunk-5XEFJBN2.js";
 import {
-  contact,
   fromVCard,
   toVCard
-} from "./chunk-QGJFZMD5.js";
+} from "./chunk-6UZFVXQF.js";
 import {
   UnsupportedError,
   avatar,
   buildSpace,
   contentAttrs,
-  defineFusorPlatform,
   definePlatform,
   edit,
+  markdown,
   rename,
   reply,
   senderAttrs,
   typing,
+  unsend,
   wrapProviderMessage
-} from "./chunk-IPOFBAIM.js";
+} from "./chunk-LX437ZTY.js";
 import {
   __commonJS,
   __esm,
@@ -49,7 +63,7 @@ import {
   reaction,
   resolveContents,
   text
-} from "./chunk-2ILTJC35.js";
+} from "./chunk-LQMDV75O.js";
 
 // ../../node_modules/@grpc/grpc-js/build/src/constants.js
 var require_constants = __commonJS({
@@ -26124,21 +26138,6 @@ var aliases = {
 };
 var Emoji = { ...GeneratedEmoji, ...aliases };
 
-// src/fusor/types.ts
-var FUSOR_BRAND = /* @__PURE__ */ Symbol.for("spectrum.fusor.client");
-
-// src/fusor/index.ts
-function fusor(platform, verify) {
-  return {
-    [FUSOR_BRAND]: true,
-    platform,
-    verify
-  };
-}
-function isFusorClient(value) {
-  return typeof value === "object" && value !== null && value[FUSOR_BRAND] === true;
-}
-
 // src/spectrum.ts
 import {
   createLogger as createLogger2,
@@ -27282,6 +27281,23 @@ function combineReplies(outcomes) {
     body
   };
 }
+function routeHandlerResult(result, handler, deliver) {
+  if (result === void 0) {
+    return;
+  }
+  const items = Array.isArray(result) ? result : [result];
+  for (const item of items) {
+    if (!isFusorEvent(item)) {
+      deliver(item);
+      continue;
+    }
+    if (item.name === FUSOR_MESSAGES_CHANNEL) {
+      deliver(item.data);
+    } else {
+      handler.pushEvent(item.name, item.data);
+    }
+  }
+}
 function runHandlerOnce(handler, parsedRequest, deliver = handler.pushMessage) {
   return (async () => {
     try {
@@ -27302,12 +27318,7 @@ function runHandlerOnce(handler, parsedRequest, deliver = handler.pushMessage) {
       };
       const result = await handler.messages({ payload, respond });
       returned = true;
-      if (result !== void 0) {
-        const records = Array.isArray(result) ? result : [result];
-        for (const record of records) {
-          deliver(record);
-        }
-      }
+      routeHandlerResult(result, handler, deliver);
       return { ok: true, reply: reply2 };
     } catch (error) {
       const errorReason = error instanceof Error ? error.message : String(error);
@@ -27403,7 +27414,7 @@ var FusorCore = class {
     const { iterable: requestIterable, sink } = createRequestSink();
     this.requestSink = sink;
     sink.push({ init: { startSeq: 0 }, reply: void 0 });
-    const metadata = Metadata().set("authorization", `Bearer ${token}`);
+    const metadata = Metadata().set("access_token", token);
     const stream2 = client.subscribe(requestIterable, { metadata });
     try {
       for await (const response of stream2) {
@@ -27558,6 +27569,7 @@ function createStore() {
 
 // src/spectrum.ts
 var PHOTON_OTEL_ENDPOINT = "https://otlp.photon.codes";
+var STREAM_CLOSE_TIMEOUT_MS = 5e3;
 var lifecycleLog = createLogger2("spectrum.lifecycle");
 var ignoreCleanupError = () => void 0;
 var spectrumOptionsSchema = z.object({
@@ -27614,15 +27626,21 @@ async function Spectrum(options) {
   const platformStates = /* @__PURE__ */ new Map();
   const fusorMessageSources = /* @__PURE__ */ new Map();
   const messageBroadcasters = /* @__PURE__ */ new Map();
+  const fusorEventSources = /* @__PURE__ */ new Map();
+  const eventBroadcasters = /* @__PURE__ */ new Map();
   const customEventStreams = /* @__PURE__ */ new Map();
   let stopped = false;
-  const adaptIterable = (iterable) => stream((emit, end) => {
+  const adaptIterable = (iterable, project) => stream((emit, end) => {
     const iterator = iterable[Symbol.asyncIterator]();
     const pump = (async () => {
       try {
         let result = await iterator.next();
         while (!result.done) {
-          await emit(result.value);
+          if (project) {
+            await project(result.value, emit);
+          } else {
+            await emit(result.value);
+          }
           result = await iterator.next();
         }
         end();
@@ -27694,20 +27712,20 @@ async function Spectrum(options) {
       projectConfig,
       store
     });
-    const bindSend = async function* () {
-      for await (const msg of raw) {
-        const tuples = await resolveRecordToMessages(msg, {
+    return adaptIterable(
+      raw,
+      async (record, emit) => {
+        const tuples = await resolveRecordToMessages(record, {
           client,
           config,
           definition,
           store
         });
         for (const tuple of tuples) {
-          yield tuple;
+          await emit(tuple);
         }
       }
-    };
-    return adaptIterable(bindSend());
+    );
   };
   const getOrCreateMessageBroadcast = (state) => {
     if (stopped) {
@@ -27723,6 +27741,24 @@ async function Spectrum(options) {
     }
     return broadcaster;
   };
+  const getOrCreateEventBroadcast = (platform, channel) => {
+    const queue = fusorEventSources.get(platform)?.get(channel);
+    if (!queue) {
+      return;
+    }
+    if (stopped) {
+      throw new Error(
+        `Spectrum instance has been stopped; cannot subscribe to "${platform}" event "${channel}"`
+      );
+    }
+    const key = `${platform}\0${channel}`;
+    let broadcaster = eventBroadcasters.get(key);
+    if (!broadcaster) {
+      broadcaster = broadcast(adaptIterable(queue.iterable));
+      eventBroadcasters.set(key, broadcaster);
+    }
+    return broadcaster;
+  };
   await withSpan(
     "spectrum.init",
     {
@@ -27744,6 +27780,7 @@ async function Spectrum(options) {
             config: userConfig,
             projectId,
             projectSecret,
+            projectConfig,
             store
           })
         );
@@ -27755,7 +27792,13 @@ async function Spectrum(options) {
         };
         platformStates.set(def.name, {
           ...state,
-          subscribeMessages: () => getOrCreateMessageBroadcast(state).subscribe()
+          projectConfig,
+          subscribeMessages: () => getOrCreateMessageBroadcast(state).subscribe(),
+          // Fanout subscription to a fusor event channel. Returns undefined for
+          // regular platforms (no per-channel queue) — callers fall back to the
+          // producer path. Resolved lazily, after the fusor bootstrap below has
+          // created the per-(platform, channel) queues.
+          subscribeEvent: (channel) => getOrCreateEventBroadcast(def.name, channel)?.subscribe()
         });
       }
     }
@@ -27778,10 +27821,36 @@ async function Spectrum(options) {
         continue;
       }
       const userMessages = runtime.definition.messages;
+      const declaredEvents = runtime.definition.events ?? {};
+      const eventQueues = /* @__PURE__ */ new Map();
+      for (const channel of Object.keys(declaredEvents)) {
+        eventQueues.set(channel, createAsyncQueue());
+      }
+      fusorEventSources.set(name, eventQueues);
       const handler = {
         verify: client.verify,
-        messages: async (ctx) => userMessages(ctx),
-        pushMessage: (record) => queue.push(record)
+        // Enrich the transport-level `{ payload, respond }` ctx with the same
+        // runtime context every other platform callback receives, so fusor
+        // handlers can read config/store/projectConfig directly instead of
+        // smuggling state through the payload.
+        messages: async (ctx) => userMessages({
+          ...ctx,
+          config: runtime.config,
+          store: runtime.store,
+          projectConfig: runtime.projectConfig
+        }),
+        pushMessage: (record) => queue.push(record),
+        pushEvent: (channel, data) => {
+          const eventQueue = eventQueues.get(channel);
+          if (!eventQueue) {
+            lifecycleLog.warn(
+              `spectrum: fusorEvent("${channel}", \u2026) names a channel not declared in "${name}".events; dropping`,
+              { platform: name, channel }
+            );
+            return;
+          }
+          eventQueue.push(data);
+        }
       };
       fusorCore.register(client.platform, handler);
     }
@@ -27828,30 +27897,35 @@ async function Spectrum(options) {
     const providerStreams = [];
     for (const state of platformStates.values()) {
       const { client, config, definition, store } = state;
-      const producer = definition.events?.[eventName];
-      if (!producer) {
-        continue;
-      }
-      const providerEvents = producer({
-        client,
-        config,
-        projectConfig,
-        store
-      });
-      const annotatePlatform = async function* () {
-        for await (const value of providerEvents) {
-          const annotated = await withSpan(
-            "spectrum.event",
-            {
-              "spectrum.provider": definition.name,
-              "spectrum.event.name": eventName
-            },
-            () => ({ ...value, platform: definition.name })
-          );
-          yield annotated;
+      let source = state.subscribeEvent?.(eventName);
+      if (!source) {
+        const producer = definition.events?.[eventName];
+        if (typeof producer !== "function") {
+          continue;
         }
-      };
-      providerStreams.push(adaptIterable(annotatePlatform()));
+        source = producer({ client, config, projectConfig, store });
+      }
+      const providerEvents = source;
+      providerStreams.push(
+        adaptIterable(
+          providerEvents,
+          async (value, emit2) => {
+            const annotated = await withSpan(
+              "spectrum.event",
+              {
+                "spectrum.provider": definition.name,
+                "spectrum.event.name": eventName
+              },
+              // Object payloads are flattened and tagged with `platform`. A
+              // primitive/null payload can't be spread (a string would mangle
+              // into indexed chars, a number/bool would vanish), so wrap it
+              // under `payload` instead.
+              () => typeof value === "object" && value !== null ? { ...value, platform: definition.name } : { platform: definition.name, payload: value }
+            );
+            await emit2(annotated);
+          }
+        )
+      );
     }
     const merged = mergeStreams(providerStreams);
     const pump = (async () => {
@@ -27870,6 +27944,18 @@ async function Spectrum(options) {
     };
   });
   const messagesStream = createMessagesStream();
+  const closeFusorSources = () => {
+    for (const queue of fusorMessageSources.values()) {
+      queue.close();
+    }
+    fusorMessageSources.clear();
+    for (const queues of fusorEventSources.values()) {
+      for (const queue of queues.values()) {
+        queue.close();
+      }
+    }
+    fusorEventSources.clear();
+  };
   const stopOnce = async () => {
     if (stopped) {
       return;
@@ -27884,13 +27970,31 @@ async function Spectrum(options) {
       ...Array.from(
         messageBroadcasters.values(),
         (broadcaster) => broadcaster.close()
+      ),
+      ...Array.from(
+        eventBroadcasters.values(),
+        (broadcaster) => broadcaster.close()
       )
     ];
     process.off("SIGINT", handleSignal);
     process.off("SIGTERM", handleSignal);
     const streamCloseStart = performance.now();
-    await Promise.allSettled(streamShutdowns);
-    const streamCloseMs = Math.round(performance.now() - streamCloseStart);
+    const streamSettled = Promise.allSettled(streamShutdowns);
+    let streamTimedOut = false;
+    await Promise.race([
+      streamSettled,
+      new Promise((resolve) => {
+        setTimeout(() => {
+          streamTimedOut = true;
+          resolve();
+        }, STREAM_CLOSE_TIMEOUT_MS).unref();
+      })
+    ]);
+    if (streamTimedOut) {
+      lifecycleLog.warn("stream close timed out; proceeding to teardown", {
+        timeoutMs: STREAM_CLOSE_TIMEOUT_MS
+      });
+    }
     let fusorCloseMs = 0;
     if (fusorCore) {
       const fusorCloseStart = performance.now();
@@ -27901,10 +28005,7 @@ async function Spectrum(options) {
         lifecycleLog.warn("fusor core close failed", { error });
       });
       fusorCloseMs = Math.round(performance.now() - fusorCloseStart);
-      for (const queue of fusorMessageSources.values()) {
-        queue.close();
-      }
-      fusorMessageSources.clear();
+      closeFusorSources();
     }
     const clientShutdowns = [];
     for (const state of platformStates.values()) {
@@ -27928,8 +28029,11 @@ async function Spectrum(options) {
     const clientCloseStart = performance.now();
     await Promise.allSettled(clientShutdowns);
     const clientCloseMs = Math.round(performance.now() - clientCloseStart);
+    await streamSettled.catch(() => void 0);
+    const streamCloseMs = Math.round(performance.now() - streamCloseStart);
     customEventStreams.clear();
     messageBroadcasters.clear();
+    eventBroadcasters.clear();
     platformStates.clear();
     lifecycleLog.info("Spectrum stopped", {
       providers: providerNames,
@@ -28102,13 +28206,15 @@ export {
   cloud,
   contact,
   custom,
-  defineFusorPlatform,
   definePlatform,
   edit,
   fromVCard,
   fusor,
+  fusorEvent,
   group,
   isFusorClient,
+  isFusorEvent,
+  markdown,
   mergeStreams,
   option,
   poll,
@@ -28121,6 +28227,7 @@ export {
   text,
   toVCard,
   typing,
+  unsend,
   voice
 };
 /*! Bundled license information:

package/dist/manifest.json

@@ -11,6 +11,12 @@
     "path": "spectrum-ts/providers/slack",
     "label": "Slack"
   },
+  {
+    "key": "telegram",
+    "import": "telegram",
+    "path": "spectrum-ts/providers/telegram",
+    "label": "telegram"
+  },
   {
     "key": "terminal",
     "import": "terminal",

package/dist/providers/imessage/index.d.ts

@@ -1,8 +1,8 @@
-import { C as ContentBuilder, c as ContentInput, M as Message, S as SchemaMessage, P as Platform, a as PlatformDef, b as Space, d as Store } from '../../types-DcQ5a7PK.js';
+import { C as ContentBuilder, h as ContentInput, M as Message, S as SchemaMessage, P as Platform, a as PlatformDef, e as Space, c as Store } from '../../types-YqCNUDIt.js';
 import * as zod_v4_core from 'zod/v4/core';
 import * as z from 'zod';
 import z__default from 'zod';
-import { A as Attachment } from '../../attachment-DfWSZS5L.js';
+import { A as Attachment } from '../../attachment-WePAHfcH.js';
 import { P as PhotoInput } from '../../photo-content-BJKnqgN-.js';
 import { MessageEffect, AdvancedIMessage } from '@photon-ai/advanced-imessage';
 import { IMessageSDK } from '@photon-ai/imessage-kit';
@@ -179,11 +179,7 @@ declare const imessage: Platform<PlatformDef<"iMessage", z.ZodUnion<readonly [z.
     id: string;
 }, {
     id: string;
-    type: "dm";
-    phone: string;
-} | {
-    id: string;
-    type: "group";
+    type: "group" | "dm";
     phone: string;
 }, z.ZodObject<{
     partIndex: z.ZodOptional<z.ZodNumber>;
@@ -213,15 +209,11 @@ declare const imessage: Platform<PlatformDef<"iMessage", z.ZodUnion<readonly [z.
             }[] | undefined;
         };
         store: Store;
-    }, space: ({
-        id: string;
-        type: "dm";
-        phone: string;
-    } | {
+    }, space: {
         id: string;
-        type: "group";
+        type: "group" | "dm";
         phone: string;
-    }) & {
+    } & {
         id: string;
         __platform: string;
     }, messageId: string) => Promise<IMessageMessage | undefined>;

package/dist/providers/imessage/index.js

@@ -5,13 +5,16 @@ import {
   effect,
   imessage,
   read
-} from "../../chunk-YN6WOTBF.js";
-import "../../chunk-JQN6CRSC.js";
+} from "../../chunk-AYCMTRVC.js";
+import "../../chunk-CHY5YLLV.js";
+import "../../chunk-MHGCPC2V.js";
 import "../../chunk-2D27WW5B.js";
-import "../../chunk-MC6ZKFSG.js";
-import "../../chunk-QGJFZMD5.js";
-import "../../chunk-IPOFBAIM.js";
-import "../../chunk-2ILTJC35.js";
+import "../../chunk-3GEJYGZK.js";
+import "../../chunk-NZ5WCMTY.js";
+import "../../chunk-5XEFJBN2.js";
+import "../../chunk-6UZFVXQF.js";
+import "../../chunk-LX437ZTY.js";
+import "../../chunk-LQMDV75O.js";
 export {
   background,
   customizedMiniApp,

package/dist/providers/index.d.ts

@@ -1,16 +1,19 @@
 export { imessage } from './imessage/index.js';
 export { slack } from './slack/index.js';
+export { telegram } from './telegram/index.js';
 export { terminal } from './terminal/index.js';
 export { whatsappBusiness } from './whatsapp-business/index.js';
-import '../types-DcQ5a7PK.js';
+import '../types-YqCNUDIt.js';
 import 'hotscript';
 import 'zod';
 import 'zod/v4/core';
-import '../attachment-DfWSZS5L.js';
+import '../attachment-WePAHfcH.js';
 import '../photo-content-BJKnqgN-.js';
 import '@photon-ai/advanced-imessage';
 import '@photon-ai/imessage-kit';
 import '@photon-ai/slack';
+import '@photon-ai/telegram-ts';
+import '../types-BujGKBin.js';
 import 'node:child_process';
 import 'node:net';
 import '@photon-ai/whatsapp-business';

package/dist/providers/index.js

@@ -1,26 +1,34 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
 import {
   imessage
-} from "../chunk-YN6WOTBF.js";
-import "../chunk-JQN6CRSC.js";
+} from "../chunk-AYCMTRVC.js";
+import "../chunk-CHY5YLLV.js";
 import {
   slack
-} from "../chunk-3OTECDNH.js";
+} from "../chunk-FULEQIRQ.js";
+import {
+  telegram
+} from "../chunk-TXRWKSNH.js";
+import "../chunk-34FQGGD7.js";
+import "../chunk-MHGCPC2V.js";
 import {
   terminal
-} from "../chunk-5BKZJMZV.js";
-import "../chunk-NNY6LMSC.js";
+} from "../chunk-EZ5SNNFS.js";
+import "../chunk-77U6SH5A.js";
 import {
   whatsappBusiness
-} from "../chunk-5TIF3FIE.js";
+} from "../chunk-UXJ5OO6P.js";
 import "../chunk-2D27WW5B.js";
-import "../chunk-MC6ZKFSG.js";
-import "../chunk-QGJFZMD5.js";
-import "../chunk-IPOFBAIM.js";
-import "../chunk-2ILTJC35.js";
+import "../chunk-3GEJYGZK.js";
+import "../chunk-NZ5WCMTY.js";
+import "../chunk-5XEFJBN2.js";
+import "../chunk-6UZFVXQF.js";
+import "../chunk-LX437ZTY.js";
+import "../chunk-LQMDV75O.js";
 export {
   imessage,
   slack,
+  telegram,
   terminal,
   whatsappBusiness
 };

package/dist/providers/slack/index.d.ts

@@ -1,4 +1,4 @@
-import { S as SchemaMessage, P as Platform, a as PlatformDef } from '../../types-DcQ5a7PK.js';
+import { S as SchemaMessage, P as Platform, a as PlatformDef } from '../../types-YqCNUDIt.js';
 import * as z from 'zod';
 import z__default from 'zod';
 import * as _photon_ai_slack from '@photon-ai/slack';
@@ -30,7 +30,6 @@ declare const slack: Platform<PlatformDef<"Slack", z.ZodUnion<readonly [z.ZodObj
     id: z.ZodString;
     teamId: z.ZodString;
 }, zod_v4_core.$strip>, z.ZodObject<{
-    channel: z.ZodOptional<z.ZodString>;
     teamId: z.ZodString;
 }, zod_v4_core.$strip>, _photon_ai_slack.SlackClient, {
     id: string;

package/dist/providers/slack/index.js

@@ -1,10 +1,11 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
 import {
   slack
-} from "../../chunk-3OTECDNH.js";
-import "../../chunk-MC6ZKFSG.js";
-import "../../chunk-IPOFBAIM.js";
-import "../../chunk-2ILTJC35.js";
+} from "../../chunk-FULEQIRQ.js";
+import "../../chunk-3GEJYGZK.js";
+import "../../chunk-5XEFJBN2.js";
+import "../../chunk-LX437ZTY.js";
+import "../../chunk-LQMDV75O.js";
 export {
   slack
 };

package/dist/providers/telegram/index.d.ts

@@ -0,0 +1,45 @@
+import { P as Platform, a as PlatformDef, g as ProviderMessage } from '../../types-YqCNUDIt.js';
+import * as _photon_ai_telegram_ts from '@photon-ai/telegram-ts';
+import * as zod_v4_core from 'zod/v4/core';
+import * as z from 'zod';
+import z__default from 'zod';
+import { F as FusorClient } from '../../types-BujGKBin.js';
+import 'hotscript';
+
+interface TelegramSpace {
+    id: string;
+}
+
+declare const configSchema: z__default.ZodObject<{
+    botToken: z__default.ZodString;
+    webhookSecret: z__default.ZodOptional<z__default.ZodString>;
+    baseUrl: z__default.ZodDefault<z__default.ZodURL>;
+}, z__default.core.$strip>;
+type TelegramConfig = z__default.infer<typeof configSchema>;
+
+/**
+ * Telegram provider for Spectrum.
+ *
+ * Inbound is delivered through Fusor: `createClient` returns a `fusor(...)`
+ * client whose `verify` checks the Telegram webhook secret token and parses the
+ * `Update` (pure parsing — no client). The `messages` handler reads `config`
+ * from its ctx and builds a photon client inline only to download media bytes.
+ * Outbound (`send`) also builds a photon client inline. Both go through
+ * `@photon-ai/telegram-ts`. Drop `telegram.config({...})` into
+ * `Spectrum({ providers: [...] })`.
+ *
+ * In cloud mode (`projectConfig` present), `createClient` also self-registers
+ * the bot's webhook against the Fusor edge for the project slug — see
+ * `ensureWebhook`. Without a slug (local/direct mode) registration is skipped.
+ */
+declare const telegram: Platform<PlatformDef<"telegram", z.ZodObject<{
+    botToken: z.ZodString;
+    webhookSecret: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodDefault<z.ZodURL>;
+}, zod_v4_core.$strip>, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, FusorClient<_photon_ai_telegram_ts.Update>, {
+    id: string;
+}, TelegramSpace, undefined, ProviderMessage<{
+    id: string;
+}, TelegramSpace, Record<never, never>>, undefined, Record<never, never>, Record<never, never>, Record<never, never>>> & Readonly<Record<never, never>>;
+
+export { type TelegramConfig, telegram };

package/dist/providers/telegram/index.js

@@ -0,0 +1,13 @@
+import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
+import {
+  telegram
+} from "../../chunk-TXRWKSNH.js";
+import "../../chunk-34FQGGD7.js";
+import "../../chunk-MHGCPC2V.js";
+import "../../chunk-77U6SH5A.js";
+import "../../chunk-6UZFVXQF.js";
+import "../../chunk-LX437ZTY.js";
+import "../../chunk-LQMDV75O.js";
+export {
+  telegram
+};