@intx/mail-memory 0.3.0 → 0.4.0

package/README.md

@@ -33,5 +33,7 @@ await alphaMail.send({
 
 Install a `RemoteSendHandler` via `transport.setRemoteSendHandler`
 to forward outbound mail for addresses the transport does not host
-locally, and add one or more `MessageSentHandler`s via
-`transport.addMessageSentHandler` for post-send observability.
+locally. The handler receives the raw message, remote recipients, and
+the sender address already validated by the scoped transport. Add one or
+more `MessageSentHandler`s via `transport.addMessageSentHandler` for
+post-send observability.

package/dist/mailbox.d.ts

@@ -1,49 +1,13 @@
 import type { CryptoProvider, MailboxEvent } from "@intx/types/runtime";
+import { type MailboxStore } from "@intx/mailbox";
 /**
- * Pre-parsed envelope extracted from MIME headers at delivery time.
- * Avoids re-parsing raw bytes for every search operation.
+ * Per-address state for the in-memory transport: one `MailboxStore` per
+ * mailbox, the watch callbacks registered against each mailbox, and the
+ * address's `CryptoProvider`.
  */
-export type StoredEnvelope = {
-    messageId: string;
-    from: string;
-    to: string[];
-    subject: string;
-    date: Date;
-    inReplyTo: string | undefined;
-    references: string[];
-    interchangeType: string | undefined;
-    interchangeCorrelationId: string | undefined;
-};
-/**
- * A single message stored in memory. The `raw` field contains the complete
- * RFC 2822 message bytes (headers + MIME body). All fetch operations parse
- * from these bytes, guaranteeing byte-exact signature verification.
- */
-export type StoredMessage = {
-    uid: number;
-    modseq: number;
-    flags: Set<string>;
-    raw: Uint8Array;
-    envelope: StoredEnvelope;
-};
-export type MailboxStore = {
-    messages: StoredMessage[];
-    uidCounter: number;
-    modseqCounter: number;
-    uidValidity: number;
-};
 export type AddressEntry = {
     mailboxes: Map<string, MailboxStore>;
     watchCallbacks: Map<string, Set<(event: MailboxEvent) => void>>;
     crypto: CryptoProvider;
 };
-export declare const DEFAULT_MAILBOXES: readonly ["INBOX", "Sent", "Drafts", "Archive", "Trash"];
-export declare function createMailboxStore(): MailboxStore;
 export declare function createAddressEntry(crypto: CryptoProvider): AddressEntry;
-/**
- * Append a message to a mailbox store. Assigns UID and MODSEQ, returns the
- * assigned UID.
- */
-export declare function appendToMailbox(store: MailboxStore, raw: Uint8Array, envelope: StoredEnvelope, flags: string[]): number;
-export declare function findMessage(store: MailboxStore, uid: number): StoredMessage | undefined;
-export declare function requireMessage(store: MailboxStore, uid: number, mailboxName: string): StoredMessage;

package/dist/mailbox.js

@@ -1,22 +1,8 @@
-export const DEFAULT_MAILBOXES = [
-    "INBOX",
-    "Sent",
-    "Drafts",
-    "Archive",
-    "Trash",
-];
-export function createMailboxStore() {
-    return {
-        messages: [],
-        uidCounter: 1,
-        modseqCounter: 1,
-        uidValidity: Date.now(),
-    };
-}
+import { DEFAULT_MAILBOXES, createInMemoryMailboxStore, } from "@intx/mailbox";
 export function createAddressEntry(crypto) {
     const mailboxes = new Map();
     for (const name of DEFAULT_MAILBOXES) {
-        mailboxes.set(name, createMailboxStore());
+        mailboxes.set(name, createInMemoryMailboxStore());
     }
     return {
         mailboxes,
@@ -24,29 +10,3 @@ export function createAddressEntry(crypto) {
         crypto,
     };
 }
-/**
- * Append a message to a mailbox store. Assigns UID and MODSEQ, returns the
- * assigned UID.
- */
-export function appendToMailbox(store, raw, envelope, flags) {
-    const uid = store.uidCounter++;
-    const modseq = store.modseqCounter++;
-    store.messages.push({
-        uid,
-        modseq,
-        flags: new Set(flags),
-        raw,
-        envelope,
-    });
-    return uid;
-}
-export function findMessage(store, uid) {
-    return store.messages.find((m) => m.uid === uid);
-}
-export function requireMessage(store, uid, mailboxName) {
-    const msg = findMessage(store, uid);
-    if (msg === undefined) {
-        throw new Error(`Message UID ${uid} not found in mailbox "${mailboxName}"`);
-    }
-    return msg;
-}

package/dist/send.d.ts

@@ -2,10 +2,10 @@ import type { OutboundMessage, SendReceipt } from "@intx/types/runtime";
 import type { AddressEntry } from "./mailbox.js";
 /**
  * Callback for delivering messages to recipients not registered on this
- * transport. The federation layer provides this to forward messages to
- * the hub for remote routing.
+ * transport. The federation layer provides this to forward messages and the
+ * transport-validated sender address to the hub for remote routing.
  */
-export type RemoteSendHandler = (rawMessage: Uint8Array, recipients: string[]) => Promise<void>;
+export type RemoteSendHandler = (rawMessage: Uint8Array, recipients: string[], senderAddress: string) => Promise<void>;
 /**
  * Context passed to MessageSentHandler callbacks after a message is fully
  * assembled and delivered.

package/dist/send.js

@@ -1,6 +1,5 @@
-import { appendToMailbox } from "./mailbox.js";
-import { assembleSignedContent, assembleMessage, generateMessageId, parseHeaderSection, createDetachedSignatureFromProvider, } from "@intx/mime";
-import { buildMessageHeaders } from "./headers.js";
+import { buildMessageHeaders } from "@intx/mailbox";
+import { assembleSignedContent, assembleMessage, generateMessageId, isMessageId, parseHeaderSection, createDetachedSignatureFromProvider, } from "@intx/mime";
 const CONVERSATION_TYPES = new Set([
     "conversation.message",
     "conversation.join",
@@ -77,7 +76,7 @@ export async function executeSend(senderAddress, message, entries, onRemoteSend,
     const signedContentBytes = assembleSignedContent(content);
     const signatureBytes = await createDetachedSignatureFromProvider(signedContentBytes, senderCrypto);
     const ccAddresses = ccAddressList.length > 0 ? ccAddressList : undefined;
-    const refs = buildReferences(message.inReplyTo, undefined);
+    const refs = buildReferences(message.inReplyTo, message.references);
     const mimeHeaders = {
         from: senderAddress,
         to: recipients,
@@ -120,7 +119,7 @@ export async function executeSend(senderAddress, message, entries, onRemoteSend,
         if (inbox === undefined) {
             throw new Error(`Mailbox "INBOX" does not exist for recipient "${recipient}"`);
         }
-        const uid = appendToMailbox(inbox, rawBytes, envelope, []);
+        const uid = inbox.append(rawBytes, envelope, []);
         deliveredUids.push({ address: recipient, uid });
     }
     // Append copy to sender's Sent mailbox.
@@ -128,7 +127,7 @@ export async function executeSend(senderAddress, message, entries, onRemoteSend,
     if (sentStore === undefined) {
         throw new Error(`Mailbox "Sent" does not exist for sender "${senderAddress}"`);
     }
-    appendToMailbox(sentStore, rawBytes, envelope, ["\\Seen"]);
+    sentStore.append(rawBytes, envelope, ["\\Seen"]);
     // Fire local recipient watch callbacks ASYNCHRONOUSLY (per MESSAGE.md
     // requirement). queueMicrotask ensures callbacks never run synchronously
     // on the sender's call stack, preserving real IMAP IDLE async delivery
@@ -155,7 +154,7 @@ export async function executeSend(senderAddress, message, entries, onRemoteSend,
     }
     // Forward to remote recipients via federation hook.
     if (remoteRecipients.length > 0 && onRemoteSend !== undefined) {
-        await onRemoteSend(rawBytes, remoteRecipients);
+        await onRemoteSend(rawBytes, remoteRecipients, senderAddress);
     }
     if (onMessageSent !== undefined) {
         const localOnly = remoteRecipients.length === 0;
@@ -180,10 +179,26 @@ export async function executeSend(senderAddress, message, entries, onRemoteSend,
         status: remoteRecipients.length > 0 ? "queued" : "delivered",
     };
 }
+/**
+ * Assemble the wire `References` chain for an outbound message.
+ *
+ * When the caller supplies a full ancestry (`existingReferences` -- the
+ * parent's References plus the parent's Message-Id, built by the threaded
+ * reply path), that chain is used and `inReplyTo` is appended only when it is
+ * not already the tail. Otherwise the chain is derived from `inReplyTo` alone,
+ * preserving the pre-existing single-element behavior.
+ *
+ * The caller-supplied chain is filtered to RFC 2822 message identifiers:
+ * inbound mail can carry a headerless-derived (sha256) or otherwise malformed
+ * Message-Id that is a valid claim-check key but not a valid `<id@host>`
+ * identifier, and such a value must not leak into a `References` header. The
+ * `inReplyTo` value is appended without filtering, matching the pre-existing
+ * `In-Reply-To`/`References` behavior for a bare reply.
+ */
 function buildReferences(inReplyTo, existingReferences) {
+    const refs = (existingReferences ?? []).filter(isMessageId);
     if (inReplyTo === undefined)
-        return existingReferences;
-    const refs = existingReferences ?? [];
+        return refs.length > 0 ? refs : undefined;
     if (!refs.includes(inReplyTo)) {
         return [...refs, inReplyTo];
     }

package/dist/transport.d.ts

@@ -73,7 +73,9 @@ export declare class InMemoryTransport implements MessageTransport, HubTransport
     clearFlags(_ref: MessageRef, _flags: string[], _signal?: AbortSignal): Promise<void>;
     move(_ref: MessageRef, _toMailbox: string, _signal?: AbortSignal): Promise<void>;
     copy(_ref: MessageRef, _toMailbox: string, _signal?: AbortSignal): Promise<void>;
-    expunge(_mailbox: string, _signal?: AbortSignal): Promise<void>;
+    expunge(_mailbox: string, _signal?: AbortSignal): Promise<{
+        expungedUids: number[];
+    }>;
     watch(_mailbox: string, _callback: (event: MailboxEvent) => void): Unsubscribe;
     sync(_mailbox: string, _knownState: SyncState, _signal?: AbortSignal): Promise<SyncResult>;
     createList(_address: string, _name: string, _signal?: AbortSignal): Promise<ListInfo>;

package/dist/transport.js

@@ -1,10 +1,7 @@
-import { createAddressEntry, createMailboxStore, requireMessage, appendToMailbox, } from "./mailbox.js";
 import { parseHeaderSection } from "@intx/mime";
-import { buildMessageHeaders } from "./headers.js";
+import { buildMessageHeaders, createInMemoryMailboxStore, executeSearch, executeThread, fetchHeaders as doFetchHeaders, fetchStructure as doFetchStructure, fetchPart as doFetchPart, fetchFull as doFetchFull, requireMessage, } from "@intx/mailbox";
+import { createAddressEntry } from "./mailbox.js";
 import { executeSend, } from "./send.js";
-import { executeSearch } from "./search.js";
-import { executeThread } from "./thread.js";
-import { fetchHeaders as doFetchHeaders, fetchStructure as doFetchStructure, fetchPart as doFetchPart, fetchFull as doFetchFull, } from "./fetch.js";
 /**
  * In-memory MessageTransport implementing full IMAP semantics within a
  * single process. Messages are stored as real RFC 2822 MIME byte buffers.
@@ -185,7 +182,7 @@ export class InMemoryTransport {
             interchangeType: headers.get("interchange-type"),
             interchangeCorrelationId: headers.get("interchange-correlation-id"),
         };
-        const uid = appendToMailbox(inbox, message, envelope, []);
+        const uid = inbox.append(message, envelope, []);
         const callbacks = entry.watchCallbacks.get("INBOX");
         if (callbacks !== undefined && callbacks.size > 0) {
             const event = {
@@ -274,7 +271,7 @@ class ScopedMessageTransport {
             interchangeType: message.headers.interchangeType,
             interchangeCorrelationId: message.headers.interchangeCorrelationId,
         };
-        const uid = appendToMailbox(store, raw, envelope, flags ?? []);
+        const uid = store.append(raw, envelope, flags ?? []);
         return { uid, mailbox };
     }
     async listMailboxes(_signal) {
@@ -286,7 +283,7 @@ class ScopedMessageTransport {
         if (this.#entry.mailboxes.has(name)) {
             throw new Error(`Mailbox "${name}" already exists for address "${this.#address}"`);
         }
-        this.#entry.mailboxes.set(name, createMailboxStore());
+        this.#entry.mailboxes.set(name, createInMemoryMailboxStore());
         return { name };
     }
     async deleteMailbox(name, _signal) {
@@ -302,42 +299,38 @@ class ScopedMessageTransport {
             total: store.messages.length,
             unseen,
             recent: 0,
-            uidNext: store.uidCounter,
+            uidNext: store.uidNext,
             uidValidity: store.uidValidity,
-            highestModSeq: store.modseqCounter - 1,
+            highestModSeq: store.highestModSeq,
         };
     }
     async search(mailbox, query, _signal) {
         const store = this.#requireMailbox(mailbox);
-        return executeSearch(mailbox, store, query);
+        return await executeSearch(mailbox, store, query);
     }
     async thread(mailbox, algorithm, query, _signal) {
         const store = this.#requireMailbox(mailbox);
-        return executeThread(mailbox, store, algorithm, query);
+        return await executeThread(mailbox, store, algorithm, query);
     }
     async fetchHeaders(ref, _signal) {
         const store = this.#requireMailbox(ref.mailbox);
-        return doFetchHeaders(ref, store);
+        return await doFetchHeaders(ref, store);
     }
     async fetchStructure(ref, _signal) {
         const store = this.#requireMailbox(ref.mailbox);
-        return doFetchStructure(ref, store);
+        return await doFetchStructure(ref, store);
     }
     async fetchPart(ref, partPath, _signal) {
         const store = this.#requireMailbox(ref.mailbox);
-        return doFetchPart(ref, partPath, store);
+        return await doFetchPart(ref, partPath, store);
     }
     async fetchFull(ref, _signal) {
         const store = this.#requireMailbox(ref.mailbox);
-        return doFetchFull(ref, store, (addr) => this.#entries.get(addr)?.crypto);
+        return await doFetchFull(ref, store, (addr) => this.#entries.get(addr)?.crypto);
     }
     async setFlags(ref, flags, _signal) {
         const store = this.#requireMailbox(ref.mailbox);
-        const msg = requireMessage(store, ref.uid, ref.mailbox);
-        for (const flag of flags) {
-            msg.flags.add(flag);
-        }
-        msg.modseq = store.modseqCounter++;
+        const msg = store.addFlags(ref.uid, flags);
         this.#fireWatchCallbacks(ref.mailbox, {
             type: "flagsChanged",
             uid: ref.uid,
@@ -346,11 +339,7 @@ class ScopedMessageTransport {
     }
     async clearFlags(ref, flags, _signal) {
         const store = this.#requireMailbox(ref.mailbox);
-        const msg = requireMessage(store, ref.uid, ref.mailbox);
-        for (const flag of flags) {
-            msg.flags.delete(flag);
-        }
-        msg.modseq = store.modseqCounter++;
+        const msg = store.removeFlags(ref.uid, flags);
         this.#fireWatchCallbacks(ref.mailbox, {
             type: "flagsChanged",
             uid: ref.uid,
@@ -360,20 +349,16 @@ class ScopedMessageTransport {
     async move(ref, toMailbox, _signal) {
         const fromStore = this.#requireMailbox(ref.mailbox);
         const toStore = this.#requireMailbox(toMailbox);
-        const msgIdx = fromStore.messages.findIndex((m) => m.uid === ref.uid);
-        if (msgIdx === -1) {
-            throw new Error(`Message UID ${ref.uid} not found in mailbox "${ref.mailbox}"`);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guarded by findIndex !== -1 above
-        const msg = fromStore.messages[msgIdx];
-        fromStore.messages.splice(msgIdx, 1);
-        const newUid = appendToMailbox(toStore, msg.raw, msg.envelope, Array.from(msg.flags));
+        const msg = requireMessage(fromStore, ref.uid, ref.mailbox);
+        const raw = await fromStore.readRaw(ref.uid);
+        fromStore.remove(ref.uid);
+        const newUid = toStore.append(raw, msg.envelope, Array.from(msg.flags));
         this.#fireWatchCallbacks(ref.mailbox, {
             type: "expunged",
             uid: ref.uid,
         });
         // Notify watchers of the new message in the destination mailbox.
-        const { headers: parsedHeaders } = parseHeaderSection(msg.raw);
+        const { headers: parsedHeaders } = parseHeaderSection(raw);
         const msgHeaders = this.#buildMessageHeaders(parsedHeaders);
         this.#fireWatchCallbacks(toMailbox, {
             type: "exists",
@@ -385,8 +370,9 @@ class ScopedMessageTransport {
         const fromStore = this.#requireMailbox(ref.mailbox);
         const toStore = this.#requireMailbox(toMailbox);
         const msg = requireMessage(fromStore, ref.uid, ref.mailbox);
-        const newUid = appendToMailbox(toStore, msg.raw, msg.envelope, Array.from(msg.flags));
-        const { headers: parsedHeaders } = parseHeaderSection(msg.raw);
+        const raw = await fromStore.readRaw(ref.uid);
+        const newUid = toStore.append(raw, msg.envelope, Array.from(msg.flags));
+        const { headers: parsedHeaders } = parseHeaderSection(raw);
         const msgHeaders = this.#buildMessageHeaders(parsedHeaders);
         this.#fireWatchCallbacks(toMailbox, {
             type: "exists",
@@ -397,13 +383,16 @@ class ScopedMessageTransport {
     async expunge(mailbox, _signal) {
         const store = this.#requireMailbox(mailbox);
         const toExpunge = store.messages.filter((m) => m.flags.has("\\Deleted"));
-        store.messages = store.messages.filter((m) => !m.flags.has("\\Deleted"));
+        for (const msg of toExpunge) {
+            store.remove(msg.uid);
+        }
         for (const msg of toExpunge) {
             this.#fireWatchCallbacks(mailbox, {
                 type: "expunged",
                 uid: msg.uid,
             });
         }
+        return { expungedUids: toExpunge.map((m) => m.uid) };
     }
     watch(mailbox, callback) {
         this.#requireMailbox(mailbox);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@intx/mail-memory",
   "description": "In-memory MessageTransport for single-process and test environments",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "LGPL-2.1-only",
   "type": "module",
   "exports": {
@@ -12,10 +12,11 @@
     }
   },
   "dependencies": {
-    "@intx/crypto": "0.3.0",
-    "@intx/log": "0.3.0",
-    "@intx/mime": "0.3.0",
-    "@intx/types": "0.3.0",
+    "@intx/crypto": "0.4.0",
+    "@intx/log": "0.4.0",
+    "@intx/mailbox": "0.4.0",
+    "@intx/mime": "0.4.0",
+    "@intx/types": "0.4.0",
     "arktype": "^2.1.29"
   },
   "files": [

package/dist/fetch.d.ts

@@ -1,19 +0,0 @@
-import type { MessageHeaders, BodyStructure, MessagePart, InboundMessage, CryptoProvider, MessageRef } from "@intx/types/runtime";
-import type { MailboxStore } from "./mailbox.js";
-/**
- * Parse raw RFC 2822 headers from a stored message.
- */
-export declare function fetchHeaders(ref: MessageRef, store: MailboxStore): MessageHeaders;
-/**
- * Compute the MIME tree structure (BODYSTRUCTURE) without transferring content.
- */
-export declare function fetchStructure(ref: MessageRef, store: MailboxStore): BodyStructure;
-/**
- * Fetch a single MIME part by dot-separated path.
- */
-export declare function fetchPart(ref: MessageRef, partPath: string, store: MailboxStore): MessagePart;
-/**
- * Fetch a complete message, verify its PGP/MIME signature, and return
- * a fully parsed InboundMessage.
- */
-export declare function fetchFull(ref: MessageRef, store: MailboxStore, getCrypto: (fromAddress: string) => CryptoProvider | undefined): Promise<InboundMessage>;

package/dist/fetch.js

@@ -1,171 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion -- MIME multipart parsing with bounds checks */
-import { type } from "arktype";
-import { InterchangeType } from "@intx/types/runtime";
-import { base64Decode } from "@intx/types";
-import { requireMessage } from "./mailbox.js";
-import { parseHeaderSection, parseMimePart, extractBoundary, parseMultipart, extractPartByPath, extractAttachments, } from "@intx/mime";
-import { buildMessageHeaders } from "./headers.js";
-import { verifyDetachedSignature } from "@intx/crypto";
-const MessagePayload = type({
-    type: InterchangeType,
-    version: "string",
-    body: "Record<string, unknown>",
-});
-/**
- * Parse raw RFC 2822 headers from a stored message.
- */
-export function fetchHeaders(ref, store) {
-    const msg = requireMessage(store, ref.uid, ref.mailbox);
-    const { headers } = parseHeaderSection(msg.raw);
-    return buildMessageHeaders(headers);
-}
-/**
- * Compute the MIME tree structure (BODYSTRUCTURE) without transferring content.
- */
-export function fetchStructure(ref, store) {
-    const msg = requireMessage(store, ref.uid, ref.mailbox);
-    const { headers, bodyOffset } = parseHeaderSection(msg.raw);
-    const body = msg.raw.slice(bodyOffset);
-    const contentType = headers.get("content-type") ?? "application/octet-stream";
-    return buildStructure(body, contentType);
-}
-/**
- * Fetch a single MIME part by dot-separated path.
- */
-export function fetchPart(ref, partPath, store) {
-    const msg = requireMessage(store, ref.uid, ref.mailbox);
-    const partBytes = extractPartByPath(msg.raw, partPath);
-    const part = parseMimePart(partBytes);
-    const enc = part.headers.get("content-transfer-encoding") ?? "7bit";
-    let content;
-    if (enc.toLowerCase() === "base64") {
-        const b64 = new TextDecoder().decode(part.body).replace(/\s/g, "");
-        content = base64Decode(b64);
-    }
-    else {
-        content = part.body;
-    }
-    const result = {
-        contentType: part.contentType,
-        content,
-    };
-    if (enc !== "7bit")
-        result.encoding = enc;
-    return result;
-}
-/**
- * Fetch a complete message, verify its PGP/MIME signature, and return
- * a fully parsed InboundMessage.
- */
-export async function fetchFull(ref, store, getCrypto) {
-    const msg = requireMessage(store, ref.uid, ref.mailbox);
-    const { headers } = parseHeaderSection(msg.raw);
-    const parsedHeaders = buildMessageHeaders(headers);
-    const rawType = parsedHeaders.interchangeType;
-    const isConversation = rawType === "conversation.message" ||
-        rawType === "conversation.join" ||
-        rawType === "conversation.leave" ||
-        rawType === undefined;
-    const signatureStatus = await verifyMessageSignature(msg.raw, parsedHeaders.from, getCrypto);
-    const result = {
-        ref,
-        headers: parsedHeaders,
-        flags: Array.from(msg.flags),
-        signatureStatus,
-    };
-    try {
-        if (isConversation) {
-            const part1 = parseMimePart(extractPartByPath(msg.raw, "1"));
-            const part1Mime = part1.contentType.split(";")[0].trim().toLowerCase();
-            if (part1Mime.startsWith("multipart/")) {
-                // Conversation shape: multipart/mixed with the text body at 1.1.
-                const textPart = parseMimePart(extractPartByPath(msg.raw, "1.1"));
-                result.content = new TextDecoder("utf-8", { fatal: false }).decode(textPart.body);
-            }
-            else {
-                // A conversation message is "literally a signed email", so a sender
-                // (e.g. a plain mail client) may sign a bare text/plain part with no
-                // multipart/mixed wrapper. This branch reads that body directly. Our
-                // own assembler always emits multipart/mixed; without this branch a
-                // bare text/plain message would fail the 1.1 lookup and silently lose
-                // its content to the catch below.
-                result.content = new TextDecoder("utf-8", { fatal: false }).decode(part1.body);
-            }
-        }
-        else {
-            // Structured messages carry their JSON payload at 1.1. Attachments on
-            // structured messages are intentionally not parsed: they have no
-            // producer today, so parsing them would handle a shape nobody sends.
-            const part11Bytes = extractPartByPath(msg.raw, "1.1");
-            const part11 = parseMimePart(part11Bytes);
-            const jsonText = new TextDecoder("utf-8", { fatal: false }).decode(part11.body);
-            const validated = MessagePayload(JSON.parse(jsonText));
-            if (validated instanceof type.errors) {
-                throw new Error(`invalid message payload: ${validated.summary}`);
-            }
-            result.payload = validated;
-        }
-    }
-    catch {
-        // If we can't parse the content, return what we have with the signature status.
-    }
-    // Attachment parsing is deliberately outside the catch above: a malformed
-    // attachment must surface as a thrown error, not be silently dropped.
-    if (isConversation) {
-        const attachments = extractAttachments(msg.raw);
-        if (attachments.length > 0) {
-            result.attachments = attachments;
-        }
-    }
-    return result;
-}
-async function verifyMessageSignature(raw, fromAddress, getCrypto) {
-    const senderCrypto = getCrypto(fromAddress);
-    if (senderCrypto === undefined) {
-        return "unknown";
-    }
-    try {
-        const { headers, bodyOffset } = parseHeaderSection(raw);
-        const body = raw.slice(bodyOffset);
-        const contentType = headers.get("content-type") ?? "";
-        if (!contentType.toLowerCase().includes("multipart/signed")) {
-            return "missing";
-        }
-        const boundary = extractBoundary(contentType);
-        if (boundary === undefined)
-            return "missing";
-        const parts = parseMultipart(body, boundary);
-        if (parts.length < 2)
-            return "missing";
-        const signedContentBytes = parts[0];
-        const sigPartBytes = parts[1];
-        const sigPart = parseMimePart(sigPartBytes);
-        if (!sigPart.contentType.toLowerCase().includes("application/pgp-signature")) {
-            return "missing";
-        }
-        const publicKey = senderCrypto.getPublicKey();
-        const valid = await verifyDetachedSignature(signedContentBytes, sigPart.body, publicKey);
-        return valid ? "valid" : "invalid";
-    }
-    catch {
-        return "invalid";
-    }
-}
-function buildStructure(body, contentType) {
-    const ct = contentType.toLowerCase();
-    if (!ct.startsWith("multipart/")) {
-        return { contentType, size: body.length };
-    }
-    const boundary = extractBoundary(contentType);
-    if (boundary === undefined) {
-        return { contentType, size: body.length };
-    }
-    const parts = parseMultipart(body, boundary);
-    const subStructures = parts.map((partBytes) => {
-        const { headers, bodyOffset } = parseHeaderSection(partBytes);
-        const partBody = partBytes.slice(bodyOffset);
-        const partContentType = headers.get("content-type") ?? "application/octet-stream";
-        return buildStructure(partBody, partContentType);
-    });
-    return { contentType, parts: subStructures };
-}

package/dist/headers.d.ts

@@ -1,8 +0,0 @@
-import type { MessageHeaders } from "@intx/types/runtime";
-/**
- * Build a MessageHeaders object from a parsed header map.
- *
- * Uses exactOptionalPropertyTypes-safe construction: optional fields are
- * only included in the returned object when they carry actual values.
- */
-export declare function buildMessageHeaders(headers: Map<string, string>): MessageHeaders;

package/dist/headers.js

@@ -1,77 +0,0 @@
-import { type } from "arktype";
-import { InterchangeType } from "@intx/types/runtime";
-function isInterchangeType(s) {
-    return !(InterchangeType(s) instanceof type.errors);
-}
-/**
- * Build a MessageHeaders object from a parsed header map.
- *
- * Uses exactOptionalPropertyTypes-safe construction: optional fields are
- * only included in the returned object when they carry actual values.
- */
-export function buildMessageHeaders(headers) {
-    const from = headers.get("from") ?? "";
-    const toRaw = headers.get("to") ?? "";
-    const to = toRaw
-        ? toRaw
-            .split(",")
-            .map((s) => s.trim())
-            .filter(Boolean)
-        : [];
-    const date = headers.get("date") ?? "";
-    const messageId = headers.get("message-id") ?? "";
-    const result = { from, to, date, messageId };
-    const ccRaw = headers.get("cc");
-    if (ccRaw !== undefined) {
-        const cc = ccRaw
-            .split(",")
-            .map((s) => s.trim())
-            .filter(Boolean);
-        if (cc.length > 0)
-            result.cc = cc;
-    }
-    const refsRaw = headers.get("references");
-    if (refsRaw !== undefined) {
-        const refs = refsRaw.split(/\s+/).filter(Boolean);
-        if (refs.length > 0)
-            result.references = refs;
-    }
-    const inReplyTo = headers.get("in-reply-to");
-    if (inReplyTo !== undefined)
-        result.inReplyTo = inReplyTo;
-    const subject = headers.get("subject");
-    if (subject !== undefined)
-        result.subject = subject;
-    const listId = headers.get("list-id");
-    if (listId !== undefined)
-        result.listId = listId;
-    const rawType = headers.get("interchange-type");
-    if (rawType !== undefined && isInterchangeType(rawType)) {
-        result.interchangeType = rawType;
-    }
-    const corrId = headers.get("interchange-correlation-id");
-    if (corrId !== undefined)
-        result.interchangeCorrelationId = corrId;
-    const tenantId = headers.get("interchange-tenant-id");
-    if (tenantId !== undefined)
-        result.interchangeTenantId = tenantId;
-    const agentId = headers.get("interchange-agent-id");
-    if (agentId !== undefined)
-        result.interchangeAgentId = agentId;
-    const sessionId = headers.get("interchange-session-id");
-    if (sessionId !== undefined)
-        result.interchangeSessionId = sessionId;
-    const offeringId = headers.get("interchange-offering-id");
-    if (offeringId !== undefined)
-        result.interchangeOfferingId = offeringId;
-    const schemaVersion = headers.get("interchange-schema-version");
-    if (schemaVersion !== undefined)
-        result.interchangeSchemaVersion = schemaVersion;
-    const traceparent = headers.get("traceparent");
-    if (traceparent !== undefined)
-        result.traceparent = traceparent;
-    const tracestate = headers.get("tracestate");
-    if (tracestate !== undefined)
-        result.tracestate = tracestate;
-    return result;
-}

package/dist/search.d.ts

@@ -1,12 +0,0 @@
-import type { SearchQuery, MessageRef } from "@intx/types/runtime";
-import type { MailboxStore } from "./mailbox.js";
-/**
- * Execute an IMAP SEARCH-equivalent query over an in-memory mailbox.
- *
- * Supports: from, to, cc, bcc, header (field match), before/after/on,
- * sentBefore/sentAfter/sentOn, hasFlags, missingFlags, body, text,
- * largerThan, smallerThan, and boolean and/or/not composition.
- *
- * Returns MessageRef[] for all matching messages, ordered by UID.
- */
-export declare function executeSearch(mailboxName: string, store: MailboxStore, query: SearchQuery): MessageRef[];

package/dist/search.js

@@ -1,151 +0,0 @@
-import { parseHeaderSection } from "@intx/mime";
-/**
- * Execute an IMAP SEARCH-equivalent query over an in-memory mailbox.
- *
- * Supports: from, to, cc, bcc, header (field match), before/after/on,
- * sentBefore/sentAfter/sentOn, hasFlags, missingFlags, body, text,
- * largerThan, smallerThan, and boolean and/or/not composition.
- *
- * Returns MessageRef[] for all matching messages, ordered by UID.
- */
-export function executeSearch(mailboxName, store, query) {
-    const results = [];
-    for (const msg of store.messages) {
-        if (matchMessage(msg, query)) {
-            results.push({ uid: msg.uid, mailbox: mailboxName });
-        }
-    }
-    return results;
-}
-function matchMessage(msg, query) {
-    if (query.from !== undefined) {
-        if (!msg.envelope.from.toLowerCase().includes(query.from.toLowerCase())) {
-            return false;
-        }
-    }
-    if (query.to !== undefined) {
-        const queryTo = query.to;
-        const toMatch = msg.envelope.to.some((addr) => addr.toLowerCase().includes(queryTo.toLowerCase()));
-        if (!toMatch)
-            return false;
-    }
-    if (query.cc !== undefined) {
-        const headers = lazyHeaders(msg);
-        const ccHeader = headers.get("cc") ?? "";
-        if (!ccHeader.toLowerCase().includes(query.cc.toLowerCase())) {
-            return false;
-        }
-    }
-    if (query.bcc !== undefined) {
-        const headers = lazyHeaders(msg);
-        const bccHeader = headers.get("bcc") ?? "";
-        if (!bccHeader.toLowerCase().includes(query.bcc.toLowerCase())) {
-            return false;
-        }
-    }
-    if (query.header !== undefined) {
-        const { field, contains } = query.header;
-        const headers = lazyHeaders(msg);
-        const value = headers.get(field.toLowerCase()) ?? "";
-        if (!value.toLowerCase().includes(contains.toLowerCase())) {
-            return false;
-        }
-    }
-    if (query.before !== undefined) {
-        if (msg.envelope.date >= query.before)
-            return false;
-    }
-    if (query.after !== undefined) {
-        if (msg.envelope.date <= query.after)
-            return false;
-    }
-    if (query.on !== undefined) {
-        const d = msg.envelope.date;
-        const q = query.on;
-        if (d.getUTCFullYear() !== q.getUTCFullYear() ||
-            d.getUTCMonth() !== q.getUTCMonth() ||
-            d.getUTCDate() !== q.getUTCDate()) {
-            return false;
-        }
-    }
-    // Sent date filters use the Date header (same as envelope date here).
-    if (query.sentBefore !== undefined) {
-        if (msg.envelope.date >= query.sentBefore)
-            return false;
-    }
-    if (query.sentAfter !== undefined) {
-        if (msg.envelope.date <= query.sentAfter)
-            return false;
-    }
-    if (query.sentOn !== undefined) {
-        const d = msg.envelope.date;
-        const q = query.sentOn;
-        if (d.getUTCFullYear() !== q.getUTCFullYear() ||
-            d.getUTCMonth() !== q.getUTCMonth() ||
-            d.getUTCDate() !== q.getUTCDate()) {
-            return false;
-        }
-    }
-    if (query.hasFlags !== undefined) {
-        for (const flag of query.hasFlags) {
-            if (!msg.flags.has(flag))
-                return false;
-        }
-    }
-    if (query.missingFlags !== undefined) {
-        for (const flag of query.missingFlags) {
-            if (msg.flags.has(flag))
-                return false;
-        }
-    }
-    if (query.largerThan !== undefined) {
-        if (msg.raw.length <= query.largerThan)
-            return false;
-    }
-    if (query.smallerThan !== undefined) {
-        if (msg.raw.length >= query.smallerThan)
-            return false;
-    }
-    if (query.body !== undefined || query.text !== undefined) {
-        const rawText = new TextDecoder("utf-8", { fatal: false }).decode(msg.raw);
-        if (query.body !== undefined) {
-            const { bodyOffset } = parseHeaderSection(msg.raw);
-            const bodyText = new TextDecoder("utf-8", { fatal: false }).decode(msg.raw.slice(bodyOffset));
-            if (!bodyText.toLowerCase().includes(query.body.toLowerCase())) {
-                return false;
-            }
-        }
-        if (query.text !== undefined) {
-            if (!rawText.toLowerCase().includes(query.text.toLowerCase())) {
-                return false;
-            }
-        }
-    }
-    if (query.and !== undefined) {
-        for (const sub of query.and) {
-            if (!matchMessage(msg, sub))
-                return false;
-        }
-    }
-    if (query.or !== undefined) {
-        if (query.or.length > 0) {
-            const anyMatch = query.or.some((sub) => matchMessage(msg, sub));
-            if (!anyMatch)
-                return false;
-        }
-    }
-    if (query.not !== undefined) {
-        if (matchMessage(msg, query.not))
-            return false;
-    }
-    return true;
-}
-const headerCache = new WeakMap();
-function lazyHeaders(msg) {
-    const cached = headerCache.get(msg);
-    if (cached !== undefined)
-        return cached;
-    const { headers } = parseHeaderSection(msg.raw);
-    headerCache.set(msg, headers);
-    return headers;
-}

package/dist/thread.d.ts

@@ -1,3 +0,0 @@
-import type { Thread, SearchQuery } from "@intx/types/runtime";
-import type { MailboxStore } from "./mailbox.js";
-export declare function executeThread(mailboxName: string, store: MailboxStore, algorithm: "references" | "orderedsubject", query?: SearchQuery): Thread[];

package/dist/thread.js

@@ -1,204 +0,0 @@
-import { executeSearch } from "./search.js";
-export function executeThread(mailboxName, store, algorithm, query) {
-    let messages;
-    if (query !== undefined) {
-        const refs = executeSearch(mailboxName, store, query);
-        const uidSet = new Set(refs.map((r) => r.uid));
-        messages = store.messages.filter((m) => uidSet.has(m.uid));
-    }
-    else {
-        messages = [...store.messages];
-    }
-    if (messages.length === 0)
-        return [];
-    if (algorithm === "orderedsubject") {
-        return orderedSubjectThread(mailboxName, messages);
-    }
-    return referencesThread(mailboxName, messages);
-}
-/**
- * RFC 5256 ORDEREDSUBJECT: sort by base subject, then date.
- * All messages with the same base subject form one thread; the first by date
- * is the root, the rest are direct children.
- */
-function orderedSubjectThread(mailboxName, messages) {
-    const bySubject = new Map();
-    for (const msg of messages) {
-        const base = baseSubject(msg.envelope.subject);
-        const bucket = bySubject.get(base);
-        if (bucket === undefined) {
-            bySubject.set(base, [msg]);
-        }
-        else {
-            bucket.push(msg);
-        }
-    }
-    const threads = [];
-    for (const [, msgs] of bySubject) {
-        const sorted = msgs.sort((a, b) => a.envelope.date.getTime() - b.envelope.date.getTime());
-        const root = sorted[0];
-        const rootThread = {
-            ref: { uid: root.uid, mailbox: mailboxName },
-            children: sorted.slice(1).map((m) => ({
-                ref: { uid: m.uid, mailbox: mailboxName },
-                children: [],
-            })),
-        };
-        threads.push(rootThread);
-    }
-    return threads.sort((a, b) => {
-        const aMsg = messages.find((m) => m.uid === a.ref.uid);
-        const bMsg = messages.find((m) => m.uid === b.ref.uid);
-        return aMsg.envelope.date.getTime() - bMsg.envelope.date.getTime();
-    });
-}
-/**
- * RFC 5256 REFERENCES algorithm.
- *
- * Step 1: For each message, create a container. Walk its References list
- *   (and In-Reply-To if not already in References) and link containers
- *   as parent-child in left-to-right order.
- *
- * Step 2: Build the id_table mapping Message-IDs to containers.
- *
- * Step 3: Prune empty containers (those with no message).
- *
- * Step 4: Collect root containers.
- *
- * Step 5: Sort each container's children by date.
- */
-function referencesThread(mailboxName, messages) {
-    const idTable = new Map();
-    function getOrCreate(msgId) {
-        const existing = idTable.get(msgId);
-        if (existing !== undefined)
-            return existing;
-        const c = {
-            messageId: msgId,
-            message: null,
-            parent: null,
-            children: [],
-        };
-        idTable.set(msgId, c);
-        return c;
-    }
-    // Step 1 & 2: Build containers and link parent-child relationships.
-    for (const msg of messages) {
-        const container = getOrCreate(msg.envelope.messageId);
-        container.message = msg;
-        // Build the reference list: References + In-Reply-To (deduplicated).
-        const refs = buildRefList(msg.envelope.references, msg.envelope.inReplyTo);
-        // Link: refs[i] is parent of refs[i+1], last ref is parent of this message.
-        let prevContainer = null;
-        for (const refId of refs) {
-            const refContainer = getOrCreate(refId);
-            if (prevContainer !== null &&
-                refContainer.parent === null &&
-                !isAncestor(refContainer, prevContainer)) {
-                prevContainer.children.push(refContainer);
-                refContainer.parent = prevContainer;
-            }
-            prevContainer = refContainer;
-        }
-        // Link the last reference as parent of this message (if no circular reference).
-        if (prevContainer !== null &&
-            container.parent === null &&
-            !isAncestor(container, prevContainer)) {
-            prevContainer.children.push(container);
-            container.parent = prevContainer;
-        }
-    }
-    // Step 3: Find root containers (no parent).
-    const roots = [];
-    for (const [, c] of idTable) {
-        if (c.parent === null) {
-            roots.push(c);
-        }
-    }
-    // Step 4: Prune dummy containers (containers with no message).
-    // A dummy with no children is dropped.
-    // A dummy with children: the children are promoted to the dummy's parent level.
-    const prunedRoots = pruneContainers(roots);
-    // Step 5: Sort and convert to Thread[].
-    return containersToThreads(mailboxName, prunedRoots);
-}
-function buildRefList(references, inReplyTo) {
-    const seen = new Set();
-    const result = [];
-    for (const ref of references) {
-        if (ref && !seen.has(ref)) {
-            seen.add(ref);
-            result.push(ref);
-        }
-    }
-    if (inReplyTo !== undefined && inReplyTo !== "" && !seen.has(inReplyTo)) {
-        result.push(inReplyTo);
-    }
-    return result;
-}
-function isAncestor(potentialAncestor, of) {
-    let cur = of;
-    while (cur !== null) {
-        if (cur === potentialAncestor)
-            return true;
-        cur = cur.parent;
-    }
-    return false;
-}
-function pruneContainers(containers) {
-    const result = [];
-    for (const c of containers) {
-        if (c.message === null && c.children.length === 0) {
-            // Dummy with no children: drop it.
-            continue;
-        }
-        if (c.message === null && c.children.length > 0) {
-            // Dummy with children: promote children (skip the dummy).
-            const promotedChildren = pruneContainers(c.children);
-            result.push(...promotedChildren);
-        }
-        else {
-            // Real message: recurse into children.
-            c.children = pruneContainers(c.children);
-            result.push(c);
-        }
-    }
-    return result;
-}
-function containerDate(c) {
-    if (c.message !== null) {
-        return c.message.envelope.date.getTime();
-    }
-    // For dummy containers, use the earliest child date.
-    let earliest = Infinity;
-    for (const child of c.children) {
-        const d = containerDate(child);
-        if (d < earliest)
-            earliest = d;
-    }
-    return earliest === Infinity ? 0 : earliest;
-}
-function containersToThreads(mailboxName, containers) {
-    // Sort by date of the container (or earliest descendant for dummies).
-    const sorted = containers.sort((a, b) => containerDate(a) - containerDate(b));
-    return sorted
-        .filter((c) => c.message !== null)
-        .map((c) => ({
-        ref: { uid: c.message.uid, mailbox: mailboxName },
-        children: containersToThreads(mailboxName, c.children),
-    }));
-}
-function baseSubject(subject) {
-    // Strip "Re:", "Fwd:", "Fw:" prefixes (case-insensitive) repeatedly.
-    let s = subject.trim();
-    let changed = true;
-    while (changed) {
-        changed = false;
-        const m = s.match(/^(?:re|fwd?)\s*:\s*/i);
-        if (m !== null) {
-            s = s.slice(m[0].length).trim();
-            changed = true;
-        }
-    }
-    return s;
-}