react-email-rails 0.1.0

package/bin/config.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { loadConfigFromFile } from "vite"
+
+const loaded = await loadConfigFromFile({ command: "serve", mode: process.env.NODE_ENV ?? "development" })
+const plugins = (loaded?.config?.plugins ?? []).flat(Infinity).filter(Boolean)
+const plugin = plugins.find((plugin) => plugin.name === "react-email-rails")
+const metadata = plugin?.[Symbol.for("react-email-rails.config")]
+
+if (!plugin) {
+  process.stderr.write("react-email-rails: reactEmailRails() plugin not found in the Vite config\n")
+  process.exit(1)
+}
+
+if (!metadata) {
+  process.stderr.write("react-email-rails: reactEmailRails() plugin metadata not found\n")
+  process.exit(1)
+}
+
+process.stdout.write(JSON.stringify(metadata))

package/bin/dev.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { createServer, isRunnableDevEnvironment, loadConfigFromFile } from "vite"
+import { RENDER_PROTOCOL_VERSION, VERSION } from "../dist/version.js"
+
+if (process.argv.includes("--health")) {
+  process.stdout.write(JSON.stringify({ ok: true, protocolVersion: RENDER_PROTOCOL_VERSION, packageVersion: VERSION }))
+  process.exit(0)
+}
+
+const toStderr = (message) => process.stderr.write(`${message}\n`)
+const logger = {
+  info: toStderr,
+  warn: toStderr,
+  warnOnce: toStderr,
+  error: toStderr,
+  clearScreen() {},
+  hasErrorLogged: () => false,
+  hasWarned: false,
+}
+
+// Load only this plugin and aliases; host dev-server plugins have global side effects.
+const loaded = await loadConfigFromFile({ command: "serve", mode: "development" })
+const userConfig = loaded?.config ?? {}
+const emailPlugin = (userConfig.plugins ?? [])
+  .flat(Infinity)
+  .find((plugin) => plugin?.name === "react-email-rails")
+
+if (!emailPlugin) {
+  process.stderr.write("react-email-rails: reactEmailRails() plugin not found in the Vite config\n")
+  process.exit(1)
+}
+
+// Forward config that affects how components resolve and compile (but not the
+// host's dev-server plugins, which have global side effects), so dev rendering
+// stays close to the production email bundle.
+const server = await createServer({
+  configFile: false,
+  resolve: userConfig.resolve,
+  define: userConfig.define,
+  css: userConfig.css,
+  esbuild: { jsx: "automatic" },
+  plugins: [emailPlugin],
+  server: { middlewareMode: true },
+  appType: "custom",
+  clearScreen: false,
+  customLogger: logger,
+})
+
+// Render through the same `email` environment the production build uses, so dev
+// and build resolve and compile components identically.
+const environment = server.environments.email
+if (!isRunnableDevEnvironment(environment)) {
+  await server.close()
+  process.stderr.write("react-email-rails: the email environment is not runnable\n")
+  process.exit(1)
+}
+
+try {
+  const { run } = await environment.runner.import("virtual:react-email-rails/server")
+  await run()
+} finally {
+  await server.close()
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from "vite";
+export type EmailsOption = string | {
+    path?: string;
+    extension?: string | string[];
+    ignore?: string | string[];
+};
+export type ReactEmailRailsOptions = {
+    emails?: EmailsOption;
+    standalone?: boolean;
+};
+export declare const EMAIL_ENVIRONMENT = "email";
+export declare function reactEmailRails(options?: ReactEmailRailsOptions): Plugin;
+export type { EmailModule, EmailRegistry, EmailRenderOptions, RenderedEmail, RenderRequest, } from "./runtime.js";
+export { RENDER_PROTOCOL_VERSION, VERSION } from "./version.js";

package/dist/index.js

@@ -0,0 +1,103 @@
+const DEFAULT_IGNORE = ["**/_*", "**/_*/**"];
+const DEFAULT_EXTENSIONS = [".tsx", ".jsx"];
+const VIRTUAL_SERVER = "virtual:react-email-rails/server";
+const VIRTUAL_MAIN = "virtual:react-email-rails/main";
+const RESOLVED_SERVER = `\0${VIRTUAL_SERVER}`;
+const RESOLVED_MAIN = `\0${VIRTUAL_MAIN}`;
+// The dedicated build environment that emits the server-side email bundle.
+export const EMAIL_ENVIRONMENT = "email";
+const CONFIG_SYMBOL = Symbol.for("react-email-rails.config");
+const OUT_DIR = "tmp/react-email-rails";
+const BUNDLE_FILE = "emails.js";
+export function reactEmailRails(options = {}) {
+    const emails = typeof options.emails === "string" ? { path: options.emails } : (options.emails ?? {});
+    const path = (emails.path ?? "app/javascript/emails").replace(/^\/|\/$/g, "");
+    const rawExtensions = emails.extension === undefined
+        ? DEFAULT_EXTENSIONS
+        : Array.isArray(emails.extension)
+            ? emails.extension
+            : [emails.extension];
+    const extensions = rawExtensions
+        .map((extension) => (extension.startsWith(".") ? extension : `.${extension}`))
+        .map((extension, index) => ({ extension, index }))
+        .sort((left, right) => right.extension.length - left.extension.length || left.index - right.index)
+        .map(({ extension }) => extension);
+    const standalone = options.standalone ?? true;
+    const root = `/${path}/`;
+    const pattern = extensions.length === 1 ? `${root}**/*${extensions[0]}` : `${root}**/*{${extensions.join(",")}}`;
+    const ignore = emails.ignore === undefined
+        ? DEFAULT_IGNORE
+        : Array.isArray(emails.ignore)
+            ? emails.ignore
+            : [emails.ignore];
+    const globPatterns = [pattern, ...ignore.map((glob) => `!${root}${glob}`)];
+    const globArg = JSON.stringify(globPatterns.length === 1 ? globPatterns[0] : globPatterns);
+    const plugin = {
+        name: "react-email-rails",
+        resolveId(id) {
+            if (id === VIRTUAL_SERVER)
+                return RESOLVED_SERVER;
+            if (id === VIRTUAL_MAIN)
+                return RESOLVED_MAIN;
+        },
+        load(id) {
+            if (id === RESOLVED_SERVER) {
+                return [
+                    `import { serve, toComponentName } from "react-email-rails/runtime"`,
+                    `const modules = import.meta.glob(${globArg})`,
+                    `const extensions = ${JSON.stringify(extensions)}`,
+                    `const registry = Object.create(null)`,
+                    `for (const path in modules) {`,
+                    `  const extension = extensions.find((extension) => path.endsWith(extension)) ?? path.slice(path.lastIndexOf("."))`,
+                    `  registry[toComponentName(path, ${JSON.stringify(root)}, extension)] = modules[path]`,
+                    `}`,
+                    `export const run = () => serve(registry)`,
+                ].join("\n");
+            }
+            if (id === RESOLVED_MAIN) {
+                return `import { run } from ${JSON.stringify(VIRTUAL_SERVER)}\nrun()\n`;
+            }
+        },
+        config() {
+            // Register a dedicated `email` build environment and opt the app into
+            // building all environments, so a plain `vite build` emits the email
+            // bundle alongside the client assets — no separate build step required.
+            // The environment is a server consumer. Standalone builds inline Node
+            // dependencies by default so Rails runtime images do not need node_modules.
+            return {
+                builder: {},
+                environments: {
+                    [EMAIL_ENVIRONMENT]: {
+                        ...(standalone ? { resolve: { noExternal: true } } : {}),
+                        build: {
+                            ssr: true,
+                            outDir: OUT_DIR,
+                            emptyOutDir: true,
+                            rollupOptions: {
+                                input: VIRTUAL_MAIN,
+                                output: { entryFileNames: BUNDLE_FILE },
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    };
+    const metadata = {
+        emails: {
+            path,
+            extensions,
+            ignore,
+        },
+        standalone,
+        outDir: OUT_DIR,
+        bundleFile: BUNDLE_FILE,
+    };
+    Object.defineProperty(plugin, CONFIG_SYMBOL, {
+        value: {
+            ...metadata,
+        },
+    });
+    return plugin;
+}
+export { RENDER_PROTOCOL_VERSION, VERSION } from "./version.js";

package/dist/runtime.d.ts

@@ -0,0 +1,26 @@
+import { type Options as ReactEmailRenderOptions } from "@react-email/render";
+import React from "react";
+export type EmailModule = {
+    default: React.ComponentType<Record<string, unknown>>;
+};
+export type EmailLoader = EmailModule | (() => Promise<EmailModule>);
+export type EmailRegistry = Record<string, EmailLoader>;
+export type RenderRequest = {
+    component: string;
+    props?: Record<string, unknown>;
+    renderOptions?: EmailRenderOptions;
+};
+export type HealthRequest = {
+    health: true;
+};
+export type RenderedEmail = {
+    html: string;
+    text: string;
+};
+export type EmailRenderOptions = {
+    html?: ReactEmailRenderOptions;
+    text?: ReactEmailRenderOptions;
+};
+export declare function toComponentName(globPath: string, root: string, extension: string): string;
+export declare function renderEmail(request: RenderRequest, registry: EmailRegistry): Promise<RenderedEmail>;
+export declare function serve(registry: EmailRegistry): Promise<void>;

package/dist/runtime.js

@@ -0,0 +1,98 @@
+import { render } from "@react-email/render";
+import React from "react";
+import { RENDER_PROTOCOL_VERSION, VERSION } from "./version.js";
+export function toComponentName(globPath, root, extension) {
+    const start = globPath.lastIndexOf(root) + root.length;
+    return globPath.slice(start, globPath.length - extension.length);
+}
+export async function renderEmail(request, registry) {
+    const loader = registry[request.component];
+    if (!loader)
+        throw new Error(`React email component not found: ${request.component}`);
+    const mod = typeof loader === "function" ? await loader() : loader;
+    const element = React.createElement(mod.default, request.props ?? {});
+    // @react-email/render re-renders the tree per call, so html and text are two passes.
+    return {
+        html: await render(element, { ...request.renderOptions?.html, plainText: false }),
+        text: await render(element, { ...request.renderOptions?.text, plainText: true }),
+    };
+}
+export async function serve(registry) {
+    if (process.argv.includes("--persistent")) {
+        await servePersistent(registry, isolateStdout());
+        return;
+    }
+    if (process.argv.includes("--health")) {
+        process.stdout.write(JSON.stringify(okResponse()));
+        return;
+    }
+    const write = isolateStdout();
+    try {
+        const request = JSON.parse(await readStdin());
+        write(JSON.stringify({ ...(await renderEmail(request, registry)), ...protocolMetadata() }));
+    }
+    catch (error) {
+        process.stderr.write(error instanceof Error ? error.message : "React Email render failed");
+        process.exitCode = 1;
+    }
+}
+// Reserve stdout for the JSON render protocol. Stray writes from email components
+// or their dependencies — including console.log, which Node routes through
+// process.stdout.write — are diverted to stderr so they cannot corrupt or desync
+// a response frame. Returns the writer to use for protocol output.
+function isolateStdout() {
+    const protocolWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = ((chunk) => process.stderr.write(chunk));
+    return (chunk) => protocolWrite(chunk);
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", reject);
+    });
+}
+async function servePersistent(registry, write) {
+    process.stdin.setEncoding("utf8");
+    let pending = "";
+    for await (const chunk of process.stdin) {
+        pending += chunk;
+        let separator = pending.indexOf("\n");
+        while (separator !== -1) {
+            const line = pending.slice(0, separator);
+            pending = pending.slice(separator + 1);
+            if (line.trim())
+                await writePersistentResponse(line, registry, write);
+            separator = pending.indexOf("\n");
+        }
+    }
+}
+async function writePersistentResponse(line, registry, write) {
+    try {
+        const request = JSON.parse(line);
+        if ("health" in request) {
+            write(`${JSON.stringify(okResponse())}\n`);
+            return;
+        }
+        write(`${JSON.stringify({ ok: true, ...(await renderEmail(request, registry)), ...protocolMetadata() })}\n`);
+    }
+    catch (error) {
+        write(`${JSON.stringify({
+            ok: false,
+            error: error instanceof Error ? error.message : "React Email render failed",
+        })}\n`);
+    }
+}
+function okResponse() {
+    return { ok: true, ...protocolMetadata() };
+}
+function protocolMetadata() {
+    return {
+        protocolVersion: RENDER_PROTOCOL_VERSION,
+        packageVersion: VERSION,
+    };
+}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.1.0";
+export declare const RENDER_PROTOCOL_VERSION = 1;

package/dist/version.js

@@ -0,0 +1,2 @@
+export const VERSION = "0.1.0";
+export const RENDER_PROTOCOL_VERSION = 1;

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "react-email-rails",
+  "version": "0.1.0",
+  "description": "Build and send emails using React and Rails",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://github.com/heysupertape/react-email-rails#readme",
+  "bugs": {
+    "url": "https://github.com/heysupertape/react-email-rails/issues"
+  },
+  "keywords": [
+    "rails",
+    "react-email",
+    "actionmailer",
+    "vite",
+    "email"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/heysupertape/react-email-rails.git",
+    "directory": "vite"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "react-email-rails-config": "./bin/config.mjs",
+    "react-email-rails-dev": "./bin/dev.mjs"
+  },
+  "scripts": {
+    "build": "tsgo -p tsconfig.json",
+    "check:version": "ruby ../scripts/check_version_sync.rb",
+    "lint": "oxlint src test bin",
+    "format": "oxfmt src test bin",
+    "typecheck": "tsgo -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "sync:version": "ruby ../scripts/sync_version.rb",
+    "ci": "pnpm run check:version && pnpm build && pnpm lint && pnpm typecheck && pnpm test",
+    "prepack": "pnpm run sync:version && pnpm build",
+    "prepublishOnly": "pnpm run check:version"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "peerDependencies": {
+    "@react-email/render": "^2.0.0",
+    "react": "^18.0 || ^19.0",
+    "vite": "^7.0.0 || ^8.0.0"
+  },
+  "devDependencies": {
+    "@react-email/render": "^2.0.8",
+    "@types/node": "^25.9.1",
+    "@types/react": "^19.2.15",
+    "@typescript/native-preview": "7.0.0-dev.20260527.2",
+    "oxfmt": "^0.52.0",
+    "oxlint": "^1.67.0",
+    "oxlint-tsgolint": "^0.23.0",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "vite": "^8.0.14",
+    "vitest": "^4.1.7"
+  }
+}

package/src/index.ts

@@ -0,0 +1,153 @@
+import type { Plugin } from "vite"
+
+export type EmailsOption =
+  | string
+  | {
+      path?: string
+      extension?: string | string[]
+      ignore?: string | string[]
+    }
+
+export type ReactEmailRailsOptions = {
+  emails?: EmailsOption
+  standalone?: boolean
+}
+
+type PluginMetadata = {
+  emails: {
+    path: string
+    extensions: string[]
+    ignore: string[]
+  }
+  standalone: boolean
+  outDir: string
+  bundleFile: string
+}
+
+const DEFAULT_IGNORE = ["**/_*", "**/_*/**"]
+const DEFAULT_EXTENSIONS = [".tsx", ".jsx"]
+
+const VIRTUAL_SERVER = "virtual:react-email-rails/server"
+const VIRTUAL_MAIN = "virtual:react-email-rails/main"
+const RESOLVED_SERVER = `\0${VIRTUAL_SERVER}`
+const RESOLVED_MAIN = `\0${VIRTUAL_MAIN}`
+
+// The dedicated build environment that emits the server-side email bundle.
+export const EMAIL_ENVIRONMENT = "email"
+const CONFIG_SYMBOL = Symbol.for("react-email-rails.config")
+const OUT_DIR = "tmp/react-email-rails"
+const BUNDLE_FILE = "emails.js"
+
+export function reactEmailRails(options: ReactEmailRailsOptions = {}): Plugin {
+  const emails =
+    typeof options.emails === "string" ? { path: options.emails } : (options.emails ?? {})
+  const path = (emails.path ?? "app/javascript/emails").replace(/^\/|\/$/g, "")
+  const rawExtensions =
+    emails.extension === undefined
+      ? DEFAULT_EXTENSIONS
+      : Array.isArray(emails.extension)
+        ? emails.extension
+        : [emails.extension]
+  const extensions = rawExtensions
+    .map((extension) => (extension.startsWith(".") ? extension : `.${extension}`))
+    .map((extension, index) => ({ extension, index }))
+    .sort(
+      (left, right) => right.extension.length - left.extension.length || left.index - right.index,
+    )
+    .map(({ extension }) => extension)
+  const standalone = options.standalone ?? true
+
+  const root = `/${path}/`
+  const pattern =
+    extensions.length === 1 ? `${root}**/*${extensions[0]}` : `${root}**/*{${extensions.join(",")}}`
+  const ignore =
+    emails.ignore === undefined
+      ? DEFAULT_IGNORE
+      : Array.isArray(emails.ignore)
+        ? emails.ignore
+        : [emails.ignore]
+  const globPatterns = [pattern, ...ignore.map((glob) => `!${root}${glob}`)]
+  const globArg = JSON.stringify(globPatterns.length === 1 ? globPatterns[0] : globPatterns)
+
+  const plugin: Plugin = {
+    name: "react-email-rails",
+
+    resolveId(id) {
+      if (id === VIRTUAL_SERVER) return RESOLVED_SERVER
+      if (id === VIRTUAL_MAIN) return RESOLVED_MAIN
+    },
+
+    load(id) {
+      if (id === RESOLVED_SERVER) {
+        return [
+          `import { serve, toComponentName } from "react-email-rails/runtime"`,
+          `const modules = import.meta.glob(${globArg})`,
+          `const extensions = ${JSON.stringify(extensions)}`,
+          `const registry = Object.create(null)`,
+          `for (const path in modules) {`,
+          `  const extension = extensions.find((extension) => path.endsWith(extension)) ?? path.slice(path.lastIndexOf("."))`,
+          `  registry[toComponentName(path, ${JSON.stringify(root)}, extension)] = modules[path]`,
+          `}`,
+          `export const run = () => serve(registry)`,
+        ].join("\n")
+      }
+
+      if (id === RESOLVED_MAIN) {
+        return `import { run } from ${JSON.stringify(VIRTUAL_SERVER)}\nrun()\n`
+      }
+    },
+
+    config() {
+      // Register a dedicated `email` build environment and opt the app into
+      // building all environments, so a plain `vite build` emits the email
+      // bundle alongside the client assets — no separate build step required.
+      // The environment is a server consumer. Standalone builds inline Node
+      // dependencies by default so Rails runtime images do not need node_modules.
+      return {
+        builder: {},
+        environments: {
+          [EMAIL_ENVIRONMENT]: {
+            ...(standalone ? { resolve: { noExternal: true } } : {}),
+            build: {
+              ssr: true,
+              outDir: OUT_DIR,
+              emptyOutDir: true,
+              rollupOptions: {
+                input: VIRTUAL_MAIN,
+                output: { entryFileNames: BUNDLE_FILE },
+              },
+            },
+          },
+        },
+      }
+    },
+  }
+
+  const metadata: PluginMetadata = {
+    emails: {
+      path,
+      extensions,
+      ignore,
+    },
+    standalone,
+    outDir: OUT_DIR,
+    bundleFile: BUNDLE_FILE,
+  }
+
+  Object.defineProperty(plugin, CONFIG_SYMBOL, {
+    value: {
+      ...metadata,
+    },
+  })
+
+  return plugin
+}
+
+export type {
+  EmailModule,
+  EmailRegistry,
+  EmailRenderOptions,
+  RenderedEmail,
+  RenderRequest,
+} from "./runtime.js"
+export { RENDER_PROTOCOL_VERSION, VERSION } from "./version.js"

package/src/runtime.ts

@@ -0,0 +1,157 @@
+import { render, type Options as ReactEmailRenderOptions } from "@react-email/render"
+import React from "react"
+
+import { RENDER_PROTOCOL_VERSION, VERSION } from "./version.js"
+
+export type EmailModule = {
+  default: React.ComponentType<Record<string, unknown>>
+}
+
+export type EmailLoader = EmailModule | (() => Promise<EmailModule>)
+export type EmailRegistry = Record<string, EmailLoader>
+
+export type RenderRequest = {
+  component: string
+  props?: Record<string, unknown>
+  renderOptions?: EmailRenderOptions
+}
+
+export type HealthRequest = {
+  health: true
+}
+
+export type RenderedEmail = {
+  html: string
+  text: string
+}
+
+type ProtocolMetadata = {
+  protocolVersion: number
+  packageVersion: string
+}
+
+export type EmailRenderOptions = {
+  html?: ReactEmailRenderOptions
+  text?: ReactEmailRenderOptions
+}
+
+export function toComponentName(globPath: string, root: string, extension: string): string {
+  const start = globPath.lastIndexOf(root) + root.length
+  return globPath.slice(start, globPath.length - extension.length)
+}
+
+export async function renderEmail(
+  request: RenderRequest,
+  registry: EmailRegistry,
+): Promise<RenderedEmail> {
+  const loader = registry[request.component]
+  if (!loader) throw new Error(`React email component not found: ${request.component}`)
+
+  const mod = typeof loader === "function" ? await loader() : loader
+  const element = React.createElement(mod.default, request.props ?? {})
+
+  // @react-email/render re-renders the tree per call, so html and text are two passes.
+  return {
+    html: await render(element, { ...request.renderOptions?.html, plainText: false }),
+    text: await render(element, { ...request.renderOptions?.text, plainText: true }),
+  }
+}
+
+export async function serve(registry: EmailRegistry): Promise<void> {
+  if (process.argv.includes("--persistent")) {
+    await servePersistent(registry, isolateStdout())
+    return
+  }
+
+  if (process.argv.includes("--health")) {
+    process.stdout.write(JSON.stringify(okResponse()))
+    return
+  }
+
+  const write = isolateStdout()
+  try {
+    const request = JSON.parse(await readStdin()) as RenderRequest
+    write(JSON.stringify({ ...(await renderEmail(request, registry)), ...protocolMetadata() }))
+  } catch (error) {
+    process.stderr.write(error instanceof Error ? error.message : "React Email render failed")
+    process.exitCode = 1
+  }
+}
+
+// Reserve stdout for the JSON render protocol. Stray writes from email components
+// or their dependencies — including console.log, which Node routes through
+// process.stdout.write — are diverted to stderr so they cannot corrupt or desync
+// a response frame. Returns the writer to use for protocol output.
+function isolateStdout(): (chunk: string) => boolean {
+  const protocolWrite = process.stdout.write.bind(process.stdout)
+  process.stdout.write = ((chunk: string | Uint8Array): boolean =>
+    process.stderr.write(chunk)) as typeof process.stdout.write
+  return (chunk) => protocolWrite(chunk)
+}
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = ""
+    process.stdin.setEncoding("utf8")
+    process.stdin.on("data", (chunk) => {
+      data += chunk
+    })
+    process.stdin.on("end", () => resolve(data))
+    process.stdin.on("error", reject)
+  })
+}
+
+async function servePersistent(
+  registry: EmailRegistry,
+  write: (chunk: string) => boolean,
+): Promise<void> {
+  process.stdin.setEncoding("utf8")
+
+  let pending = ""
+  for await (const chunk of process.stdin) {
+    pending += chunk
+
+    let separator = pending.indexOf("\n")
+    while (separator !== -1) {
+      const line = pending.slice(0, separator)
+      pending = pending.slice(separator + 1)
+
+      if (line.trim()) await writePersistentResponse(line, registry, write)
+      separator = pending.indexOf("\n")
+    }
+  }
+}
+
+async function writePersistentResponse(
+  line: string,
+  registry: EmailRegistry,
+  write: (chunk: string) => boolean,
+): Promise<void> {
+  try {
+    const request = JSON.parse(line) as RenderRequest | HealthRequest
+    if ("health" in request) {
+      write(`${JSON.stringify(okResponse())}\n`)
+      return
+    }
+
+    write(`${JSON.stringify({ ok: true, ...(await renderEmail(request, registry)), ...protocolMetadata() })}\n`)
+  } catch (error) {
+    write(
+      `${JSON.stringify({
+        ok: false,
+        error: error instanceof Error ? error.message : "React Email render failed",
+      })}\n`,
+    )
+  }
+}
+
+function okResponse(): { ok: true } & ProtocolMetadata {
+  return { ok: true, ...protocolMetadata() }
+}
+
+function protocolMetadata(): ProtocolMetadata {
+  return {
+    protocolVersion: RENDER_PROTOCOL_VERSION,
+    packageVersion: VERSION,
+  }
+}

package/src/version.ts

@@ -0,0 +1,2 @@
+export const VERSION = "0.1.0"
+export const RENDER_PROTOCOL_VERSION = 1