@plitzi/sdk-server 0.35.3 → 0.35.5

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @plitzi/sdk-server
 
+## 0.35.5
+
+### Patch Changes
+
+- v0.35.5
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.35.5
+  - @plitzi/sdk-shared@0.35.5
+
+## 0.35.4
+
+### Patch Changes
+
+- v0.35.4
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.35.4
+  - @plitzi/sdk-shared@0.35.4
+
 ## 0.35.3
 
 ### Patch Changes

package/dist/actions.d.ts

@@ -55,7 +55,8 @@ export { createKvStore } from './modules/actions/runtime/kvStore';
  * and still wants refusals on the log stream wires one of each; that is the normal shape, not a workaround.
  */
 export { createRunLogger, createRejectLogger } from './modules/actions/runtime/runLogger';
-export type { ActionCredential, ActionDbDriver, ActionKvAdapter, ActionKvStore, ActionLookups, ActionRejectRecord, ActionRunRecord, ActionRunRequest, ActionRunResult, ActionsConfig, ActionTask, ActionTaskContext, ActionTaskRegistry, RegisteredTask, ResolvedConnector } from './modules/actions/types';
+export type { TaskRegistryOptions } from './modules/actions/tasks/registry';
+export type { ActionCredential, ActionDbDriver, ActionEmailConfig, ActionEmailDelivery, ActionEmailMessage, ActionEmailTransport, ActionKvAdapter, ActionKvStore, ActionLookups, ActionRejectRecord, ActionRunRecord, ActionRunRequest, ActionRunResult, ActionsConfig, ActionTask, ActionTaskContext, ActionTaskRegistry, RegisteredTask, ResolvedConnector } from './modules/actions/types';
 export type { ActionsModule } from './modules/actions';
 export type { ActiveRun, RunGuards } from './modules/actions/runtime/guards';
 export type { ScheduleResult, ScheduleRunner, ScheduleTick } from './modules/actions/runtime/schedule';

package/dist/core/oauth/metadata.js

@@ -1,4 +1,4 @@
-import { requestOrigin } from "@plitzi/sdk-server/kernel";
+import { requestOrigin } from "../requestParser.js";
 //#region src/core/oauth/metadata.ts
 var AUTHORIZE_PATH = "/authorize";
 var TOKEN_PATH = "/token";

package/dist/modules/actions/index.d.ts

@@ -37,4 +37,5 @@ export { handleActionCancel } from './transport/cancelHandler';
 export type { ActiveRun, RunGuards } from './runtime/guards';
 export type { ScheduleResult, ScheduleRunner, ScheduleTick } from './runtime/schedule';
 export type { ActionTaskDescriptor } from './taskCatalog';
-export type { ActionCredential, ActionDbDriver, ActionKvStore, ActionLookups, ActionRejectRecord, ActionRunRecord, ActionRunRequest, ActionRunResult, ActionsConfig, ActionTask, ActionTaskContext, ActionTaskRegistry, RegisteredTask, ResolvedConnector } from './types';
+export type { TaskRegistryOptions } from './tasks/registry';
+export type { ActionCredential, ActionDbDriver, ActionEmailConfig, ActionEmailDelivery, ActionEmailMessage, ActionEmailTransport, ActionKvStore, ActionLookups, ActionRejectRecord, ActionRunRecord, ActionRunRequest, ActionRunResult, ActionsConfig, ActionTask, ActionTaskContext, ActionTaskRegistry, RegisteredTask, ResolvedConnector } from './types';

package/dist/modules/actions/index.js

