spectrum-ts 1.18.0 → 3.0.0

package/README.md

@@ -1,6 +1,9 @@
 <div align="center">
   <h1>Spectrum</h1>
   <p><strong>Bring agents to any interface.</strong></p>
+  
+  Photon (photon.codes) builds Spectrum, a multi-channel agent framework that makes AI agents reachable over real conversation surfaces like iMessage, SMS, and email instead of trapping them in web chat.
+  
   <p>
     <a href="https://www.npmjs.com/package/spectrum-ts"><img src="https://img.shields.io/npm/v/spectrum-ts.svg?style=flat&colorA=1a1a1a&colorB=3178c6" alt="npm version" /></a>
     <a href="https://www.npmjs.com/package/spectrum-ts"><img src="https://img.shields.io/npm/dm/spectrum-ts.svg?style=flat&colorA=1a1a1a&colorB=3178c6" alt="npm downloads" /></a>
@@ -10,7 +13,13 @@
   </p>
 </div>
 
-Spectrum is a unified messaging SDK for TypeScript. Write your agent logic once and deliver it across every messaging platform — iMessage, WhatsApp, terminal, or your own — through one fully type-safe interface.
+## About Photon
+
+**[Photon](https://photon.codes)** builds infrastructure for AI agents that operate over real communication channels.
+
+Spectrum is Photon’s open-source multi-channel agent framework, enabling AI agents to communicate through interfaces people already use—such as iMessage, SMS, email, Slack, Discord, and voice—instead of being confined to web chat.
+
+Learn more at **https://photon.codes**.
 
 ## Getting Started
 
@@ -54,6 +63,7 @@ Visit **[docs.photon.codes](https://docs.photon.codes)** to view the full docume
 |----------|---------|
 | iMessage | `spectrum-ts/providers/imessage` |
 | WhatsApp | `spectrum-ts/providers/whatsapp` |
+| Telegram | `spectrum-ts/providers/telegram` |
 | Terminal | `spectrum-ts/providers/terminal` |
 | Custom   | `definePlatform` from `spectrum-ts` |
 

package/dist/{attachment-DfWSZS5L.d.ts → attachment-WePAHfcH.d.ts}

@@ -1,5 +1,5 @@
 import z__default from 'zod';
-import { C as ContentBuilder } from './types-DcQ5a7PK.js';
+import { C as ContentBuilder } from './types-YqCNUDIt.js';
 
 declare const attachmentSchema: z__default.ZodObject<{
     type: z__default.ZodLiteral<"attachment">;

package/dist/{authoring-C9uDdZ2F.d.ts → authoring-DDh3muGT.d.ts}

@@ -1,7 +1,7 @@
-import './attachment-DfWSZS5L.js';
+import './attachment-WePAHfcH.js';
 import vCard from 'vcf';
 import z__default from 'zod';
-import { U as User, C as ContentBuilder, M as Message, b as Space, c as ContentInput } from './types-DcQ5a7PK.js';
+import { U as User, C as ContentBuilder, M as Message, e as Space, h as ContentInput } from './types-YqCNUDIt.js';
 
 declare const nameSchema: z__default.ZodObject<{
     formatted: z__default.ZodOptional<z__default.ZodString>;
@@ -140,6 +140,43 @@ declare const asGroup: (input: {
 }) => Group;
 declare function group(...items: [ContentInput, ContentInput, ...ContentInput[]]): ContentBuilder;
 
+/**
+ * Maps one chunk emitted by a stream to the incremental text it carries.
+ * Return a string to emit, or `null`/`undefined` to skip the chunk (e.g. for
+ * control events that carry no text).
+ */
+type DeltaExtractor<T> = (chunk: T) => string | null | undefined;
+/**
+ * Anything the stream overloads of `text()` and `markdown()` accept as a
+ * source. The builder normalizes all of these to an internal
+ * `AsyncIterable<string>` of text deltas:
+ *
+ * - the Vercel AI SDK `streamText()` result (its `.textStream` is picked up
+ *   automatically — pass either the whole result or `.textStream` directly),
+ * - a raw `AsyncIterable<T>` (e.g. an OpenAI / Anthropic streaming response),
+ * - a raw `ReadableStream<T>` of chunks.
+ */
+type StreamTextSource<T = unknown> = {
+    textStream: AsyncIterable<string> | ReadableStream<string>;
+} | AsyncIterable<T> | ReadableStream<T>;
+interface TextStreamOptions<T = unknown> {
+    /**
+     * Map each chunk to its incremental text. Omit to rely on built-in
+     * auto-detection of the common SDK shapes (OpenAI chat/responses, Anthropic
+     * messages, AI SDK text streams, and plain strings).
+     */
+    extract?: DeltaExtractor<T>;
+}
+declare const streamTextSchema: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"streamText">;
+    stream: z__default.ZodCustom<() => AsyncIterable<string>, () => AsyncIterable<string>>;
+    format: z__default.ZodOptional<z__default.ZodEnum<{
+        markdown: "markdown";
+        plain: "plain";
+    }>>;
+}, z__default.core.$strip>;
+type StreamText = z__default.infer<typeof streamTextSchema>;
+
 declare const pollChoiceSchema: z__default.ZodObject<{
     title: z__default.ZodString;
 }, z__default.core.$strip>;
@@ -185,28 +222,6 @@ declare const option: (title: string) => PollChoice;
 declare function poll(title: string, options: PollChoiceInput[]): ContentBuilder;
 declare function poll(title: string, ...options: PollChoiceInput[]): ContentBuilder;
 
-declare const reactionSchema: z__default.ZodObject<{
-    type: z__default.ZodLiteral<"reaction">;
-    emoji: z__default.ZodString;
-    target: z__default.ZodCustom<Message<string, User, Space<unknown>>, Message<string, User, Space<unknown>>>;
-}, z__default.core.$strip>;
-type Reaction = z__default.infer<typeof reactionSchema>;
-declare const asReaction: (input: {
-    emoji: string;
-    target: Message;
-}) => Reaction;
-/**
- * Construct a `reaction` content value targeting the given message.
- *
- * `space.send(reaction(emoji, message))` is sugar for `message.react(emoji)`.
- * Reactions are fire-and-forget — the returned `Message` will be `undefined`
- * because platforms do not surface a message id for reactions.
- *
- * To react to a message known only by id, resolve it first via
- * `space.getMessage(id)`.
- */
-declare function reaction(emoji: string, target: Message): ContentBuilder;
-
 declare const richlinkSchema: z__default.ZodObject<{
     type: z__default.ZodLiteral<"richlink">;
     url: z__default.ZodURL;
@@ -239,7 +254,27 @@ declare const textSchema: z__default.ZodObject<{
     text: z__default.ZodString;
 }, z__default.core.$strip>;
 declare const asText: (text: string) => z__default.infer<typeof textSchema>;
-declare function text(text: string): ContentBuilder;
+/**
+ * Send plain text — a static string or a streaming LLM response.
+ *
+ * `text("hi")` sends one message. `text(source)` wraps a text stream so it
+ * can be sent like any other content; delivery is platform-specific —
+ * iMessage (remote) sends the first chunk as a real message and then edits it
+ * in place as more text arrives; Telegram (private chats) animates a native
+ * draft preview and persists the final text as one message. Platforms that
+ * can't stream wait for the stream to finish and deliver the accumulated text
+ * as one plain message.
+ *
+ * A stream source accepts whatever the popular SDKs return (the AI SDK
+ * `streamText()` result, OpenAI / Anthropic streaming responses, or any
+ * `AsyncIterable` / `ReadableStream`); pass `options.extract` for any chunk
+ * shape the built-in detection doesn't recognize. A stream can only be sent
+ * once. Options apply to stream sources only — they are ignored for strings.
+ *
+ * For text written in markdown, use `markdown()` instead.
+ */
+declare function text(source: string): ContentBuilder;
+declare function text<T = unknown>(source: StreamTextSource<T>, options?: TextStreamOptions<T>): ContentBuilder;
 
 declare const voiceSchema: z__default.ZodObject<{
     type: z__default.ZodLiteral<"voice">;
@@ -266,4 +301,4 @@ declare function voice(input: VoiceInput, options?: {
     duration?: number;
 }): ContentBuilder;
 
-export { asRichlink as A, asText as B, type ContactInput as C, asVoice as D, type Group as G, type Poll as P, type Reaction as R, type Voice as V, type Contact as a, type ContactAddress as b, type ContactDetails as c, type ContactEmail as d, type ContactName as e, type ContactOrg as f, type ContactPhone as g, type PollChoice as h, type PollChoiceInput as i, type PollOption as j, type Richlink as k, contact as l, custom as m, group as n, option as o, poll as p, richlink as q, reaction as r, asContact as s, text as t, asCustom as u, voice as v, asGroup as w, asPoll as x, asPollOption as y, asReaction as z };
+export { asVoice as A, type ContactInput as C, type DeltaExtractor as D, type Group as G, type Poll as P, type Richlink as R, type StreamTextSource as S, type TextStreamOptions as T, type Voice as V, type Contact as a, type ContactAddress as b, type ContactDetails as c, type ContactEmail as d, type ContactName as e, type ContactOrg as f, type ContactPhone as g, type PollChoice as h, type PollChoiceInput as i, type PollOption as j, type StreamText as k, contact as l, custom as m, group as n, option as o, poll as p, asContact as q, richlink as r, asCustom as s, text as t, asGroup as u, voice as v, asPoll as w, asPollOption as x, asRichlink as y, asText as z };

package/dist/authoring.d.ts

@@ -1,6 +1,6 @@
-export { c as asAttachment } from './attachment-DfWSZS5L.js';
-export { s as asContact, u as asCustom, w as asGroup, x as asPoll, y as asPollOption, z as asReaction, A as asRichlink, B as asText, D as asVoice } from './authoring-C9uDdZ2F.js';
-export { f as ProviderMessageRecord } from './types-DcQ5a7PK.js';
+export { c as asAttachment } from './attachment-WePAHfcH.js';
+export { q as asContact, s as asCustom, u as asGroup, w as asPoll, x as asPollOption, y as asRichlink, z as asText, A as asVoice } from './authoring-DDh3muGT.js';
+export { d as ProviderMessageRecord, $ as asReaction } from './types-YqCNUDIt.js';
 import 'zod';
 import 'vcf';
 import 'hotscript';

package/dist/authoring.js

@@ -1,24 +1,27 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
 import {
-  asGroup,
   asRichlink
-} from "./chunk-JQN6CRSC.js";
+} from "./chunk-CHY5YLLV.js";
+import {
+  asGroup
+} from "./chunk-MHGCPC2V.js";
 import {
   asVoice
-} from "./chunk-NNY6LMSC.js";
+} from "./chunk-77U6SH5A.js";
 import {
   asPoll,
   asPollOption
 } from "./chunk-2D27WW5B.js";
 import {
   asContact
-} from "./chunk-QGJFZMD5.js";
+} from "./chunk-NZ5WCMTY.js";
+import "./chunk-6UZFVXQF.js";
 import {
   asAttachment,
   asCustom,
   asReaction,
   asText
-} from "./chunk-2ILTJC35.js";
+} from "./chunk-LQMDV75O.js";
 export {
   asAttachment,
   asContact,

package/dist/chunk-34FQGGD7.js

@@ -0,0 +1,34 @@
+import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
+
+// src/fusor/event.ts
+var FUSOR_EVENT_BRAND = /* @__PURE__ */ Symbol.for("spectrum.fusor.event");
+var FUSOR_MESSAGES_CHANNEL = "messages";
+function fusorEvent(name, data) {
+  return { [FUSOR_EVENT_BRAND]: true, name, data };
+}
+function isFusorEvent(value) {
+  return typeof value === "object" && value !== null && value[FUSOR_EVENT_BRAND] === true;
+}
+
+// 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;
+}
+
+export {
+  FUSOR_MESSAGES_CHANNEL,
+  fusorEvent,
+  isFusorEvent,
+  fusor,
+  isFusorClient
+};

package/dist/chunk-3GEJYGZK.js

@@ -0,0 +1,84 @@
+import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
+
+// src/utils/cloud.ts
+var SPECTRUM_CLOUD_URL = process.env.SPECTRUM_CLOUD_URL ?? "https://spectrum.photon.codes";
+var SpectrumCloudError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.name = "SpectrumCloudError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var request = async (path, init) => {
+  const response = await fetch(`${SPECTRUM_CLOUD_URL}${path}`, init);
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    try {
+      const parsed = JSON.parse(body);
+      throw new SpectrumCloudError(
+        response.status,
+        parsed.code,
+        parsed.message
+      );
+    } catch (error) {
+      if (error instanceof SpectrumCloudError) {
+        throw error;
+      }
+      throw new SpectrumCloudError(
+        response.status,
+        "UNKNOWN",
+        body || response.statusText
+      );
+    }
+  }
+  const json = await response.json();
+  if (!json.succeed) {
+    throw new SpectrumCloudError(
+      response.status,
+      "UNKNOWN",
+      "Server returned succeed=false"
+    );
+  }
+  return json.data;
+};
+var basicAuth = (projectId, projectSecret) => `Basic ${btoa(`${projectId}:${projectSecret}`)}`;
+var cloud = {
+  getProject: (projectId, projectSecret) => request(`/projects/${projectId}/`, {
+    headers: { Authorization: basicAuth(projectId, projectSecret) }
+  }),
+  getSubscription: (projectId) => request(`/projects/${projectId}/billing/subscription`),
+  issueImessageTokens: (projectId, projectSecret) => request(`/projects/${projectId}/imessage/tokens`, {
+    method: "POST",
+    headers: { Authorization: basicAuth(projectId, projectSecret) }
+  }),
+  getImessageInfo: (projectId) => request(`/projects/${projectId}/imessage/`),
+  issueWhatsappBusinessTokens: (projectId, projectSecret) => request(`/projects/${projectId}/whatsapp-business/tokens`, {
+    method: "POST",
+    headers: { Authorization: basicAuth(projectId, projectSecret) }
+  }),
+  issueSlackTokens: (projectId, projectSecret) => request(`/projects/${projectId}/slack/tokens`, {
+    method: "POST",
+    headers: { Authorization: basicAuth(projectId, projectSecret) }
+  }),
+  issueFusorToken: (projectId, projectSecret) => request(`/projects/${projectId}/fusor/token`, {
+    method: "POST",
+    headers: { Authorization: basicAuth(projectId, projectSecret) }
+  }),
+  getPlatforms: (projectId) => request(`/projects/${projectId}/platforms/`),
+  togglePlatform: (projectId, projectSecret, platform, enabled) => request(`/projects/${projectId}/platforms/`, {
+    method: "PATCH",
+    headers: {
+      Authorization: basicAuth(projectId, projectSecret),
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ platform, enabled })
+  })
+};
+
+export {
+  SpectrumCloudError,
+  cloud
+};

