@yolk-sdk/emulators 0.1.0-canary.96

package/dist/email.mjs

@@ -0,0 +1,608 @@
+import { bindRouteHandlers, emulatorRouteKey } from "./route-evidence.mjs";
+import { emailEmulatorFixtures } from "./email-fixtures.mjs";
+import { Data, Equal, Predicate, Result } from "effect";
+import * as Schema from "effect/Schema";
+//#region src/email.ts
+/**
+* Email emulator: a fixture-driven, in-memory fake backend for the generic `EmailClient` port.
+*
+* Yolk never speaks IMAP, POP3, or SMTP; hosts implement `EmailClient`. This emulator stands in for
+* such a host at the port level: `call(method, request)` takes one port call as plain JSON (the
+* credential-free request) and answers `{ response }`, `{ failure }`, or a fail-closed
+* `{ notEmulated }`. There is no socket, TLS, MIME, or mail library here, no `node:` builtin, and
+* no SDK import: it is a plain structural object, and
+* `emailClientLayerFromBackend` in `@yolk-sdk/connectors/email/conformance` turns it into the
+* `EmailClient` layer.
+*
+* Response behaviour comes ONLY from the email conformance fixtures (copied as data in
+* `email-fixtures.ts`). The emulator keeps an in-memory mailbox (folders, messages, flags) seeded
+* with the mailbox the fixtures describe; the state only selects which fixture answers (the first
+* matching fixture consistent with the mailbox) and is updated with what that fixture says
+* happened (flags set, a message moved to the destination id the fixture names, a draft appended,
+* a Sent copy saved). It never invents an id, a flag, or a response.
+*
+* Request-shape latitude (the only one): credential fields are never compared or recorded, and
+* `connection.host` is not compared (the practice host comes from seeds). Every other connection
+* field (`protocol`, `port`, `security`) is compared. Everything else must equal a fixture request
+* exactly. Anything that does not
+* match (an unknown method, no matching fixture, or no fixture consistent with the mailbox state)
+* fails closed with a ledgered `notEmulated` answer, the port analogue of HTTP 400.
+*
+* @experimental
+*/
+/** The port every email fixture and manifest route names. */
+const emailEmulatorPort = "EmailClient";
+/** Manifest routes of port emulators use this pseudo method; `path` is `<Port>.<method>`. */
+const emailEmulatorRouteMethod = "PORT";
+const portRoute = (method, write, caseIds) => ({
+	method: emailEmulatorRouteMethod,
+	path: `${emailEmulatorPort}.${method}`,
+	kind: "connector",
+	write,
+	caseIds,
+	evidence: "unverified",
+	observedAt: void 0
+});
+const listAndGet = "email.imap.list-and-get-headers";
+const filteredList = "email.imap.filtered-list-no-fallback";
+const draftsDiscovery = "email.imap.draft-drafts-discovery";
+const setReadAndFlag = "email.imap.set-read-and-flag";
+const trashUntrash = "email.imap.trash-untrash-to-inbox";
+const moveIds = "email.imap.move-destination-ids";
+/**
+* Route evidence manifest: every emulated `EmailClient` method (`PORT EmailClient.<method>`) and the
+* email conformance cases whose (synthetic, unverified) fixtures it follows. Write methods are
+* unverified connector writes: they need a pending entry in the repo's evidence check until an
+* owner-approved live run against a practice mailbox verifies them.
+*/
+const emailEmulatorRoutes = [
+	portRoute("listMessages", false, [listAndGet, "email.pop3.rejects-folders-drafts-mutations"]),
+	portRoute("listMessagesFiltered", false, [filteredList]),
+	portRoute("getMessage", false, [
+		listAndGet,
+		draftsDiscovery,
+		setReadAndFlag,
+		trashUntrash,
+		moveIds
+	]),
+	portRoute("createDraft", true, [
+		draftsDiscovery,
+		trashUntrash,
+		moveIds
+	]),
+	portRoute("sendMessage", true, [
+		"email.smtp.sent-copy-statuses",
+		"email.smtp.legacy-host-sent-copy",
+		"email.smtp.acceptance-not-delivery"
+	]),
+	portRoute("setRead", true, [setReadAndFlag]),
+	portRoute("setFlag", true, [setReadAndFlag]),
+	portRoute("trash", true, [trashUntrash]),
+	portRoute("untrash", true, [trashUntrash]),
+	portRoute("move", true, [moveIds]),
+	portRoute("deletePermanently", true, [
+		draftsDiscovery,
+		trashUntrash,
+		moveIds
+	])
+];
+const NonEmpty = Schema.String.check(Schema.isNonEmpty());
+/** SPECIAL-USE attributes (RFC 6154) a seeded folder may advertise. */
+const EmailEmulatorSpecialUse = Schema.Literals([
+	"\\All",
+	"\\Archive",
+	"\\Drafts",
+	"\\Flagged",
+	"\\Junk",
+	"\\Sent",
+	"\\Trash"
+]);
+/**
+* One message in the emulated mailbox. `id` is the opaque IMAP id (absent for a Sent copy whose
+* id no fixture named), `uidl` the POP3 id of an INBOX message; unknown flags stay absent until a
+* fixture reports them.
+*/
+const EmailEmulatorMessage = Schema.Struct({
+	id: Schema.optionalKey(NonEmpty),
+	uidl: Schema.optionalKey(NonEmpty),
+	subject: Schema.optionalKey(Schema.String),
+	isRead: Schema.optionalKey(Schema.Boolean),
+	isFlagged: Schema.optionalKey(Schema.Boolean)
+});
+const EmailEmulatorFolder = Schema.Struct({
+	name: NonEmpty,
+	specialUse: Schema.optionalKey(EmailEmulatorSpecialUse),
+	messages: Schema.Array(EmailEmulatorMessage)
+});
+/** The emulated mailbox: plain JSON, used both as the seed and as the `state()` snapshot. */
+const EmailEmulatorSeed = Schema.Struct({ folders: Schema.Array(EmailEmulatorFolder) });
+/** The synthetic practice mailbox the email fixtures describe (the default seed). */
+const emailEmulatorDefaultSeed = { folders: [
+	{
+		name: "INBOX",
+		messages: [{
+			id: "1700000001:41",
+			uidl: "uidl-synthetic-0041",
+			subject: "Synthetic welcome",
+			isRead: false,
+			isFlagged: false
+		}, {
+			id: "1700000001:42",
+			uidl: "uidl-synthetic-0042",
+			subject: "Synthetic weekly summary",
+			isRead: true,
+			isFlagged: false
+		}]
+	},
+	{
+		name: "Saved Drafts",
+		specialUse: "\\Drafts",
+		messages: []
+	},
+	{
+		name: "Sent Items",
+		specialUse: "\\Sent",
+		messages: []
+	},
+	{
+		name: "Deleted Items",
+		specialUse: "\\Trash",
+		messages: []
+	},
+	{
+		name: "Archive",
+		messages: []
+	}
+] };
+const Failure = Schema.Struct({
+	kind: Schema.Literals(["expected", "error"]),
+	code: NonEmpty,
+	message: Schema.String,
+	status: Schema.optionalKey(Schema.Int)
+});
+/**
+* A fault: answer the next `count` calls (every one when omitted) of `method` whose credential-free
+* request contains `match` (a deep subset: objects by key, arrays element by element, other values
+* exactly) with `failure` instead of a fixture. Faults change no mailbox state.
+*/
+const EmailEmulatorFault = Schema.Struct({
+	kind: Schema.Literal("failure"),
+	method: NonEmpty,
+	match: Schema.optionalKey(Schema.Record(Schema.String, Schema.Json)),
+	count: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
+	failure: Failure
+});
+/** Thrown by `makeEmailEmulator` (invalid seed) and `faults.add` (invalid fault). */
+var EmailEmulatorInputInvalid = class extends Data.TaggedError("EmailEmulatorInputInvalid") {
+	get message() {
+		return `Invalid email emulator ${this.input}: ${this.reason}`;
+	}
+};
+const notEmulatedText = {
+	"unknown-method": "unknown-method: the method has no emulated route",
+	"invalid-request": "invalid-request: the request is not a JSON object",
+	"no-matching-fixture": "no-matching-fixture: no fixture matches this request",
+	"state-conflict": "state-conflict: no matching fixture is consistent with the emulated mailbox"
+};
+const isJsonObject = (value) => value !== void 0 && value !== null && Predicate.isObject(value) && !Array.isArray(value);
+const objectField = (value, key) => {
+	const field = isJsonObject(value) ? value[key] : void 0;
+	return isJsonObject(field) ? field : void 0;
+};
+const stringField = (value, key) => {
+	const field = isJsonObject(value) ? value[key] : void 0;
+	return Predicate.isString(field) ? field : void 0;
+};
+const booleanField = (value, key) => {
+	const field = isJsonObject(value) ? value[key] : void 0;
+	return Predicate.isBoolean(field) ? field : void 0;
+};
+const arrayField = (value, key) => {
+	const field = isJsonObject(value) ? value[key] : void 0;
+	return Array.isArray(field) ? field : void 0;
+};
+const credentialKeyPattern = /^(?:credentials?|(?:access|refresh|id|auth|api|session|private|bearer|oauth)[_-]?token|token|client[_-]?secret|secret(?:[_-]?key)?|private[_-]?key|password|passwd|api[_-]?key|authorization)$/i;
+/** A copy without credential fields; `ignoreConnectionHost` applies the request-shape latitude. */
+const scrub = (value, ignoreConnectionHost) => {
+	if (Array.isArray(value)) return value.map((item) => scrub(item, ignoreConnectionHost));
+	if (!isJsonObject(value)) return value;
+	const copy = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (credentialKeyPattern.test(key)) continue;
+		if (ignoreConnectionHost && key === "connection" && isJsonObject(item)) {
+			const { host: _host, ...connection } = item;
+			copy[key] = scrub(connection, ignoreConnectionHost);
+			continue;
+		}
+		copy[key] = scrub(item, ignoreConnectionHost);
+	}
+	return copy;
+};
+/** Deep subset: objects by key, arrays element by element (same length), other values exactly. */
+const containsSubset = (value, pattern) => {
+	if (value === void 0) return false;
+	if (Array.isArray(pattern)) return Array.isArray(value) && value.length === pattern.length && pattern.every((item, index) => containsSubset(value[index], item));
+	if (isJsonObject(pattern)) return isJsonObject(value) && Object.entries(pattern).every(([key, item]) => containsSubset(value[key], item));
+	return Equal.equals(value, pattern);
+};
+const copyMessage = (message) => {
+	const copy = {};
+	if (message.id !== void 0) copy.id = message.id;
+	if (message.uidl !== void 0) copy.uidl = message.uidl;
+	if (message.subject !== void 0) copy.subject = message.subject;
+	if (message.isRead !== void 0) copy.isRead = message.isRead;
+	if (message.isFlagged !== void 0) copy.isFlagged = message.isFlagged;
+	return copy;
+};
+const mailboxFrom = (seed) => ({ folders: seed.folders.map((folder) => folder.specialUse === void 0 ? {
+	name: folder.name,
+	messages: folder.messages.map(copyMessage)
+} : {
+	name: folder.name,
+	specialUse: folder.specialUse,
+	messages: folder.messages.map(copyMessage)
+}) });
+const snapshotOf = (state) => ({ folders: state.folders.map((folder) => folder.specialUse === void 0 ? {
+	name: folder.name,
+	messages: folder.messages.map(copyMessage)
+} : {
+	name: folder.name,
+	specialUse: folder.specialUse,
+	messages: folder.messages.map(copyMessage)
+}) });
+const folderNamed = (state, name) => name === void 0 ? void 0 : state.folders.find((folder) => folder.name === name);
+const specialUseFolder = (state, use) => state.folders.find((folder) => folder.specialUse === use);
+const isPop3 = (request) => stringField(objectField(request, "connection"), "protocol") === "pop3";
+const messageIn = (folder, id, pop3 = false) => folder === void 0 || id === void 0 ? void 0 : folder.messages.find((message) => (pop3 ? message.uidl : message.id) === id);
+const flagKeys = ["isRead", "isFlagged"];
+/** Reported flags and subject agree with what the mailbox knows (unknown state agrees). */
+const agrees = (message, reported) => {
+	const subject = stringField(reported, "subject");
+	return flagKeys.every((key) => {
+		const value = booleanField(reported, key);
+		return value === void 0 || message[key] === void 0 || message[key] === value;
+	}) && (subject === void 0 || message.subject === void 0 || message.subject === subject);
+};
+/** Remember flags and subject the mailbox did not know yet. */
+const learn = (message, reported) => {
+	for (const key of flagKeys) {
+		const value = booleanField(reported, key);
+		if (message[key] === void 0 && value !== void 0) message[key] = value;
+	}
+	const subject = stringField(reported, "subject");
+	if (message.subject === void 0 && subject !== void 0) message.subject = subject;
+};
+const requestFolder = (state, request) => folderNamed(state, stringField(request, "folder") ?? "INBOX");
+/** Every known message that certainly passes the request's read/flagged filters. */
+const certainlyListed = (message, request) => flagKeys.every((key) => {
+	const filter = booleanField(request, key);
+	return filter === void 0 || message[key] === filter;
+});
+const listModel = {
+	consistent: (state, request, fixture) => {
+		if (fixture.failure !== void 0) return true;
+		const folder = requestFolder(state, request);
+		const listed = arrayField(fixture.response, "messages");
+		const pop3 = isPop3(request);
+		if (folder === void 0 || listed === void 0) return false;
+		if (!listed.every((summary) => {
+			const message = messageIn(folder, stringField(summary, "id"), pop3);
+			return message !== void 0 && agrees(message, summary);
+		})) return false;
+		if (stringField(fixture.response, "nextCursor") !== void 0) return true;
+		const listedIds = new Set(listed.map((summary) => stringField(summary, "id")));
+		return folder.messages.every((message) => {
+			const id = pop3 ? message.uidl : message.id;
+			return id === void 0 || !certainlyListed(message, request) || listedIds.has(id);
+		});
+	},
+	apply: (state, request, fixture) => {
+		const folder = requestFolder(state, request);
+		const pop3 = isPop3(request);
+		for (const summary of arrayField(fixture.response, "messages") ?? []) {
+			const message = messageIn(folder, stringField(summary, "id"), pop3);
+			if (message !== void 0) learn(message, summary);
+		}
+	}
+};
+const getModel = {
+	consistent: (state, request, fixture) => {
+		const id = stringField(request, "messageId");
+		const message = messageIn(requestFolder(state, request), id, isPop3(request));
+		if (fixture.failure !== void 0) return message === void 0;
+		const reported = objectField(fixture.response, "message");
+		return message !== void 0 && stringField(reported, "id") === id && agrees(message, reported);
+	},
+	apply: (state, request, fixture) => {
+		const message = messageIn(requestFolder(state, request), stringField(request, "messageId"), isPop3(request));
+		if (message !== void 0 && fixture.failure === void 0) learn(message, objectField(fixture.response, "message"));
+	}
+};
+const flagModel = (key) => ({
+	consistent: (state, request, fixture) => {
+		if (fixture.failure !== void 0) return true;
+		const id = stringField(request, "messageId");
+		return messageIn(requestFolder(state, request), id) !== void 0 && stringField(fixture.response, "messageId") === id && booleanField(fixture.response, key) === booleanField(request, key);
+	},
+	apply: (state, request, fixture) => {
+		const message = messageIn(requestFolder(state, request), stringField(request, "messageId"));
+		const value = booleanField(request, key);
+		if (fixture.failure === void 0 && message !== void 0 && value !== void 0) message[key] = value;
+	}
+});
+/** A move-shaped method: where the message comes from and which destination is acceptable. */
+const moveModel = (source, destinationAllowed) => {
+	const plan = (state, request, fixture) => {
+		const from = source(state, request);
+		return {
+			from,
+			message: messageIn(from, stringField(request, "messageId")),
+			destination: folderNamed(state, stringField(fixture.response, "folder")),
+			movedId: stringField(fixture.response, "messageId")
+		};
+	};
+	return {
+		consistent: (state, request, fixture) => {
+			if (fixture.failure !== void 0) return true;
+			const { from, message, destination, movedId } = plan(state, request, fixture);
+			return booleanField(fixture.response, "moved") === true && from !== void 0 && message !== void 0 && destination !== void 0 && destination !== from && destinationAllowed(state, request, destination) && messageIn(destination, movedId) === void 0;
+		},
+		apply: (state, request, fixture) => {
+			if (fixture.failure !== void 0) return;
+			const { from, message, destination, movedId } = plan(state, request, fixture);
+			if (from === void 0 || message === void 0 || destination === void 0) return;
+			from.messages = from.messages.filter((candidate) => candidate !== message);
+			const moved = { ...message };
+			delete moved.uidl;
+			if (movedId === void 0) delete moved.id;
+			else moved.id = movedId;
+			destination.messages.push(moved);
+		}
+	};
+};
+const createDraftModel = {
+	consistent: (state, request, fixture) => {
+		if (fixture.failure !== void 0) return true;
+		const destination = folderNamed(state, stringField(fixture.response, "folder"));
+		const requested = stringField(request, "folder");
+		return booleanField(fixture.response, "saved") === true && destination !== void 0 && (requested === void 0 ? destination.specialUse === "\\Drafts" : destination.name === requested) && messageIn(destination, stringField(fixture.response, "draftId")) === void 0;
+	},
+	apply: (state, request, fixture) => {
+		const destination = folderNamed(state, stringField(fixture.response, "folder"));
+		if (fixture.failure !== void 0 || destination === void 0) return;
+		const draft = {};
+		const draftId = stringField(fixture.response, "draftId");
+		const subject = stringField(objectField(request, "message"), "subject");
+		if (draftId !== void 0) draft.id = draftId;
+		if (subject !== void 0) draft.subject = subject;
+		destination.messages.push(draft);
+	}
+};
+const deletePermanentlyModel = {
+	consistent: (state, request, fixture) => {
+		if (fixture.failure !== void 0) return true;
+		const folder = requestFolder(state, request);
+		const results = arrayField(fixture.response, "results");
+		return folder !== void 0 && results !== void 0 && results.every((result) => {
+			const present = messageIn(folder, stringField(result, "messageId")) !== void 0;
+			const status = stringField(result, "status");
+			return status === "succeeded" ? present : status !== "failed" || stringField(result, "code") !== "not_found" || !present;
+		});
+	},
+	apply: (state, request, fixture) => {
+		const folder = requestFolder(state, request);
+		if (fixture.failure !== void 0 || folder === void 0) return;
+		const deleted = new Set((arrayField(fixture.response, "results") ?? []).flatMap((result) => stringField(result, "status") === "succeeded" ? [stringField(result, "messageId")] : []));
+		folder.messages = folder.messages.filter((message) => message.id === void 0 || !deleted.has(message.id));
+	}
+};
+/** The mailbox a saved Sent copy lands in, or `undefined` when none is consistent. */
+const savedCopyFolder = (state, request, fixture) => {
+	const requestedCopy = objectField(request, "sentCopy");
+	if (requestedCopy === void 0) return;
+	const requestedFolder = stringField(requestedCopy, "folder");
+	const reportedFolder = stringField(objectField(fixture.response, "sentCopy"), "folder");
+	const folder = requestedFolder === void 0 ? reportedFolder === void 0 ? specialUseFolder(state, "\\Sent") : folderNamed(state, reportedFolder) : folderNamed(state, requestedFolder);
+	if (folder === void 0 || reportedFolder !== void 0 && reportedFolder !== folder.name) return;
+	return requestedFolder !== void 0 || folder.specialUse === "\\Sent" ? folder : void 0;
+};
+const sentCopyStatus = (fixture) => stringField(objectField(fixture.response, "sentCopy"), "status");
+const sendMessageModel = {
+	consistent: (state, request, fixture) => {
+		if (fixture.failure !== void 0) return true;
+		const status = sentCopyStatus(fixture);
+		const requestedCopy = objectField(request, "sentCopy");
+		const requestedFolder = stringField(requestedCopy, "folder");
+		const failedConsistent = requestedCopy !== void 0 && (requestedFolder === void 0 || folderNamed(state, requestedFolder) === void 0);
+		return booleanField(fixture.response, "accepted") === true && (status === "saved" ? savedCopyFolder(state, request, fixture) !== void 0 : status !== "failed" || failedConsistent);
+	},
+	apply: (state, request, fixture) => {
+		if (fixture.failure !== void 0 || sentCopyStatus(fixture) !== "saved") return;
+		const folder = savedCopyFolder(state, request, fixture);
+		const subject = stringField(objectField(request, "message"), "subject");
+		folder?.messages.push(subject === void 0 ? {} : { subject });
+	}
+};
+const routeKey = (method) => emulatorRouteKey(emailEmulatorRouteMethod, `${emailEmulatorPort}.${method}`);
+const methodModels = new Map([
+	[routeKey("listMessages"), listModel],
+	[routeKey("listMessagesFiltered"), listModel],
+	[routeKey("getMessage"), getModel],
+	[routeKey("createDraft"), createDraftModel],
+	[routeKey("sendMessage"), sendMessageModel],
+	[routeKey("setRead"), flagModel("isRead")],
+	[routeKey("setFlag"), flagModel("isFlagged")],
+	[routeKey("trash"), moveModel((state, request) => requestFolder(state, request), (_state, request, destination) => {
+		const trashFolder = stringField(request, "trashFolder");
+		return trashFolder === void 0 ? destination.specialUse === "\\Trash" : destination.name === trashFolder;
+	})],
+	[routeKey("untrash"), moveModel((state, request) => {
+		const folder = stringField(request, "folder");
+		return folder === void 0 ? specialUseFolder(state, "\\Trash") : folderNamed(state, folder);
+	}, (_state, request, destination) => destination.name === stringField(request, "destinationFolder"))],
+	[routeKey("move"), moveModel((state, request) => requestFolder(state, request), (_state, request, destination) => destination.name === stringField(request, "destinationFolder"))],
+	[routeKey("deletePermanently"), deletePermanentlyModel]
+]);
+const strict = { onExcessProperty: "error" };
+const decodeSeed = Schema.decodeUnknownResult(EmailEmulatorSeed, strict);
+const decodeFault = Schema.decodeUnknownResult(EmailEmulatorFault, strict);
+const issueText = (error) => error.message;
+/** Folder names and message ids (and POP3 ids) must be unique so fixtures address one message. */
+const seedProblem = (seed) => {
+	const names = seed.folders.map((folder) => folder.name);
+	if (new Set(names).size !== names.length) return "folder names must be unique";
+	for (const folder of seed.folders) {
+		const ids = folder.messages.flatMap((message) => message.id === void 0 ? [] : [message.id]);
+		const uidls = folder.messages.flatMap((message) => message.uidl === void 0 ? [] : [message.uidl]);
+		if (new Set(ids).size !== ids.length || new Set(uidls).size !== uidls.length) return `message ids in ${folder.name} must be unique`;
+	}
+};
+/**
+* Create an email emulator. Each call has its own mailbox, ledger, faults, and fixture use.
+*
+* `call(method, request)` answers in this order: an unknown method or a non-object request fails
+* closed; the first active matching fault answers its failure; otherwise the fixtures whose method
+* and request match (after the request-shape latitude) are checked against the mailbox, and the
+* first consistent one (preferring one not used since the last reset) answers and updates the
+* mailbox; no match (`no-matching-fixture`) or no consistent match (`state-conflict`) fails closed.
+* Every call is written to the ledger without credential fields.
+*
+* Throws `EmailEmulatorInputInvalid` for an invalid seed.
+*/
+const makeEmailEmulator = (options = {}) => {
+	const seedResult = decodeSeed(options.seed ?? emailEmulatorDefaultSeed);
+	if (Result.isFailure(seedResult)) throw new EmailEmulatorInputInvalid({
+		input: "seed",
+		reason: issueText(seedResult.failure)
+	});
+	const seed = seedResult.success;
+	const problem = seedProblem(seed);
+	if (problem !== void 0) throw new EmailEmulatorInputInvalid({
+		input: "seed",
+		reason: problem
+	});
+	const bound = new Map(bindRouteHandlers(emailEmulatorRoutes, methodModels).map(({ route, handler }) => [route.path.slice(12), {
+		route,
+		model: handler
+	}]));
+	let state = mailboxFrom(seed);
+	let entries = [];
+	let faults = [];
+	let nextFaultId = 1;
+	let nextSeq = 1;
+	const used = /* @__PURE__ */ new Set();
+	const record = (entry) => {
+		entries.push({
+			seq: nextSeq,
+			...entry
+		});
+		nextSeq += 1;
+	};
+	const refuse = (method, request, reason, evidence) => {
+		record({
+			method,
+			request,
+			outcome: "not-emulated",
+			evidence,
+			reason
+		});
+		return { notEmulated: { reason: notEmulatedText[reason] } };
+	};
+	const call = (method, rawRequest) => {
+		const request = scrub(rawRequest, false);
+		const target = bound.get(method);
+		if (target === void 0) return refuse(method, request, "unknown-method", "unknown-method");
+		const evidence = target.route.evidence;
+		if (!isJsonObject(request)) return refuse(method, request, "invalid-request", evidence);
+		const comparable = scrub(request, true);
+		const matching = emailEmulatorFixtures.filter((fixture) => fixture.port === "EmailClient" && fixture.method === method && Equal.equals(scrub(fixture.request, true), comparable));
+		if (matching.length === 0) return refuse(method, request, "no-matching-fixture", evidence);
+		const consistent = matching.filter((fixture) => target.model.consistent(state, request, fixture));
+		const chosen = consistent.find((fixture) => !used.has(fixture.id)) ?? consistent[0];
+		if (chosen === void 0) return refuse(method, request, "state-conflict", evidence);
+		const fault = faults.find((candidate) => candidate.fault.method === method && (candidate.remaining === void 0 || candidate.remaining > 0) && (candidate.fault.match === void 0 || containsSubset(request, candidate.fault.match)));
+		if (fault !== void 0) {
+			fault.applied += 1;
+			if (fault.remaining !== void 0) fault.remaining -= 1;
+			record({
+				method,
+				request,
+				outcome: "fault",
+				evidence,
+				faultId: fault.id
+			});
+			return { failure: fault.fault.failure };
+		}
+		target.model.apply(state, request, chosen);
+		used.add(chosen.id);
+		record({
+			method,
+			request,
+			outcome: "answered",
+			evidence,
+			fixtureId: chosen.id
+		});
+		return chosen.failure === void 0 ? { response: chosen.response } : { failure: chosen.failure };
+	};
+	const faultState = (fault) => ({
+		id: fault.id,
+		fault: fault.fault,
+		remaining: fault.remaining,
+		applied: fault.applied
+	});
+	return {
+		call,
+		state: () => snapshotOf(state),
+		seed: () => snapshotOf(mailboxFrom(seed)),
+		ledger: {
+			entries: () => entries.map((entry) => ({ ...entry })),
+			clear: () => {
+				entries = [];
+			}
+		},
+		reset: () => {
+			state = mailboxFrom(seed);
+			entries = [];
+			faults = [];
+			used.clear();
+		},
+		faults: {
+			add: (input) => {
+				const decoded = decodeFault(input);
+				if (Result.isFailure(decoded)) throw new EmailEmulatorInputInvalid({
+					input: "fault",
+					reason: issueText(decoded.failure)
+				});
+				if (!bound.has(decoded.success.method)) throw new EmailEmulatorInputInvalid({
+					input: "fault",
+					reason: `method ${decoded.success.method} has no emulated route`
+				});
+				const added = {
+					id: nextFaultId,
+					fault: decoded.success,
+					remaining: decoded.success.count,
+					applied: 0
+				};
+				nextFaultId += 1;
+				faults.push(added);
+				return faultState(added);
+			},
+			list: () => faults.map(faultState),
+			clear: () => {
+				faults = [];
+			}
+		},
+		coverage: () => ({
+			routes: emailEmulatorRoutes.map((route) => ({
+				...route,
+				calls: entries.filter((entry) => `${emailEmulatorPort}.${entry.method}` === route.path).length
+			})),
+			notEmulatedCalls: entries.filter((entry) => entry.outcome === "not-emulated").length,
+			unusedFixtureIds: emailEmulatorFixtures.flatMap((fixture) => used.has(fixture.id) ? [] : [fixture.id])
+		})
+	};
+};
+//#endregion
+export { EmailEmulatorFault, EmailEmulatorFolder, EmailEmulatorInputInvalid, EmailEmulatorMessage, EmailEmulatorSeed, EmailEmulatorSpecialUse, emailEmulatorDefaultSeed, emailEmulatorFixtures, emailEmulatorPort, emailEmulatorRouteMethod, emailEmulatorRoutes, makeEmailEmulator };
+
+//# sourceMappingURL=email.mjs.map