@@ -0,0 +1,21 @@
+---
+'@objectstack/plugin-email': patch
+'@objectstack/service-messaging': patch
+---
+
+fix(plugin-email, service-messaging)!: retire the render exports that take a template body with no save moment (`renderTemplate`, `renderNotification`, `interpolate`)
+
+The hole-placement rule is judged where a template is saved or registered: the `sys_notification_template` save hooks, and the authoring rule for email templates. Three exports took a template body inline and rendered it at once, with no save moment, so the rule could not see them. They leave the two packages' published entries. Nothing in this repository imported them from either entry. The renderers stay inside the packages: the mail service and the email and sms channels still render every stored template through them, unchanged.
+
+Clause-②: no (narrowing)
+Metadata-protocol: none
+
+<!-- adr-0087: not-required (runtime-export-retired @objectstack/plugin-email#renderTemplate, @objectstack/service-messaging#renderNotification, @objectstack/service-messaging#interpolate) Three runtime functions leave two published package entries; no key of any metadata schema, no object definition and no stored shape is added, removed, renamed or re-shaped, so there is nothing for `objectstack migrate meta` to rewrite and no tombstone. A TypeScript consumer meets the break at its own import, and the lines below name the door to use instead. -->
+
+**BREAKING** (three runtime exports are removed). It ships as `patch` because the metadata protocol does not move. There is no staged window.
+
+- FROM `renderTemplate` imported from `@objectstack/plugin-email` TO a template saved or registered as an `email_template` and rendered by name through the mail service: `renderTemplate({ template, data, locale })` on the `email` service (render only) or `sendTemplate` (render and send).
+- FROM `renderNotification` imported from `@objectstack/service-messaging` TO a `sys_notification_template` row for the topic, channel and locale, which the delivering channel renders when the notification is emitted.
+- FROM `interpolate` imported from `@objectstack/service-messaging` TO the subject or plain-text body of a `sys_notification_template` row, rendered the same way by the delivering channel.
+
+Unchanged: `requireVars` and `htmlToText` in `@objectstack/plugin-email`, and the mail service's `setTemplateLoader`; `NotificationTemplateStore`, `TEMPLATE_OBJECT`, `DEFAULT_LOCALE` and the template types in `@objectstack/service-messaging`; and how every stored template renders.
@@ -85,7 +85,12 @@ export {
   type AttachmentReclaimOutcome,
   type ReclaimAttachmentContentOptions,
 } from './attachment-reclaim.js';
-export { renderTemplate, requireVars, htmlToText } from './template-engine.js';
+// [#25190] `renderTemplate` (the HTML-face renderer) is not on this entry: it
+// took a template body inline and rendered it with no save moment, so the
+// hole-placement rule judged where a template is saved or registered could not
+// see it (ruling 6335348115 on #25082, F2 B3). A template is rendered from the
+// mail service by NAME: `IEmailService.renderTemplate` / `sendTemplate`.
+export { requireVars, htmlToText } from './template-engine.js';
 export {
   ResendTransport,
   PostmarkTransport,
 
@@ -0,0 +1,49 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * #25190 — `renderTemplate`, the HTML-face renderer that took a template body
+ * inline, is retired from this package's published entry (ruling 6335348115 on
+ * #25082, F2 B3; ADR-0087 `runtime-export-retired`). The hole-placement rule is
+ * judged where a template is saved or registered, and a body handed straight to
+ * that function had neither moment, so it was the one door the rule could not
+ * see.
+ *
+ * Pinned both ways: the entry no longer names it (its two siblings from the same
+ * module stay), and a template still renders through the stored-template door —
+ * the mail service, by NAME — with every hole encoded for the HTML face.
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as entry from './index.js';
+import { EmailService, type EmailTemplateRow } from './email-service.js';
+
+describe('plugin-email entry: the body-taking renderer is retired (#25190)', () => {
+  it('the published entry does not export renderTemplate', () => {
+    expect('renderTemplate' in entry).toBe(false);
+  });
+
+  it('THE CONTROL: the entry still exports its siblings from the same module', () => {
+    expect(typeof entry.requireVars).toBe('function');
+    expect(typeof entry.htmlToText).toBe('function');
+  });
+
+  it('a stored template still renders by name through the mail service, holes encoded for HTML', async () => {
+    const row: EmailTemplateRow = {
+      name: 'deal.won',
+      locale: 'en-US',
+      subject: 'Deal won: {{deal.name}}',
+      body_html: '<p>Deal <b>{{deal.name}}</b> closed.</p>',
+      active: true,
+    };
+    const svc = new EmailService({
+      transport: { async send() { return { messageId: 'never' }; } },
+      defaultFrom: { address: 'no-reply@x.com' },
+      templateLoader: { async load(name) { return name === row.name ? row : null; } },
+    });
+
+    const out = await svc.renderTemplate({ template: 'deal.won', data: { deal: { name: 'A<b>' } } });
+
+    expect(out.subject).toBe('Deal won: A<b>');
+    expect(out.html).toBe('<p>Deal <b>A&lt;b&gt;</b> closed.</p>');
+  });
+});
@@ -87,10 +87,15 @@ export type {
 } from './notification-text.js';
 
 // Templates + renderer (ADR-0030 P3)
+//
+// [#25190] The renderer itself (`renderNotification`, and `interpolate`, its
+// plain-text face) is not on this entry: both took a template body inline and
+// rendered it with no save moment, so the hole-placement rule the template
+// object's save hooks run could not see them (ruling 6335348115 on #25082,
+// F2 B3). A notification template is a `sys_notification_template` row, judged
+// when it is saved and rendered by the channels that deliver it.
 export {
     NotificationTemplateStore,
-    renderNotification,
-    interpolate,
     TEMPLATE_OBJECT,
     DEFAULT_LOCALE,
 } from './template-renderer.js';
 
@@ -0,0 +1,81 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * #25190 — `renderNotification` and `interpolate`, the renderer that took a
+ * template body inline, are retired from this package's published entry
+ * (ruling 6335348115 on #25082, F2 B3; ADR-0087 `runtime-export-retired`). The
+ * hole-placement rule is judged by the `sys_notification_template` save hooks,
+ * and a body handed straight to either function was never saved, so they were
+ * the one door the rule could not see.
+ *
+ * Pinned both ways: the entry no longer names them (the template store and the
+ * channels stay), and a stored template row still renders through a channel
+ * built from the entry — the html body with every hole encoded, the subject
+ * (`interpolate`'s plain-text face) verbatim.
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as entry from './index.js';
+
+describe('service-messaging entry: the body-taking renderer is retired (#25190)', () => {
+  it('the published entry does not export renderNotification or interpolate', () => {
+    expect('renderNotification' in entry).toBe(false);
+    expect('interpolate' in entry).toBe(false);
+  });
+
+  it('THE CONTROL: the entry still exports the template store and the channels that render', () => {
+    expect(typeof entry.NotificationTemplateStore).toBe('function');
+    expect(entry.TEMPLATE_OBJECT).toBe('sys_notification_template');
+    expect(typeof entry.createEmailChannel).toBe('function');
+    expect(typeof entry.createSmsChannel).toBe('function');
+  });
+
+  it('a stored html template row still renders through the email channel', async () => {
+    const row = {
+      organization_id: 'org_1',
+      topic: 'deal.won',
+      channel: 'email',
+      locale: 'en',
+      is_active: true,
+      format: 'html',
+      subject: 'Won {{ payload.title }}',
+      body: '<h1>{{ payload.title }}</h1>',
+    };
+    const data = {
+      async findOne(object: string, query: any) {
+        const w = query?.where ?? {};
+        if (object === 'sys_user') return w.id === 'user_1' ? { email: 'ada@example.com' } : null;
+        if (object === entry.TEMPLATE_OBJECT) {
+          return row.organization_id === w.organization_id && row.topic === w.topic
+            && row.channel === w.channel && row.locale === w.locale ? row : null;
+        }
+        return null;
+      },
+    } as any;
+    const sent: any[] = [];
+    const ch = entry.createEmailChannel({
+      getEmail: () => ({ async send(input: any) { sent.push(input); return { id: 'email_row_1' }; } }) as any,
+      getData: () => data,
+      store: new entry.NotificationTemplateStore({ getData: () => data }),
+    });
+    const logger = { info: () => {}, warn: () => {}, error: () => {} };
+
+    const r = await ch.send({ logger } as any, {
+      channel: 'email',
+      recipient: 'user_1',
+      notification: {
+        notificationId: 'evt_1',
+        organizationId: 'org_1',
+        topic: 'deal.won',
+        title: 'A<b>',
+        body: '',
+        severity: 'info',
+        recipients: ['user_1'],
+        payload: { title: 'A<b>' },
+      },
+    } as any);
+
+    expect(r.ok).toBe(true);
+    expect(sent).toEqual([{ to: 'ada@example.com', subject: 'Won A<b>', html: '<h1>A&lt;b&gt;</h1>', organizationId: 'org_1' }]);
+  });
+});