spectrum-ts 4.0.0 → 4.2.0

package/dist/index.js

@@ -1,7 +1,4 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  richlink
-} from "./chunk-ZR3TKZMT.js";
 import {
   FUSOR_MESSAGES_CHANNEL,
   fusor,
@@ -9,33 +6,38 @@ import {
   isFusorClient,
   isFusorEvent
 } from "./chunk-34FQGGD7.js";
-import {
-  group
-} from "./chunk-LZXPLXZF.js";
 import {
   voice
 } from "./chunk-FAIFTUV2.js";
+import {
+  asRichlink,
+  richlink
+} from "./chunk-ZR3TKZMT.js";
+import {
+  group
+} from "./chunk-LZXPLXZF.js";
 import {
   option,
   poll
 } from "./chunk-2D27WW5B.js";
+import {
+  asContact,
+  contact
+} from "./chunk-A37PM5N2.js";
+import {
+  fromVCard,
+  toVCard
+} from "./chunk-6UZFVXQF.js";
 import {
   SpectrumCloudError,
   cloud
 } from "./chunk-3GEJYGZK.js";
-import {
-  contact
-} from "./chunk-A37PM5N2.js";
 import {
   broadcast,
   createAsyncQueue,
   mergeStreams,
   stream
 } from "./chunk-5XEFJBN2.js";
-import {
-  fromVCard,
-  toVCard
-} from "./chunk-6UZFVXQF.js";
 import {
   UnsupportedError,
   avatar,
@@ -44,14 +46,17 @@ import {
   definePlatform,
   edit,
   markdown,
+  read,
   rename,
   reply,
   senderAttrs,
   typing,
   unsend,
   wrapProviderMessage
-} from "./chunk-OGTHPDG7.js";
+} from "./chunk-B52VPQO3.js";
 import {
+  asAttachment,
+  asCustom,
   attachment,
   custom,
   reaction,
@@ -1995,7 +2000,7 @@ import {
   withSpan
 } from "@photon-ai/otel";
 import { RawInboundEvent } from "@photon-ai/proto/photon/fusor/v1/inbound";
-import z from "zod";
+import z2 from "zod";
 
 // src/build-env.ts
 var SPECTRUM_SDK_VERSION = "local";
@@ -2706,28 +2711,284 @@ function createStore() {
   };
 }
 
+// src/webhook/deserialize.ts
+var MESSAGES_EVENT = "messages";
+var DEFAULT_ATTACHMENT_NAME = "attachment";
+var DEFAULT_MIME_TYPE = "application/octet-stream";
+var isRecord = (value) => typeof value === "object" && value !== null;
+var asString = (value) => typeof value === "string" ? value : "";
+var asOptionalDate = (value) => typeof value === "string" ? new Date(value) : void 0;
+function deserializeSpectrumMessage(envelope, ctx) {
+  if (envelope.event !== MESSAGES_EVENT) {
+    return null;
+  }
+  const message = envelope.message;
+  const platform = resolvePlatform(message);
+  if (!platform) {
+    return null;
+  }
+  const spaceRef = { ...message.space };
+  return {
+    platform,
+    record: {
+      id: message.id,
+      direction: "inbound",
+      content: deserializeContent(message.content, platform, spaceRef, ctx),
+      space: spaceRef,
+      sender: message.sender ? { ...message.sender } : void 0,
+      timestamp: asOptionalDate(message.timestamp)
+    }
+  };
+}
+var resolvePlatform = (message) => message.platform ?? message.space.platform;
+var deserializeContent = (content, platform, spaceRef, ctx) => {
+  try {
+    return mapContent(content, platform, spaceRef, ctx);
+  } catch {
+    return asCustom(content);
+  }
+};
+var mapContent = (content, platform, spaceRef, ctx) => {
+  const raw = content;
+  switch (content.type) {
+    case "text":
+      return { type: "text", text: asString(raw.text) };
+    case "richlink":
+      return asRichlink({ url: asString(raw.url) });
+    case "contact":
+      return deserializeContact(raw);
+    case "reaction":
+      return deserializeReaction(raw, spaceRef);
+    case "group":
+      return deserializeGroup(raw, platform, spaceRef, ctx);
+    case "attachment":
+      return deserializeAttachment(raw, platform, spaceRef, ctx);
+    default:
+      return asCustom(content);
+  }
+};
+var deserializeAttachment = (raw, platform, spaceRef, ctx) => {
+  const id = asString(raw.id);
+  const bytes = ctx.resolveAttachment?.(platform, spaceRef, id);
+  const unavailable = () => Promise.reject(
+    UnsupportedError.action(
+      "getAttachment",
+      platform,
+      `attachment "${id}" arrived without bytes over the Spectrum webhook and "${platform}" exposes no getAttachment`
+    )
+  );
+  return asAttachment({
+    id,
+    name: asString(raw.name) || DEFAULT_ATTACHMENT_NAME,
+    mimeType: asString(raw.mimeType) || DEFAULT_MIME_TYPE,
+    size: typeof raw.size === "number" ? raw.size : void 0,
+    read: bytes ? bytes.read : unavailable,
+    stream: bytes?.stream
+  });
+};
+var deserializeReaction = (raw, spaceRef) => (
+  // `target` is a raw record; `wrapNestedContent` wraps it into a Message.
+  {
+    type: "reaction",
+    emoji: asString(raw.emoji),
+    target: buildTargetRecord(raw.target, spaceRef)
+  }
+);
+var buildTargetRecord = (target, spaceRef) => {
+  const ref = isRecord(target) ? target : {};
+  return {
+    id: asString(ref.id),
+    // The target's full content is not delivered; the 80-char `contentPreview`
+    // (text targets only) is the best available stand-in.
+    content: { type: "text", text: asString(ref.contentPreview) },
+    space: { ...spaceRef },
+    sender: ref.sender ? { ...ref.sender } : void 0,
+    timestamp: asOptionalDate(ref.timestamp)
+  };
+};
+var deserializeGroup = (raw, platform, spaceRef, ctx) => {
+  const rawItems = Array.isArray(raw.items) ? raw.items : [];
+  return {
+    type: "group",
+    items: rawItems.map(
+      (item) => buildItemRecord(item, platform, spaceRef, ctx)
+    )
+  };
+};
+var buildItemRecord = (item, platform, spaceRef, ctx) => {
+  const record = isRecord(item) ? item : {};
+  const itemSpace = isRecord(record.space) ? {
+    ...record.space,
+    id: asString(record.space.id) || spaceRef.id
+  } : spaceRef;
+  const content = isRecord(record.content) ? deserializeContent(
+    record.content,
+    platform,
+    itemSpace,
+    ctx
+  ) : asCustom(record.content);
+  return {
+    id: asString(record.id),
+    content,
+    space: itemSpace,
+    sender: isRecord(record.sender) ? { ...record.sender, id: asString(record.sender.id) } : void 0,
+    timestamp: asOptionalDate(record.timestamp)
+  };
+};
+var deserializeContact = (raw) => {
+  const input = {};
+  const name = normalizeContactName(raw.name);
+  if (name) {
+    input.name = name;
+  }
+  const phones = normalizeContactPhones(raw.phones);
+  if (phones) {
+    input.phones = phones;
+  }
+  if (typeof raw.note === "string") {
+    input.note = raw.note;
+  }
+  if (raw.raw !== void 0) {
+    input.raw = raw.raw;
+  }
+  return asContact(input);
+};
+var CONTACT_NAME_KEYS = [
+  "formatted",
+  "first",
+  "last",
+  "middle",
+  "prefix",
+  "suffix"
+];
+var normalizeContactName = (value) => {
+  if (typeof value === "string") {
+    return { formatted: value };
+  }
+  if (!isRecord(value)) {
+    return;
+  }
+  const name = {};
+  for (const key of CONTACT_NAME_KEYS) {
+    const part = value[key];
+    if (typeof part === "string") {
+      name[key] = part;
+    }
+  }
+  return Object.keys(name).length > 0 ? name : void 0;
+};
+var normalizeContactPhones = (value) => {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  const phones = [];
+  for (const entry of value) {
+    if (typeof entry === "string") {
+      phones.push({ value: entry });
+    } else if (isRecord(entry) && typeof entry.value === "string") {
+      phones.push({ value: entry.value });
+    }
+  }
+  return phones.length > 0 ? phones : void 0;
+};
+
+// src/webhook/types.ts
+import z from "zod";
+var slimSenderSchema = z.looseObject({
+  id: z.string(),
+  platform: z.string().optional()
+});
+var slimSpaceSchema = z.looseObject({
+  id: z.string(),
+  platform: z.string().optional()
+});
+var slimContentSchema = z.looseObject({
+  type: z.string()
+});
+var slimMessageRefSchema = z.looseObject({
+  id: z.string(),
+  platform: z.string().optional(),
+  timestamp: z.string().optional(),
+  sender: slimSenderSchema.optional(),
+  contentPreview: z.string().optional()
+});
+var slimMessageSchema = z.looseObject({
+  id: z.string(),
+  platform: z.string().optional(),
+  // Webhooks are inbound-only; `direction` is left loose (not a `"inbound"`
+  // literal) so a future direction value cannot fail an older SDK's parse.
+  direction: z.string().optional(),
+  timestamp: z.string().optional(),
+  sender: slimSenderSchema.optional(),
+  space: slimSpaceSchema,
+  content: slimContentSchema
+});
+var slimEnvelopeSchema = z.looseObject({
+  event: z.string(),
+  space: slimSpaceSchema.optional(),
+  message: slimMessageSchema
+});
+
+// src/webhook/verify.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var SIGNATURE_HEADER = "x-spectrum-signature";
+var TIMESTAMP_HEADER = "x-spectrum-timestamp";
+var SIGNATURE_PREFIX = "v0=";
+var SIGNATURE_SCHEME = "v0";
+var REPLAY_TOLERANCE_SECONDS = 300;
+var MILLIS_PER_SECOND = 1e3;
+function verifySpectrumSignature(input) {
+  const { rawBody, headers, secret, now = Date.now() } = input;
+  const provided = headers[SIGNATURE_HEADER];
+  const timestamp = headers[TIMESTAMP_HEADER];
+  if (!(provided && timestamp)) {
+    return { ok: false, reason: "missing-headers" };
+  }
+  const timestampSeconds = Number(timestamp);
+  if (!Number.isFinite(timestampSeconds)) {
+    return { ok: false, reason: "missing-headers" };
+  }
+  const nowSeconds = Math.floor(now / MILLIS_PER_SECOND);
+  if (Math.abs(nowSeconds - timestampSeconds) > REPLAY_TOLERANCE_SECONDS) {
+    return { ok: false, reason: "expired" };
+  }
+  const base = Buffer.concat([
+    Buffer.from(`${SIGNATURE_SCHEME}:${timestamp}:`, "utf8"),
+    Buffer.from(rawBody)
+  ]);
+  const expected = createHmac("sha256", secret).update(base).digest();
+  const providedHex = provided.startsWith(SIGNATURE_PREFIX) ? provided.slice(SIGNATURE_PREFIX.length) : provided;
+  const providedBytes = Buffer.from(providedHex, "hex");
+  if (providedBytes.length !== expected.length || !timingSafeEqual(providedBytes, expected)) {
+    return { ok: false, reason: "signature-mismatch" };
+  }
+  return { ok: true };
+}
+
 // src/spectrum.ts
 var PHOTON_OTEL_ENDPOINT = "https://otlp.photon.codes";
 var STREAM_CLOSE_TIMEOUT_MS = 5e3;
 var lifecycleLog = createLogger3("spectrum.lifecycle");
 var ignoreCleanupError = () => void 0;
-var spectrumOptionsSchema = z.object({
-  flattenGroups: z.boolean().optional()
+var spectrumOptionsSchema = z2.object({
+  flattenGroups: z2.boolean().optional()
 }).optional();
-var spectrumConfigSchema = z.union([
-  z.object({
-    projectId: z.string().min(1),
-    projectSecret: z.string().min(1),
-    providers: z.array(z.custom()),
+var spectrumConfigSchema = z2.union([
+  z2.object({
+    projectId: z2.string().min(1),
+    projectSecret: z2.string().min(1),
+    providers: z2.array(z2.custom()),
     options: spectrumOptionsSchema,
-    telemetry: z.boolean().optional()
+    telemetry: z2.boolean().optional(),
+    webhookSecret: z2.string().min(1).optional()
   }),
-  z.object({
-    projectId: z.undefined().optional(),
-    projectSecret: z.undefined().optional(),
-    providers: z.array(z.custom()),
+  z2.object({
+    projectId: z2.undefined().optional(),
+    projectSecret: z2.undefined().optional(),
+    providers: z2.array(z2.custom()),
     options: spectrumOptionsSchema,
-    telemetry: z.boolean().optional()
+    telemetry: z2.boolean().optional(),
+    webhookSecret: z2.string().min(1).optional()
   })
 ]);
 function bootstrapTelemetry(opts) {
@@ -2757,9 +3018,11 @@ async function Spectrum(options) {
     projectSecret,
     providers,
     options: runtimeOptions,
-    telemetry
+    telemetry,
+    webhookSecret
   } = options;
   const flattenGroups = runtimeOptions?.flattenGroups ?? false;
+  const resolvedWebhookSecret = webhookSecret ?? process.env.SPECTRUM_WEBHOOK_SECRET;
   const otelHandle = telemetry ? bootstrapTelemetry({ projectId, projectSecret }) : void 0;
   const projectConfig = projectId !== void 0 && projectSecret !== void 0 ? await cloud.getProject(projectId, projectSecret) : void 0;
   const platformStates = /* @__PURE__ */ new Map();
@@ -3216,16 +3479,25 @@ async function Spectrum(options) {
   };
   const readWebhookInput = async (request) => {
     if (typeof Request !== "undefined" && request instanceof Request) {
+      const headers2 = {};
+      for (const [key, value] of request.headers) {
+        headers2[key.toLowerCase()] = value;
+      }
       return {
         asWeb: true,
-        bodyBytes: new Uint8Array(await request.arrayBuffer())
+        bodyBytes: new Uint8Array(await request.arrayBuffer()),
+        headers: headers2
       };
     }
     const raw = request;
     const bodyBytes = raw.body instanceof ArrayBuffer ? new Uint8Array(raw.body) : raw.body;
-    return { asWeb: false, bodyBytes };
+    const headers = {};
+    for (const [key, value] of Object.entries(raw.headers ?? {})) {
+      headers[key.toLowerCase()] = String(value);
+    }
+    return { asWeb: false, bodyBytes, headers };
   };
-  const deliverWebhookMessages = async (collected, runtime, handler, event) => {
+  const deliverWebhookMessages = async (collected, runtime, handler, context) => {
     for (const record of collected) {
       const tuples = await resolveRecordToMessages(record, runtime);
       for (const [space, message] of tuples) {
@@ -3235,8 +3507,8 @@ async function Spectrum(options) {
           lifecycleLog.error(
             `spectrum.webhook: handler threw (async), ${error}`,
             {
-              eventId: event.eventId,
-              platform: event.platform,
+              eventId: context.eventId,
+              platform: context.platform,
               messageId: message.id,
               error: error instanceof Error ? error.message : String(error)
             }
@@ -3289,13 +3561,132 @@ async function Spectrum(options) {
     }
     return result;
   };
+  const looksLikeNativePayload = (bodyBytes) => {
+    for (const byte of bodyBytes) {
+      if (byte === 32 || byte === 9 || byte === 10 || byte === 13) {
+        continue;
+      }
+      return byte === 123;
+    }
+    return false;
+  };
+  const webhookText = (status, text2) => ({
+    status,
+    headers: {},
+    body: encodeText(text2)
+  });
+  const resolveWebhookAttachment = (platform, spaceRef, attachmentId) => {
+    const runtime = platformStates.get(platform);
+    const action = runtime?.definition?.actions?.getAttachment;
+    if (!runtime || typeof action !== "function") {
+      return;
+    }
+    const getAttachment = action;
+    const phone = typeof spaceRef.phone === "string" ? spaceRef.phone : void 0;
+    let cached;
+    const fetchOnce = () => {
+      cached ??= getAttachment(
+        {
+          client: runtime.client,
+          config: runtime.config,
+          store: runtime.store
+        },
+        attachmentId,
+        phone
+      );
+      return cached;
+    };
+    return {
+      read: async () => {
+        const found = await fetchOnce();
+        if (!found) {
+          throw new Error(
+            `Spectrum webhook attachment "${attachmentId}" not found on "${platform}"`
+          );
+        }
+        return found.read();
+      },
+      stream: async () => {
+        const found = await fetchOnce();
+        if (!found?.stream) {
+          throw new Error(
+            `Spectrum webhook attachment "${attachmentId}" has no stream on "${platform}"`
+          );
+        }
+        return found.stream();
+      }
+    };
+  };
+  const handleSpectrumWebhook = async (bodyBytes, headers, handler) => {
+    if (!resolvedWebhookSecret) {
+      lifecycleLog.error(
+        "spectrum.webhook: received a signed Spectrum webhook but no webhookSecret is configured (set Spectrum({ webhookSecret }) or SPECTRUM_WEBHOOK_SECRET)"
+      );
+      return webhookText(500, "webhook secret not configured");
+    }
+    const verification = verifySpectrumSignature({
+      rawBody: bodyBytes,
+      headers,
+      secret: resolvedWebhookSecret
+    });
+    if (!verification.ok) {
+      const status = verification.reason === "missing-headers" ? 400 : 401;
+      return webhookText(status, verification.reason);
+    }
+    let envelope;
+    try {
+      const parsed = JSON.parse(new TextDecoder().decode(bodyBytes));
+      envelope = slimEnvelopeSchema.parse(parsed);
+    } catch (error) {
+      lifecycleLog.warn(
+        `spectrum.webhook: malformed Spectrum webhook payload, ${error}`
+      );
+      return webhookText(400, "malformed payload");
+    }
+    const deserialized = deserializeSpectrumMessage(envelope, {
+      resolveAttachment: resolveWebhookAttachment
+    });
+    if (!deserialized) {
+      return webhookText(200, "ok");
+    }
+    const { platform, record } = deserialized;
+    const runtime = platformStates.get(platform);
+    if (!runtime) {
+      lifecycleLog.warn(
+        `spectrum.webhook: no provider configured for platform "${platform}"; acknowledging without delivery`,
+        { platform }
+      );
+      return webhookText(200, "ok");
+    }
+    deliverWebhookMessages([record], runtime, handler, { platform }).catch(
+      (error) => {
+        lifecycleLog.error(
+          `spectrum.webhook: Spectrum delivery failed (async), ${error}`,
+          {
+            platform,
+            messageId: record.id,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+      }
+    );
+    return webhookText(200, "ok");
+  };
   const handleWebhook = async (request, handler) => {
+    const { asWeb, bodyBytes, headers } = await readWebhookInput(request);
+    if (looksLikeNativePayload(bodyBytes)) {
+      const spectrumResult = await handleSpectrumWebhook(
+        bodyBytes,
+        headers,
+        handler
+      );
+      return buildWebhookResult(asWeb, spectrumResult);
+    }
     if (!fusorCore) {
       throw new Error(
-        "spectrum.webhook() requires at least one fusor provider; none are configured"
+        "spectrum.webhook() received a non-Spectrum (fusor) request but no fusor provider is configured"
       );
     }
-    const { asWeb, bodyBytes } = await readWebhookInput(request);
     const event = decodeWebhookEvent(bodyBytes);
     if (!event) {
       return buildWebhookResult(asWeb, {
@@ -3358,6 +3749,7 @@ export {
   option,
   poll,
   reaction,
+  read,
   rename,
   reply,
   resolveContents,

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

@@ -1,9 +1,10 @@
-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-Be0T6E0e.js';
+import { C as ContentBuilder, h as ContentInput, a as SchemaMessage, P as Platform, b as PlatformDef, S as Space, d as Store } from '../../types-CyfLJXgu.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-CEpGtZLm.js';
-import { P as PhotoInput } from '../../photo-content-BJKnqgN-.js';
+import { A as Attachment } from '../../attachment-CnivEhr6.js';
+import { P as PhotoInput } from '../../read-C4uvozGX.js';
+export { r as read } from '../../read-C4uvozGX.js';
 import { MessageEffect, AdvancedIMessage } from '@photon-ai/advanced-imessage';
 import { IMessageSDK } from '@photon-ai/imessage-kit';
 import 'hotscript';
@@ -114,26 +115,6 @@ declare function customizedMiniApp(input: CustomizedMiniAppInput): ContentBuilde
 type IMessageMessageEffect = MessageEffect;
 declare function effect(input: ContentInput, messageEffect: IMessageMessageEffect): ContentBuilder;
 
-/**
- * Mark the chat containing `target` as read. iMessage-only, remote-only.
- *
- * Implemented via `chats.markRead(chatGuid)`, which marks **every unread
- * message in the chat** as read — there is no per-message read receipt in
- * the SDK. `target` is used only to identify the chat (and to give
- * `message.read()` something to pass), so passing any message from a chat
- * marks the whole chat as read.
- *
- * `space.send(read(message))` is the canonical form; `space.read(message)`
- * and `message.read()` are sugar attached via the iMessage platform's
- * `space.actions` / `message.actions` slots.
- *
- * `Read` is intentionally not a member of the universal `Content` union —
- * the `as unknown as Content` cast keeps the builder shape compatible with
- * the framework's `ContentBuilder.build(): Promise<Content>` signature. The
- * framework treats it as a fire-and-forget control signal at runtime.
- */
-declare function read(target: Message): ContentBuilder;
-
 interface RemoteClient {
     client: AdvancedIMessage;
     phone: string;
@@ -143,8 +124,8 @@ declare const userSchema: z__default.ZodObject<{}, z__default.core.$strip>;
 declare const spaceSchema: z__default.ZodObject<{
     id: z__default.ZodString;
     type: z__default.ZodEnum<{
-        group: "group";
         dm: "dm";
+        group: "group";
     }>;
     phone: z__default.ZodString;
 }, z__default.core.$strip>;
@@ -170,8 +151,8 @@ declare const imessage: Platform<PlatformDef<"iMessage", z.ZodUnion<readonly [z.
 }, zod_v4_core.$strip>]>, z.ZodType<object, unknown, zod_v4_core.$ZodTypeInternals<object, unknown>> | undefined, z.ZodObject<{
     id: z.ZodString;
     type: z.ZodEnum<{
-        group: "group";
         dm: "dm";
+        group: "group";
     }>;
     phone: z.ZodString;
 }, zod_v4_core.$strip>, z.ZodObject<{
@@ -180,7 +161,7 @@ declare const imessage: Platform<PlatformDef<"iMessage", z.ZodUnion<readonly [z.
     id: string;
 }, {
     id: string;
-    type: "group" | "dm";
+    type: "dm" | "group";
     phone: string;
 }, z.ZodObject<{
     partIndex: z.ZodOptional<z.ZodNumber>;
@@ -189,10 +170,7 @@ declare const imessage: Platform<PlatformDef<"iMessage", z.ZodUnion<readonly [z.
     background: (space: Space, input: BackgroundInput, opts?: {
         mimeType?: string;
     }) => Promise<void>;
-    read: (space: Space, message: Message) => Promise<void>;
-}, {
-    read: (message: Message) => Promise<void>;
-}, {
+}, Record<never, never>, {
     getMessage: ({ client }: {
         client: IMessageClient;
         config: {
@@ -212,7 +190,7 @@ declare const imessage: Platform<PlatformDef<"iMessage", z.ZodUnion<readonly [z.
         store: Store;
     }, space: {
         id: string;
-        type: "group" | "dm";
+        type: "dm" | "group";
         phone: string;
     } & {
         id: string;
@@ -241,4 +219,4 @@ declare const imessage: Platform<PlatformDef<"iMessage", z.ZodUnion<readonly [z.
     };
 }>;
 
-export { type BackgroundInput, type CustomizedMiniApp, type CustomizedMiniAppInput, type CustomizedMiniAppLayout, type IMessageMessageEffect, background, customizedMiniApp, effect, imessage, read };
+export { type BackgroundInput, type CustomizedMiniApp, type CustomizedMiniAppInput, type CustomizedMiniAppLayout, type IMessageMessageEffect, background, customizedMiniApp, effect, imessage };

package/dist/providers/imessage/index.js

@@ -3,17 +3,18 @@ import {
   background,
   customizedMiniApp,
   effect,
-  imessage,
-  read
-} from "../../chunk-W5HNZ7YT.js";
+  imessage
+} from "../../chunk-NLMQ75LH.js";
 import "../../chunk-ZR3TKZMT.js";
 import "../../chunk-LZXPLXZF.js";
 import "../../chunk-2D27WW5B.js";
-import "../../chunk-3GEJYGZK.js";
 import "../../chunk-A37PM5N2.js";
-import "../../chunk-5XEFJBN2.js";
 import "../../chunk-6UZFVXQF.js";
-import "../../chunk-OGTHPDG7.js";
+import "../../chunk-3GEJYGZK.js";
+import "../../chunk-5XEFJBN2.js";
+import {
+  read
+} from "../../chunk-B52VPQO3.js";
 import "../../chunk-UXAKIXVM.js";
 export {
   background,