@benclmnt/postmock 0.0.1

package/dist/src/api/templates/validate.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { apiError } from "../../errors.js";
+import { absent } from "../../http/normalize.js";
+import { mergeModels, parseTemplate, renderTemplate, suggestModel, } from "../../render/mustachio.js";
+import { checkInlineCss } from "./content.js";
+import { activeLayout, CONTENT_PARTS, layoutRuleError, parseOrReject, parseTemplateType, templateModelField, } from "./templates.js";
+// `POST /templates/validate` (docs/06 §3.3; refs/api_templates-api.md:779-887).
+const text = absent(z.string());
+const validateBody = z.object({
+    Subject: text,
+    HtmlBody: text,
+    TextBody: text,
+    TestRenderModel: templateModelField,
+    InlineCssForHtmlTestRender: absent(z.boolean()),
+    TemplateType: text,
+    LayoutTemplate: text,
+});
+export function validateTemplate(state, serverId, body) {
+    const input = parseOrReject(validateBody, body);
+    if (CONTENT_PARTS.every((part) => input[part] === undefined)) {
+        // refs/api_templates-api.md:813-815: one part is required. Code and text INFERRED.
+        throw apiError(1120, { message: "One of 'Subject', 'HtmlBody' or 'TextBody' is required." });
+    }
+    const type = parseTemplateType(input.TemplateType);
+    if (type === "Layout" && input.LayoutTemplate !== undefined) {
+        throw apiError(1123, { message: "A layout template cannot use a 'LayoutTemplate'." });
+    }
+    const layout = input.LayoutTemplate === undefined ? null : activeLayout(state, serverId, input.LayoutTemplate);
+    const parsed = new Map();
+    const results = new Map();
+    for (const part of CONTENT_PARTS) {
+        const source = input[part];
+        if (source === undefined)
+            continue;
+        const result = parseTemplate(source);
+        const ruleError = result.ok
+            ? layoutRuleError(type, part, result.template.contentPlaceholders)
+            : undefined;
+        if (!result.ok || ruleError !== undefined) {
+            // RenderedContent is null for invalid content (INFERRED, docs/06 Q7).
+            const errors = result.ok
+                ? [{ Message: ruleError ?? "", Line: null, CharacterPosition: null }]
+                : result.errors;
+            results.set(part, { ContentIsValid: false, ValidationErrors: errors, RenderedContent: null });
+        }
+        else {
+            parsed.set(part, result.template);
+        }
+    }
+    // The layout's own keys join the suggestion (INFERRED).
+    const frames = new Map();
+    for (const part of ["HtmlBody", "TextBody"]) {
+        const source = layout?.[part] ?? null;
+        const frame = source === null ? undefined : parseTemplate(source);
+        if (frame?.ok)
+            frames.set(part, frame.template);
+    }
+    const SuggestedTemplateModel = mergeModels(suggestModel([...parsed.values(), ...frames.values()]), input.TestRenderModel ?? {});
+    for (const [part, template] of parsed) {
+        // A layout renders with an empty `{{{ @content }}}` (INFERRED).
+        let rendered = renderTemplate(template, SuggestedTemplateModel);
+        const frame = frames.get(part);
+        if (frame !== undefined)
+            rendered = renderTemplate(frame, SuggestedTemplateModel, rendered);
+        if (part === "HtmlBody")
+            checkInlineCss(rendered, input.InlineCssForHtmlTestRender ?? true);
+        results.set(part, { ContentIsValid: true, ValidationErrors: [], RenderedContent: rendered });
+    }
+    // A part not sent is null (INFERRED from sdk/postmark-python/tests/test_templates.py:374-375).
+    return {
+        AllContentIsValid: [...results.values()].every((r) => r.ContentIsValid),
+        HtmlBody: results.get("HtmlBody") ?? null,
+        TextBody: results.get("TextBody") ?? null,
+        Subject: results.get("Subject") ?? null,
+        SuggestedTemplateModel,
+    };
+}

package/dist/src/api/triggers/routes.d.ts

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