@@ -25,7 +25,7 @@ import { handleActionCancel } from "./transport/cancelHandler.js";
 * the same as having no single-flight at all. Nothing outside this folder needs to know how a run is assembled.
 */
 var createActionsModule = (config) => {
-	const registry = createTaskRegistry(config.tasks, (config.dbDrivers?.length ?? 0) > 0);
+	const registry = createTaskRegistry(config.tasks, { db: (config.dbDrivers?.length ?? 0) > 0 });
 	const { runAction } = createActionRunner(config, registry, config.fetchImpl);
 	/**
 	* Single-flight over the store the deployment already gave the `kv` tasks — its own Redis, table or whatever it

package/dist/modules/actions/moduleFor.js

@@ -26,6 +26,7 @@ var actionsModuleFor = (config) => {
 		rateLimit: config.action?.rateLimit,
 		idempotency: config.action?.idempotency,
 		dbDrivers: config.action?.dbDrivers,
+		email: config.action?.email,
 		onRun: config.action?.onRun
 	});
 	modules.set(config, module);

package/dist/modules/actions/runtime/check.js

@@ -1,6 +1,6 @@
 import { triggerParams } from "./triggers.js";
 import { hasValidToken } from "@plitzi/sdk-shared/helpers/twigWrapper";
-import { parseCron, triggerHasStaleVerify, triggerVerify } from "@plitzi/sdk-shared/actions";
+import { parseCron, readSmtpCredential, triggerHasStaleVerify, triggerVerify } from "@plitzi/sdk-shared/actions";
 //#region src/modules/actions/runtime/check.ts
 /** A value the check can reason about: a literal the author typed, not a template resolved at run time. */
 var literal = (value) => {
@@ -82,6 +82,17 @@ var checkAction = async (entry, deps) => {
 		const connector = literal(params.connector);
 		if (connector && !await lookups.getConnector?.(spaceId, connector)) add("error", `nodes.${node.id}.params.connector`, `This space has no connector called "${connector}"`, "Add it in Connectors, or name one that exists");
 		const identifier = literal(params.credential);
+		if (node.action === "email.send") {
+			const path = `nodes.${node.id}.params.credential`;
+			if (!identifier) {
+				add("error", path, "This step names no SMTP server to send through", "Add an SMTP credential and pick it here");
+				return;
+			}
+			const credential = await checkCredential(node, identifier);
+			if (!credential) return;
+			readSmtpCredential(credential).problems.forEach((problem) => add("error", path, `The credential "${identifier}" is not a usable SMTP server: ${problem.key} — ${problem.message}`));
+			return;
+		}
 		if (!identifier) return;
 		if (node.action === "db.query") {
 			const credential = await checkCredential(node, identifier, "dsn");

package/dist/modules/actions/runtime/email.d.ts

@@ -0,0 +1,39 @@
+import { HostLookup } from '../../../helpers/outboundGuard';
+import { ActionKvStore } from '../types';
+import { ActionEmailConfig, ActionEmailMessage } from '@plitzi/sdk-shared';
+import { SmtpSettings } from '@plitzi/sdk-shared/actions';
+export declare const DEFAULT_EMAIL_DAILY_LIMIT = 200;
+/** Hands one message to the SMTP server of a space, at an address this module already resolved and judged. */
+export type SmtpDelivery = (delivery: {
+    /** The IP to connect to. The host name travels separately, as what the TLS certificate must be for. */
+    address: string;
+    smtp: SmtpSettings;
+    message: ActionEmailMessage;
+    signal: AbortSignal;
+}) => Promise<void>;
+/** What the `email.send` task sends through: the policy around a space's own SMTP server, and the connection. */
+export type ActionEmailSender = {
+    send: (spaceId: number, smtp: SmtpSettings, message: ActionEmailMessage, signal: AbortSignal) => Promise<void>;
+};
+export type EmailSenderOptions = ActionEmailConfig & {
+    /** The server's own store, NOT a space's: a flow must not be able to reach the counter that limits it. */
+    kv: ActionKvStore;
+    lookup?: HostLookup;
+    deliver?: SmtpDelivery;
+    now?: () => Date;
+};
+/**
+ * Sends a flow's message under the deployment's rules, in this order:
+ *
+ * 1. **Where it goes is settled.** A deployment's own `transport` owns its connection and receives the message as it
+ *    is. Without one, the message goes to the SMTP server the space's credential names, and the host is resolved and
+ *    every address judged first: a credential is typed by a customer and the connection starts inside the
+ *    deployment's network, so `localhost` or an address that resolves to `10.0.0.5` is refused unless the deployment
+ *    allowed it. The connection then goes to the address that was judged, so a name that answers differently a second
+ *    later cannot be how it gets in.
+ * 2. **The message is counted against the space's day.** Before it leaves, and never given back: a failing server
+ *    still spends the allowance, or retrying against an outage would be how the limit is walked past. A host refused
+ *    in step 1 spends nothing, because nothing was attempted.
+ * 3. **The message is delivered.**
+ */
+export declare const createEmailSender: ({ kv, dailyLimitPerSpace, allowPrivateHosts, transport, lookup, deliver, now }: EmailSenderOptions) => ActionEmailSender;

package/dist/modules/actions/runtime/email.js

@@ -0,0 +1,91 @@
+import { isBlockedHost } from "../../../helpers/outboundGuard.js";
+import { lookup } from "node:dns/promises";
+var DAY_SECONDS = 86400;
+var CONNECTION_TIMEOUT_MS = 1e4;
+var SOCKET_TIMEOUT_MS = 2e4;
+var resolveAll = (hostname) => lookup(hostname, {
+	all: true,
+	verbatim: true
+});
+/** Loaded on the first message, so a server whose flows send no mail never loads a mail client to find that out. */
+var deliverWithNodemailer = async ({ address, smtp, message, signal }) => {
+	const { createTransport } = await import("nodemailer");
+	const transport = createTransport({
+		host: address,
+		port: smtp.port,
+		secure: smtp.security === "tls",
+		requireTLS: smtp.security === "starttls",
+		ignoreTLS: smtp.security === "none",
+		tls: { servername: smtp.host },
+		...smtp.username ? { auth: {
+			user: smtp.username,
+			pass: smtp.password
+		} } : {},
+		connectionTimeout: CONNECTION_TIMEOUT_MS,
+		greetingTimeout: CONNECTION_TIMEOUT_MS,
+		socketTimeout: SOCKET_TIMEOUT_MS
+	});
+	const abort = () => transport.close();
+	signal.addEventListener("abort", abort, { once: true });
+	try {
+		await transport.sendMail({
+			from: {
+				name: smtp.fromName,
+				address: smtp.fromEmail
+			},
+			to: message.to,
+			subject: message.subject,
+			text: message.text,
+			...message.replyTo ? { replyTo: message.replyTo } : {}
+		});
+	} finally {
+		signal.removeEventListener("abort", abort);
+		transport.close();
+	}
+};
+/**
+* Sends a flow's message under the deployment's rules, in this order:
+*
+* 1. **Where it goes is settled.** A deployment's own `transport` owns its connection and receives the message as it
+*    is. Without one, the message goes to the SMTP server the space's credential names, and the host is resolved and
+*    every address judged first: a credential is typed by a customer and the connection starts inside the
+*    deployment's network, so `localhost` or an address that resolves to `10.0.0.5` is refused unless the deployment
+*    allowed it. The connection then goes to the address that was judged, so a name that answers differently a second
+*    later cannot be how it gets in.
+* 2. **The message is counted against the space's day.** Before it leaves, and never given back: a failing server
+*    still spends the allowance, or retrying against an outage would be how the limit is walked past. A host refused
+*    in step 1 spends nothing, because nothing was attempted.
+* 3. **The message is delivered.**
+*/
+var createEmailSender = ({ kv, dailyLimitPerSpace = 200, allowPrivateHosts = false, transport, lookup = resolveAll, deliver = deliverWithNodemailer, now = () => /* @__PURE__ */ new Date() }) => {
+	const viaSmtp = async (smtp) => {
+		let addresses;
+		try {
+			addresses = await lookup(smtp.host);
+		} catch {
+			throw new Error(`The SMTP host "${smtp.host}" does not resolve`);
+		}
+		const [first] = addresses;
+		if (addresses.length === 0) throw new Error(`The SMTP host "${smtp.host}" does not resolve`);
+		if (!allowPrivateHosts && (isBlockedHost(smtp.host) || addresses.some(({ address }) => isBlockedHost(address)))) throw new Error(`The SMTP host "${smtp.host}" is on a private network, which this server does not connect to`);
+		return (delivery) => deliver({
+			address: first.address,
+			smtp: delivery.smtp,
+			message: delivery.message,
+			signal: delivery.signal
+		});
+	};
+	return { send: async (spaceId, smtp, message, signal) => {
+		const deliverMessage = transport ?? await viaSmtp(smtp);
+		const day = now().toISOString().slice(0, 10);
+		if (await kv.increment(`email-limit:${spaceId}:${day}`, 1, 2 * DAY_SECONDS) > dailyLimitPerSpace) throw new Error(`This space has sent its ${dailyLimitPerSpace} emails for today`);
+		await deliverMessage({
+			spaceId,
+			smtp,
+			message,
+			signal
+		});
+	} };
+};
+//#endregion
+export { createEmailSender };

package/dist/modules/actions/runtime/email.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/actions/runtime/runAction.js

@@ -4,6 +4,7 @@ import { createKvStore } from "./kvStore.js";
 import { resolveLimits } from "./limits.js";
 import { createMemoryKv } from "./memoryKv.js";
 import { namespaceKv } from "./namespaceKv.js";
+import { createEmailSender } from "./email.js";
 import { createRedactor, projectUser } from "./scope.js";
 import { precheckRun } from "./precheck.js";
 import onAbort from "../../../helpers/onAbort.js";
@@ -200,6 +201,10 @@ var runNode = async (node, scope, registry, buildContext) => {
 */
 var createActionRunner = (config, registry, baseFetch = fetch) => {
 	const kv = createKvStore(config.kv ?? createMemoryKv());
+	const emailSender = createEmailSender({
+		...config.email,
+		kv
+	});
 	/** Never allowed to fail a run: a logging outage must not take an action down, the same rule metering follows. */
 	const record = async (entry) => {
 		try {
@@ -260,6 +265,7 @@ var createActionRunner = (config, registry, baseFetch = fetch) => {
 			fetch: runFetch,
 			kv: scopedKv,
 			dbDrivers: config.dbDrivers ?? [],
+			email: emailSender,
 			emit: (chunk) => request.emit?.(redact(chunk))
 		});
 		const trace = [];
@@ -280,7 +286,13 @@ var createActionRunner = (config, registry, baseFetch = fetch) => {
 			spaceId: request.spaceId,
 			environment: request.environment,
 			trigger: request.trigger,
-			runId
+			runId,
+			/**
+			* The moment the run started, as an ISO string — and the same moment for every step. A check that asks the
+			* time and the write it guards cannot straddle midnight, and a template reads it in the zone it cares about
+			* with `{{ now|date('Y-m-d', 'Europe/Madrid') }}`.
+			*/
+			now: new Date(startedAt).toISOString()
 		};
 		let status = "completed";
 		let returned;

package/dist/modules/actions/tasks/builtins.d.ts

@@ -2,7 +2,9 @@ import { ActionTask } from '../types';
 /**
  * The tasks `sdk-server` itself ships: the ones that are mechanism rather than policy.
  *
- * Anything needing an account somewhere — email, AI, object storage — is the DEPLOYMENT's, registered through
- * `actions.tasks`. A server with no mail transport must not offer a step whose only possible outcome is failure.
+ * Anything needing an account somewhere the deployment owns — AI, object storage — is the DEPLOYMENT's, registered
+ * through `actions.tasks`. `email.send` is shipped because the account is the SPACE's: it sends through an SMTP server
+ * the space holds as a credential, so every server can offer it. `db.query` sits in between — the task is shipped,
+ * the engine driver is the deployment's, and the registry offers it only when one was given.
  */
 export declare const builtinTasks: ActionTask<Record<string, unknown>>[];

package/dist/modules/actions/tasks/builtins.js

@@ -1,5 +1,6 @@
 import { authTasks } from "./auth.js";
 import { connectorTasks } from "./connector.js";
+import { emailTasks } from "./email.js";
 import { flowTasks, streamTasks } from "./flow.js";
 import { httpTasks } from "./http.js";
 import { kvTasks } from "./kv.js";
@@ -8,8 +9,10 @@ import { transformTasks } from "./transform.js";
 /**
 * The tasks `sdk-server` itself ships: the ones that are mechanism rather than policy.
 *
-* Anything needing an account somewhere — email, AI, object storage — is the DEPLOYMENT's, registered through
-* `actions.tasks`. A server with no mail transport must not offer a step whose only possible outcome is failure.
+* Anything needing an account somewhere the deployment owns — AI, object storage — is the DEPLOYMENT's, registered
+* through `actions.tasks`. `email.send` is shipped because the account is the SPACE's: it sends through an SMTP server
+* the space holds as a credential, so every server can offer it. `db.query` sits in between — the task is shipped,
+* the engine driver is the deployment's, and the registry offers it only when one was given.
 */
 var builtinTasks = [
 	...flowTasks,
@@ -18,6 +21,7 @@ var builtinTasks = [
 	...connectorTasks,
 	...authTasks,
 	...kvTasks,
+	...emailTasks,
 	...streamTasks
 ];
 //#endregion

package/dist/modules/actions/tasks/email.d.ts

@@ -0,0 +1,2 @@
+import { ActionTask } from '../types';
+export declare const emailTasks: ActionTask<Record<string, unknown>>[];

package/dist/modules/actions/tasks/email.js

@@ -0,0 +1,67 @@
+import { isSingleEmailAddress, readSmtpCredential } from "@plitzi/sdk-shared/actions";
+//#region src/modules/actions/tasks/email.ts
+var MAX_SUBJECT = 200;
+var MAX_TEXT = 2e4;
+var emailTasks = [{
+	namespace: "email",
+	action: "send",
+	title: "Send Email",
+	description: "Sends a plain-text message through an SMTP server this space holds as a credential",
+	params: {
+		credential: {
+			type: "text",
+			canBind: false,
+			defaultValue: "",
+			label: "SMTP server (credential)",
+			credentialProvider: "smtp"
+		},
+		to: {
+			type: "text",
+			canBind: true,
+			defaultValue: "",
+			label: "To"
+		},
+		subject: {
+			type: "text",
+			canBind: true,
+			defaultValue: "",
+			label: "Subject"
+		},
+		text: {
+			type: "codemirror-text",
+			canBind: true,
+			defaultValue: "",
+			label: "Text"
+		},
+		replyTo: {
+			type: "text",
+			canBind: true,
+			defaultValue: "",
+			label: "Reply to"
+		}
+	},
+	run: async ({ credential, to, subject, text, replyTo }, ctx) => {
+		const identifier = credential.trim();
+		if (identifier === "") throw new Error("This step names no SMTP credential to send through — add one in Credentials and pick it here");
+		const recipient = to.trim();
+		if (!isSingleEmailAddress(recipient)) throw new Error("The recipient is not one email address");
+		const answerTo = replyTo.trim();
+		if (answerTo !== "" && !isSingleEmailAddress(answerTo)) throw new Error("The reply-to is not one email address");
+		const title = subject.trim();
+		if (title === "" || /[\r\n]/.test(title) || title.length > MAX_SUBJECT) throw new Error(`The subject must be one line of 1 to ${MAX_SUBJECT} characters`);
+		if (text.trim() === "" || text.length > MAX_TEXT) throw new Error(`The text must have 1 to ${MAX_TEXT} characters`);
+		const stored = await ctx.credential(identifier);
+		if (!stored) throw new Error(`This space has no SMTP credential called "${identifier}" — add it in Credentials`);
+		const reading = readSmtpCredential(stored);
+		if (!("settings" in reading)) throw new Error(`Credential "${identifier}" is not a usable SMTP server: ${reading.problems.map((problem) => `${problem.key} — ${problem.message}`).join("; ")}`);
+		await ctx.email.send(ctx.spaceId, reading.settings, {
+			to: recipient,
+			subject: title,
+			text,
+			...answerTo === "" ? {} : { replyTo: answerTo }
+		}, ctx.signal);
+		return { sent: true };
+	}
+}];
+//#endregion
+export { emailTasks };

package/dist/modules/actions/tasks/email.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/actions/tasks/registry.d.ts

@@ -1,5 +1,10 @@
 import { ActionTask, ActionTaskRegistry } from '../types';
 export declare const taskName: (task: Pick<ActionTask, "namespace" | "action">) => string;
+/** The shipped tasks that are only real when the deployment supplied what they run through. */
+export type TaskRegistryOptions = {
+    /** At least one database driver is registered, so `db.query` has an engine to run against. */
+    db?: boolean;
+};
 /**
  * Builds the set of tasks this server can run.
  *
@@ -7,4 +12,4 @@ export declare const taskName: (task: Pick<ActionTask, "namespace" | "action">)
  * name is unreachable from any document, and one shadowing a built-in silently changes what every existing action
  * in that deployment does. Both are invisible until a run misbehaves in production.
  */
-export declare const createTaskRegistry: (custom?: ActionTask<never>[], hasDbDrivers?: boolean) => ActionTaskRegistry;
+export declare const createTaskRegistry: (custom?: ActionTask<never>[], { db }?: TaskRegistryOptions) => ActionTaskRegistry;

package/dist/modules/actions/tasks/registry.js

@@ -11,9 +11,9 @@ var reservedNamespaces = new Set([...builtinTasks, ...dbTasks].map((task) => tas
 * name is unreachable from any document, and one shadowing a built-in silently changes what every existing action
 * in that deployment does. Both are invisible until a run misbehaves in production.
 */
-var createTaskRegistry = (custom = [], hasDbDrivers = false) => {
+var createTaskRegistry = (custom = [], { db = false } = {}) => {
 	const tasks = /* @__PURE__ */ new Map();
-	(hasDbDrivers ? [...builtinTasks, ...dbTasks] : builtinTasks).forEach((task) => tasks.set(taskName(task), {
+	(db ? [...builtinTasks, ...dbTasks] : builtinTasks).forEach((task) => tasks.set(taskName(task), {
 		...task,
 		name: taskName(task)
 	}));

package/dist/modules/actions/transport/catalogHandler.d.ts

@@ -9,7 +9,7 @@ export type ActionCatalogDeps = {
  *
  * The editor asks the SERVER what steps exist instead of holding a hardcoded list, and that is the whole reason a
  * self-hoster's own task appears in their builder with no fork: registering it is publishing it. It also means a
- * deployment with no mail transport never offers `email.send` — the catalog is what that deployment actually has,
+ * deployment with no database driver never offers `db.query` — the catalog is what that deployment actually has,
  * not what the SDK could imagine.
  *
  * Session-gated by the pipeline: the catalog names a deployment's server-side capabilities, which is not something

package/dist/modules/actions/transport/catalogHandler.js

@@ -5,7 +5,7 @@ import { describeCatalog } from "../taskCatalog.js";
 *
 * The editor asks the SERVER what steps exist instead of holding a hardcoded list, and that is the whole reason a
 * self-hoster's own task appears in their builder with no fork: registering it is publishing it. It also means a
-* deployment with no mail transport never offers `email.send` — the catalog is what that deployment actually has,
+* deployment with no database driver never offers `db.query` — the catalog is what that deployment actually has,
 * not what the SDK could imagine.
 *
 * Session-gated by the pipeline: the catalog names a deployment's server-side capabilities, which is not something

package/dist/modules/actions/types.d.ts

@@ -1,4 +1,5 @@
-import { ActionEntry, ActionLimits, ActionRejectRecord, ActionRunRecord, ActionRunStatus, ActionTriggerType, ConnectorManifest, Environment, InteractionCallbackParam, InteractionNode, InteractionNodeStatus, SpaceRevision, SSRUser } from '@plitzi/sdk-shared';
+import { ActionEmailSender } from './runtime/email';
+import { ActionEmailConfig, ActionEntry, ActionLimits, ActionRejectRecord, ActionRunRecord, ActionRunStatus, ActionTriggerType, ConnectorManifest, Environment, InteractionCallbackParam, InteractionNode, InteractionNodeStatus, SpaceRevision, SSRUser } from '@plitzi/sdk-shared';
 /** Resolved secret material, as the connector engine already models it. */
 export type ActionCredential = Record<string, string>;
 /**
@@ -109,6 +110,8 @@ export type ActionTaskContext = {
     kv: ActionKvStore;
     /** The database engines this deployment registered, for the `db.query` task. */
     dbDrivers: ActionDbDriver[];
+    /** How `email.send` reaches a space's SMTP server, under the deployment's limits. */
+    email: ActionEmailSender;
     /** Pushes a `data` frame to a streaming caller. A no-op when nobody negotiated a stream. */
     emit: (chunk: unknown) => void;
 };
@@ -162,6 +165,8 @@ export type ActionsConfig = {
     };
     /** Database engines this deployment lets a flow reach. Empty → the `db.query` task is not offered at all. */
     dbDrivers?: ActionDbDriver[];
+    /** The limits on `email.send`: messages per space per day, and whether an SMTP host may be on a private network. */
+    email?: ActionEmailConfig;
     /**
      * Called once per run that started, for a deployment that keeps a record.
      *
@@ -197,7 +202,7 @@ export type ActionsConfig = {
 };
 /** Re-exported so the module's own files import one place, and a deployment writing an `onRun` or an `onReject`
  *  sees the same shapes the module emits. */
-export type { ActionRejectRecord, ActionRunRecord } from '@plitzi/sdk-shared';
+export type { ActionEmailConfig, ActionEmailDelivery, ActionEmailMessage, ActionEmailTransport, ActionRejectRecord, ActionRunRecord } from '@plitzi/sdk-shared';
 export type ResolvedActionLimits = Required<ActionLimits>;
 export type ActionRunRequest = {
     entry: ActionEntry;

package/dist/modules/connectors/engine.js

@@ -1,5 +1,5 @@
-import { getByPath } from "./getByPath.js";
 import { assertOutboundAllowed } from "../../helpers/outboundGuard.js";
+import { getByPath } from "./getByPath.js";
 import { processTwig } from "@plitzi/sdk-shared/helpers/twigWrapper";
 import { BODYLESS_METHODS, DEFAULT_READ_ENDPOINT, EMPTY_RESPONSE_METHODS } from "@plitzi/sdk-shared/connectors";
 //#region src/modules/connectors/engine.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-server",
-  "version": "0.35.3",
+  "version": "0.35.5",
   "license": "AGPL-3.0",
   "files": [
     "dist",
@@ -58,11 +58,12 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@plitzi/plitzi-sdk": "0.35.3",
-    "@plitzi/sdk-shared": "0.35.3",
+    "@plitzi/plitzi-sdk": "0.35.5",
+    "@plitzi/sdk-shared": "0.35.5",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.2",
-    "jsonwebtoken": "^9.0.3"
+    "jsonwebtoken": "^9.0.3",
+    "nodemailer": "^10.0.9"
   },
   "peerDependencies": {
     "mysql2": "^3",
@@ -78,6 +79,7 @@
     "@types/ejs": "^3.1.5",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^26.5.1",
+    "@types/nodemailer": "^8.0.1",
     "@types/react": "^19.3.0",
     "@vitejs/plugin-react": "^6.1.1",
     "@vitest/coverage-v8": "^5.0.0",