@primitivedotdev/sdk 0.7.0 → 0.9.0

package/dist/parser/index.js

@@ -1,114 +1,9 @@
+import { n as parseFromHeaderLoose, t as parseFromHeader } from "../address-parser-BYn8oW5r.js";
 import { createHash } from "node:crypto";
-import addressparser from "nodemailer/lib/addressparser/index.js";
-import isEmail from "validator/lib/isEmail.js";
 import { createGzip } from "node:zlib";
 import { pack } from "tar-stream";
 import { simpleParser } from "mailparser";
 import DOMPurify from "isomorphic-dompurify";
-
-//#region src/parser/address-parser.ts
-const MAX_HEADER_LENGTH = 998;
-const IS_EMAIL_OPTIONS = {
-	allow_ip_domain: true,
-	require_tld: true,
-	allow_display_name: false,
-	allow_utf8_local_part: true
-};
-/**
-* Strict parser for RFC 5322 From-style headers in security-bearing
-* contexts (allowlist gates, permission grants).
-*
-* Rejects, without falling back to a "best guess":
-*   - empty / whitespace-only input
-*   - inputs longer than RFC 5322's 998-octet line limit
-*   - multi-address From (RFC 5322 allows it but it is vanishingly
-*     rare and ambiguous as an identity)
-*   - group syntax ("Friends: a@b.com, c@d.com;")
-*   - any address that fails validator's isEmail check with our chosen
-*     options. That covers per-part length limits, dot-atom rules,
-*     hostname-label rules, TLD requirement, and other RFC 5321/5322
-*     conformance checks.
-*
-* Returns ONLY the validated address, with no display name. Strict
-* exists for gating decisions, where the address is the security-
-* bearing field. Display names from addressparser are not trustworthy
-* here: weird inputs like `Name <user@x.com> <attacker@y.com>` get
-* parsed as a single entry whose `name` silently includes the second
-* address. Surfacing that as a "parsed name" would invite downstream
-* misuse, so we drop it. If you need the name, call
-* {@link parseFromHeaderLoose} alongside (it returns null on failure
-* anyway, so you can still gate on strict's Result).
-*
-* Returns a typed Result so callers can map the failure reason to
-* stable error codes without inspecting message text.
-*/
-function parseFromHeader(header) {
-	if (header === null || header === void 0) return {
-		ok: false,
-		reason: "empty"
-	};
-	const trimmed = header.trim();
-	if (trimmed.length === 0) return {
-		ok: false,
-		reason: "empty"
-	};
-	if (Buffer.byteLength(trimmed, "utf8") > MAX_HEADER_LENGTH) return {
-		ok: false,
-		reason: "too_long"
-	};
-	const parsed = addressparser(trimmed);
-	if (parsed.length > 1) return {
-		ok: false,
-		reason: "multiple_addresses"
-	};
-	const entry = parsed[0];
-	if (entry === void 0) return {
-		ok: false,
-		reason: "invalid_address"
-	};
-	if ("group" in entry) return {
-		ok: false,
-		reason: "group_syntax"
-	};
-	if (!isEmail(entry.address, IS_EMAIL_OPTIONS)) return {
-		ok: false,
-		reason: "invalid_address"
-	};
-	return {
-		ok: true,
-		value: { address: entry.address.toLowerCase() }
-	};
-}
-/**
-* Lenient parser for display-only call sites (inbox card "from",
-* log lines, debugging). Returns the first parseable address with its
-* display name, or null.
-*
-* Differences from {@link parseFromHeader}:
-*   - Multi-address From returns the first address instead of rejecting
-*   - Group syntax is flattened into its member addresses
-*   - Returns null instead of a typed reason on failure
-*   - Includes the parsed display name in the result
-*
-* Do not use for permission gates or any decision that grants access.
-* That is what {@link parseFromHeader} is for. Names returned here can
-* include addressparser's recovery output (trailing tokens, garbage
-* before the address); treat as opaque text for display.
-*/
-function parseFromHeaderLoose(header) {
-	if (header === null || header === void 0) return null;
-	const trimmed = header.trim();
-	if (trimmed.length === 0 || Buffer.byteLength(trimmed, "utf8") > MAX_HEADER_LENGTH) return null;
-	const parsed = addressparser(trimmed, { flatten: true });
-	const entry = parsed[0];
-	if (entry === void 0 || !isEmail(entry.address, IS_EMAIL_OPTIONS)) return null;
-	return {
-		address: entry.address.toLowerCase(),
-		name: entry.name && entry.name.length > 0 ? entry.name : null
-	};
-}
-
-//#endregion
 //#region src/parser/attachment-bundler.ts
 function appendTarEntry(archive, name, content) {
 	return new Promise((resolve, reject) => {
@@ -185,10 +80,9 @@ async function bundleAttachments(attachments) {
 			}
 		})();
 	});