package/dist/src/api/triggers/routes.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { apiError } from "../../errors.js";
+import { parseBody, queryInt } from "../../http/normalize.js";
+import { paged } from "../../http/respond.js";
+import { defineRoute } from "../../http/routes.js";
+// Inbound rule triggers (docs/05 §1.6). postmark.js and java spell the path `inboundRules`; route
+// literals match without case.
+const MAX_COUNT = 500;
+defineRoute({
+    method: "GET",
+    path: "/triggers/inboundrules",
+    auth: "server",
+    handler: ({ store, query, auth }) => {
+        const parsed = query.pick(z.object({ count: queryInt, offset: queryInt }));
+        // 800 texts INFERRED from the docs/02 §4.4 summary.
+        if (!parsed.success || parsed.data.count < 0 || parsed.data.offset < 0) {
+            throw apiError(800, {
+                message: "The 'count' and 'offset' parameters are required integers.",
+            });
+        }
+        const { count, offset } = parsed.data;
+        if (count > MAX_COUNT) {
+            throw apiError(800, { message: "You may only request up to 500 triggers per call." });
+        }
+        const rules = [...store.state.inboundRules.values()]
+            .filter((r) => r.ServerID === auth.server.ID)
+            .map((r) => ({ ID: r.ID, Rule: r.Rule }));
+        return paged("InboundRules", rules, count, offset);
+    },
+});
+defineRoute({
+    method: "POST",
+    path: "/triggers/inboundrules",
+    auth: "server",
+    handler: ({ store, body, auth }) => {
+        const parsed = parseBody(z.object({ Rule: z.string().trim().min(1) }), body);
+        // A rule is an address or a domain (refs/api_inbound-rules-triggers-api.md:98); postmock checks
+        // no form (INFERRED).
+        if (!parsed.success)
+            throw apiError(809);
+        const rule = parsed.data.Rule;
+        const rules = [...store.state.inboundRules.values()].filter((r) => r.ServerID === auth.server.ID);
+        if (rules.some((r) => r.Rule.toLowerCase() === rule.toLowerCase()))
+            throw apiError(810);
+        const created = { ID: store.nextId("inboundRule"), ServerID: auth.server.ID, Rule: rule };
+        store.state.inboundRules.set(created.ID, created);
+        return { ID: created.ID, Rule: created.Rule };
+    },
+});
+defineRoute({
+    method: "DELETE",
+    path: "/triggers/inboundrules/:id",
+    auth: "server",
+    handler: ({ store, params, auth }) => {
+        const id = /^\d+$/.test(params.id ?? "") ? Number(params.id) : undefined;
+        const rule = id === undefined ? undefined : store.state.inboundRules.get(id);
+        if (rule === undefined || rule.ServerID !== auth.server.ID)
+            throw apiError(812);
+        store.state.inboundRules.delete(rule.ID);
+        return { ErrorCode: 0, Message: `Rule ${rule.Rule} removed.` };
+    },
+});

package/dist/src/api/webhooks/routes.d.ts

@@ -0,0 +1,14 @@
+import type { Webhook, WebhookTriggers } from "../../state/types.ts";
+/** The wire shape (refs/api_webhooks-api.md:155-227). No auth or headers: `null` and `[]` (INFERRED). */
+export declare const webhookJson: (w: Webhook) => {
+    ID: number;
+    Url: string;
+    MessageStream: string;
+    Status: "unverified" | "verified";
+    HttpAuth: {
+        Username: string;
+        Password: string;
+    } | null;
+    HttpHeaders: import("../../state/types.ts").Header[];
+    Triggers: WebhookTriggers;
+};

package/dist/src/api/webhooks/routes.js

