@bhooai/nexus-email 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# @bhooai/nexus-email
+
+Email providers, a template engine, and a Redis-backed queue.
+
+## Exports
+
+- `createEmail(config, { templates })` → `EmailService` with `send`.
+- **providers** — SMTP via `nodemailer`; a log provider for dev. Pluggable
+  `EmailProvider` interface.
+- **TemplateEngine** — `register(name, template)` + render with `{{var}}` interpolation.
+- **queue** — Redis-backed send queue (uses `nexus-cache` when available).
+
+## Usage
+
+```ts
+import { createEmail, TemplateEngine } from '@bhooai/nexus-email';
+const templates = new TemplateEngine();
+templates.register('welcome', '<h1>Welcome, {{name}}!</h1>');
+const email = createEmail(config.email, { templates });
+await email.send({ to: 'a@b.com', template: 'welcome', vars: { name: 'Ravi' } });
+```

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@bhooai/nexus-email",
+  "version": "0.1.0",
+  "publishConfig": { "access": "public" },
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@bhooai/nexus-core": "^0.1.0",
+    "nodemailer": "^6.9.16"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.0",
+    "@types/nodemailer": "^6.4.17",
+    "typescript": "^5.6.2",
+    "vitest": "^2.1.1"
+  }
+}

package/src/EmailService.ts

@@ -0,0 +1,76 @@
+import type { EmailProvider, EmailInput, EmailResult, QueueBackend } from './types.js';
+import { renderTemplate } from './providers.js';
+import { TemplateEngine } from './TemplateEngine.js';
+
+export interface EmailServiceOptions {
+  provider: EmailProvider;
+  templates?: TemplateEngine;
+  /** Optional queue; when set, `queue()` enqueues and a worker drains it. */
+  queue?: QueueBackend;
+  /** Max send attempts per queued job (exponential backoff). */
+  maxAttempts?: number;
+}
+
+/**
+ * EmailService ties a provider + template engine + optional queue together.
+ * `send()` renders (if a template is named) and sends immediately.
+ * `queue()` enqueues for background delivery; `startWorker()` drains the queue
+ * with retries (exponential backoff) until success or max attempts exhausted.
+ */
+export class EmailService {
+  readonly provider: EmailProvider;
+  private readonly templates?: TemplateEngine;
+  private readonly queueBackend?: QueueBackend;
+  private readonly maxAttempts: number;
+  private running = false;
+
+  constructor(opts: EmailServiceOptions) {
+    this.provider = opts.provider;
+    this.templates = opts.templates;
+    this.queueBackend = opts.queue;
+    this.maxAttempts = opts.maxAttempts ?? 3;
+  }
+
+  async send(input: EmailInput): Promise<EmailResult> {
+    const rendered = this.templates ? renderTemplate(input, this.templates) : input;
+    return this.provider.send(rendered);
+  }
+
+  async queue(input: EmailInput): Promise<void> {
+    if (!this.queueBackend) throw new Error('[nexus-email] no queue configured');
+    const rendered = this.templates ? renderTemplate(input, this.templates) : input;
+    await this.queueBackend.push(rendered);
+  }
+
+  /** Start the background worker (idempotent). */
+  startWorker(): void {
+    if (!this.queueBackend || this.running) return;
+    this.running = true;
+    (this.queueBackend as any).subscribe?.((job: EmailInput) => this.processWithRetry(job));
+  }
+
+  /** Process a queued job with exponential backoff up to maxAttempts. */
+  private async processWithRetry(job: EmailInput): Promise<void> {
+    let attempt = 0;
+    let lastErr: unknown;
+    while (attempt < this.maxAttempts) {
+      try {
+        await this.provider.send(job);
+        return;
+      } catch (err) {
+        lastErr = err;
+        attempt++;
+        if (attempt >= this.maxAttempts) break;
+        const backoff = 250 * 2 ** (attempt - 1);
+        await new Promise<void>((r) => setTimeout(r, backoff));
+      }
+    }
+    // Give up; in production this should go to a dead-letter store.
+    console.error(`[nexus-email] delivery failed after ${this.maxAttempts} attempts:`, (lastErr as Error)?.message);
+  }
+
+  async close(): Promise<void> {
+    this.running = false;
+    await this.queueBackend?.close();
+  }
+}

package/src/TemplateEngine.ts

