@teleporthq/teleport-plugin-next-workflows 0.43.65 → 0.43.67

package/dist/cjs/data-api-route-generator.js

@@ -502,6 +502,24 @@ async function getColumnTypes(client, tableName) {
   } catch(e) { return {}; }
 }
 
+// Tables whose rows remember the language of the storefront they were
+// written from, so the emails about them can be sent in it later (by a cron,
+// a webhook, an admin action — none of which run in the buyer's language).
+// The column is stamped ONLY when the table actually has it: a store
+// provisioned before the column existed keeps inserting exactly as before.
+var LOCALE_STAMPED_TABLES = { teleport_orders: 1 };
+var LOCALE_COLUMN = 'locale';
+
+function stampRequestLocale(tableName, entries, colTypes, requestLocale) {
+  if (!LOCALE_STAMPED_TABLES[tableName]) return entries;
+  if (typeof requestLocale !== 'string' || !requestLocale) return entries;
+  if (!colTypes[LOCALE_COLUMN]) return entries;
+  for (var i = 0; i < entries.length; i++) {
+    if (entries[i][0] === LOCALE_COLUMN) return entries;
+  }
+  return entries.concat([[LOCALE_COLUMN, requestLocale.slice(0, 10)]]);
+}
+
 async function handleCreate(client, body) {
   var tableName = body.tableName;
   var columnMappings = body.columnMappings || {};
@@ -528,6 +546,7 @@ async function handleCreate(client, body) {
   }
 
   var colTypes = await getColumnTypes(client, tableName);
+  entries = stampRequestLocale(tableName, entries, colTypes, body.__requestLocale);
 
   var TEXT_TYPES = { 'character varying': 1, 'text': 1, 'char': 1, 'character': 1, 'varchar': 1, 'name': 1 };
   var columns = entries.map(function(e) { return e[0]; });

package/dist/cjs/data-api-route-generator.js.map

@@ -1 +1 @@
-{"version":3,"file":"data-api-route-generator.js","sourceRoot":"","sources":["../../src/data-api-route-generator.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEH,mDAA0D;AAC1D,uEAAoF;AAEpF,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC;IAC9B,aAAa;IACb,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;IAClB,YAAY;IACZ,gBAAgB;IAChB,uEAAuE;IACvE,0EAA0E;IAC1E,sCAAsC;IACtC,yBAAyB;CAC1B,CAAC,CAAA;AAEK,MAAM,iBAAiB,GAAG,CAAC,aAA0B,EAAW,EAAE;IACvE,KAAK,MAAM,EAAE,IAAI,aAAa,EAAE;QAC9B,IAAI,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;YAC3B,OAAO,IAAI,CAAA;SACZ;KACF;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAPY,QAAA,iBAAiB,qBAO7B;AAqBM,MAAM,oBAAoB,GAAG,CAAC,UAA+B,EAAE,EAAU,EAAE;IAChF,MAAM,aAAa,GAAG,IAAA,wCAAwB,GAAE,CAAA;IAChD,MAAM,cAAc,GAAG,OAAO,CAAC,kBAAkB,IAAI,IAAI,CAAA;IACzD,MAAM,qBAAqB,GAAG,CAAC,CAAC,OAAO,CAAC,qBAAqB,CAAA;IAC7D,MAAM,iBAAiB,GACrB,OAAO,OAAO,CAAC,iBAAiB,KAAK,QAAQ,IAAI,OAAO,CAAC,iBAAiB,IAAI,CAAC;QAC7E,CAAC,CAAC,OAAO,CAAC,iBAAiB;QAC3B,CAAC,CAAC,CAAC,CAAA;IAEP,OAAO;EACP;IACA,mEAAmE;IACnE,4EAA4E;IAC5E,6EAA6E;IAC7E,qEAAqE;IACrE,cAAc,CAAC,CAAC,CAAC,IAAA,kEAAwC,GAAE,CAAC,CAAC,CAAC,EAChE,4BAA4B,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC;mCACvB,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC;8BAC1C,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC;EAC7D,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAm1Bd,CAAA;AACD,CAAC,CAAA;AAv2BY,QAAA,oBAAoB,wBAu2BhC"}
+{"version":3,"file":"data-api-route-generator.js","sourceRoot":"","sources":["../../src/data-api-route-generator.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEH,mDAA0D;AAC1D,uEAAoF;AAEpF,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC;IAC9B,aAAa;IACb,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;IAClB,YAAY;IACZ,gBAAgB;IAChB,uEAAuE;IACvE,0EAA0E;IAC1E,sCAAsC;IACtC,yBAAyB;CAC1B,CAAC,CAAA;AAEK,MAAM,iBAAiB,GAAG,CAAC,aAA0B,EAAW,EAAE;IACvE,KAAK,MAAM,EAAE,IAAI,aAAa,EAAE;QAC9B,IAAI,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;YAC3B,OAAO,IAAI,CAAA;SACZ;KACF;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAPY,QAAA,iBAAiB,qBAO7B;AAqBM,MAAM,oBAAoB,GAAG,CAAC,UAA+B,EAAE,EAAU,EAAE;IAChF,MAAM,aAAa,GAAG,IAAA,wCAAwB,GAAE,CAAA;IAChD,MAAM,cAAc,GAAG,OAAO,CAAC,kBAAkB,IAAI,IAAI,CAAA;IACzD,MAAM,qBAAqB,GAAG,CAAC,CAAC,OAAO,CAAC,qBAAqB,CAAA;IAC7D,MAAM,iBAAiB,GACrB,OAAO,OAAO,CAAC,iBAAiB,KAAK,QAAQ,IAAI,OAAO,CAAC,iBAAiB,IAAI,CAAC;QAC7E,CAAC,CAAC,OAAO,CAAC,iBAAiB;QAC3B,CAAC,CAAC,CAAC,CAAA;IAEP,OAAO;EACP;IACA,mEAAmE;IACnE,4EAA4E;IAC5E,6EAA6E;IAC7E,qEAAqE;IACrE,cAAc,CAAC,CAAC,CAAC,IAAA,kEAAwC,GAAE,CAAC,CAAC,CAAC,EAChE,4BAA4B,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC;mCACvB,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC;8BAC1C,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC;EAC7D,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAs2Bd,CAAA;AACD,CAAC,CAAA;AA13BY,QAAA,oBAAoB,wBA03BhC"}

package/dist/cjs/email-locale/email-locale-code.d.ts

@@ -0,0 +1,25 @@
+import { EmailLocaleConfig } from './email-locale-scope';
+/**
+ * The locale helpers every generated email sender and every generated
+ * navigation runs. Emitted twice from this one source: as the standalone
+ * `utils/email/email-locale.js` module (the account routes, the invoice
+ * sender, the cart route and the cart provider use it) and inlined into the
+ * workflow runtime (`runtime-utils.js`), which is bundled for the browser as
+ * well and must not depend on a sibling file being resolvable.
+ *
+ * Every function is total: an unknown or missing locale resolves to the
+ * project's default language, so a sender can never pick a template that does
+ * not exist and a navigation can never be sent to a locale the app does not
+ * serve.
+ */
+export declare const generateEmailLocaleHelpersCode: (config: EmailLocaleConfig) => string;
+/**
+ * The runtime-only helpers, on top of the shared ones: how a workflow run
+ * learns its locale and how an email node's config resolves the language it
+ * sends in. Inlined into \`runtime-utils.js\` right after
+ * \`generateEmailLocaleHelpersCode\`.
+ */
+export declare const generateWorkflowLocaleHelpersCode: () => string;
+/** `utils/email/email-locale.js` — the shared helpers as a CommonJS module. */
+export declare const generateEmailLocaleModuleCode: (config: EmailLocaleConfig) => string;
+//# sourceMappingURL=email-locale-code.d.ts.map

package/dist/cjs/email-locale/email-locale-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-locale-code.d.ts","sourceRoot":"","sources":["../../../src/email-locale/email-locale-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,iBAAiB,EAIlB,MAAM,sBAAsB,CAAA;AAE7B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,8BAA8B,WAAY,iBAAiB,KAAG,MAmI1E,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,QAAO,MAmDpD,CAAA;AAED,+EAA+E;AAC/E,eAAO,MAAM,6BAA6B,WAAY,iBAAiB,KAAG,MAuBzE,CAAA"}

package/dist/cjs/email-locale/email-locale-code.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmailLocaleModuleCode = exports.generateWorkflowLocaleHelpersCode = exports.generateEmailLocaleHelpersCode = void 0;
+const email_locale_scope_1 = require("./email-locale-scope");
+/**
+ * The locale helpers every generated email sender and every generated
+ * navigation runs. Emitted twice from this one source: as the standalone
+ * `utils/email/email-locale.js` module (the account routes, the invoice
+ * sender, the cart route and the cart provider use it) and inlined into the
+ * workflow runtime (`runtime-utils.js`), which is bundled for the browser as
+ * well and must not depend on a sibling file being resolvable.
+ *
+ * Every function is total: an unknown or missing locale resolves to the
+ * project's default language, so a sender can never pick a template that does
+ * not exist and a navigation can never be sent to a locale the app does not
+ * serve.
+ */
+const generateEmailLocaleHelpersCode = (config) => `
+var EMAIL_LOCALES = ${JSON.stringify(config.locales)};
+var DEFAULT_EMAIL_LOCALE = ${JSON.stringify(config.defaultLocale)};
+var EMAIL_LOCALE_HEADER = ${JSON.stringify(email_locale_scope_1.EMAIL_LOCALE_HEADER)};
+var NEXT_LOCALE_COOKIE = ${JSON.stringify(email_locale_scope_1.NEXT_LOCALE_COOKIE)};
+
+// The project locale a raw value names, or null. Case-insensitive so a
+// visitor-supplied "ES" still matches, but always answers the canonical code.
+function normalizeEmailLocale(value) {
+  if (typeof value !== 'string') return null;
+  var trimmed = value.trim();
+  if (!trimmed) return null;
+  var lower = trimmed.toLowerCase();
+  for (var i = 0; i < EMAIL_LOCALES.length; i++) {
+    if (String(EMAIL_LOCALES[i]).toLowerCase() === lower) return EMAIL_LOCALES[i];
+  }
+  return null;
+}
+
+function readCookieValue(cookieHeader, name) {
+  if (typeof cookieHeader !== 'string' || !cookieHeader) return null;
+  var parts = cookieHeader.split(';');
+  for (var i = 0; i < parts.length; i++) {
+    var pair = parts[i].trim();
+    var eq = pair.indexOf('=');
+    if (eq === -1) continue;
+    if (pair.slice(0, eq).trim() !== name) continue;
+    try { return decodeURIComponent(pair.slice(eq + 1).trim()); } catch (e) { return pair.slice(eq + 1).trim(); }
+  }
+  return null;
+}
+
+// The locale prefix of a localized page path ("/es/checkout" → "es"). The
+// default language is served unprefixed, which resolves to null here and to
+// the default further down.
+function localeFromPathname(pathname) {
+  if (typeof pathname !== 'string') return null;
+  var segments = pathname.split('/');
+  for (var i = 0; i < segments.length; i++) {
+    if (segments[i]) return normalizeEmailLocale(segments[i]);
+  }
+  return null;
+}
+
+function firstHeaderValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+
+// The language of the page a request came from: the explicit header the
+// generated client runtime sends, else the locale prefix of the referring page
+// (the page the browser is actually on), else the Next.js locale cookie (a
+// stored preference, which a request without a referer is all we have), else
+// the default language.
+function resolveRequestLocale(req) {
+  var headers = req && req.headers ? req.headers : null;
+  if (!headers) return DEFAULT_EMAIL_LOCALE;
+  var fromHeader = normalizeEmailLocale(firstHeaderValue(headers[EMAIL_LOCALE_HEADER]));
+  if (fromHeader) return fromHeader;
+  var referer = firstHeaderValue(headers.referer || headers.referrer);
+  if (typeof referer === 'string' && referer) {
+    try {
+      var fromReferer = localeFromPathname(new URL(referer).pathname);
+      if (fromReferer) return fromReferer;
+    } catch (e) { /* not an absolute URL — nothing to read */ }
+  }
+  var fromCookie = normalizeEmailLocale(readCookieValue(firstHeaderValue(headers.cookie), NEXT_LOCALE_COOKIE));
+  if (fromCookie) return fromCookie;
+  return DEFAULT_EMAIL_LOCALE;
+}
+
+// The locale of the page the browser is on, read LIVE off the Next.js router.
+// After a client-side language switch the page data
+// (window.__NEXT_DATA__.locale) still names the locale the document was
+// served in, while the router — and the <html lang> attribute it keeps in
+// sync on every transition — already name the one the visitor switched to.
+// Null outside a browser, or when no candidate is a project locale.
+function getClientLocale() {
+  if (typeof window === 'undefined') return null;
+  var candidates = [];
+  try { candidates.push(window.next && window.next.router && window.next.router.locale); } catch (e) { /* router not mounted */ }
+  try { candidates.push(document.documentElement && document.documentElement.lang); } catch (e) { /* no document */ }
+  try { candidates.push(window.__NEXT_DATA__ && window.__NEXT_DATA__.locale); } catch (e) { /* no page data */ }
+  for (var i = 0; i < candidates.length; i++) {
+    var resolved = normalizeEmailLocale(candidates[i]);
+    if (resolved) return resolved;
+  }
+  return null;
+}
+
+// The href a navigation should use so the visitor stays in \`locale\`. Next.js
+// serves the default language unprefixed and every other language under
+// "/<locale>", so a site-relative page path gets that prefix. Left untouched:
+// anything that is not a site-relative path (an external URL, a hash, a
+// mailto:), an API route or a Next.js internal path (never localized), a file
+// served from /public (not served under a locale prefix) and a path that
+// already names a project locale. The default language, an unknown locale and
+// a project without languages all leave the href as it is.
+function localizeHref(href, locale) {
+  if (typeof href !== 'string' || href.charAt(0) !== '/' || href.charAt(1) === '/') return href;
+  var resolved = normalizeEmailLocale(locale);
+  if (!resolved || resolved === DEFAULT_EMAIL_LOCALE) return href;
+  var pathEnd = href.length;
+  var queryStart = href.indexOf('?');
+  if (queryStart !== -1) pathEnd = queryStart;
+  var hashStart = href.indexOf('#');
+  if (hashStart !== -1 && hashStart < pathEnd) pathEnd = hashStart;
+  var pathname = href.slice(0, pathEnd);
+  if (pathname === '/api' || pathname.indexOf('/api/') === 0) return href;
+  if (pathname.indexOf('/_next/') === 0) return href;
+  if (/\\.[A-Za-z0-9]{1,5}$/.test(pathname)) return href;
+  if (localeFromPathname(pathname)) return href;
+  return '/' + resolved + (pathname === '/' ? '' : pathname) + href.slice(pathEnd);
+}
+
+// The copy of a template that goes out in \`locale\`: its own body, its own
+// subject when it has one (else the base subject), or the base copy for the
+// default language and for any language that has no copy.
+function pickLocalizedTemplate(base, localized, locale) {
+  var baseCopy = base || {};
+  var resolved = normalizeEmailLocale(locale) || DEFAULT_EMAIL_LOCALE;
+  var fallback = { subject: baseCopy.subject, body: baseCopy.body, locale: DEFAULT_EMAIL_LOCALE };
+  if (!resolved || resolved === DEFAULT_EMAIL_LOCALE) return fallback;
+  if (!localized || typeof localized !== 'object') return fallback;
+  var copy = localized[resolved];
+  if (!copy || typeof copy !== 'object' || typeof copy.body !== 'string' || !copy.body) return fallback;
+  return {
+    subject: typeof copy.subject === 'string' && copy.subject ? copy.subject : baseCopy.subject,
+    body: copy.body,
+    locale: resolved,
+  };
+}
+`;
+exports.generateEmailLocaleHelpersCode = generateEmailLocaleHelpersCode;
+/**
+ * The runtime-only helpers, on top of the shared ones: how a workflow run
+ * learns its locale and how an email node's config resolves the language it
+ * sends in. Inlined into \`runtime-utils.js\` right after
+ * \`generateEmailLocaleHelpersCode\`.
+ */
+const generateWorkflowLocaleHelpersCode = () => `
+// The locale a server route runs a segment in: the one the client runtime put
+// on the context (validated — it crossed the network), else the request's.
+function resolveWorkflowLocale(req, incomingContext) {
+  var fromContext = incomingContext ? normalizeEmailLocale(incomingContext[${JSON.stringify(email_locale_scope_1.WORKFLOW_CONTEXT_LOCALE_KEY)}]) : null;
+  return fromContext || resolveRequestLocale(req);
+}
+
+// The language an email node sends in. A config that BINDS the locale (the
+// order's, the cart's) is authoritative even when the binding resolved to
+// nothing — the request locale belongs to whoever triggered the workflow, which
+// for an admin action is not the recipient. Otherwise the run's locale, then
+// the default language.
+function resolveEmailLocale(resolvedConfig, context) {
+  var config = resolvedConfig || {};
+  if (Object.prototype.hasOwnProperty.call(config, ${JSON.stringify(email_locale_scope_1.EMAIL_LOCALE_CONFIG_KEY)})) {
+    return normalizeEmailLocale(config[${JSON.stringify(email_locale_scope_1.EMAIL_LOCALE_CONFIG_KEY)}]) || DEFAULT_EMAIL_LOCALE;
+  }
+  var fromRun = context ? normalizeEmailLocale(context[${JSON.stringify(email_locale_scope_1.WORKFLOW_CONTEXT_LOCALE_KEY)}]) : null;
+  return fromRun || DEFAULT_EMAIL_LOCALE;
+}
+
+// Swaps a component-bodied email node's body/subject for the copy of the
+// language it sends in, then drops the per-language map and the binding so
+// neither reaches a provider handler or the sent-email ledger. Runs BEFORE the
+// {{token}} fill: the copies carry the same merge fields as the base body.
+function applyLocalizedEmailTemplate(resolvedConfig, context) {
+  var localized = resolvedConfig[${JSON.stringify(email_locale_scope_1.LOCALIZED_TEMPLATES_CONFIG_KEY)}];
+  var hasLocalized = !!localized && typeof localized === 'object';
+  var hasBinding = Object.prototype.hasOwnProperty.call(resolvedConfig, ${JSON.stringify(email_locale_scope_1.EMAIL_LOCALE_CONFIG_KEY)});
+  if (!hasLocalized && !hasBinding) return;
+  if (hasLocalized) {
+    var picked = pickLocalizedTemplate(
+      { subject: resolvedConfig.subject, body: resolvedConfig.body },
+      localized,
+      resolveEmailLocale(resolvedConfig, context)
+    );
+    if (typeof picked.body === 'string') resolvedConfig.body = picked.body;
+    if (typeof picked.subject === 'string') resolvedConfig.subject = picked.subject;
+    delete resolvedConfig[${JSON.stringify(email_locale_scope_1.LOCALIZED_TEMPLATES_CONFIG_KEY)}];
+  }
+  if (hasBinding) delete resolvedConfig[${JSON.stringify(email_locale_scope_1.EMAIL_LOCALE_CONFIG_KEY)}];
+}
+`;
+exports.generateWorkflowLocaleHelpersCode = generateWorkflowLocaleHelpersCode;
+/** `utils/email/email-locale.js` — the shared helpers as a CommonJS module. */
+const generateEmailLocaleModuleCode = (config) => `/**
+ * Email locale resolution.
+ *
+ * A customer email goes out in the language of the page it was triggered from;
+ * the store owner's notifications always use the project's main language. This
+ * module answers "which locale?" for the senders that live outside the workflow
+ * runtime (the account routes, the invoice sender, the cart route) — the
+ * runtime carries the same helpers inline.
+ *
+ * Auto-generated. Edit the generator at
+ * teleport-plugin-next-workflows/src/email-locale/email-locale-code.ts.
+ */
+${(0, exports.generateEmailLocaleHelpersCode)(config)}
+module.exports = {
+  EMAIL_LOCALES: EMAIL_LOCALES,
+  DEFAULT_EMAIL_LOCALE: DEFAULT_EMAIL_LOCALE,
+  EMAIL_LOCALE_HEADER: EMAIL_LOCALE_HEADER,
+  normalizeEmailLocale: normalizeEmailLocale,
+  resolveRequestLocale: resolveRequestLocale,
+  getClientLocale: getClientLocale,
+  localizeHref: localizeHref,
+  pickLocalizedTemplate: pickLocalizedTemplate,
+};
+`;
+exports.generateEmailLocaleModuleCode = generateEmailLocaleModuleCode;
+//# sourceMappingURL=email-locale-code.js.map

package/dist/cjs/email-locale/email-locale-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-locale-code.js","sourceRoot":"","sources":["../../../src/email-locale/email-locale-code.ts"],"names":[],"mappings":";;;AAAA,6DAO6B;AAE7B;;;;;;;;;;;;GAYG;AACI,MAAM,8BAA8B,GAAG,CAAC,MAAyB,EAAU,EAAE,CAAC;sBAC/D,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC;6BACvB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC;4BACrC,IAAI,CAAC,SAAS,CAAC,wCAAmB,CAAC;2BACpC,IAAI,CAAC,SAAS,CAAC,uCAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+H5D,CAAA;AAnIY,QAAA,8BAA8B,kCAmI1C;AAED;;;;;GAKG;AACI,MAAM,iCAAiC,GAAG,GAAW,EAAE,CAAC;;;;6EAIc,IAAI,CAAC,SAAS,CACvF,gDAA2B,CAC5B;;;;;;;;;;;qDAWkD,IAAI,CAAC,SAAS,CAAC,4CAAuB,CAAC;yCACnD,IAAI,CAAC,SAAS,CACjD,4CAAuB,CACxB;;yDAEoD,IAAI,CAAC,SAAS,CACnE,gDAA2B,CAC5B;;;;;;;;;mCASgC,IAAI,CAAC,SAAS,CAAC,mDAA8B,CAAC;;0EAEP,IAAI,CAAC,SAAS,CACpF,4CAAuB,CACxB;;;;;;;;;;4BAUyB,IAAI,CAAC,SAAS,CAAC,mDAA8B,CAAC;;0CAEhC,IAAI,CAAC,SAAS,CAAC,4CAAuB,CAAC;;CAEhF,CAAA;AAnDY,QAAA,iCAAiC,qCAmD7C;AAED,+EAA+E;AACxE,MAAM,6BAA6B,GAAG,CAAC,MAAyB,EAAU,EAAE,CAAC;;;;;;;;;;;;EAYlF,IAAA,sCAA8B,EAAC,MAAM,CAAC;;;;;;;;;;;CAWvC,CAAA;AAvBY,QAAA,6BAA6B,iCAuBzC"}

package/dist/cjs/email-locale/email-locale-scope.d.ts

@@ -0,0 +1,46 @@
+import { ProjectUIDL } from '@teleporthq/teleport-types';
+/**
+ * The vocabulary every generated email sender shares to decide WHICH language a
+ * customer email goes out in. The module itself is emitted by
+ * `ensureEmailLocaleModule` (see `index.ts`); this file only holds the names
+ * the route generators, the workflow runtime and the UIDL mapper agree on.
+ */
+export declare const EMAIL_LOCALE_FILE_KEY = "email-locale";
+export declare const EMAIL_LOCALE_PATH: string[];
+export declare const EMAIL_LOCALE_FILE_NAME = "email-locale";
+/**
+ * Request header the generated client runtime sends with every call to the
+ * app's own API routes, carrying the locale of the page the visitor is on.
+ */
+export declare const EMAIL_LOCALE_HEADER = "x-teleport-locale";
+/** The cookie Next.js reads for locale detection; honoured as a fallback. */
+export declare const NEXT_LOCALE_COOKIE = "NEXT_LOCALE";
+/**
+ * Export-only node config key written by the editor's domain→UIDL mapper on a
+ * component-bodied email node: the per-language copies of its body/subject,
+ * keyed by locale short code (main language excluded). Consumed by the runtime
+ * (`resolveConfig`) and never by a handler.
+ */
+export declare const LOCALIZED_TEMPLATES_CONFIG_KEY = "localizedTemplates";
+/**
+ * Node config key that pins an email to a language independently of the
+ * request: a lifecycle email bound to the order's stored locale, a reminder
+ * bound to the cart's. When the key is present its resolved value is
+ * authoritative — an empty one means the default language, never the locale of
+ * whoever triggered the workflow (an admin shipping an order is not the buyer).
+ */
+export declare const EMAIL_LOCALE_CONFIG_KEY = "emailLocale";
+/** Workflow-context key carrying the request locale through a run. */
+export declare const WORKFLOW_CONTEXT_LOCALE_KEY = "__locale";
+/**
+ * The locales the generated app serves, as the email senders need them: the
+ * full list to validate an incoming value against and the default to fall back
+ * to. A project without internationalization has no locales at all — every
+ * sender then keeps its single template and nothing is ever localized.
+ */
+export interface EmailLocaleConfig {
+    locales: string[];
+    defaultLocale: string;
+}
+export declare const resolveEmailLocaleConfig: (uidl: ProjectUIDL) => EmailLocaleConfig;
+//# sourceMappingURL=email-locale-scope.d.ts.map

package/dist/cjs/email-locale/email-locale-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-locale-scope.d.ts","sourceRoot":"","sources":["../../../src/email-locale/email-locale-scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAExD;;;;;GAKG;AAEH,eAAO,MAAM,qBAAqB,iBAAiB,CAAA;AACnD,eAAO,MAAM,iBAAiB,UAAqB,CAAA;AACnD,eAAO,MAAM,sBAAsB,iBAAiB,CAAA;AAEpD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,sBAAsB,CAAA;AAEtD,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,gBAAgB,CAAA;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,uBAAuB,CAAA;AAElE;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,gBAAgB,CAAA;AAEpD,sEAAsE;AACtE,eAAO,MAAM,2BAA2B,aAAa,CAAA;AAErD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,eAAO,MAAM,wBAAwB,SAAU,WAAW,KAAG,iBAW5D,CAAA"}

package/dist/cjs/email-locale/email-locale-scope.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEmailLocaleConfig = exports.WORKFLOW_CONTEXT_LOCALE_KEY = exports.EMAIL_LOCALE_CONFIG_KEY = exports.LOCALIZED_TEMPLATES_CONFIG_KEY = exports.NEXT_LOCALE_COOKIE = exports.EMAIL_LOCALE_HEADER = exports.EMAIL_LOCALE_FILE_NAME = exports.EMAIL_LOCALE_PATH = exports.EMAIL_LOCALE_FILE_KEY = void 0;
+/**
+ * The vocabulary every generated email sender shares to decide WHICH language a
+ * customer email goes out in. The module itself is emitted by
+ * `ensureEmailLocaleModule` (see `index.ts`); this file only holds the names
+ * the route generators, the workflow runtime and the UIDL mapper agree on.
+ */
+exports.EMAIL_LOCALE_FILE_KEY = 'email-locale';
+exports.EMAIL_LOCALE_PATH = ['utils', 'email'];
+exports.EMAIL_LOCALE_FILE_NAME = 'email-locale';
+/**
+ * Request header the generated client runtime sends with every call to the
+ * app's own API routes, carrying the locale of the page the visitor is on.
+ */
+exports.EMAIL_LOCALE_HEADER = 'x-teleport-locale';
+/** The cookie Next.js reads for locale detection; honoured as a fallback. */
+exports.NEXT_LOCALE_COOKIE = 'NEXT_LOCALE';
+/**
+ * Export-only node config key written by the editor's domain→UIDL mapper on a
+ * component-bodied email node: the per-language copies of its body/subject,
+ * keyed by locale short code (main language excluded). Consumed by the runtime
+ * (`resolveConfig`) and never by a handler.
+ */
+exports.LOCALIZED_TEMPLATES_CONFIG_KEY = 'localizedTemplates';
+/**
+ * Node config key that pins an email to a language independently of the
+ * request: a lifecycle email bound to the order's stored locale, a reminder
+ * bound to the cart's. When the key is present its resolved value is
+ * authoritative — an empty one means the default language, never the locale of
+ * whoever triggered the workflow (an admin shipping an order is not the buyer).
+ */
+exports.EMAIL_LOCALE_CONFIG_KEY = 'emailLocale';
+/** Workflow-context key carrying the request locale through a run. */
+exports.WORKFLOW_CONTEXT_LOCALE_KEY = '__locale';
+const resolveEmailLocaleConfig = (uidl) => {
+    var _a;
+    const i18n = uidl.internationalization;
+    if (!i18n) {
+        return { locales: [], defaultLocale: '' };
+    }
+    const defaultLocale = ((_a = i18n.main) === null || _a === void 0 ? void 0 : _a.locale) || '';
+    const locales = Object.keys(i18n.languages || {});
+    if (defaultLocale && locales.indexOf(defaultLocale) === -1) {
+        locales.unshift(defaultLocale);
+    }
+    return { locales, defaultLocale };
+};
+exports.resolveEmailLocaleConfig = resolveEmailLocaleConfig;
+//# sourceMappingURL=email-locale-scope.js.map

package/dist/cjs/email-locale/email-locale-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-locale-scope.js","sourceRoot":"","sources":["../../../src/email-locale/email-locale-scope.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AAEU,QAAA,qBAAqB,GAAG,cAAc,CAAA;AACtC,QAAA,iBAAiB,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;AACtC,QAAA,sBAAsB,GAAG,cAAc,CAAA;AAEpD;;;GAGG;AACU,QAAA,mBAAmB,GAAG,mBAAmB,CAAA;AAEtD,6EAA6E;AAChE,QAAA,kBAAkB,GAAG,aAAa,CAAA;AAE/C;;;;;GAKG;AACU,QAAA,8BAA8B,GAAG,oBAAoB,CAAA;AAElE;;;;;;GAMG;AACU,QAAA,uBAAuB,GAAG,aAAa,CAAA;AAEpD,sEAAsE;AACzD,QAAA,2BAA2B,GAAG,UAAU,CAAA;AAa9C,MAAM,wBAAwB,GAAG,CAAC,IAAiB,EAAqB,EAAE;;IAC/E,MAAM,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAA;IACtC,IAAI,CAAC,IAAI,EAAE;QACT,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,CAAA;KAC1C;IACD,MAAM,aAAa,GAAG,CAAA,MAAA,IAAI,CAAC,IAAI,0CAAE,MAAM,KAAI,EAAE,CAAA;IAC7C,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,CAAA;IACjD,IAAI,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE;QAC1D,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAA;KAC/B;IACD,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,CAAA;AACnC,CAAC,CAAA;AAXY,QAAA,wBAAwB,4BAWpC"}

package/dist/cjs/email-locale/index.d.ts

@@ -0,0 +1,11 @@
+import { ProjectPluginStructure } from '@teleporthq/teleport-types';
+export { EMAIL_LOCALE_CONFIG_KEY, EMAIL_LOCALE_HEADER, EmailLocaleConfig, LOCALIZED_TEMPLATES_CONFIG_KEY, WORKFLOW_CONTEXT_LOCALE_KEY, resolveEmailLocaleConfig, } from './email-locale-scope';
+export { generateEmailLocaleHelpersCode, generateEmailLocaleModuleCode, generateWorkflowLocaleHelpersCode, } from './email-locale-code';
+/**
+ * Writes `utils/email/email-locale.js` into the project, once. Like the
+ * sent-email ledger, every emitter of a send path that lives outside the
+ * workflow runtime calls this right where it emits the `require`, so the file
+ * exists exactly when something needs it, whichever plugin ran first.
+ */
+export declare const ensureEmailLocaleModule: (structure: ProjectPluginStructure) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/email-locale/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/email-locale/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,sBAAsB,EAAE,MAAM,4BAA4B,CAAA;AAS7E,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,iBAAiB,EACjB,8BAA8B,EAC9B,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC7B,iCAAiC,GAClC,MAAM,qBAAqB,CAAA;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,cAAe,sBAAsB,KAAG,IAgB3E,CAAA"}

package/dist/cjs/email-locale/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureEmailLocaleModule = exports.generateWorkflowLocaleHelpersCode = exports.generateEmailLocaleModuleCode = exports.generateEmailLocaleHelpersCode = exports.resolveEmailLocaleConfig = exports.WORKFLOW_CONTEXT_LOCALE_KEY = exports.LOCALIZED_TEMPLATES_CONFIG_KEY = exports.EMAIL_LOCALE_HEADER = exports.EMAIL_LOCALE_CONFIG_KEY = void 0;
+const teleport_types_1 = require("@teleporthq/teleport-types");
+const email_locale_code_1 = require("./email-locale-code");
+const email_locale_scope_1 = require("./email-locale-scope");
+var email_locale_scope_2 = require("./email-locale-scope");
+Object.defineProperty(exports, "EMAIL_LOCALE_CONFIG_KEY", { enumerable: true, get: function () { return email_locale_scope_2.EMAIL_LOCALE_CONFIG_KEY; } });
+Object.defineProperty(exports, "EMAIL_LOCALE_HEADER", { enumerable: true, get: function () { return email_locale_scope_2.EMAIL_LOCALE_HEADER; } });
+Object.defineProperty(exports, "LOCALIZED_TEMPLATES_CONFIG_KEY", { enumerable: true, get: function () { return email_locale_scope_2.LOCALIZED_TEMPLATES_CONFIG_KEY; } });
+Object.defineProperty(exports, "WORKFLOW_CONTEXT_LOCALE_KEY", { enumerable: true, get: function () { return email_locale_scope_2.WORKFLOW_CONTEXT_LOCALE_KEY; } });
+Object.defineProperty(exports, "resolveEmailLocaleConfig", { enumerable: true, get: function () { return email_locale_scope_2.resolveEmailLocaleConfig; } });
+var email_locale_code_2 = require("./email-locale-code");
+Object.defineProperty(exports, "generateEmailLocaleHelpersCode", { enumerable: true, get: function () { return email_locale_code_2.generateEmailLocaleHelpersCode; } });
+Object.defineProperty(exports, "generateEmailLocaleModuleCode", { enumerable: true, get: function () { return email_locale_code_2.generateEmailLocaleModuleCode; } });
+Object.defineProperty(exports, "generateWorkflowLocaleHelpersCode", { enumerable: true, get: function () { return email_locale_code_2.generateWorkflowLocaleHelpersCode; } });
+/**
+ * Writes `utils/email/email-locale.js` into the project, once. Like the
+ * sent-email ledger, every emitter of a send path that lives outside the
+ * workflow runtime calls this right where it emits the `require`, so the file
+ * exists exactly when something needs it, whichever plugin ran first.
+ */
+const ensureEmailLocaleModule = (structure) => {
+    const { files, uidl } = structure;
+    if (files.has(email_locale_scope_1.EMAIL_LOCALE_FILE_KEY)) {
+        return;
+    }
+    files.set(email_locale_scope_1.EMAIL_LOCALE_FILE_KEY, {
+        path: email_locale_scope_1.EMAIL_LOCALE_PATH,
+        files: [
+            {
+                name: email_locale_scope_1.EMAIL_LOCALE_FILE_NAME,
+                fileType: teleport_types_1.FileType.JS,
+                content: (0, email_locale_code_1.generateEmailLocaleModuleCode)((0, email_locale_scope_1.resolveEmailLocaleConfig)(uidl)),
+            },
+        ],
+    });
+};
+exports.ensureEmailLocaleModule = ensureEmailLocaleModule;
+//# sourceMappingURL=index.js.map

package/dist/cjs/email-locale/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/email-locale/index.ts"],"names":[],"mappings":";;;AAAA,+DAA6E;AAC7E,2DAAmE;AACnE,6DAK6B;AAE7B,2DAO6B;AAN3B,6HAAA,uBAAuB,OAAA;AACvB,yHAAA,mBAAmB,OAAA;AAEnB,oIAAA,8BAA8B,OAAA;AAC9B,iIAAA,2BAA2B,OAAA;AAC3B,8HAAA,wBAAwB,OAAA;AAE1B,yDAI4B;AAH1B,mIAAA,8BAA8B,OAAA;AAC9B,kIAAA,6BAA6B,OAAA;AAC7B,sIAAA,iCAAiC,OAAA;AAGnC;;;;;GAKG;AACI,MAAM,uBAAuB,GAAG,CAAC,SAAiC,EAAQ,EAAE;IACjF,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,SAAS,CAAA;IACjC,IAAI,KAAK,CAAC,GAAG,CAAC,0CAAqB,CAAC,EAAE;QACpC,OAAM;KACP;IAED,KAAK,CAAC,GAAG,CAAC,0CAAqB,EAAE;QAC/B,IAAI,EAAE,sCAAiB;QACvB,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,2CAAsB;gBAC5B,QAAQ,EAAE,yBAAQ,CAAC,EAAE;gBACrB,OAAO,EAAE,IAAA,iDAA6B,EAAC,IAAA,6CAAwB,EAAC,IAAI,CAAC,CAAC;aACvE;SACF;KACF,CAAC,CAAA;AACJ,CAAC,CAAA;AAhBY,QAAA,uBAAuB,2BAgBnC"}

package/dist/cjs/executor-generator.d.ts

@@ -1,4 +1,14 @@
-export declare const generateSharedRuntimeUtilsCode: () => string;
+import { EmailLocaleConfig } from './email-locale';
+export interface SharedRuntimeUtilsOptions {
+    /**
+     * The project's locales, baked in so the runtime can validate the locale a
+     * request or the browser reports and pick the matching copy of a localized
+     * email. Absent (a project without internationalization): no locale is ever
+     * recognised and every email keeps its single template.
+     */
+    emailLocales?: EmailLocaleConfig;
+}
+export declare const generateSharedRuntimeUtilsCode: (options?: SharedRuntimeUtilsOptions) => string;
 export declare const generateClientRuntimeCode: () => string;
 export declare const generateServerRuntimeCode: () => string;
 //# sourceMappingURL=executor-generator.d.ts.map

package/dist/cjs/executor-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor-generator.d.ts","sourceRoot":"","sources":["../../src/executor-generator.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,QAAO,MA2xCjD,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MAmlB5C,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MAK5C,CAAA"}
+{"version":3,"file":"executor-generator.d.ts","sourceRoot":"","sources":["../../src/executor-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EAGlB,MAAM,gBAAgB,CAAA;AAEvB,MAAM,WAAW,yBAAyB;IACxC;;;;;OAKG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAA;CACjC;AAID,eAAO,MAAM,8BAA8B,aAAa,yBAAyB,KAAQ,MA2zCxF,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MA2lB5C,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAO,MAK5C,CAAA"}

package/dist/cjs/executor-generator.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateServerRuntimeCode = exports.generateClientRuntimeCode = exports.generateSharedRuntimeUtilsCode = void 0;
-const generateSharedRuntimeUtilsCode = () => {
+const email_locale_1 = require("./email-locale");
+const NO_EMAIL_LOCALES = { locales: [], defaultLocale: '' };
+const generateSharedRuntimeUtilsCode = (options = {}) => {
     return `/**
  * Workflow Runtime Utilities
  * 
@@ -11,7 +13,8 @@ const generateSharedRuntimeUtilsCode = () => {
  * - executeNodes: Executes a sequence of workflow nodes
  * - executeWorkflow: Main workflow execution entry point
  */
-
+${(0, email_locale_1.generateEmailLocaleHelpersCode)(options.emailLocales || NO_EMAIL_LOCALES)}
+${(0, email_locale_1.generateWorkflowLocaleHelpersCode)()}
 function resolveValue(value, context) {
   if (value === null || value === undefined) return value;
   if (Array.isArray(value)) {
@@ -525,6 +528,11 @@ function resolveConfig(config, context) {
   //
   // Runs after resolution on purpose: \`templateParams[].value\` is itself a
   // workflow-context ref that the loop above has just resolved.
+  //
+  // The language is chosen first, for the same reason: a customer email carries
+  // one copy per project language, and the copy has to be picked before its
+  // tokens are filled.
+  applyLocalizedEmailTemplate(resolved, context);
   if (Array.isArray(resolved.templateParams)) {
     if (typeof resolved.body === 'string') {
       resolved.body = applyTemplateParams(resolved.body, resolved.templateParams);
@@ -654,6 +662,12 @@ async function executeWorkflow(workflowConfig, triggerContext, nodeHandlers, opt
   if (triggerContext && triggerContext.triggerElement) {
     context.triggerElement = triggerContext.triggerElement;
   }
+  // The language of the page this run started on, carried to every server
+  // segment (the context crosses whole) so a customer email can be sent in it.
+  var runLocale = getClientLocale();
+  if (runLocale) {
+    context.__locale = runLocale;
+  }
 
   const callServerSegment = options.callServerSegment;
 
@@ -753,6 +767,15 @@ function isFireAndForgetNode(node) {
   return !!node.config && node.config.awaitResult === false;
 }
 
+// A node the author marked \`continueOnError\`: a failed RESULT ({ success:
+// false } / { error }) is published under the node's id like any other result
+// instead of aborting the workflow, so a later if-statement can read
+// \`success\` and warn. Only an explicit \`true\` opts in. A handler that THROWS
+// still aborts — every provider handler reports failure as a result.
+function continuesOnError(node) {
+  return !!(node && node.config && node.config.continueOnError === true);
+}
+
 // Starts a fire-and-forget node and returns a promise that ALWAYS resolves.
 // The workflow has already moved on, so a failure here can neither abort it nor
 // reach the error handler — it is reported to the console and swallowed, which
@@ -794,10 +817,13 @@ async function settlePendingNodePromises(context) {
   for (var pass = 0; pass < 5; pass++) {
     var pending = context.__pendingNodePromises;
     if (!pending || pending.length === 0) return;
-    context.__pendingNodePromises = [];
+    // Drained IN PLACE, never by swapping in a fresh array: a parallel branch
+    // that is still running holds a reference to this very array (its context
+    // is a shallow copy) and must keep landing on the queue the route drains.
+    var batch = pending.splice(0, pending.length);
     // Every entry swallows its own rejection (see startFireAndForgetNode), so
     // this can never reject.
-    await Promise.all(pending);
+    await Promise.all(batch);
   }
 }
 
@@ -921,7 +947,7 @@ async function executeNodes(nodes, edges, context, nodeHandlers, workflowConfig,
               await executeNodes(onStreamNodes, edges, context, nodeHandlers, workflowConfig, callServerSegment, executionId);
             }
           });
-          if (isFatalNodeResult(streamResult)) {
+          if (isFatalNodeResult(streamResult) && !continuesOnError(node)) {
             throw new Error(fatalNodeResultMessage(streamResult));
           }
           context[node.id] = streamResult;
@@ -980,7 +1006,7 @@ async function executeNodes(nodes, edges, context, nodeHandlers, workflowConfig,
         throw earlyErr;
       }
 
-      if (isFatalNodeResult(result)) {
+      if (isFatalNodeResult(result) && !continuesOnError(node)) {
         throw new Error(fatalNodeResultMessage(result));
       }
 
@@ -1279,6 +1305,13 @@ function internalRequestHeaders(req) {
 
 module.exports = {
   internalRequestHeaders,
+  normalizeEmailLocale,
+  resolveRequestLocale,
+  resolveWorkflowLocale,
+  resolveEmailLocale,
+  getClientLocale,
+  localizeHref,
+  pickLocalizedTemplate,
   resolveValue,
   resolveSecret,
   resolveConfig,
@@ -1302,6 +1335,7 @@ module.exports = {
   isStreamingAINode,
   isFatalNodeResult,
   fatalNodeResultMessage,
+  continuesOnError,
   isFireAndForgetNode,
   startFireAndForgetNode,
   registerPendingNodePromise,
@@ -1548,6 +1582,11 @@ function buildContext(workflowConfig, triggerContext) {
     if (triggerContext.__dynamicRouteParam) context.__dynamicRouteParam = triggerContext.__dynamicRouteParam;
     if (triggerContext.triggerElement) context.triggerElement = triggerContext.triggerElement;
   }
+  // See executeWorkflow: the page's language travels with the run.
+  var runLocale = utils.getClientLocale();
+  if (runLocale) {
+    context.__locale = runLocale;
+  }
   return context;
 }
 
@@ -1875,7 +1914,10 @@ async function executeWorkflowWithSegments(workflowConfig, triggerContext, clien
       if (__terminalResult) {
         var __redirectUrl = __terminalResult.__redirectUrl;
         if (typeof __redirectUrl === 'string' && __redirectUrl.length > 0 && typeof window !== 'undefined' && window.location) {
-          window.location.href = __redirectUrl;
+          // A site-relative target keeps the visitor in the language of the
+          // page the run started on (the provider's hosted page is absolute
+          // and passes through untouched).
+          window.location.href = utils.localizeHref(__redirectUrl, context.__locale);
         }
         break;
       }