@@ -0,0 +1,192 @@
+import { z } from "zod";
+import { apiError } from "../../errors.js";
+import { parseBody } from "../../http/normalize.js";
+import { Unsupported } from "../../http/respond.js";
+import { defineRoute } from "../../http/routes.js";
+import { streamKey } from "../../state/store.js";
+// The webhooks API (docs/05 §1.1–1.4). Errors are ErrorCodes 1350–1364.
+const orNull = (schema) => z.preprocess((v) => (v === null ? undefined : v), schema.optional());
+const flag = orNull(z.boolean());
+const trigger = z.object({ Enabled: flag });
+const triggersSchema = z.object({
+    Open: orNull(z.object({ Enabled: flag, PostFirstOpenOnly: flag })),
+    Click: orNull(trigger),
+    Delivery: orNull(trigger),
+    Bounce: orNull(z.object({ Enabled: flag, IncludeContent: flag })),
+    SpamComplaint: orNull(z.object({ Enabled: flag, IncludeContent: flag })),
+    SubscriptionChange: orNull(trigger),
+});
+const bodySchema = z.object({
+    ID: orNull(z.unknown()),
+    Status: orNull(z.unknown()),
+    Url: orNull(z.string()),
+    MessageStream: orNull(z.string()),
+    HttpAuth: orNull(z.object({ Username: z.string(), Password: z.string() })),
+    HttpHeaders: orNull(z.array(z.object({ Name: z.string(), Value: z.string() }))),
+    Triggers: orNull(triggersSchema),
+    Verify: orNull(z.boolean()),
+});
+function parse(body) {
+    if (body === undefined)
+        throw apiError(1355);
+    const parsed = parseBody(bodySchema, body);
+    if (!parsed.success)
+        throw apiError(1361);
+    const data = parsed.data;
+    if (data.Status !== undefined)
+        throw apiError(1363);
+    // `Verify` absent or true saves with no probe (INFERRED until docs/05 Q13 captures the probe):
+    // SDK live tests create webhooks at hosts that answer no probe (docs/05 §1.3 conflict V1).
+    const url = data.Url;
+    if (url !== undefined && !isWebhookUrl(url))
+        throw apiError(1354);
+    // An HTTP header name is an RFC 9110 token.
+    if (data.HttpHeaders?.some((h) => !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(h.Name))) {
+        throw apiError(1358);
+    }
+    return data;
+}
+function isWebhookUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+const FALSE_TRIGGERS = {
+    Open: { Enabled: false, PostFirstOpenOnly: false },
+    Click: { Enabled: false },
+    Delivery: { Enabled: false },
+    Bounce: { Enabled: false, IncludeContent: false },
+    SpamComplaint: { Enabled: false, IncludeContent: false },
+    SubscriptionChange: { Enabled: false },
+};
+/** A partial `Triggers` object changes only the given triggers and sub-fields (docs/05 §1.2). */
+function mergeTriggers(current, patch) {
+    const merged = structuredClone(current);
+    for (const [name, fields] of Object.entries(patch ?? {})) {
+        if (fields === undefined)
+            continue;
+        const target = merged[name];
+        for (const [field, value] of Object.entries(fields)) {
+            if (typeof value === "boolean")
+                target[field] = value;
+        }
+    }
+    return merged;
+}
+/** The wire shape (refs/api_webhooks-api.md:155-227). No auth or headers: `null` and `[]` (INFERRED). */
+export const webhookJson = (w) => ({
+    ID: w.ID,
+    Url: w.Url,
+    MessageStream: w.MessageStream,
+    Status: w.Status,
+    HttpAuth: w.HttpAuth,
+    HttpHeaders: w.HttpHeaders,
+    Triggers: w.Triggers,
+});
+function findWebhook({ store, params, auth }) {
+    const id = /^\d+$/.test(params.id ?? "") ? Number(params.id) : undefined;
+    const webhook = id === undefined ? undefined : store.state.webhooks.get(id);
+    if (webhook === undefined || webhook.ServerID !== auth.server.ID)
+        throw apiError(1352);
+    return webhook;
+}
+defineRoute({
+    method: "GET",
+    path: "/webhooks",
+    auth: "server",
+    handler: ({ store, query, auth }) => {
+        // Doc spells the filter `MessageStream`, postmark.js `messageStream`; the query matches both.
+        const stream = query.get("MessageStream");
+        const webhooks = [...store.state.webhooks.values()].filter((w) => w.ServerID === auth.server.ID && (stream === undefined || w.MessageStream === stream));
+        return { Webhooks: webhooks.map(webhookJson) };
+    },
+});
+defineRoute({
+    method: "GET",
+    path: "/webhooks/:id",
+    auth: "server",
+    handler: (ctx) => webhookJson(findWebhook(ctx)),
+});
+defineRoute({
+    method: "POST",
+    path: "/webhooks",
+    auth: "server",
+    handler: ({ store, body, auth }) => {
+        const data = parse(body);
+        if (data.ID !== undefined)
+            throw apiError(1356);
+        if (data.Url === undefined)
+            throw apiError(1354);
+        const streamId = data.MessageStream ?? "outbound";
+        const stream = store.state.streams.get(streamKey(auth.server.ID, streamId));
+        // No webhooks ErrorCode names an unknown stream; 1226 is the streams API text (INFERRED).
+        if (stream === undefined)
+            throw apiError(1226, { family: "streams" });
+        if (stream.ArchivedAt !== null)
+            throw apiError(1350);
+        if (stream.MessageStreamType === "Inbound")
+            throw apiError(1351);
+        const webhook = {
+            ID: store.nextId("webhook"),
+            ServerID: auth.server.ID,
+            Url: data.Url,
+            MessageStream: stream.ID,
+            Status: data.Verify === false ? "unverified" : "verified",
+            HttpAuth: data.HttpAuth ?? null,
+            HttpHeaders: data.HttpHeaders ?? [],
+            Triggers: mergeTriggers(FALSE_TRIGGERS, data.Triggers),
+        };
+        store.state.webhooks.set(webhook.ID, webhook);
+        return webhookJson(webhook);
+    },
+});
+defineRoute({
+    method: "PUT",
+    path: "/webhooks/:id",
+    auth: "server",
+    handler: (ctx) => {
+        const webhook = findWebhook(ctx);
+        const data = parse(ctx.body);
+        if ((data.ID !== undefined && data.ID !== webhook.ID) ||
+            (data.MessageStream !== undefined && data.MessageStream !== webhook.MessageStream)) {
+            throw apiError(1357);
+        }
+        Object.assign(webhook, {
+            ...(data.Url !== undefined && { Url: data.Url }),
+            ...(data.HttpAuth !== undefined && { HttpAuth: data.HttpAuth }),
+            ...(data.HttpHeaders !== undefined && { HttpHeaders: data.HttpHeaders }),
+            ...(data.Verify === false && { Status: "unverified" }),
+            Triggers: mergeTriggers(webhook.Triggers, data.Triggers),
+        });
+        return webhookJson(webhook);
+    },
+});
+defineRoute({
+    method: "DELETE",
+    path: "/webhooks/:id",
+    auth: "server",
+    handler: (ctx) => {
+        const webhook = findWebhook(ctx);
+        ctx.store.state.webhooks.delete(webhook.ID);
+        return { ErrorCode: 0, Message: `Webhook ${webhook.ID} removed.` };
+    },
+});
+// No SDK calls these; their probe body (Q13) and slow thresholds (Q19) are not captured.
+for (const [method, path, question] of [
+    ["POST", "/webhooks/:id/verify", "Q13"],
+    ["GET", "/webhooks/:id/statistics", "Q19"],
+]) {
+    defineRoute({
+        method,
+        path,
+        auth: "server",
+        handler: (ctx) => {
+            findWebhook(ctx);
+            throw new Unsupported(`${method} ${path} not captured (docs/05 ${question})`);
+        },
+    });
+}