-	const sha256 = createHash("sha256").update(tarGzBuffer).digest("hex");
 	return {
 		tarGzBuffer,
-		sha256,
+		sha256: createHash("sha256").update(tarGzBuffer).digest("hex"),
 		attachmentCount: downloadable.length,
 		totalAttachmentBytes
 	};
@@ -218,10 +112,8 @@ function extractAttachmentMetadata(attachments) {
 * @returns Storage key in format: attachments/{email_id}_{hash8}.tar.gz
 */
 function getAttachmentsStorageKey(emailId, sha256) {
-	const hash8 = sha256.substring(0, 8);
-	return `attachments/${emailId}_${hash8}.tar.gz`;
+	return `attachments/${emailId}_${sha256.substring(0, 8)}.tar.gz`;
 }
-
 //#endregion
 //#region src/parser/sanitize-html.ts
 const ALLOWED_TAGS = [
@@ -307,8 +199,7 @@ DOMPurify.addHook("uponSanitizeAttribute", (_node, data) => {
 });
 DOMPurify.addHook("afterSanitizeAttributes", (node) => {
 	if (node.tagName === "A") {
-		const target = node.getAttribute("target");
-		if (target === "_blank") node.setAttribute("rel", "noopener noreferrer");
+		if (node.getAttribute("target") === "_blank") node.setAttribute("rel", "noopener noreferrer");
 	}
 });
 const SANITIZE_OPTIONS = {
@@ -338,7 +229,6 @@ const SANITIZE_OPTIONS = {
 function sanitizeHtml(html) {
 	return DOMPurify.sanitize(html, SANITIZE_OPTIONS);
 }
-
 //#endregion
 //#region src/parser/attachment-parser.ts
 const SIGNATURE_ARTIFACTS = new Set([
@@ -449,8 +339,7 @@ function normalizeReferences(refs) {
 */
 function normalizeContentType(contentType) {
 	if (!contentType?.trim()) return "application/octet-stream";
-	const mediaType = contentType.split(";")[0].trim().toLowerCase();
-	return mediaType || "application/octet-stream";
+	return contentType.split(";")[0].trim().toLowerCase() || "application/octet-stream";
 }
 /**
 * Parse disposition string to typed value.
@@ -479,8 +368,7 @@ function getHeaderString(value) {
 	return String(value);
 }
 function getOriginalHeaderValue(parsed, key) {
-	const headerLines = parsed.headerLines;
-	const original = headerLines?.find((header) => header.key?.toLowerCase() === key.toLowerCase())?.line;
+	const original = parsed.headerLines?.find((header) => header.key?.toLowerCase() === key.toLowerCase())?.line;
 	if (!original) return null;
 	const separator = original.indexOf(":");
 	return separator === -1 ? original : original.slice(separator + 1).trimStart();
@@ -510,7 +398,6 @@ function sanitizeFilename(filename, partIndex) {
 	if (!safe) return `attachment_${partIndex}`;
 	return safe;
 }
-
 //#endregion
 //#region src/parser/email-parser.ts
 /**
@@ -570,7 +457,6 @@ function structuredHeaderToString(value) {
 	}
 	return JSON.stringify(value);
 }
-
 //#endregion
 //#region src/parser/mapping.ts
 /**
@@ -660,6 +546,5 @@ function requireNonEmptyHeader(value, headerName) {
 	if (typeof value !== "string" || value.trim() === "") throw new Error(`Parsed email is missing a usable ${headerName} header value`);
 	return value;
 }
-
 //#endregion
-export { attachmentMetadataToWebhookAttachments, bundleAttachments, extractAttachmentMetadata, getAttachmentsStorageKey, normalizeContentType, parseEmail, parseEmailWithAttachments, parseFromHeader, parseFromHeaderLoose, sanitizeFilename, sanitizeHtml, sha256Hex, toCanonicalHeaders, toParsedDataComplete, toWebhookAttachments };
+export { attachmentMetadataToWebhookAttachments, bundleAttachments, extractAttachmentMetadata, getAttachmentsStorageKey, normalizeContentType, parseEmail, parseEmailWithAttachments, parseFromHeader, parseFromHeaderLoose, sanitizeFilename, sanitizeHtml, sha256Hex, toCanonicalHeaders, toParsedDataComplete, toWebhookAttachments };

package/dist/received-email-D6tKtWwW.js

@@ -0,0 +1,69 @@
+import { n as parseFromHeaderLoose } from "./address-parser-BYn8oW5r.js";
+//#region src/webhook/received-email.ts
+const REPLY_PREFIX_RE = /^re\s*:/i;
+const FORWARD_PREFIX_RE = /^(fwd?|fw)\s*:/i;
+function normalizeReceivedEmail(event) {
+	const receivedBy = event.email.smtp.rcpt_to[0];
+	if (!receivedBy) throw new Error("email.smtp.rcpt_to must contain at least one recipient");
+	const sender = parseHeaderAddress(event.email.headers.from) ?? {
+		address: event.email.smtp.mail_from.trim().toLowerCase(),
+		name: null
+	};
+	const replyTarget = firstStructuredAddress(event.email.parsed.reply_to) ?? sender;
+	const subject = event.email.headers.subject ?? null;
+	const references = event.email.parsed.references ?? [];
+	const messageId = event.email.headers.message_id ?? null;
+	return {
+		id: event.email.id,
+		eventId: event.id,
+		receivedAt: event.email.received_at,
+		sender,
+		replyTarget,
+		receivedBy,
+		receivedByAll: [...event.email.smtp.rcpt_to],
+		subject,
+		replySubject: buildReplySubject(subject),
+		forwardSubject: buildForwardSubject(subject),
+		text: event.email.parsed.body_text ?? null,
+		thread: {
+			messageId,
+			inReplyTo: event.email.parsed.in_reply_to ?? [],
+			references
+		},
+		attachments: event.email.parsed.attachments ?? [],
+		auth: event.email.auth,
+		analysis: event.email.analysis,
+		raw: event
+	};
+}
+function buildReplySubject(subject) {
+	const trimmed = subject?.trim() ?? "";
+	if (trimmed.length === 0) return "Re:";
+	return REPLY_PREFIX_RE.test(trimmed) ? trimmed : `Re: ${trimmed}`;
+}
+function buildForwardSubject(subject) {
+	const trimmed = subject?.trim() ?? "";
+	if (trimmed.length === 0) return "Fwd:";
+	return FORWARD_PREFIX_RE.test(trimmed) ? trimmed : `Fwd: ${trimmed}`;
+}
+function formatAddress(address) {
+	return address.name ? `${address.name} <${address.address}>` : address.address;
+}
+function firstStructuredAddress(addresses) {
+	const address = addresses?.[0];
+	if (!address) return null;
+	return {
+		address: address.address.trim().toLowerCase(),
+		name: address.name ?? null
+	};
+}
+function parseHeaderAddress(value) {
+	const parsed = parseFromHeaderLoose(value);
+	if (!parsed) return null;
+	return {
+		address: parsed.address,
+		name: parsed.name?.trim() || null
+	};
+}
+//#endregion
+export { parseHeaderAddress as a, normalizeReceivedEmail as i, buildReplySubject as n, formatAddress as r, buildForwardSubject as t };

package/dist/received-email-DNjpq_Wt.d.ts

@@ -0,0 +1,37 @@
+import { M as WebhookAttachment, c as EmailAnalysis, l as EmailAuth, u as EmailReceivedEvent } from "./types-9vXGZjPd.js";
+
+//#region src/webhook/received-email.d.ts
+interface ReceivedEmailAddress {
+  address: string;
+  name: string | null;
+}
+interface ReceivedEmailThread {
+  messageId: string | null;
+  inReplyTo: string[];
+  references: string[];
+}
+interface ReceivedEmail {
+  id: string;
+  eventId: string;
+  receivedAt: string;
+  sender: ReceivedEmailAddress;
+  replyTarget: ReceivedEmailAddress;
+  receivedBy: string;
+  receivedByAll: string[];
+  subject: string | null;
+  replySubject: string;
+  forwardSubject: string;
+  text: string | null;
+  thread: ReceivedEmailThread;
+  attachments: WebhookAttachment[];
+  auth: EmailAuth;
+  analysis: EmailAnalysis;
+  raw: EmailReceivedEvent;
+}
+declare function normalizeReceivedEmail(event: EmailReceivedEvent): ReceivedEmail;
+declare function buildReplySubject(subject: string | null | undefined): string;
+declare function buildForwardSubject(subject: string | null | undefined): string;
+declare function formatAddress(address: ReceivedEmailAddress): string;
+declare function parseHeaderAddress(value: string | null | undefined): ReceivedEmailAddress | null;
+//#endregion
+export { buildReplySubject as a, parseHeaderAddress as c, buildForwardSubject as i, ReceivedEmailAddress as n, formatAddress as o, ReceivedEmailThread as r, normalizeReceivedEmail as s, ReceivedEmail as t };

package/dist/{types-CKFmgitP.d.ts → types-9vXGZjPd.d.ts}

@@ -17,13 +17,6 @@
  * via the `definition` "ForwardResult".
  */
 type ForwardResult$1 = (ForwardResultInline$1 | ForwardResultAttachmentAnalyzed$1 | ForwardResultAttachmentSkipped$1);
-/**
- * Valid webhook version format (YYYY-MM-DD date string). The SDK accepts any valid date-formatted version, not just the current one, for forward and backward compatibility.
- *
- * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
- * via the `definition` "WebhookVersion".
- */
-
 /**
  * Webhook payload for the `email.received` event.
  *
@@ -693,17 +686,9 @@ interface DkimSignature$1 {
    * Optional in self-hosted environments.
    */
   algo: (string | null);
-} //#endregion
+}
+//#endregion
 //#region src/types.d.ts
-
-/**
- * Webhook payload for the `email.received` event.
- *
- * This is delivered to your webhook endpoint when Primitive receives an email matching your domain configuration.
- *
- * This interface was referenced by `EmailReceivedEvent`'s JSON-Schema
- * via the `definition` "EmailReceivedEvent".
- */
 type EmailReceivedEvent = EmailReceivedEvent$1;
 type EventType = EmailReceivedEvent["event"];
 declare const EventType: {
@@ -814,6 +799,5 @@ interface UnknownEvent {
 }
 type KnownWebhookEvent = EmailReceivedEvent;
 type WebhookEvent = KnownWebhookEvent | UnknownEvent;
-
 //#endregion
-export { AuthConfidence as AuthConfidence$1, AuthVerdict as AuthVerdict$1, DkimResult as DkimResult$1, DkimSignature, DmarcPolicy as DmarcPolicy$1, DmarcResult as DmarcResult$1, EmailAddress, EmailAnalysis, EmailAuth, EmailReceivedEvent, EventType as EventType$1, ForwardAnalysis, ForwardOriginalSender, ForwardResult, ForwardResultAttachmentAnalyzed, ForwardResultAttachmentSkipped, ForwardResultInline, ForwardVerdict as ForwardVerdict$1, ForwardVerification, KnownWebhookEvent, ParsedData, ParsedDataComplete, ParsedDataFailed, ParsedError, ParsedStatus as ParsedStatus$1, RawContent, RawContentDownloadOnly, RawContentInline, SpfResult as SpfResult$1, UnknownEvent, ValidateEmailAuthResult, WebhookAttachment, WebhookEvent };
+export { UnknownEvent as A, ParsedDataFailed as C, RawContentDownloadOnly as D, RawContent as E, WebhookAttachment as M, WebhookEvent as N, RawContentInline as O, ParsedDataComplete as S, ParsedStatus as T, ForwardResultInline as _, DmarcPolicy as a, KnownWebhookEvent as b, EmailAnalysis as c, EventType as d, ForwardAnalysis as f, ForwardResultAttachmentSkipped as g, ForwardResultAttachmentAnalyzed as h, DkimSignature as i, ValidateEmailAuthResult as j, SpfResult as k, EmailAuth as l, ForwardResult as m, AuthVerdict as n, DmarcResult as o, ForwardOriginalSender as p, DkimResult as r, EmailAddress as s, AuthConfidence as t, EmailReceivedEvent as u, ForwardVerdict as v, ParsedError as w, ParsedData as x, ForwardVerification as y };

package/dist/types.generated.js

@@ -0,0 +1,7 @@
+/**
+ * Types for Primitive webhook payloads.
+ *
+ * AUTO-GENERATED - DO NOT EDIT
+ * Run `pnpm generate:types` to regenerate.
+ */
+export {};

package/dist/types.js

@@ -0,0 +1,53 @@
+/**
+ * Primitive webhook event types derived from the canonical JSON schema.
+ *
+ * @packageDocumentation
+ */
+export const EventType = {
+    EmailReceived: "email.received",
+};
+export const ParsedStatus = {
+    Complete: "complete",
+    Failed: "failed",
+};
+export const ForwardVerdict = {
+    Legit: "legit",
+    Unknown: "unknown",
+};
+export const SpfResult = {
+    Pass: "pass",
+    Fail: "fail",
+    Softfail: "softfail",
+    Neutral: "neutral",
+    None: "none",
+    Temperror: "temperror",
+    Permerror: "permerror",
+};
+export const DmarcResult = {
+    Pass: "pass",
+    Fail: "fail",
+    None: "none",
+    Temperror: "temperror",
+    Permerror: "permerror",
+};
+export const DmarcPolicy = {
+    Reject: "reject",
+    Quarantine: "quarantine",
+    None: "none",
+};
+export const DkimResult = {
+    Pass: "pass",
+    Fail: "fail",
+    Temperror: "temperror",
+    Permerror: "permerror",
+};
+export const AuthConfidence = {
+    High: "high",
+    Medium: "medium",
+    Low: "low",
+};
+export const AuthVerdict = {
+    Legit: "legit",
+    Suspicious: "suspicious",
+    Unknown: "unknown",
+};

package/dist/webhook/index.d.ts

@@ -1,3 +1,4 @@
-import { AuthConfidence$1 as AuthConfidence, AuthVerdict$1 as AuthVerdict, DkimResult$1 as DkimResult, DkimSignature, DmarcPolicy$1 as DmarcPolicy, DmarcResult$1 as DmarcResult, EmailAddress, EmailAnalysis, EmailAuth, EmailReceivedEvent, EventType$1 as EventType, ForwardAnalysis, ForwardOriginalSender, ForwardResult, ForwardResultAttachmentAnalyzed, ForwardResultAttachmentSkipped, ForwardResultInline, ForwardVerdict$1 as ForwardVerdict, ForwardVerification, KnownWebhookEvent, ParsedData, ParsedDataComplete, ParsedDataFailed, ParsedError, ParsedStatus$1 as ParsedStatus, RawContent, RawContentDownloadOnly, RawContentInline, SpfResult$1 as SpfResult, UnknownEvent, ValidateEmailAuthResult, WebhookAttachment, WebhookEvent } from "../types-CKFmgitP.js";
-import { DecodeRawEmailOptions, GenerateDownloadTokenOptions, HandleWebhookOptions, LEGACY_CONFIRMED_HEADER$1 as LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER$1 as LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS$1 as PAYLOAD_ERRORS, PRIMITIVE_CONFIRMED_HEADER$1 as PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER$1 as PRIMITIVE_SIGNATURE_HEADER, PrimitiveWebhookError$1 as PrimitiveWebhookError, RAW_EMAIL_ERRORS$1 as RAW_EMAIL_ERRORS, RawEmailDecodeError$1 as RawEmailDecodeError, RawEmailDecodeErrorCode, STANDARD_WEBHOOK_ID_HEADER$1 as STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER$1 as STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER$1 as STANDARD_WEBHOOK_TIMESTAMP_HEADER, SignResult, StandardWebhooksSignResult, StandardWebhooksVerifyOptions, VERIFICATION_ERRORS$1 as VERIFICATION_ERRORS, VerifyDownloadTokenOptions, VerifyDownloadTokenResult, VerifyOptions, WEBHOOK_VERSION$1 as WEBHOOK_VERSION, WebhookErrorCode, WebhookHeaders, WebhookPayloadError$1 as WebhookPayloadError, WebhookPayloadErrorCode, WebhookValidationError$1 as WebhookValidationError, WebhookValidationErrorCode, WebhookVerificationError$1 as WebhookVerificationError, WebhookVerificationErrorCode, confirmedHeaders$1 as confirmedHeaders, decodeRawEmail$1 as decodeRawEmail, emailReceivedEventJsonSchema$1 as emailReceivedEventJsonSchema, generateDownloadToken$1 as generateDownloadToken, getDownloadTimeRemaining$1 as getDownloadTimeRemaining, handleWebhook$1 as handleWebhook, isDownloadExpired$1 as isDownloadExpired, isEmailReceivedEvent$1 as isEmailReceivedEvent, isRawIncluded$1 as isRawIncluded, parseWebhookEvent$1 as parseWebhookEvent, safeValidateEmailReceivedEvent$1 as safeValidateEmailReceivedEvent, signStandardWebhooksPayload$1 as signStandardWebhooksPayload, signWebhookPayload$1 as signWebhookPayload, validateEmailAuth$1 as validateEmailAuth, validateEmailReceivedEvent$1 as validateEmailReceivedEvent, verifyDownloadToken$1 as verifyDownloadToken, verifyRawEmailDownload$1 as verifyRawEmailDownload, verifyStandardWebhooksSignature$1 as verifyStandardWebhooksSignature, verifyWebhookSignature$1 as verifyWebhookSignature } from "../index-DLmAI4UQ.js";
-export { AuthConfidence, AuthVerdict, DecodeRawEmailOptions, DkimResult, DkimSignature, DmarcPolicy, DmarcResult, EmailAddress, EmailAnalysis, EmailAuth, EmailReceivedEvent, EventType, ForwardAnalysis, ForwardOriginalSender, ForwardResult, ForwardResultAttachmentAnalyzed, ForwardResultAttachmentSkipped, ForwardResultInline, ForwardVerdict, ForwardVerification, GenerateDownloadTokenOptions, HandleWebhookOptions, KnownWebhookEvent, LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS, PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER, ParsedData, ParsedDataComplete, ParsedDataFailed, ParsedError, ParsedStatus, PrimitiveWebhookError, RAW_EMAIL_ERRORS, RawContent, RawContentDownloadOnly, RawContentInline, RawEmailDecodeError, RawEmailDecodeErrorCode, STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER, SignResult, SpfResult, StandardWebhooksSignResult, StandardWebhooksVerifyOptions, UnknownEvent, VERIFICATION_ERRORS, ValidateEmailAuthResult, VerifyDownloadTokenOptions, VerifyDownloadTokenResult, VerifyOptions, WEBHOOK_VERSION, WebhookAttachment, WebhookErrorCode, WebhookEvent, WebhookHeaders, WebhookPayloadError, WebhookPayloadErrorCode, WebhookValidationError, WebhookValidationErrorCode, WebhookVerificationError, WebhookVerificationErrorCode, confirmedHeaders, decodeRawEmail, emailReceivedEventJsonSchema, generateDownloadToken, getDownloadTimeRemaining, handleWebhook, isDownloadExpired, isEmailReceivedEvent, isRawIncluded, parseWebhookEvent, safeValidateEmailReceivedEvent, signStandardWebhooksPayload, signWebhookPayload, validateEmailAuth, validateEmailReceivedEvent, verifyDownloadToken, verifyRawEmailDownload, verifyStandardWebhooksSignature, verifyWebhookSignature };
+import { A as UnknownEvent, C as ParsedDataFailed, D as RawContentDownloadOnly, E as RawContent, M as WebhookAttachment, N as WebhookEvent, O as RawContentInline, S as ParsedDataComplete, T as ParsedStatus, _ as ForwardResultInline, a as DmarcPolicy, b as KnownWebhookEvent, c as EmailAnalysis, d as EventType, f as ForwardAnalysis, g as ForwardResultAttachmentSkipped, h as ForwardResultAttachmentAnalyzed, i as DkimSignature, j as ValidateEmailAuthResult, k as SpfResult, l as EmailAuth, m as ForwardResult, n as AuthVerdict, o as DmarcResult, p as ForwardOriginalSender, r as DkimResult, s as EmailAddress, t as AuthConfidence, u as EmailReceivedEvent, v as ForwardVerdict, w as ParsedError, x as ParsedData, y as ForwardVerification } from "../types-9vXGZjPd.js";
+import { a as buildReplySubject, c as parseHeaderAddress, i as buildForwardSubject, n as ReceivedEmailAddress, o as formatAddress, r as ReceivedEmailThread, s as normalizeReceivedEmail, t as ReceivedEmail } from "../received-email-DNjpq_Wt.js";
+import { A as VerifyOptions, B as PAYLOAD_ERRORS, C as signStandardWebhooksPayload, D as PRIMITIVE_CONFIRMED_HEADER, E as LEGACY_SIGNATURE_HEADER, F as VerifyDownloadTokenResult, G as VERIFICATION_ERRORS, H as RAW_EMAIL_ERRORS, I as generateDownloadToken, J as WebhookPayloadErrorCode, K as WebhookErrorCode, L as verifyDownloadToken, M as verifyWebhookSignature, N as GenerateDownloadTokenOptions, O as PRIMITIVE_SIGNATURE_HEADER, P as VerifyDownloadTokenOptions, Q as WebhookVerificationErrorCode, R as safeValidateEmailReceivedEvent, S as StandardWebhooksVerifyOptions, T as LEGACY_CONFIRMED_HEADER, U as RawEmailDecodeError, V as PrimitiveWebhookError, W as RawEmailDecodeErrorCode, X as WebhookValidationErrorCode, Y as WebhookValidationError, Z as WebhookVerificationError, _ as emailReceivedEventJsonSchema, a as confirmedHeaders, b as STANDARD_WEBHOOK_TIMESTAMP_HEADER, c as handleWebhook, d as isRawIncluded, f as parseWebhookEvent, g as validateEmailAuth, h as WEBHOOK_VERSION, i as WebhookHeaders, j as signWebhookPayload, k as SignResult, l as isDownloadExpired, m as verifyRawEmailDownload, n as HandleWebhookOptions, o as decodeRawEmail, p as receive, q as WebhookPayloadError, r as ReceiveRequestOptions, s as getDownloadTimeRemaining, t as DecodeRawEmailOptions, u as isEmailReceivedEvent, v as STANDARD_WEBHOOK_ID_HEADER, w as verifyStandardWebhooksSignature, x as StandardWebhooksSignResult, y as STANDARD_WEBHOOK_SIGNATURE_HEADER, z as validateEmailReceivedEvent } from "../index-CbEivn3S.js";
+export { AuthConfidence, AuthVerdict, DecodeRawEmailOptions, DkimResult, DkimSignature, DmarcPolicy, DmarcResult, EmailAddress, EmailAnalysis, EmailAuth, EmailReceivedEvent, EventType, ForwardAnalysis, ForwardOriginalSender, ForwardResult, ForwardResultAttachmentAnalyzed, ForwardResultAttachmentSkipped, ForwardResultInline, ForwardVerdict, ForwardVerification, GenerateDownloadTokenOptions, HandleWebhookOptions, KnownWebhookEvent, LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS, PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER, ParsedData, ParsedDataComplete, ParsedDataFailed, ParsedError, ParsedStatus, PrimitiveWebhookError, RAW_EMAIL_ERRORS, RawContent, RawContentDownloadOnly, RawContentInline, RawEmailDecodeError, RawEmailDecodeErrorCode, ReceiveRequestOptions, ReceivedEmail, ReceivedEmailAddress, ReceivedEmailThread, STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER, SignResult, SpfResult, StandardWebhooksSignResult, StandardWebhooksVerifyOptions, UnknownEvent, VERIFICATION_ERRORS, ValidateEmailAuthResult, VerifyDownloadTokenOptions, VerifyDownloadTokenResult, VerifyOptions, WEBHOOK_VERSION, WebhookAttachment, WebhookErrorCode, WebhookEvent, WebhookHeaders, WebhookPayloadError, WebhookPayloadErrorCode, WebhookValidationError, WebhookValidationErrorCode, WebhookVerificationError, WebhookVerificationErrorCode, buildForwardSubject, buildReplySubject, confirmedHeaders, decodeRawEmail, emailReceivedEventJsonSchema, formatAddress, generateDownloadToken, getDownloadTimeRemaining, handleWebhook, isDownloadExpired, isEmailReceivedEvent, isRawIncluded, normalizeReceivedEmail, parseHeaderAddress, parseWebhookEvent, receive, safeValidateEmailReceivedEvent, signStandardWebhooksPayload, signWebhookPayload, validateEmailAuth, validateEmailReceivedEvent, verifyDownloadToken, verifyRawEmailDownload, verifyStandardWebhooksSignature, verifyWebhookSignature };

package/dist/webhook/index.js

@@ -1,3 +1,3 @@
-import { AuthConfidence, AuthVerdict, DkimResult, DmarcPolicy, DmarcResult, EventType, ForwardVerdict, LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS, PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER, ParsedStatus, PrimitiveWebhookError, RAW_EMAIL_ERRORS, RawEmailDecodeError, STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER, SpfResult, VERIFICATION_ERRORS, WEBHOOK_VERSION, WebhookPayloadError, WebhookValidationError, WebhookVerificationError, confirmedHeaders, decodeRawEmail, emailReceivedEventJsonSchema, generateDownloadToken, getDownloadTimeRemaining, handleWebhook, isDownloadExpired, isEmailReceivedEvent, isRawIncluded, parseWebhookEvent, safeValidateEmailReceivedEvent, signStandardWebhooksPayload, signWebhookPayload, validateEmailAuth, validateEmailReceivedEvent, verifyDownloadToken, verifyRawEmailDownload, verifyStandardWebhooksSignature, verifyWebhookSignature } from "../webhook-COe5N_Uj.js";
-
-export { AuthConfidence, AuthVerdict, DkimResult, DmarcPolicy, DmarcResult, EventType, ForwardVerdict, LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS, PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER, ParsedStatus, PrimitiveWebhookError, RAW_EMAIL_ERRORS, RawEmailDecodeError, STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER, SpfResult, VERIFICATION_ERRORS, WEBHOOK_VERSION, WebhookPayloadError, WebhookValidationError, WebhookVerificationError, confirmedHeaders, decodeRawEmail, emailReceivedEventJsonSchema, generateDownloadToken, getDownloadTimeRemaining, handleWebhook, isDownloadExpired, isEmailReceivedEvent, isRawIncluded, parseWebhookEvent, safeValidateEmailReceivedEvent, signStandardWebhooksPayload, signWebhookPayload, validateEmailAuth, validateEmailReceivedEvent, verifyDownloadToken, verifyRawEmailDownload, verifyStandardWebhooksSignature, verifyWebhookSignature };
+import { a as parseHeaderAddress, i as normalizeReceivedEmail, n as buildReplySubject, r as formatAddress, t as buildForwardSubject } from "../received-email-D6tKtWwW.js";
+import { A as PRIMITIVE_CONFIRMED_HEADER, B as RAW_EMAIL_ERRORS, C as STANDARD_WEBHOOK_ID_HEADER, D as verifyStandardWebhooksSignature, E as signStandardWebhooksPayload, F as verifyDownloadToken, G as WebhookVerificationError, H as VERIFICATION_ERRORS, I as safeValidateEmailReceivedEvent, L as validateEmailReceivedEvent, M as signWebhookPayload, N as verifyWebhookSignature, O as LEGACY_CONFIRMED_HEADER, P as generateDownloadToken, R as PAYLOAD_ERRORS, S as emailReceivedEventJsonSchema, T as STANDARD_WEBHOOK_TIMESTAMP_HEADER, U as WebhookPayloadError, V as RawEmailDecodeError, W as WebhookValidationError, _ as DmarcResult, a as isDownloadExpired, b as ParsedStatus, c as parseWebhookEvent, d as WEBHOOK_VERSION, f as validateEmailAuth, g as DmarcPolicy, h as DkimResult, i as handleWebhook, j as PRIMITIVE_SIGNATURE_HEADER, k as LEGACY_SIGNATURE_HEADER, l as receive, m as AuthVerdict, n as decodeRawEmail, o as isEmailReceivedEvent, p as AuthConfidence, r as getDownloadTimeRemaining, s as isRawIncluded, t as confirmedHeaders, u as verifyRawEmailDownload, v as EventType, w as STANDARD_WEBHOOK_SIGNATURE_HEADER, x as SpfResult, y as ForwardVerdict, z as PrimitiveWebhookError } from "../webhook-zkN4wUTs.js";
+export { AuthConfidence, AuthVerdict, DkimResult, DmarcPolicy, DmarcResult, EventType, ForwardVerdict, LEGACY_CONFIRMED_HEADER, LEGACY_SIGNATURE_HEADER, PAYLOAD_ERRORS, PRIMITIVE_CONFIRMED_HEADER, PRIMITIVE_SIGNATURE_HEADER, ParsedStatus, PrimitiveWebhookError, RAW_EMAIL_ERRORS, RawEmailDecodeError, STANDARD_WEBHOOK_ID_HEADER, STANDARD_WEBHOOK_SIGNATURE_HEADER, STANDARD_WEBHOOK_TIMESTAMP_HEADER, SpfResult, VERIFICATION_ERRORS, WEBHOOK_VERSION, WebhookPayloadError, WebhookValidationError, WebhookVerificationError, buildForwardSubject, buildReplySubject, confirmedHeaders, decodeRawEmail, emailReceivedEventJsonSchema, formatAddress, generateDownloadToken, getDownloadTimeRemaining, handleWebhook, isDownloadExpired, isEmailReceivedEvent, isRawIncluded, normalizeReceivedEmail, parseHeaderAddress, parseWebhookEvent, receive, safeValidateEmailReceivedEvent, signStandardWebhooksPayload, signWebhookPayload, validateEmailAuth, validateEmailReceivedEvent, verifyDownloadToken, verifyRawEmailDownload, verifyStandardWebhooksSignature, verifyWebhookSignature };

package/dist/webhook/received-email.js

@@ -0,0 +1,82 @@
+import { parseFromHeaderLoose } from "../parser/address-parser.js";
+const REPLY_PREFIX_RE = /^re\s*:/i;
+const FORWARD_PREFIX_RE = /^(fwd?|fw)\s*:/i;
+export function normalizeReceivedEmail(event) {
+    const receivedBy = event.email.smtp.rcpt_to[0];
+    if (!receivedBy) {
+        throw new Error("email.smtp.rcpt_to must contain at least one recipient");
+    }
+    const sender = parseHeaderAddress(event.email.headers.from) ?? {
+        address: event.email.smtp.mail_from.trim().toLowerCase(),
+        name: null,
+    };
+    const replyTarget = firstStructuredAddress(event.email.parsed.reply_to) ?? sender;
+    const subject = event.email.headers.subject ?? null;
+    const references = event.email.parsed.references ?? [];
+    const messageId = event.email.headers.message_id ?? null;
+    return {
+        id: event.email.id,
+        eventId: event.id,
+        receivedAt: event.email.received_at,
+        sender,
+        replyTarget,
+        receivedBy,
+        receivedByAll: [...event.email.smtp.rcpt_to],
+        subject,
+        replySubject: buildReplySubject(subject),
+        forwardSubject: buildForwardSubject(subject),
+        text: event.email.parsed.body_text ?? null,
+        thread: {
+            messageId,
+            inReplyTo: event.email.parsed.in_reply_to ?? [],
+            references,
+        },
+        attachments: event.email.parsed.attachments ?? [],
+        auth: event.email.auth,
+        analysis: event.email.analysis,
+        raw: event,
+    };
+}
+export function buildReplySubject(subject) {
+    const trimmed = subject?.trim() ?? "";
+    if (trimmed.length === 0) {
+        return "Re:";
+    }
+    return REPLY_PREFIX_RE.test(trimmed) ? trimmed : `Re: ${trimmed}`;
+}
+export function buildForwardSubject(subject) {
+    const trimmed = subject?.trim() ?? "";
+    if (trimmed.length === 0) {
+        return "Fwd:";
+    }
+    return FORWARD_PREFIX_RE.test(trimmed) ? trimmed : `Fwd: ${trimmed}`;
+}
+export function formatAddress(address) {
+    return address.name
+        ? `${address.name} <${address.address}>`
+        : address.address;
+}
+function firstStructuredAddress(addresses) {
+    const address = addresses?.[0];
+    if (!address) {
+        return null;
+    }
+    return {
+        address: address.address.trim().toLowerCase(),
+        name: address.name ?? null,
+    };
+}
+// Lenient about quirky headers (unquoted commas in display names, missing
+// closing angle brackets) but strict about the resulting address: it must
+// validate as an email, otherwise the normalizer falls back to the SMTP
+// envelope sender. Exported so cross-SDK fixtures can exercise it directly.
+export function parseHeaderAddress(value) {
+    const parsed = parseFromHeaderLoose(value);
+    if (!parsed) {
+        return null;
+    }
+    return {
+        address: parsed.address,
+        name: parsed.name?.trim() || null,
+    };
+}