Fold render into one module and export renderMany

AGENTS.md

@@ -32,9 +32,8 @@ ESLint and Prettier both run in CI. Tests are Vitest, not Jest. `markup-generato
 ```
 src/index.ts                      public exports only — consumers import the package root
 src/runtime/types.ts              template, context, and trace types
-src/runtime/render.ts             public re-exports
-src/runtime/renderTemplate.ts     renderTemplate from @llazyemail/render-template
-src/runtime/api.ts                defineTemplate, slot, hasSlot
+src/runtime/render.ts             defineTemplate, renderTemplate, renderMany
+src/runtime/api.ts                slot, hasSlot
 src/runtime/errors.ts             DisplayError, codes, and message catalog
 src/runtime/explain.ts            explain()
 src/templates/email/email.ts      defineEmailTemplate, renderEmail

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llazyemail/template-runtime-display",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Standalone runtime that renders a whole HTML email from named parts and records which part broke.",
   "type": "module",
   "license": "MIT",

src/index.ts

@@ -2,12 +2,12 @@ export {
   defineTemplate,
   displayErrors,
   hasSlot,
+  renderMany,
   renderTemplate,
   slot,
   DisplayError,
   DisplayErrorCode,
 } from './runtime/render';
-export { renderMany, RenderError } from '@llazyemail/render-template';
 export type {
   PartFailure,
   PartStatus,
@@ -19,6 +19,7 @@ export type {
   TemplatePart,
 } from './runtime/types';
 export type { RenderJob, RenderOptions } from '@llazyemail/render-template';
+export { RenderError } from '@llazyemail/render-template';
 export { explain } from './runtime/explain';
 
 export { defineEmailTemplate, renderEmail } from './templates/email/email';

src/runtime/api.ts

@@ -1,24 +1,8 @@
-import { assertTemplate, type Template as PackageTemplate } from '@llazyemail/render-template';
-import type { RenderContext, Template } from './types';
+import type { RenderContext } from './types';
 import { displayErrors } from './errors';
 
 export { DisplayError, DisplayErrorCode, displayErrors } from './errors';
 
-/**
- * Validate, copy, and freeze a template. Later edits to the caller's part
- * array do not change a template that has already been defined.
- */
-export function defineTemplate<TProps>(template: Template<TProps>): Template<TProps> {
-  assertTemplate(template as PackageTemplate<TProps>);
-  return Object.freeze({
-    id: template.id,
-    parts: Object.freeze(
-      template.parts.map((part) => Object.freeze({ id: part.id, render: part.render })),
-    ),
-    compose: template.compose,
-  });
-}
-
 /** Read a slot. A missing slot is `''`. A function slot is called with the same context. */
 export function slot<TProps>(ctx: RenderContext<TProps>, id: string): string {
   if (!hasSlot(ctx, id)) return '';

src/runtime/render.ts

@@ -1,9 +1,44 @@
-export { renderTemplate } from './renderTemplate';
-export {
-  defineTemplate,
-  hasSlot,
-  slot,
-  DisplayError,
-  DisplayErrorCode,
-  displayErrors,
-} from './api';
+import {
+  assertTemplate,
+  renderMany,
+  renderTemplate as renderPackageTemplate,
+  type RenderOptions,
+  type RenderResult as PackageRenderResult,
+  type Template as PackageTemplate,
+} from '@llazyemail/render-template';
+import type { RenderResult, Template } from './types';
+
+export { renderMany };
+
+export { hasSlot, slot, DisplayError, DisplayErrorCode, displayErrors } from './api';
+
+/**
+ * Validate, copy, and freeze a template. Later edits to the caller's part
+ * array do not change a template that has already been defined.
+ */
+export function defineTemplate<TProps>(template: Template<TProps>): Template<TProps> {
+  assertTemplate(template as PackageTemplate<TProps>);
+  return Object.freeze({
+    id: template.id,
+    parts: Object.freeze(
+      template.parts.map((part) => Object.freeze({ id: part.id, render: part.render })),
+    ),
+    compose: template.compose,
+  });
+}
+
+/**
+ * Render one template. The same template and props produce the same HTML.
+ * The runtime keeps no state between calls.
+ */
+export function renderTemplate<TProps>(
+  template: Template<TProps>,
+  props: TProps,
+  options: RenderOptions<TProps> = {},
+): RenderResult {
+  return renderPackageTemplate(
+    template as PackageTemplate<TProps>,
+    props,
+    options,
+  ) as PackageRenderResult as RenderResult;
+}