package/dist/src/config.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import type { PostmockConfig } from "./server.ts";
+/** Every setting is one of these env keys. Plugins read their own keys when they start. */
+export declare const ENV_KEYS: readonly ["POSTMOCK_HOST", "POSTMOCK_API_PORT", "POSTMOCK_CONTROL_PORT", "POSTMOCK_SEED", "POSTMOCK_HTTPS_PORT", "POSTMOCK_HTTPS_TLS_KEY", "POSTMOCK_HTTPS_TLS_CERT", "POSTMOCK_SMTP_PORTS", "POSTMOCK_SMTP_TLS_KEY", "POSTMOCK_SMTP_TLS_CERT", "POSTMOCK_WEBHOOKS_ALLOW_HOSTS"];
+export declare const flagOf: (key: string) => string;
+export declare const USAGE: string;
+/**
+ * Writes each flag in `argv` into `env` under its key, so plugins that read `process.env` see it.
+ * Returns `help` for `--help`. An unknown flag, a positional argument, or an empty value throws.
+ */
+export declare function applyFlags(argv: string[], env: NodeJS.ProcessEnv): "help" | "run";
+/** A decimal TCP port; `0` picks a free port. */
+export declare const portSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodInt>;
+/** The content of the PEM file that env key `key` names. */
+export declare function readPem(key: string, path: string): string;
+/** The core listeners' config from env. A bad value throws. */
+export declare function configFromEnv(env: NodeJS.ProcessEnv): PostmockConfig;