package/dist/{chunk-MC6ZKFSG.js → chunk-5XEFJBN2.js}

@@ -1,83 +1,5 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
 
-// src/utils/cloud.ts
-var SPECTRUM_CLOUD_URL = process.env.SPECTRUM_CLOUD_URL ?? "https://spectrum.photon.codes";
-var SpectrumCloudError = class extends Error {
-  status;
-  code;
-  constructor(status, code, message) {
-    super(message);
-    this.name = "SpectrumCloudError";
-    this.status = status;
-    this.code = code;
-  }
-};
-var request = async (path, init) => {
-  const response = await fetch(`${SPECTRUM_CLOUD_URL}${path}`, init);
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    try {
-      const parsed = JSON.parse(body);
-      throw new SpectrumCloudError(
-        response.status,
-        parsed.code,
-        parsed.message
-      );
-    } catch (error) {
-      if (error instanceof SpectrumCloudError) {
-        throw error;
-      }
-      throw new SpectrumCloudError(
-        response.status,
-        "UNKNOWN",
-        body || response.statusText
-      );
-    }
-  }
-  const json = await response.json();
-  if (!json.succeed) {
-    throw new SpectrumCloudError(
-      response.status,
-      "UNKNOWN",
-      "Server returned succeed=false"
-    );
-  }
-  return json.data;
-};
-var basicAuth = (projectId, projectSecret) => `Basic ${btoa(`${projectId}:${projectSecret}`)}`;
-var cloud = {
-  getProject: (projectId, projectSecret) => request(`/projects/${projectId}/`, {
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  getSubscription: (projectId) => request(`/projects/${projectId}/billing/subscription`),
-  issueImessageTokens: (projectId, projectSecret) => request(`/projects/${projectId}/imessage/tokens`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  getImessageInfo: (projectId) => request(`/projects/${projectId}/imessage/`),
-  issueWhatsappBusinessTokens: (projectId, projectSecret) => request(`/projects/${projectId}/whatsapp-business/tokens`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  issueSlackTokens: (projectId, projectSecret) => request(`/projects/${projectId}/slack/tokens`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  issueFusorToken: (projectId, projectSecret) => request(`/projects/${projectId}/fusor/token`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  getPlatforms: (projectId) => request(`/projects/${projectId}/platforms/`),
-  togglePlatform: (projectId, projectSecret, platform, enabled) => request(`/projects/${projectId}/platforms/`, {
-    method: "PATCH",
-    headers: {
-      Authorization: basicAuth(projectId, projectSecret),
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ platform, enabled })
-  })
-};
-
 // src/utils/stream.ts
 import { Repeater } from "@repeaterjs/repeater";
 function createAsyncQueue() {
@@ -190,6 +112,16 @@ function broadcast(source) {
   let terminalError;
   let pumpPromise;
   let closed = false;
+  const closeConsumers = (error) => {
+    if (consumers.size === 0) {
+      return;
+    }
+    const current = Array.from(consumers);
+    consumers.clear();
+    for (const consumer of current) {
+      consumer.end(error);
+    }
+  };
   const startPump = () => {
     if (pumping || terminated) {
       return;
@@ -198,35 +130,35 @@ function broadcast(source) {
     pumpPromise = (async () => {
       try {
         for await (const value of source) {
-          for (const consumer of consumers) {
+          if (terminated) {
+            break;
+          }
+          for (const consumer of Array.from(consumers)) {
             consumer.deliveries = consumer.deliveries.then(
               () => consumer.emit(value).catch(() => {
               })
             );
           }
         }
+        if (terminated) {
+          return;
+        }
         terminated = true;
         await Promise.allSettled(
           Array.from(consumers, (consumer) => consumer.deliveries)
         );
-        for (const consumer of consumers) {
-          consumer.end();
-        }
-        consumers.clear();
+        closeConsumers();
       } catch (error) {
         terminated = true;
         terminalError = error;
-        for (const consumer of consumers) {
-          consumer.end(error);
-        }
-        consumers.clear();
+        closeConsumers(error);
       }
     })();
   };
   return {
     subscribe() {
       return stream((emit, end) => {
-        if (terminated) {
+        if (terminated || closed) {
           end(terminalError);
           return;
         }
@@ -247,27 +179,17 @@ function broadcast(source) {
         return;
       }
       closed = true;
-      try {
-        await source.close();
-        if (pumpPromise) {
-          await pumpPromise.catch(ignoreCleanupError);
-        }
-      } finally {
-        if (!terminated) {
-          terminated = true;
-          for (const consumer of consumers) {
-            consumer.end();
-          }
-          consumers.clear();
-        }
+      terminated = true;
+      closeConsumers();
+      await source.close().catch(ignoreCleanupError);
+      if (pumpPromise) {
+        await pumpPromise.catch(ignoreCleanupError);
       }
     }
   };
 }
 
 export {
-  SpectrumCloudError,
-  cloud,
   createAsyncQueue,
   stream,
   mergeStreams,

package/dist/{chunk-QGJFZMD5.js → chunk-6UZFVXQF.js}

@@ -1,7 +1,4 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  readSchema
-} from "./chunk-2ILTJC35.js";
 
 // src/utils/vcard.ts
 import vCard from "vcf";
@@ -350,109 +347,28 @@ var writePhoto = async (card, photo) => {
     type: photoTypeParam(photo.mimeType)
   });
 };
-var toVCard = async (contact2) => {
-  if (typeof contact2.raw === "string" && contact2.raw.startsWith("BEGIN:VCARD")) {
-    return contact2.raw;
+var toVCard = async (contact) => {
+  if (typeof contact.raw === "string" && contact.raw.startsWith("BEGIN:VCARD")) {
+    return contact.raw;
   }
   const card = new vCard();
-  writeName(card, contact2.name);
-  writePhones(card, contact2.phones);
-  writeEmails(card, contact2.emails);
-  writeAddresses(card, contact2.addresses);
-  writeOrg(card, contact2.org);
-  writeUrls(card, contact2.urls);
-  if (contact2.birthday) {
-    card.set("bday", contact2.birthday);
-  }
-  if (contact2.note) {
-    card.set("note", contact2.note);
-  }
-  await writePhoto(card, contact2.photo);
+  writeName(card, contact.name);
+  writePhones(card, contact.phones);
+  writeEmails(card, contact.emails);
+  writeAddresses(card, contact.addresses);
+  writeOrg(card, contact.org);
+  writeUrls(card, contact.urls);
+  if (contact.birthday) {
+    card.set("bday", contact.birthday);
+  }
+  if (contact.note) {
+    card.set("note", contact.note);
+  }
+  await writePhoto(card, contact.photo);
   return card.toString();
 };
 
-// src/content/contact.ts
-import vCard2 from "vcf";
-import z from "zod";
-var userRefSchema = z.object({
-  __platform: z.string(),
-  id: z.string()
-});
-var nameSchema = z.object({
-  formatted: z.string().optional(),
-  first: z.string().optional(),
-  last: z.string().optional(),
-  middle: z.string().optional(),
-  prefix: z.string().optional(),
-  suffix: z.string().optional()
-});
-var phoneTypeSchema = z.enum(["mobile", "home", "work", "other"]);
-var emailTypeSchema = z.enum(["home", "work", "other"]);
-var addressTypeSchema = z.enum(["home", "work", "other"]);
-var phoneSchema = z.object({
-  value: z.string(),
-  type: phoneTypeSchema.optional()
-});
-var emailSchema = z.object({
-  value: z.string(),
-  type: emailTypeSchema.optional()
-});
-var addressSchema = z.object({
-  street: z.string().optional(),
-  city: z.string().optional(),
-  region: z.string().optional(),
-  postalCode: z.string().optional(),
-  country: z.string().optional(),
-  type: addressTypeSchema.optional()
-});
-var orgSchema = z.object({
-  name: z.string().optional(),
-  title: z.string().optional(),
-  department: z.string().optional()
-});
-var photoSchema = z.object({
-  mimeType: z.string(),
-  read: readSchema
-});
-var contactSchema = z.object({
-  type: z.literal("contact"),
-  user: userRefSchema.optional(),
-  name: nameSchema.optional(),
-  phones: z.array(phoneSchema).optional(),
-  emails: z.array(emailSchema).optional(),
-  addresses: z.array(addressSchema).optional(),
-  org: orgSchema.optional(),
-  urls: z.array(z.string()).optional(),
-  birthday: z.string().optional(),
-  note: z.string().optional(),
-  photo: photoSchema.optional(),
-  raw: z.unknown().optional()
-});
-var asContact = (input) => contactSchema.parse({ type: "contact", ...input });
-var isUser = (value) => typeof value === "object" && value !== null && "__platform" in value && "id" in value && typeof value.__platform === "string" && typeof value.id === "string";
-function contact(input, details) {
-  return {
-    build: async () => {
-      if (typeof input === "string") {
-        return asContact(fromVCard(input));
-      }
-      if (input instanceof vCard2) {
-        return asContact(fromVCard(input.toString()));
-      }
-      if (isUser(input)) {
-        return asContact({
-          user: { __platform: input.__platform, id: input.id },
-          ...details
-        });
-      }
-      return asContact(input);
-    }
-  };
-}
-
 export {
   fromVCard,
-  toVCard,
-  asContact,
-  contact
+  toVCard
 };

package/dist/{chunk-NNY6LMSC.js → chunk-77U6SH5A.js}

@@ -4,7 +4,7 @@ import {
   fetchUrlBytes,
   readSchema,
   streamSchema
-} from "./chunk-2ILTJC35.js";
+} from "./chunk-LQMDV75O.js";
 
 // src/content/voice.ts
 import { createReadStream } from "fs";