@@ -0,0 +1,62 @@
+/**
+ * Minimal template engine for emails: `{{name}}` interpolation, `{{#if cond}}…{{/if}}`
+ * conditionals (with optional `{{else}}`), and `{{#each items}}…{{this}}…{{/each}}`
+ * iteration over arrays. No external dependency (no Handlebars) — sufficient for
+ * transactional email templates. Each transformation is applied in sequence
+ * (each → if → interpolate); `#each` bodies are rendered recursively per item with
+ * `this` merged into the vars.
+ */
+export class TemplateEngine {
+  private readonly templates = new Map<string, string>();
+
+  register(name: string, body: string): void {
+    this.templates.set(name, body);
+  }
+
+  has(name: string): boolean {
+    return this.templates.has(name);
+  }
+
+  render(name: string, vars: Record<string, unknown> = {}): string {
+    const body = this.templates.get(name);
+    if (body == null) throw new Error(`[nexus-email] unknown template: ${name}`);
+    return this.renderString(body, vars);
+  }
+
+  renderString(tpl: string, vars: Record<string, unknown>): string {
+    return interpolate(expandIf(expandEach(tpl, vars), vars), vars);
+  }
+}
+
+/** Expand `{{#each key}}…{{/each}}` by rendering the body recursively per item. */
+function expandEach(tpl: string, vars: Record<string, unknown>): string {
+  return tpl.replace(/\{\{#each\s+(\w+(?:\.\w+)*)\s*\}\}([\s\S]*?)\{\{\/each\}\}/g, (_m, key: string, body: string) => {
+    const arr = lookup(vars, key.trim());
+    if (!Array.isArray(arr)) return '';
+    return arr.map((item) => interpolate(expandIf(expandEach(body, { ...vars, this: item }), { ...vars, this: item }), { ...vars, this: item })).join('');
+  });
+}
+
+/** Expand `{{#if cond}}…{{else}}…{{/if}}` (cond truthy; empty arrays are falsy). */
+function expandIf(tpl: string, vars: Record<string, unknown>): string {
+  return tpl.replace(/\{\{#if\s+([^}]+?)\s*\}\}([\s\S]*?)(?:\{\{else\}\}([\s\S]*?))?\{\{\/if\}\}/g, (_m, cond: string, then: string, els?: string) => {
+    const val = lookup(vars, cond.trim());
+    const truthy = Array.isArray(val) ? val.length > 0 : !!val;
+    return truthy ? then : (els ?? '');
+  });
+}
+
+/** Replace `{{key}}` (and `{{ a.b.c }}`) with values; unknown keys → ''. */
+function interpolate(tpl: string, vars: Record<string, unknown>): string {
+  return tpl.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_m, expr: string) => {
+    const val = lookup(vars, expr.trim());
+    return val == null ? '' : String(val);
+  });
+}
+
+function lookup(vars: Record<string, unknown>, path: string): unknown {
+  return path.split('.').reduce<unknown>((acc, key) => {
+    if (acc == null || typeof acc !== 'object') return undefined;
+    return (acc as Record<string, unknown>)[key];
+  }, vars);
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+export * from './types.js';
+export * from './TemplateEngine.js';
+export * from './providers.js';
+export * from './queue.js';
+export * from './EmailService.js';
+
+import { SmtpProvider, LogProvider } from './providers.js';
+import { TemplateEngine } from './TemplateEngine.js';
+import { EmailService, type EmailServiceOptions } from './EmailService.js';
+import type { EmailProvider, QueueBackend } from './types.js';
+
+export interface EmailConfigLike {
+  provider: 'smtp' | 'log';
+  smtp?: { host: string; port: number; secure: boolean; user: string; pass: string };
+  from: string;
+}
+
+export interface CreateEmailOptions {
+  /** Inject a custom provider (tests). */
+  provider?: EmailProvider;
+  /** Inject a queue backend (default: none → send is synchronous only). */
+  queue?: QueueBackend;
+  templates?: TemplateEngine;
+  maxAttempts?: number;
+}
+
+/**
+ * Build an EmailService from the `email` config section. `provider: 'log'`
+ * never sends (dev/test); `provider: 'smtp'` uses nodemailer with the smtp config.
+ */
+export function createEmail(config: EmailConfigLike, opts: CreateEmailOptions = {}): EmailService {
+  const provider: EmailProvider = opts.provider
+    ?? (config.provider === 'smtp' && config.smtp
+      ? new SmtpProvider(config.smtp)
+      : new LogProvider());
+  return new EmailService({ provider, templates: opts.templates, queue: opts.queue, maxAttempts: opts.maxAttempts });
+}

package/src/providers.ts

@@ -0,0 +1,63 @@
+import nodemailer, { type Transport } from 'nodemailer';
+import type { EmailProvider, EmailInput, EmailResult } from './types.js';
+import { TemplateEngine } from './TemplateEngine.js';
+
+/** SMTP provider backed by nodemailer. The transport is injectable for tests. */
+export class SmtpProvider implements EmailProvider {
+  readonly name = 'smtp';
+  private readonly transport: { sendMail: (opts: any) => Promise<unknown> };
+
+  constructor(
+    opts: {
+      host: string;
+      port: number;
+      secure: boolean;
+      user: string;
+      pass: string;
+    },
+    /** Inject a custom nodemailer Transport (tests use `jsonTransport`). */
+    customTransport?: Transport,
+  ) {
+    this.transport = customTransport
+      ? nodemailer.createTransport(customTransport as any)
+      : nodemailer.createTransport({ host: opts.host, port: opts.port, secure: opts.secure, auth: { user: opts.user, pass: opts.pass } });
+  }
+
+  async send(input: EmailInput): Promise<EmailResult> {
+    const res = (await this.transport.sendMail({
+      to: input.to,
+      cc: input.cc,
+      bcc: input.bcc,
+      subject: input.subject,
+      html: input.html,
+      text: input.text,
+      attachments: input.attachments,
+      replyTo: input.replyTo,
+      headers: input.headers,
+    })) as { messageId?: string; envelope?: unknown };
+    return { messageId: res.messageId, envelope: res.envelope, raw: res, input };
+  }
+}
+
+/**
+ * Log provider: writes the email to the logger instead of sending it. Used when
+ * `config.email.provider === 'log'` (dev/test) so the app runs without SMTP.
+ */
+export class LogProvider implements EmailProvider {
+  readonly name = 'log';
+  private readonly log: (line: string) => void;
+  constructor(log?: (line: string) => void) {
+    this.log = log ?? ((line) => console.log(`[nexus-email] ${line}`));
+  }
+  async send(input: EmailInput): Promise<EmailResult> {
+    this.log(JSON.stringify({ name: input.to, subject: input.subject, text: input.text ?? input.html }));
+    return { messageId: `log-${Date.now()}`, input };
+  }
+}
+
+/** Render an EmailInput's template (if any) against the provided engine. */
+export function renderTemplate(input: EmailInput, engine: TemplateEngine): EmailInput {
+  if (!input.template) return input;
+  const html = engine.render(input.template, input.vars ?? {});
+  return { ...input, html: input.html ?? html, subject: /\{\{/.test(input.subject) ? engine.renderString(input.subject, input.vars ?? {}) : input.subject };
+}

package/src/queue.ts

@@ -0,0 +1,103 @@
+import type { EmailInput, QueueBackend } from './types.js';
+
+/**
+ * In-memory queue backend: push appends to an array; the consumer drains it on a
+ * poll interval. Sufficient for single-instance apps and tests; RedisQueue is the
+ * horizontal-scale option (below). The queue never blocks the sender.
+ */
+export class MemoryQueue implements QueueBackend {
+  private readonly jobs: EmailInput[] = [];
+  private readonly consumers = new Set<(job: EmailInput) => Promise<void>>();
+  private readonly interval: ReturnType<typeof setInterval>;
+  private closed = false;
+
+  constructor(pollMs = 50) {
+    this.interval = setInterval(() => void this.drain(), pollMs);
+  }
+
+  async push(job: EmailInput): Promise<void> {
+    if (this.closed) throw new Error('[nexus-email] queue closed');
+    this.jobs.push(job);
+  }
+
+  subscribe(consumer: (job: EmailInput) => Promise<void>): void {
+    this.consumers.add(consumer);
+  }
+
+  private async drain(): Promise<void> {
+    while (this.jobs.length > 0 && this.consumers.size > 0) {
+      const job = this.jobs.shift();
+      if (!job) break;
+      for (const c of this.consumers) {
+        await c(job);
+      }
+    }
+  }
+
+  get pending(): number {
+    return this.jobs.length;
+  }
+
+  async close(): Promise<void> {
+    this.closed = true;
+    clearInterval(this.interval);
+  }
+}
+
+/**
+ * Redis-backed queue using LPUSH (producer) + RPOP (consumer poll). Uses a
+ * dedicated redis client (the `redis` package). Jobs are JSON-serialized
+ * EmailInputs. Gracefully degrades to no-op if a client can't connect — callers
+ * that need guaranteed delivery should check connectivity at boot.
+ */
+export class RedisQueue implements QueueBackend {
+  private readonly key: string;
+  private client: any;
+  private connected = false;
+  private readonly consumers = new Set<(job: EmailInput) => Promise<void>>();
+  private interval: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private readonly createClient: () => any,
+    key = 'nexus:email:queue',
+    pollMs = 100,
+  ) {
+    this.key = key;
+    this.interval = setInterval(() => void this.drain(), pollMs);
+  }
+
+  async ensureConnected(): Promise<void> {
+    if (this.connected) return;
+    this.client = this.createClient();
+    await this.client.connect();
+    this.connected = true;
+  }
+
+  async push(job: EmailInput): Promise<void> {
+    await this.ensureConnected();
+    await this.client.lPush(this.key, JSON.stringify(job));
+  }
+
+  subscribe(consumer: (job: EmailInput) => Promise<void>): void {
+    this.consumers.add(consumer);
+  }
+
+  private async drain(): Promise<void> {
+    if (!this.connected || this.consumers.size === 0) return;
+    try {
+      while (true) {
+        const raw = (await this.client.rPop(this.key)) as string | null;
+        if (!raw) break;
+        const job = JSON.parse(raw) as EmailInput;
+        for (const c of this.consumers) await c(job);
+      }
+    } catch {
+      // transient redis errors shouldn't kill the poller
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.interval) clearInterval(this.interval);
+    if (this.connected) await this.client?.quit();
+  }
+}

package/src/types.ts

@@ -0,0 +1,49 @@
+/** Email-domain types shared by providers, templates, and the service. */
+
+export interface EmailAttachment {
+  filename: string;
+  content: string | Buffer;
+  contentType?: string;
+  /** Path to a file on disk (alternative to inline `content`). */
+  path?: string;
+}
+
+export interface EmailInput {
+  to: string | string[];
+  cc?: string | string[];
+  bcc?: string | string[];
+  subject: string;
+  /** HTML body. */
+  html?: string;
+  /** Plain-text body. */
+  text?: string;
+  /** Named template to render (used by EmailService, not providers directly). */
+  template?: string;
+  /** Variables for the template. */
+  vars?: Record<string, unknown>;
+  attachments?: EmailAttachment[];
+  replyTo?: string;
+  headers?: Record<string, string>;
+}
+
+export interface EmailResult {
+  /** Provider message id. */
+  messageId?: string;
+  /** Provider response envelope (nodemailer). */
+  envelope?: unknown;
+  /** Raw response for debugging. */
+  raw?: unknown;
+  /** The input that was sent (for queue/audit). */
+  input: EmailInput;
+}
+
+export interface EmailProvider {
+  readonly name: string;
+  send(input: EmailInput): Promise<EmailResult>;
+}
+
+/** Generic send-queue backend (memory or Redis). */
+export interface QueueBackend {
+  push(job: EmailInput): Promise<void>;
+  close(): Promise<void>;
+}

package/tests/email.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest';
+import nodemailer from 'nodemailer';
+import {
+  TemplateEngine,
+  SmtpProvider,
+  LogProvider,
+  MemoryQueue,
+  EmailService,
+  createEmail,
+  renderTemplate,
+  type EmailInput,
+} from '../src/index.js';
+
+/** A capturing log provider for assertions. */
+function capturingLog(): { provider: LogProvider; lines: string[] } {
+  const lines: string[] = [];
+  return { provider: new LogProvider((l) => lines.push(l)), lines };
+}
+
+describe('TemplateEngine', () => {
+  it('interpolates {{var}} and nested paths', () => {
+    const e = new TemplateEngine();
+    expect(e.renderString('Hi {{user.name}}, {{x}}!', { user: { name: 'Al' }, x: 1 })).toBe('Hi Al, 1!');
+  });
+  it('renders #if / #else', () => {
+    const e = new TemplateEngine();
+    expect(e.renderString('{{#if ok}}yes{{else}}no{{/if}}', { ok: true })).toBe('yes');
+    expect(e.renderString('{{#if ok}}yes{{else}}no{{/if}}', { ok: false })).toBe('no');
+  });
+  it('renders #each with {{this}}', () => {
+    const e = new TemplateEngine();
+    expect(e.renderString('{{#each items}}[{{this}}]{{/each}}', { items: ['a', 'b', 'c'] })).toBe('[a][b][c]');
+  });
+  it('registered templates render with vars', () => {
+    const e = new TemplateEngine();
+    e.register('welcome', 'Hello {{name}}!');
+    expect(e.render('welcome', { name: 'Bob' })).toBe('Hello Bob!');
+  });
+  it('throws on unknown template', () => {
+    expect(() => new TemplateEngine().render('nope', {})).toThrow(/unknown template/);
+  });
+});
+
+describe('LogProvider', () => {
+  it('logs the email and returns a messageId', async () => {
+    const { provider, lines } = capturingLog();
+    const res = await provider.send({ to: 'a@x.com', subject: 'Hi', text: 'body' });
+    expect(res.messageId).toMatch(/^log-/);
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toContain('a@x.com');
+    expect(lines[0]).toContain('Hi');
+  });
+});
+
+describe('SmtpProvider', () => {
+  it('sends via a jsonTransport (no network) and returns a messageId', async () => {
+    const provider = new SmtpProvider({ host: 'localhost', port: 25, secure: false, user: 'u', pass: 'p' }, { jsonTransport: true } as any);
+    const res = await provider.send({ to: 'a@x.com', subject: 'Hi', html: '<b>hi</b>' });
+    expect(res.messageId).toBeDefined();
+    expect(res.raw).toBeDefined();
+  });
+
+  it('nodemailer jsonTransport round-trip via createTransport directly', async () => {
+    const transport = nodemailer.createTransport({ jsonTransport: true });
+    const info = await transport.sendMail({ to: 'a@x.com', subject: 'x', html: '<b>x</b>' });
+    expect(info.messageId).toBeDefined();
+  });
+});
+
+describe('renderTemplate', () => {
+  it('renders html + subject from a named template', () => {
+    const e = new TemplateEngine();
+    e.register('receipt', 'Hi {{name}}, your order {{order}} is confirmed');
+    const input: EmailInput = { to: 'a@x.com', subject: 'Order {{order}}', template: 'receipt', vars: { name: 'Al', order: '42' } };
+    const out = renderTemplate(input, e);
+    expect(out.html).toBe('Hi Al, your order 42 is confirmed');
+    expect(out.subject).toBe('Order 42');
+  });
+});
+
+describe('EmailService (queue + retry)', () => {
+  it('send() renders template and delegates to provider', async () => {
+    const e = new TemplateEngine();
+    e.register('welcome', 'Hello {{name}}');
+    const { provider, lines } = capturingLog();
+    const svc = new EmailService({ provider, templates: e });
+    await svc.send({ to: 'a@x.com', subject: 's', template: 'welcome', vars: { name: 'Zed' } });
+    expect(lines[0]).toContain('Hello Zed');
+  });
+
+  it('queue + worker delivers once, with retries on failure', async () => {
+    let calls = 0;
+    const provider = { name: 'flaky', async send() { calls++; if (calls < 2) throw new Error('boom'); return { input: {} as EmailInput }; } };
+    const queue = new MemoryQueue(20);
+    const svc = new EmailService({ provider: provider as any, queue, maxAttempts: 3 });
+    svc.startWorker();
+    await svc.queue({ to: 'a@x.com', subject: 's', text: 't' });
+    await new Promise<void>((r) => setTimeout(r, 400)); // let the worker drain + retry
+    expect(calls).toBe(2); // failed once, succeeded on retry
+    await svc.close();
+  });
+
+  it('gives up after maxAttempts', async () => {
+    let calls = 0;
+    const provider = { name: 'dead', async send() { calls++; throw new Error('always'); } };
+    const queue = new MemoryQueue(20);
+    const svc = new EmailService({ provider: provider as any, queue, maxAttempts: 2 });
+    svc.startWorker();
+    await svc.queue({ to: 'a@x.com', subject: 's', text: 't' });
+    await new Promise<void>((r) => setTimeout(r, 800));
+    expect(calls).toBe(2);
+    await svc.close();
+  });
+});
+
+describe('createEmail factory', () => {
+  it('uses LogProvider when provider === "log"', () => {
+    const svc = createEmail({ provider: 'log', from: 'x@x.com' });
+    expect(svc.provider.name).toBe('log');
+  });
+  it('uses SmtpProvider when provider === "smtp"', () => {
+    const svc = createEmail({ provider: 'smtp', smtp: { host: 'h', port: 587, secure: false, user: 'u', pass: 'p' }, from: 'x@x.com' });
+    expect(svc.provider.name).toBe('smtp');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "references": [{ "path": "../nexus-core" }]
+}

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineProject } from 'vitest/config';
+
+export default defineProject({
+  test: {
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    globals: false,
+    testTimeout: 15_000,
+  },
+});

package/vitest.config.ts.timestamp-1786095205351-97e80dff9b2c7.mjs

@@ -0,0 +1,14 @@
+// packages/nexus-email/vitest.config.ts
+import { defineProject } from "file:///C:/server/BhooAI/BhooAI-Nexus/BhooAI-Nexus/bhooai-nexus/node_modules/vitest/dist/config.js";
+var vitest_config_default = defineProject({
+  test: {
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+    globals: false,
+    testTimeout: 15e3
+  }
+});
+export {
+  vitest_config_default as default
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsicGFja2FnZXMvbmV4dXMtZW1haWwvdml0ZXN0LmNvbmZpZy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiY29uc3QgX192aXRlX2luamVjdGVkX29yaWdpbmFsX2Rpcm5hbWUgPSBcIkM6XFxcXHNlcnZlclxcXFxCaG9vQUlcXFxcQmhvb0FJLU5leHVzXFxcXEJob29BSS1OZXh1c1xcXFxiaG9vYWktbmV4dXNcXFxccGFja2FnZXNcXFxcbmV4dXMtZW1haWxcIjtjb25zdCBfX3ZpdGVfaW5qZWN0ZWRfb3JpZ2luYWxfZmlsZW5hbWUgPSBcIkM6XFxcXHNlcnZlclxcXFxCaG9vQUlcXFxcQmhvb0FJLU5leHVzXFxcXEJob29BSS1OZXh1c1xcXFxiaG9vYWktbmV4dXNcXFxccGFja2FnZXNcXFxcbmV4dXMtZW1haWxcXFxcdml0ZXN0LmNvbmZpZy50c1wiO2NvbnN0IF9fdml0ZV9pbmplY3RlZF9vcmlnaW5hbF9pbXBvcnRfbWV0YV91cmwgPSBcImZpbGU6Ly8vQzovc2VydmVyL0Job29BSS9CaG9vQUktTmV4dXMvQmhvb0FJLU5leHVzL2Job29haS1uZXh1cy9wYWNrYWdlcy9uZXh1cy1lbWFpbC92aXRlc3QuY29uZmlnLnRzXCI7aW1wb3J0IHsgZGVmaW5lUHJvamVjdCB9IGZyb20gJ3ZpdGVzdC9jb25maWcnO1xuXG5leHBvcnQgZGVmYXVsdCBkZWZpbmVQcm9qZWN0KHtcbiAgdGVzdDoge1xuICAgIGVudmlyb25tZW50OiAnbm9kZScsXG4gICAgaW5jbHVkZTogWyd0ZXN0cy8qKi8qLnRlc3QudHMnXSxcbiAgICBnbG9iYWxzOiBmYWxzZSxcbiAgICB0ZXN0VGltZW91dDogMTVfMDAwLFxuICB9LFxufSk7Il0sCiAgIm1hcHBpbmdzIjogIjtBQUEwYSxTQUFTLHFCQUFxQjtBQUV4YyxJQUFPLHdCQUFRLGNBQWM7QUFBQSxFQUMzQixNQUFNO0FBQUEsSUFDSixhQUFhO0FBQUEsSUFDYixTQUFTLENBQUMsb0JBQW9CO0FBQUEsSUFDOUIsU0FBUztBQUFBLElBQ1QsYUFBYTtBQUFBLEVBQ2Y7QUFDRixDQUFDOyIsCiAgIm5hbWVzIjogW10KfQo=