package/dist/src/config.js

@@ -0,0 +1,95 @@
+import { existsSync, readFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { z } from "zod";
+/** Every setting is one of these env keys. Plugins read their own keys when they start. */
+export const ENV_KEYS = [
+    "POSTMOCK_HOST",
+    "POSTMOCK_API_PORT",
+    "POSTMOCK_CONTROL_PORT",
+    "POSTMOCK_SEED",
+    "POSTMOCK_HTTPS_PORT",
+    "POSTMOCK_HTTPS_TLS_KEY",
+    "POSTMOCK_HTTPS_TLS_CERT",
+    "POSTMOCK_SMTP_PORTS",
+    "POSTMOCK_SMTP_TLS_KEY",
+    "POSTMOCK_SMTP_TLS_CERT",
+    "POSTMOCK_WEBHOOKS_ALLOW_HOSTS",
+];
+export const flagOf = (key) => key.slice("POSTMOCK_".length).toLowerCase().replaceAll("_", "-");
+export const USAGE = [
+    "usage: postmock [--<flag> <value>]...",
+    "Each flag sets an env key; a flag wins over the env:",
+    ...ENV_KEYS.map((key) => `  --${flagOf(key).padEnd(22)} ${key}`),
+].join("\n");
+/**
+ * Writes each flag in `argv` into `env` under its key, so plugins that read `process.env` see it.
+ * Returns `help` for `--help`. An unknown flag, a positional argument, or an empty value throws.
+ */
+export function applyFlags(argv, env) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            help: { type: "boolean" },
+            ...Object.fromEntries(ENV_KEYS.map((key) => [flagOf(key), { type: "string" }])),
+        },
+    });
+    if (values.help)
+        return "help";
+    for (const key of ENV_KEYS) {
+        const value = values[flagOf(key)];
+        if (typeof value === "string")
+            env[key] = value;
+    }
+    for (const key of ENV_KEYS) {
+        if (env[key] === "")
+            throw new Error(`${key} is empty; unset it or give a value`);
+    }
+    return "run";
+}
+/** A decimal TCP port; `0` picks a free port. */
+export const portSchema = z
+    .string()
+    .regex(/^\d+$/, "a decimal port")
+    .transform(Number)
+    .pipe(z.int().max(65535));
+/** The content of the PEM file that env key `key` names. */
+export function readPem(key, path) {
+    if (!existsSync(path))
+        throw new Error(`${key}: no file at ${path}`);
+    return readFileSync(path, "utf8");
+}
+const envSchema = z.object({
+    POSTMOCK_HOST: z.string().min(1).default("127.0.0.1"),
+    POSTMOCK_API_PORT: portSchema.default(8080),
+    POSTMOCK_CONTROL_PORT: portSchema.default(8025),
+    POSTMOCK_SEED: z.string().min(1).default("empty"),
+    POSTMOCK_HTTPS_PORT: portSchema.optional(),
+    POSTMOCK_HTTPS_TLS_KEY: z.string().min(1).optional(),
+    POSTMOCK_HTTPS_TLS_CERT: z.string().min(1).optional(),
+});
+/** The core listeners' config from env. A bad value throws. */
+export function configFromEnv(env) {
+    const e = envSchema.parse(env);
+    const config = {
+        host: e.POSTMOCK_HOST,
+        apiPort: e.POSTMOCK_API_PORT,
+        controlPort: e.POSTMOCK_CONTROL_PORT,
+        seed: e.POSTMOCK_SEED,
+    };
+    const https = [e.POSTMOCK_HTTPS_PORT, e.POSTMOCK_HTTPS_TLS_KEY, e.POSTMOCK_HTTPS_TLS_CERT];
+    if (https.every((v) => v === undefined))
+        return config;
+    if (e.POSTMOCK_HTTPS_PORT === undefined ||
+        e.POSTMOCK_HTTPS_TLS_KEY === undefined ||
+        e.POSTMOCK_HTTPS_TLS_CERT === undefined) {
+        throw new Error("set POSTMOCK_HTTPS_PORT, POSTMOCK_HTTPS_TLS_KEY and POSTMOCK_HTTPS_TLS_CERT, or none");
+    }
+    return {
+        ...config,
+        https: {
+            port: e.POSTMOCK_HTTPS_PORT,
+            key: readPem("POSTMOCK_HTTPS_TLS_KEY", e.POSTMOCK_HTTPS_TLS_KEY),
+            cert: readPem("POSTMOCK_HTTPS_TLS_CERT", e.POSTMOCK_HTTPS_TLS_CERT),
+        },
+    };
+}

