moonmail
RFC-driven SMTP client and MIME message builder for MoonBit.
email
smtp
mime
mail
message
moon add howhere7/moonmail@0.1.0
Download zipAuthor
Version
0.1.0
License
Apache-2.0
Repository
Last updated
6 hours ago
Downloads
3
Dependencies
- gmlewis/base640.16.11
- gmlewis/md50.19.34
- moonbitlang/async0.20.4
README#MoonMail
A transport-agnostic, RFC-driven email sending library for MoonBit. MoonMail builds RFC 5322/5321 messages with full MIME encoding (including an original Quoted-Printable implementation) and drives a complete SMTP client session over a pluggable transport.
#Features
- Message model — MailMessage, MailAddress (addr-spec parsing, display names, comments), header building, folding and line-length control.
- Header-injection protection — any CR/LF or NUL in a header value is rejected before it can reach the wire (MM_INJ_001 / MM_INJ_002).
- MIME — Content-Type parsing, Base64 and original Quoted-Printable encoders, 7bit/8bit, multipart/mixed|alternative|related, boundaries, attachments and inline images (CID).
- MessageBuilder — a fluent API for plain text, HTML, alternatives, attachments and multiple recipients (To/Cc/Bcc).
- CRLF normalization + dot-stuffing — arbitrary newlines become CRLF; lines starting with . are escaped for SMTP DATA.
- SMTP client — EHLO/HELO, capability parsing, AUTH LOGIN/PLAIN/CRAM-MD5 (HMAC-MD5 built on the gmlewis/md5 dependency), MAIL/RCPT/DATA/QUIT, multi-line reply parsing, enhanced status codes and error classification.
- Transport abstraction — the protocol core never touches a socket. It talks to a SmtpTransport: FakeTransport (deterministic, offline, scripted server) or SocketTransport (native, over moonbitlang/async/socket).
- Diagnostics — every session returns a SmtpTrace (command -> reply steps, capabilities, auth mechanism). Credentials and full AUTH payloads are never recorded.
#Quick start
import "howhere7/moonmail"
async fn main {
let builder = @moonmail.MessageBuilder::new()
let _ = builder
.from("alice@example.com")
.to("bob@example.com")
.subject("Hello")
.text("This is a plain text message.")
let msg = builder.build()
let env = builder.envelope()
// Deterministic offline session using the scripted server.
let script = [
@moonmail.FakeStep::greeting(["220 smtp.example.com ESMTP"]),
@moonmail.FakeStep::reply("EHLO localhost", ["250 OK"]),
@moonmail.FakeStep::reply("MAIL FROM:<alice@example.com>", ["250 2.1.0 OK"]),
@moonmail.FakeStep::reply("RCPT TO:<bob@example.com>", ["250 2.1.5 OK"]),
@moonmail.FakeStep::reply("DATA", ["354 End data"]),
@moonmail.FakeStep::reply(".", ["250 2.0.0 OK"]),
@moonmail.FakeStep::reply("QUIT", ["221 2.0.0 Bye"]),
]
let client = @moonmail.SmtpClient::new(
@moonmail.FakeTransport::new(script),
@moonmail.SmtpConfig::new("localhost"),
)
let trace = client.send(msg, env, @moonmail.RenderConfig::deterministic())
println(trace.render())
}To send over a real connection on native, use SocketTransport:
///|
let config = @moonmail.SmtpConfig::new("smtp.example.com", port=587).with_auth(
@moonmail.AuthMethod::Plain("user", "password"),
)
///|
let client = @moonmail.SmtpClient::new(@moonmail.SocketTransport::new(), config)
///|
let trace = client.send(msg, env, @moonmail.RenderConfig::new())#CLI
moonmail send --smtp smtp.example.com --port 587 \
--from user@example.com --to a@b.com --cc c@d.com \
--subject "title" --body text.txt [--html] \
[--attach f1] [--attach f2] \
[--auth-user u --auth-pass p]
moonmail explain scenario.json # replay a FakeTransport script offlineRun from the repository root with:
moon run cmd/main --target native -- send --help
moon run cmd/main --target native -- explain testdata/scenarios/basic.json#Examples
Five runnable examples live under examples/:
| example | demonstrates |
|---|---|
| send_plain | plain text message |
| send_html | HTML body in multipart/alternative |
| send_attachment | binary attachment in multipart/mixed |
| send_multiple | To/Cc/Bcc multi-recipient envelope |
| fake_session | full scripted session over FakeTransport (offline) |
moon run examples/fake_session --target native#Testing
moon check --deny-warn
moon check --target native/js/wasm-gc --deny-warn
moon test --target nativeThe core package checks on native, js and wasm-gc. The socket adapter and the CLI/examples are native-only (the socket adapter has js/wasm stubs that raise Unsupported). All core tests run offline; the only network test spins up a local mock SMTP server over TcpServer on native.
#Documentation
- docs/SCOPE.md — what MoonMail does and does not do
- docs/DESIGN.md — architecture and layering
- docs/MIME_MODEL.md — the MIME representation
- docs/SMTP_SUPPORT.md — RFC support matrix
- docs/REASON_CODES.md — stable reason codes
- docs/SECURITY_MODEL.md — security properties
- docs/TESTING.md — test strategy
- docs/LIMITATIONS.md — known limitations
#License
Apache-2.0.
#SmtpTransport
pub(open) trait SmtpTransport {
async fn connect(Self, SmtpConfig) -> Unit raise MailFailure
async fn write_line(Self, String) -> Unit raise MailFailure
async fn read_line(Self) -> String raise MailFailure
fn close(Self) -> Unit
}The transport abstraction. The SMTP session talks only to this interface:
the network adapter (socket_transport) and the deterministic scripted
server (FakeTransport) both implement it. The core never touches a socket
directly, so it stays portable across backends.
#MailFailure
Raised by MoonMail functions that fail. The payload is a MailError that
carries the stable reason code and a human-readable message.
impl Show for MailFailure
#MailFailure::header_injection
#MailFailure::of
#Attachment
A single attachment or inline image attached to a message.
#Attachment::inline_image
#AuthMethod
SMTP authentication mechanism selection.
#ContentTransferEncoding
Transfer-encoding choice for a body part (RFC 2045 section 6.1).
impl Show for ContentTransferEncoding#ContentTransferEncoding::to_string
#ContentType
A parsed MIME Content-Type: a type/subtype plus ordered parameters
(RFC 2045 section 5.1).
#ContentType::get_param
#ContentType::parse
Parse a Content-Type header value into a ContentType.
#ContentType::set_param
Add (or replace) a parameter like boundary=... or charset=utf-8.
#ContentType::to_string
Render the Content-Type header value, e.g.
multipart/mixed; boundary="abc".
#Disposition
Content-Disposition disposition type (RFC 2183).
impl Show for Disposition#Envelope
The SMTP envelope: the sender (MAIL FROM) and the recipients (RCPT TO).
#Envelope::mail_from
The reverse-path as required by MAIL FROM, with an empty sender (<>)
allowed for null reverse-paths used in bounces.
#Envelope::new
#Envelope::rcpt_to
One RCPT TO per recipient.
#FakeStep
One step of a FakeTransport script: the client command to expect (verbatim,
or "" for a spontaneous server reply such as the greeting, or "*" to
accept any line) and the reply lines to send back.
#FakeTransport
A deterministic, scripted SMTP server used for offline testing. It
implements SmtpTransport and records every client command so tests can
assert the exact command sequence and the message body transmitted.
impl SmtpTransport for FakeTransport#FakeTransport::data_lines
The message body lines received during the DATA phase.
#FakeTransport::failure
The first script mismatch description, if any.
#FakeTransport::is_complete
True when every script step was consumed (the conversation completed).
#FakeTransport::is_connected
Whether the transport is connected.
#FakeTransport::received
Every client command line received (verbatim).
#MailAddress
A parsed email address: an optional display name plus the local@domain
addr-spec (RFC 5322 section 3.4).
impl Show for MailAddress#MailAddress::new
#MailAddress::parse
Parse a single mailbox:
- "Display Name" <local@domain>
- local@domain (comment)
- local@domain
- Display Name <local@domain>
#MailAddress::to_string
Render the address back to a single RFC 5322 mailbox:
Display Name <local@domain> when a display name is present,
otherwise the bare addr-spec.
#MailError
The unified error type for MoonMail. Every failure carries a stable
ReasonCode (see docs/REASON_CODES.md) plus a human-readable message.
#MailError::of
#MailMessage
A parsed email message: header fields plus a MIME body tree.
#MailMessage::add_header
#MailMessage::header
Find the first header value for name (case-insensitive), or None.
#MailMessage::set_header
Set (replacing any existing) header name.
#MessageBuilder
pub struct MessageBuilder {
from : MailAddress?
to : Array[MailAddress]
cc : Array[MailAddress]
bcc : Array[MailAddress]
reply_to : Array[MailAddress]
subject : String
text_part : String?
html_part : String?
attachments : Array[Attachment]
inline_images : Array[Attachment]
custom_headers : Array[(String, String)]
date : String
message_id : String
boundary_seed : String
}Fluent builder for MailMessage. Addresses and header values are validated
(including header-injection checks) as they are added, so a built message
is always safe to render.
#MessageBuilder::attach
fn MessageBuilder::attach(self : MessageBuilder, data : Bytes, filename : String, content_type? : String) -> MessageBuilderAdd a binary attachment with an optional explicit Content-Type.
#MessageBuilder::bcc
#MessageBuilder::boundary_seed
#MessageBuilder::build
Assemble the final message tree plus headers.
#MessageBuilder::cc
#MessageBuilder::date
#MessageBuilder::envelope
The envelope derived from the builder: the sender plus To/Cc/Bcc recipients.
The sender must be set before calling this.
#MessageBuilder::from
#MessageBuilder::from_addr
#MessageBuilder::header
fn MessageBuilder::header(self : MessageBuilder, name : String, value : String) -> MessageBuilder raise MailFailureAdd a custom header. The value is checked for CR/LF injection immediately.
#MessageBuilder::html
#MessageBuilder::inline_image
fn MessageBuilder::inline_image(self : MessageBuilder, data : Bytes, filename : String, cid : String) -> MessageBuilder#MessageBuilder::message_id
#MessageBuilder::reply_to
fn MessageBuilder::reply_to(self : MessageBuilder, list : String) -> MessageBuilder raise MailFailure#MessageBuilder::subject
fn MessageBuilder::subject(self : MessageBuilder, subject : String) -> MessageBuilder raise MailFailure#MessageBuilder::text
#MessageBuilder::to
#MimeBody
pub(all) enum MimeBody {
Text(String)
Html(String)
Binary(Bytes, String)
MultiPart(Array[Part], MimeSubtype)
} derive(Eq, Debug)The body of a message or part.
#MimeSubtype
MIME multipart subtype.
impl Show for MimeSubtype#Part
A single MIME part: its own headers plus a body.
#Part::header
Find the first header value for name (case-insensitive), or None.
#ReasonCode
pub(all) enum ReasonCode {
MM_HEADER_001
MM_HEADER_002
MM_HEADER_003
MM_HEADER_004
MM_ADDR_001
MM_ADDR_002
MM_ADDR_003
MM_ADDR_004
MM_ADDR_005
MM_ADDR_006
MM_ADDR_007
MM_ADDR_008
MM_ENCOD_001
MM_ENCOD_002
MM_ENCOD_003
MM_ENCOD_004
MM_ENCOD_005
MM_MIME_001
MM_MIME_002
MM_MIME_003
MM_MIME_004
MM_MIME_005
MM_MIME_006
MM_CRLF_001
MM_DOT_001
MM_INJ_001
MM_INJ_002
MM_INJ_003
MM_SMTP_001
MM_SMTP_002
MM_SMTP_003
MM_SMTP_004
MM_SMTP_005
MM_SMTP_006
MM_SMTP_007
MM_AUTH_001
MM_AUTH_002
MM_TRANS_001
MM_TRANS_002
Other
} derive(Eq, Debug)Stable, documented reason codes used to classify the outcome of every
encoding, parsing and protocol step. Codes are permanent identifiers:
they never change meaning across releases, and new codes are only
appended. The full mapping is documented in docs/REASON_CODES.md.
impl Show for ReasonCode#RenderConfig
Deterministic rendering controls. The date, message-id and boundary seed
are all injected by the caller so that tests are reproducible; nothing here
reads the system clock or an RNG.
#RenderConfig::deterministic
A fully deterministic default configuration (no date, no message-id,
fixed seed).
#RenderConfig::new
#ReplyLine
A single SMTP reply line: a 3-digit code, an optional enhanced status code
(RFC 3463, e.g. 2.1.0), the text, and whether more lines follow.
#ServerReply
A fully collected server reply (all lines of a multi-line response).
impl Show for ServerReply#ServerReply::from_lines
Build a ServerReply from the collected reply lines (the raw lines that
were received, including code prefixes).
#ServerReply::is_intermediate
The reply carries a 3xx intermediate code.
#ServerReply::is_permanent
The reply carries a 5xx permanent negative completion code.
#ServerReply::is_positive
The reply carries a 2xx positive completion code.
#ServerReply::is_transient
The reply carries a 4xx transient negative completion code.
#SmtpCaps
The capabilities advertised by the server in the EHLO reply.
#SmtpClient
The high-level SMTP client: drives a full session over a SmtpTransport
from a rendered message and an envelope, and returns the diagnostic trace.
#SmtpClient::send
async fn[T : SmtpTransport] SmtpClient::send(self : SmtpClient[T], message : MailMessage, envelope : Envelope, render : RenderConfig) -> SmtpTrace raise MailFailureRender a MailMessage and send it over the session.
#SmtpClient::send_rendered
async fn[T : SmtpTransport] SmtpClient::send_rendered(self : SmtpClient[T], wire : String, envelope : Envelope) -> SmtpTrace raise MailFailureSend an already rendered wire message (CRLF line endings) over the session.
The message is dot-stuffed and line-length checked before transmission.
#SmtpClient::session
Access the underlying session (and through it the transport), for
inspection in tests and tooling.
#SmtpClient::transport
Access the transport captured inside the client (post-send state).
#SmtpConfig
pub struct SmtpConfig {
host : String
port : Int
auth : AuthMethod?
timeout_ms : Int64
connect_retries : Int
} derive(Eq, Debug)Connection configuration for an SMTP session.
#SmtpConfig::with_auth
#SmtpConfig::with_connect_retries
#SmtpConfig::with_timeout
#SmtpSession
pub struct SmtpSession[T] {
transport : T
config : SmtpConfig
state : SmtpState
caps : SmtpCaps
trace : SmtpTrace
}A stateful SMTP client session over a SmtpTransport. The session never
touches a socket itself; all I/O goes through the injected transport
(FakeTransport for deterministic tests, the async socket adapter on native).
#SmtpSession::auth
async fn[T : SmtpTransport] SmtpSession::auth(self : SmtpSession[T], auth : AuthMethod) -> Unit raise MailFailureAuthenticate using the configured method (MM_AUTH_001 / MM_AUTH_002).
#SmtpSession::connect
Connect and read the server greeting (220).
#SmtpSession::ehlo
Negotiate with EHLO (falling back to HELO when the server rejects EHLO).
#SmtpSession::mail_from
async fn[T : SmtpTransport] SmtpSession::mail_from(self : SmtpSession[T], reverse_path : String) -> Unit raise MailFailure#SmtpSession::quit
Send QUIT and close.
#SmtpSession::rcpt_to
async fn[T : SmtpTransport] SmtpSession::rcpt_to(self : SmtpSession[T], forward_path : String) -> Unit raise MailFailure#SmtpSession::send_data
async fn[T : SmtpTransport] SmtpSession::send_data(self : SmtpSession[T], lines : Array[String]) -> Unit raise MailFailureSend the DATA command, the already dot-stuffed message lines, and the
terminating . (MM_SMTP_007).
#SmtpState
The session state machine tracks the SMTP conversation progress.
#SmtpStep
One recorded command -> response interaction of an SMTP session.
#SmtpTrace
A full diagnostic report of an SMTP session: every step, the negotiated
capabilities, the auth mechanism used, and any diagnostics accumulated.
#SmtpTrace::add_diagnostic
#SmtpTrace::add_step
fn SmtpTrace::add_step(self : SmtpTrace, command : String, reply : ServerReply, duration_ms : Int64) -> Unit#SmtpTrace::render
Render the trace as a readable transcript, e.g. for moonmail explain.
#SocketTransport
A real SMTP transport over moonbitlang/async/socket (native only).
This file is compiled only for the native target; the js and wasm targets
use stubs that raise Unsupported.
impl SmtpTransport for SocketTransport#CRAM_MD5_VECTOR_CHALLENGE
let CRAM_MD5_VECTOR_CHALLENGE : StringA CRAM-MD5 test vector for documentation purposes (RFC 2195 example values
come from the smtplib documentation).
#assemble_multipart
A MIME multipart container rendered on the wire. children are the fully
rendered wire texts of the child parts, wrapped between --boundary
delimiter lines (RFC 2046 section 5.1).
Layout:
--boundary\r\n
<child 1 rendered, ending with CRLF>
--boundary\r\n
<child 2 rendered>
--boundary--\r\n#auth_plain_credentials
fn auth_plain_credentials(username : String, password : String) -> StringRFC 4616 PLAIN credentials: \0username\0password, base64 encoded.
#base64_decode_str
Base64-decode a string.
#base64_encode_str
fn base64_encode_str(s : String) -> StringBase64-encode a string (used for AUTH LOGIN/PLAIN payloads).
#base64_mime_decode
Base64-decode MIME text (whitespace/newlines tolerated, per RFC 2045).
#base64_mime_encode
fn base64_mime_encode(data : Bytes) -> StringBase64-encode data for MIME: the output is split into lines of exactly
76 characters separated by CRLF (MM_ENCOD_002, RFC 2045 section 6.8).
Uses the gmlewis/base64 standard encoding as a dependency.
#boundary_collides
fn boundary_collides(boundary : String, body : String) -> BoolCheck that boundary does not occur anywhere inside body (MM_MIME_002).
A boundary line is --boundary at the start of a line; to be safe we
search for --boundary anywhere in the body.
#bytes_to_string
fn bytes_to_string(b : Bytes) -> StringDecode bytes back to a string, replacing any malformed sequences lossily.
Only use for content that is expected to be text.
#check_header_value
Check a header value for injection: CR, LF and NUL are all rejected
(RFC 5322 3.6.8 / security model). See injection.mbt.
#check_line_lengths
Check that every line of s (split on LF) is at most max bytes. Used to
enforce the RFC 5322 998-octet hard limit before transmission (MM_ENCOD_005).
#check_seven_bit
Check a 7bit body: every byte must be <= 127 (MM_ENCOD_003).
#contains_crlf
fn contains_crlf(s : String) -> BoolTrue when the string contains a CR, LF or bare control newline, which must
never appear inside a header field value.
#cram_md5_response
fn cram_md5_response(username : String, password : String, challenge_b64 : String) -> String raise MailFailureBuild the CRAM-MD5 client response: username <hmac-md5-hex>.
challenge_b64 is the text after 334 in the server challenge.
#display_name_to_string
fn display_name_to_string(display_name : String) -> StringQuote the display name when it contains characters outside the safe atom set.
#dot_stuff
fn dot_stuff(s : String) -> StringDot-stuff every line of s: a line starting with . gets a leading .
prepended (MM_DOT_001). Operates on the already CRLF-normalized text.
#encode_body
fn encode_body(content : String, encoding : ContentTransferEncoding) -> (String, ContentTransferEncoding) raise MailFailureEncode text content with an explicit transfer encoding.
Returns the encoded body (which already uses CRLF line endings) together
with the effective encoding that was actually applied (relevant for Auto).
#encode_ehlo
fn encode_ehlo(host : String) -> StringSMTP command encoding helpers. Every command is a single line (no CRLF).
#fixedarray_to_string
fn fixedarray_to_string(fa : FixedArray[Byte], len : Int) -> StringConvert the first len bytes of a FixedArray into a string.
#generate_boundary
fn generate_boundary(seed : String) -> StringBoundary generation for multipart messages (RFC 2046 section 5.1.1).
The boundary is derived from a caller-supplied seed so that rendering is
deterministic and reproducible in tests.
#hex_to_bytes
Decode a hex string to bytes. Raises on odd length or non-hex input.
#hmac_md5
HMAC-MD5 (RFC 2104) with a 64-byte block, built on the MD5 dependency.
Returns the digest as a lowercase hex string (MM_AUTH_001).
#index_of
fn index_of(s : String, sub : String) -> IntFind the byte index of sub in s, or -1 when absent.
#is_pure_ascii
fn is_pure_ascii(s : String) -> BoolTrue when every byte of text is ASCII (<= 127).
#is_valid_boundary
fn is_valid_boundary(boundary : String) -> BoolCharacters permitted inside a boundary value: [0-9a-zA-Z'()+_,-./:=?]
(MM_MIME_003, RFC 2046).
#is_valid_field_name
fn is_valid_field_name(name : String) -> BoolA field-name is any printable ASCII character except : (RFC 5322 3.6.1,
ftext). MoonMail additionally requires a nonempty name.
#make_disposition
Build a Content-Disposition header value. The filename is sanitized
(MM_INJ_003); ASCII filenames use filename="...", non-ASCII filenames use
RFC 2231 extended notation filename*=utf-8''... (MM_MIME_006).
#make_header
Build a single (possibly folded) header field Name: value followed by
CRLF. The value is validated against CR/LF injection and folded so that no
line exceeds max_width (default 78) columns, per RFC 5322 2.2.3.
#normalize_crlf
fn normalize_crlf(s : String) -> StringNormalize every line ending to CRLF: \r\n stays, a lone \r becomes
\r\n, and a lone \n becomes \r\n (MM_CRLF_001).
#parse_address_list
Parse a comma separated list of addresses (e.g. a To header value).
#parse_caps
Parse the EHLO capability lines (the reply lines after the greeting line,
without their numeric prefixes). MM_SMTP_004.
#parse_reply_line
Parse a single SMTP reply line of the form ddd[- ]text where - means
more lines follow and means this is the last line.
#qp_decode
Decode Quoted-Printable text back to a string. Soft line breaks (=\r\n)
are removed; =XX escapes are decoded. Raises on malformed input.
#qp_encode
fn qp_encode(input : String) -> StringQuoted-Printable encoding (RFC 2045 section 6.7), implemented from scratch.
Rules applied:
- Tab and space must be encoded when at the end of a line.
- = must always be encoded as =3D.
- Printable ASCII 33..126 except = is passed through.
- All other bytes (control and >127) are encoded as =XX.
- Lines are limited to 76 characters including any trailing soft break (MM_ENCOD_001); a soft break is a trailing =.
- Line endings are CRLF.
#redact_command
fn redact_command(command : String) -> StringRedact a command for the trace: AUTH payloads (which contain credentials)
are never recorded (MM_SMTP_001 security model, section 15).
#reject_crlf
Reject any CR, LF or NUL byte in value. This is the core header-injection
guard (MM_INJ_001 / MM_INJ_002): user-controlled input must not introduce
new header fields or terminate the header block.
#render_message
Render a MailMessage to its RFC 5322 / MIME wire form (CRLF line
endings). All header values are validated against injection before being
emitted.
#sanitize_filename
fn sanitize_filename(name : String) -> StringSanitize a filename for use inside Content-Disposition: strips path
separators, CR/LF, NUL and other control characters (MM_INJ_003).
#slice_array
Copy arr[start:] into a new array.
#split_address_list
Split an address list on commas, respecting quoted strings and comments.
#string_to_bytes
fn string_to_bytes(s : String) -> BytesUTF-8 encode a string to bytes (replaces the deprecated String::to_bytes).
#strip_reply_code
fn strip_reply_code(line : String) -> StringStrip the leading ddd[- ] reply-code prefix from a line, returning just
the text (e.g. 250-8BITMIME -> 8BITMIME).
#to_lines
Split text into lines on \n, stripping a trailing \r. A trailing
newline does not produce an empty final line.
#unfold_header_value
fn unfold_header_value(value : String) -> StringRemove folding whitespace: each CRLF followed by WSP is removed and the
WSP collapsed. Used by tests and by MIME parsers.
#unique_boundary
fn unique_boundary(seed : String, body : String) -> StringGenerate a boundary that is valid and does not collide with body.
The seed can be reused: a counter is appended until no collision occurs.
#validate_addr_spec
Validate a local-part / domain pair as an addr-spec (RFC 5322 3.4.1).
#with_retry
Execute f, retrying up to max_retries total attempts when it fails with
a retryable error (transport or transient SMTP failure). Permanent errors
(SmtpPermanent, Auth, Config, ContentLength, Timeout) are raised
immediately. This gives callers bounded retry with no external waiting
beyond a single scheduler pause between attempts.
Source Files
- address.mbt
- boundary.mbt
- client.mbt
- content_type.mbt
- crlf.mbt
- disposition.mbt
- encode_base64.mbt
- encode_qp.mbt
- encode_text.mbt
- envelope.mbt
- error.mbt
- fake_transport.mbt
- header.mbt
- injection.mbt
- message.mbt
- message_builder.mbt
- moonmail.mbt
- multipart.mbt
- reason_code.mbt
- render.mbt
- retry.mbt
- smtp_auth.mbt
- smtp_caps.mbt
- smtp_codec.mbt
- smtp_reply.mbt
- smtp_session.mbt
- socket_transport.js.mbt
- socket_transport.native.mbt
- socket_transport.wasm.mbt
- trace.mbt
- transport.mbt
- util.mbt
RFC-driven SMTP client and MIME message builder for MoonBit.
emailsmtpmimemailmessage
0.1.0
Apache-2.0
Updated 6 hours ago
3 downloadsDependencies
- gmlewis/base640.16.11
- gmlewis/md50.19.34
- moonbitlang/async0.20.4