package/dist/src/control/app.d.ts

@@ -0,0 +1,5 @@
+import { Hono } from "hono";
+import "./index.ts";
+import type { Runtime } from "../runtime.ts";
+/** The test-facing control API on its own port (docs/09 §3, §5). */
+export declare function createControlApp(runtime: Runtime, startupSeed: string): Hono;

package/dist/src/control/app.js

@@ -0,0 +1,42 @@
+import { Hono } from "hono";
+import "./index.js";
+import { textResponse, toJson } from "../http/respond.js";
+import { ControlError, controlRoutes } from "./registry.js";
+const json = (status, body) => new Response(toJson(body), { status, headers: { "Content-Type": "application/json" } });
+/** The test-facing control API on its own port (docs/09 §3, §5). */
+export function createControlApp(runtime, startupSeed) {
+    const app = new Hono();
+    app.all("*", async (c) => {
+        const url = new URL(c.req.url);
+        const matched = controlRoutes.match(c.req.method, url.pathname);
+        if (!matched)
+            return json(404, { error: `no control route ${c.req.method} ${url.pathname}` });
+        let body;
+        try {
+            body = JSON.parse(new TextDecoder().decode(await c.req.arrayBuffer()) || "null") ?? undefined;
+        }
+        catch {
+            return json(400, { error: "body is not JSON" });
+        }
+        try {
+            const result = await matched.route.handler({
+                ...runtime,
+                params: matched.params,
+                query: url.searchParams,
+                body,
+                startupSeed,
+            });
+            return json(200, result);
+        }
+        catch (error) {
+            if (error instanceof ControlError)
+                return json(400, { error: error.message });
+            throw error;
+        }
+    });
+    app.onError((error) => {
+        console.error(error);
+        return textResponse(500, `postmock crashed: ${error.stack ?? error.message}`);
+    });
+    return app;
+}

package/dist/src/control/endpoints/account.d.ts

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

package/dist/src/control/endpoints/account.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { confirmDkim } from "../../api/account/authentication.js";
+import { domainJson } from "../../api/account/domains.js";
+import { pathId } from "../../api/account/paging.js";
+import { senderJson } from "../../api/account/senders.js";
+import { ControlError, controlInput, defineControl } from "../registry.js";
+// Account events postmock cannot observe: a support decision, DNS records, a click on a confirmation link.
+defineControl({
+    method: "POST",
+    path: "/control/account/server-deletion",
+    handler: ({ store, body }) => {
+        const { enabled } = controlInput(z.object({ enabled: z.boolean() }), body);
+        store.state.account.serverDeletionEnabled = enabled;
+        return { serverDeletionEnabled: enabled };
+    },
+});
+const verifyInput = z
+    .object({ dkim: z.literal(true).optional(), returnPath: z.literal(true).optional() })
+    .refine((v) => v.dkim || v.returnPath, "set dkim or returnPath to true");
+/**
+ * Postmark finds the DNS records: the pending DKIM key becomes active, the Return-Path CNAME
+ * points to `pm.mtasv.net`. It never finds a record for a key or Return-Path that does not exist.
+ */
+function verify(auth, body) {
+    const { dkim, returnPath } = controlInput(verifyInput, body);
+    if (dkim && auth.DKIMUpdateStatus !== "Pending")
+        throw new ControlError("no pending DKIM key");
+    if (returnPath && auth.ReturnPathDomain === "")
+        throw new ControlError("no ReturnPathDomain set");
+    if (dkim)
+        confirmDkim(auth);
+    if (returnPath)
+        auth.ReturnPathDomainVerified = true;
+}
+const found = (item, what) => {
+    if (item === undefined)
+        throw new ControlError(`${what} not found`);
+    return item;
+};
+defineControl({
+    method: "POST",
+    path: "/control/domains/:id/verify",
+    handler: ({ store, params, body }) => {
+        const domain = found(store.state.domains.get(pathId(params.id) ?? -1), "domain");
+        verify(domain, body);
+        return domainJson(domain);
+    },
+});
+defineControl({
+    method: "POST",
+    path: "/control/senders/:id/verify",
+    handler: ({ store, params, body }) => {
+        const sender = found(store.state.senders.get(pathId(params.id) ?? -1), "sender");
+        verify(sender, body);
+        return senderJson(sender);
+    },
+});
+defineControl({
+    method: "POST",
+    path: "/control/senders/:id/confirm",
+    handler: ({ store, params }) => {
+        const sender = found(store.state.senders.get(pathId(params.id) ?? -1), "sender");
+        if (sender.Confirmed)
+            throw new ControlError("sender already confirmed");
+        sender.Confirmed = true;
+        return senderJson(sender);
+    },
+});

package/dist/src/control/endpoints/bulk.d.ts

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

package/dist/src/control/endpoints/bulk.js

@@ -0,0 +1,29 @@
+import { bulkStatusJson } from "../../api/bulk/bulk.js";
+import { ControlError, defineControl } from "../registry.js";
+// Postmark cancels a bulk request that has not finished (refs/api_bulk-email.md:190 `Cancelled`).
+// The messages not yet released stay unsent; the counters keep their values.
+defineControl({
+    method: "POST",
+    path: "/control/bulk/:id/cancel",
+    handler: ({ store, params }) => {
+        const bulk = store.state.bulkRequests.get(params.id ?? "");
+        if (bulk === undefined)
+            throw new ControlError(`no bulk request '${params.id}'`);
+        if (bulk.Status !== "Accepted" && bulk.Status !== "Processing") {
+            throw new ControlError(`bulk request '${bulk.Id}' is ${bulk.Status}`);
+        }
+        bulk.Status = "Cancelled";
+        return bulkStatusJson(bulk);
+    },
+});
+// The bulk request as the API shows it, plus why processing stopped on uncaptured behavior.
+defineControl({
+    method: "GET",
+    path: "/control/bulk/:id",
+    handler: ({ store, params }) => {
+        const bulk = store.state.bulkRequests.get(params.id ?? "");
+        if (bulk === undefined)
+            throw new ControlError(`no bulk request '${params.id}'`);
+        return { ...bulkStatusJson(bulk), Unsupported: bulk.unsupported };
+    },
+});

package/dist/src/control/endpoints/core.d.ts

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