@pikku/core 0.12.93 → 0.12.95

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -11,7 +11,7 @@ import { buildRunTimeline, reconstructStateAt, } from './run-timeline.js';
 import { DEFAULT_STEP_RETRIES, WORKFLOW_CHILD_POLL_MAX_MS, WORKFLOW_END_STATES, WORKFLOW_POLL_FACTOR, WORKFLOW_POLL_MIN_MS, WORKFLOW_TERMINAL_STATES, isRunSettled, } from './workflow-constants.js';
 import { WorkflowAsyncException, WorkflowCancelledException, WorkflowDispatchException, WorkflowNotFoundError, WorkflowRunCancelledError, WorkflowRunFailedError, WorkflowRunNotFoundError, WorkflowStepNameNotString, WorkflowSuspendedException, } from './workflow-errors.js';
 import { resolveWorkflowMeta } from './workflow-meta-resolver.js';
-import { jobGroupFor, orchestratorQueueName, resolveWorkflowConfig, stepJobOptions, stepWorkerQueueName, } from './workflow-queue-routing.js';
+import { jobGroupFor, orchestratorQueueName, resolveWorkflowConfig, stepDispatchTarget, stepJobOptions, stepWorkerQueueName, } from './workflow-queue-routing.js';
 import { wireWorkflowQueueWorkers } from './workflow-queue-wiring.js';
 import { approvalStepNameFor, evaluateApprovalStep, recordApprovalDecision, } from './workflow-approval.js';
 import { auditApprovalDecision } from './workflow-approval-audit.js';
@@ -323,16 +323,10 @@ export class PikkuWorkflowService {
         });
     }
     async dispatchStep(runId, stepName, rpcName, data, stepOptions, fromStepName) {
-        const functionsMeta = pikkuState(null, 'function', 'meta');
-        const rpcFuncId = pikkuState(null, 'rpc', 'meta')[rpcName];
-        const rpcMeta = typeof rpcFuncId === 'string' ? functionsMeta[rpcFuncId] : undefined;
-        const forceQueue = rpcMeta?.workflowQueued === true;
-        if (!forceQueue) {
+        const target = await stepDispatchTarget(rpcName, stepName, () => this.isInline(runId));
+        if (target === 'inline') {
             return false;
         }
-        if (!getSingletonServices()?.queueService) {
-            throw new Error(`Workflow step '${stepName}' (function '${rpcName}') is marked 'workflowQueued: true' but no queue service is configured.`);
-        }
         try {
             await getSingletonServices().queueService.add(this.getStepWorkerQueueName(rpcName), { runId, stepName, rpcName, data, fromStepName }, {
                 ...this.resolveStepJobOptions(stepOptions),

package/dist/wirings/workflow/workflow-queue-routing.d.ts

@@ -4,5 +4,23 @@ export type WorkflowQueueStrategy = 'per-workflow' | 'shared-groups';
 export declare const resolveWorkflowConfig: () => WorkflowServiceConfig;
 export declare const orchestratorQueueName: (strategy: WorkflowQueueStrategy, workflowName?: string) => string;
 export declare const stepWorkerQueueName: (strategy: WorkflowQueueStrategy, rpcName?: string) => string;
+/**
+ * How a step reaches its worker: on the queue, or here in the orchestrator.
+ *
+ * A step naming a workflow queues whenever a queue exists, even unmarked. Run
+ * here, it holds the parent's run lock — and its lock connection — until the
+ * child ends, and marks the child inline so the child's own `sleep` degrades
+ * from a suspension into a real in-process wait. Workflows cannot opt in
+ * through `workflowQueued`: that flag is read off `rpc` meta, and `addWorkflow`
+ * never registers there.
+ *
+ * Throws only for a step that asked for the queue by name and has none, which
+ * is a deployment missing a service rather than a routing choice.
+ *
+ * `parentIsInline` is a thunk because resolving it can read the run store, and
+ * every step dispatch would pay for that — only a step that names a workflow
+ * and has a queue to reach ever asks.
+ */
+export declare const stepDispatchTarget: (rpcName: string, stepName: string, parentIsInline: () => Promise<boolean>) => Promise<"queue" | "inline">;
 export declare const jobGroupFor: (strategy: WorkflowQueueStrategy, id?: string) => JobGroup | undefined;
 export declare const stepJobOptions: (stepOptions?: WorkflowStepOptions) => JobOptions;

package/dist/wirings/workflow/workflow-queue-routing.js

@@ -25,6 +25,41 @@ const dedicatedQueueName = (prefix, name, strategy, fallback) => {
 };
 export const orchestratorQueueName = (strategy, workflowName) => dedicatedQueueName('wf-orchestrator-', workflowName, strategy, resolveWorkflowConfig().orchestratorQueueName);
 export const stepWorkerQueueName = (strategy, rpcName) => dedicatedQueueName('wf-step-', rpcName, strategy, resolveWorkflowConfig().stepWorkerQueueName);
+/**
+ * How a step reaches its worker: on the queue, or here in the orchestrator.
+ *
+ * A step naming a workflow queues whenever a queue exists, even unmarked. Run
+ * here, it holds the parent's run lock — and its lock connection — until the
+ * child ends, and marks the child inline so the child's own `sleep` degrades
+ * from a suspension into a real in-process wait. Workflows cannot opt in
+ * through `workflowQueued`: that flag is read off `rpc` meta, and `addWorkflow`
+ * never registers there.
+ *
+ * Throws only for a step that asked for the queue by name and has none, which
+ * is a deployment missing a service rather than a routing choice.
+ *
+ * `parentIsInline` is a thunk because resolving it can read the run store, and
+ * every step dispatch would pay for that — only a step that names a workflow
+ * and has a queue to reach ever asks.
+ */
+export const stepDispatchTarget = async (rpcName, stepName, parentIsInline) => {
+    const rpcFuncId = pikkuState(null, 'rpc', 'meta')[rpcName];
+    const rpcMeta = typeof rpcFuncId === 'string'
+        ? pikkuState(null, 'function', 'meta')[rpcFuncId]
+        : undefined;
+    const hasQueue = getSingletonServices()?.queueService !== undefined;
+    if (rpcMeta?.workflowQueued === true) {
+        if (!hasQueue) {
+            throw new Error(`Workflow step '${stepName}' (function '${rpcName}') is marked 'workflowQueued: true' but no queue service is configured.`);
+        }
+        return 'queue';
+    }
+    const isWorkflow = pikkuState(null, 'workflows', 'meta')[rpcName] !== undefined;
+    if (!isWorkflow || !hasQueue) {
+        return 'inline';
+    }
+    return (await parentIsInline()) ? 'inline' : 'queue';
+};
 export const jobGroupFor = (strategy, id) => id && strategy === 'shared-groups' ? { id, tier: id } : undefined;
 export const stepJobOptions = (stepOptions) => {
     const retries = stepOptions?.retries ?? DEFAULT_STEP_RETRIES;

package/dist/wirings/workflow/workflow-status-stream.d.ts

@@ -0,0 +1,28 @@
+import type { CoreUserSession } from '../../types/core.types.js';
+import type { PikkuChannel } from '../channel/channel.types.js';
+import type { WorkflowRunService } from './workflow.types.js';
+export interface WorkflowStatusStreamParams {
+    workflowRunService: WorkflowRunService;
+    runId: string;
+    channel: Pick<PikkuChannel<unknown, any>, 'send' | 'close'>;
+    session: CoreUserSession | undefined;
+    /**
+     * Whether to include what the run produced. Off for the user-facing route:
+     * a workflow's output and its error messages are internal detail, and a step
+     * that spawned a child run says so only to tooling that can follow it.
+     */
+    detailed?: boolean;
+    pollIntervalMs?: number;
+}
+/**
+ * Streams one run's progress until it reaches a terminal state.
+ *
+ * Polled rather than subscribed because a run's steps are written by whichever
+ * worker picked them up, in whichever process — there is no in-memory event to
+ * listen for that every deployment shape would deliver.
+ *
+ * Each poll sends only when something changed, compared by a hash of exactly
+ * what this stream reports. A run that sits on a slow step for a minute costs
+ * one message, not a hundred and twenty.
+ */
+export declare const streamWorkflowRunStatus: ({ workflowRunService, runId, channel, session, detailed, pollIntervalMs, }: WorkflowStatusStreamParams) => Promise<void>;

package/dist/wirings/workflow/workflow-status-stream.js

@@ -0,0 +1,105 @@
+import { assertWorkflowRunOwner } from './workflow-run-ownership.js';
+/**
+ * The status stream behind the scaffolded workflow SSE routes.
+ *
+ * Two routes share it, and they differ by one thing: whether the caller is
+ * trusted with what the run produced. A user-facing frontend gets step names
+ * and statuses; an admin console also gets the output, the error and the child
+ * run ids. That is a parameter, not a second copy of the loop.
+ */
+const TERMINAL = new Set([
+    'completed',
+    'failed',
+    'cancelled',
+]);
+const DEFAULT_POLL_INTERVAL_MS = 500;
+/**
+ * Streams one run's progress until it reaches a terminal state.
+ *
+ * Polled rather than subscribed because a run's steps are written by whichever
+ * worker picked them up, in whichever process — there is no in-memory event to
+ * listen for that every deployment shape would deliver.
+ *
+ * Each poll sends only when something changed, compared by a hash of exactly
+ * what this stream reports. A run that sits on a slow step for a minute costs
+ * one message, not a hundred and twenty.
+ */
+export const streamWorkflowRunStatus = async ({ workflowRunService, runId, channel, session, detailed = false, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, }) => {
+    let lastHash = '';
+    let initSent = false;
+    const poll = async () => {
+        const run = await workflowRunService.getRun(runId);
+        if (!run) {
+            await channel.close();
+            return false;
+        }
+        // Checked on every poll, not just the first: ownership is read from the run
+        // itself, and a stream that outlives a session should stop rather than keep
+        // reporting.
+        assertWorkflowRunOwner(run.wire, session);
+        const steps = await workflowRunService.getRunSteps(runId);
+        // A deterministic run knows its whole shape up front, so the client can
+        // draw every step — including the ones not started — before anything runs.
+        // A dynamic run has nothing to send here, and gets no init frame.
+        if (!initSent && run.deterministic) {
+            const statusByStep = new Map(steps.map((step) => [step.stepName, step.status]));
+            await channel.send({
+                type: 'init',
+                deterministic: true,
+                steps: (run.plannedSteps ?? []).map((step) => ({
+                    stepName: step.stepName,
+                    status: statusByStep.get(step.stepName) ?? 'pending',
+                })),
+            });
+            initSent = true;
+        }
+        const hash = JSON.stringify({
+            s: run.status,
+            ...(detailed ? { o: run.output } : {}),
+            steps: steps.map((step) => [step.stepName, step.status]),
+        });
+        if (hash !== lastHash) {
+            lastHash = hash;
+            await channel.send({
+                type: 'update',
+                status: run.status,
+                ...(detailed ? { output: run.output, error: run.error } : {}),
+                steps: steps.map((step) => ({
+                    stepName: step.stepName,
+                    status: step.status,
+                    ...(detailed && step.childRunId
+                        ? { childRunId: step.childRunId }
+                        : {}),
+                })),
+            });
+        }
+        if (TERMINAL.has(run.status)) {
+            await channel.send({ type: 'done' });
+            await channel.close();
+            return false;
+        }
+        return true;
+    };
+    // Every exit from here closes the channel, including the ones a throw takes:
+    // `assertWorkflowRunOwner` rejecting a session that lost access is exactly
+    // the case where the stream should end rather than be left hanging open.
+    try {
+        // A run that is already finished is answered without ever starting a timer.
+        if (!(await poll())) {
+            return;
+        }
+        // The next poll is scheduled when the previous one resolves rather than on
+        // a fixed interval. A timer that fires regardless would let two polls
+        // overlap on a slow store — both seeing `initSent` unset and sending the
+        // init frame twice, and racing `lastHash` into out-of-order updates.
+        while (await new Promise((resolve, reject) => {
+            setTimeout(() => void poll().then(resolve, reject), pollIntervalMs);
+        })) {
+            // The condition is the whole loop: poll until it says to stop.
+        }
+    }
+    catch (error) {
+        await channel.close();
+        throw error;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.93",
+  "version": "0.12.95",
   "description": "The Pikku runtime — functions, wirings, services, middleware and types",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",

package/src/public-surface.json

@@ -67,6 +67,7 @@
     "pikkuWorkflowGraph",
     "reconstructFinalState",
     "reconstructStateAt",
+    "streamWorkflowRunStatus",
     "template",
     "uuidv5"
   ],
@@ -103,22 +104,35 @@
     "IntentStack",
     "PRODUCTION_DISPOSITION",
     "STALE_RUN_AFTER_MS",
+    "VIRTUAL_USER_VARIABLES",
     "catalogueClassification",
     "catalogueLookup",
     "deriveCatalogue",
     "deriveIntents",
     "dispositionProfile",
+    "executeVirtualUserRun",
     "intentsForPersona",
     "isDue",
     "isReadOnly",
+    "logVirtualUserTick",
     "nextRunAt",
     "personaScopes",
     "personaVirtualUserTarget",
     "prepareVirtualUserRun",
     "reachableCatalogue",
+    "requireVirtualUserRunStore",
+    "requireVirtualUserScheduleStore",
     "runVirtualUser",
+    "runnablePersona",
+    "serializeVirtualUserRun",
+    "serializeVirtualUserSchedule",
+    "serializeVirtualUserSteps",
+    "signInPathFor",
+    "startVirtualUserRun",
     "tickVirtualUserSchedules",
-    "unreachableCatalogue"
+    "unreachableCatalogue",
+    "virtualUserScheduleRunInput",
+    "writeVirtualUserSchedule"
   ],
   "./channel/local": [
     "LocalEventHubService",
@@ -203,6 +217,7 @@
     "addAgent",
     "agent",
     "agentApprove",
+    "agentCallOptions",
     "agentInterrupt",
     "agentResume",
     "agentStream",
@@ -272,10 +287,13 @@
     "validateAndBuildSystemRoleDefinitionsMeta"
   ],
   "./persona": [
+    "APP_SCOPE_ROOT",
     "ActorSignIn",
     "HttpPersona",
     "IMPERSONATE_USER_ID_HEADER",
     "OperatorSignIn",
+    "appScopeId",
+    "buildAppScopeDefinition",
     "createHttpPersonas",
     "definePersonas",
     "establishOperatorSession",
@@ -381,6 +399,7 @@
     "getStubTracker",
     "isTestRun",
     "pikkuWebhookWorkerFunc",
+    "renderEmail",
     "scenarioArtifactContentType",
     "scenarioRunSummary",
     "spy",

package/src/services/email-template.test.ts

@@ -0,0 +1,311 @@
+import assert from 'node:assert'
+import { describe, test } from 'node:test'
+import { renderEmail, type EmailAssets } from './email-template.js'
+
+const THEME = {
+  appName: 'Pikku App',
+  colors: {
+    background: '#f5f7fb',
+    surface: '#ffffff',
+    text: '#101828',
+    border: '#d0d5dd',
+    primary: '#7c3aed',
+  },
+  fonts: {
+    body: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+  },
+}
+
+const LOCALES = {
+  en: {
+    passwordReset: {
+      subject: 'Reset your {{appName}} password',
+      note: 'If you did not ask for this, you can ignore it.',
+      cta: 'Choose a new password',
+    },
+  },
+}
+
+const PARTIALS = {
+  layout: `<!doctype html>
+<html lang="{{locale}}">
+  <head><title>{{subject}}</title></head>
+  <body style="font-family:{{theme.fonts.body}};color:{{theme.colors.text}};">
+    <div>{{content}}</div>
+  </body>
+</html>`,
+  footer: `<div class="footer" style="color:{{theme.colors.border}};">{{t.passwordReset.note}}</div>`,
+}
+
+const HTML = `<div>
+  <p>Hello {{userName}}.</p>
+  <a href="{{resetUrl}}" style="background:{{theme.colors.primary}};">{{t.passwordReset.cta}}</a>
+  <p>{{{rawNotice}}}</p>
+</div>
+{{> footer}}`
+
+const SUBJECT = `{{t.passwordReset.subject}}\n`
+
+const TEXT = `{{t.passwordReset.subject}}
+
+Hello {{userName}}.
+
+{{t.passwordReset.cta}}: {{resetUrl}}
+`
+
+const ASSETS: EmailAssets = {
+  theme: THEME,
+  locales: LOCALES,
+  partials: PARTIALS,
+  templates: {
+    'password-reset': {
+      html: HTML,
+      subject: SUBJECT,
+      text: TEXT,
+      variables: ['appName', 'rawNotice', 'resetUrl', 'userName'],
+      hashes: {
+        en: {
+          contentHash: 'content-hash',
+          htmlHash: 'html-hash',
+          subjectHash: 'subject-hash',
+          textHash: 'text-hash',
+        },
+      },
+    },
+  },
+}
+
+const render = (data: Record<string, unknown>) =>
+  renderEmail(ASSETS, { name: 'password-reset', locale: 'en', data })
+
+describe('renderEmail escaping', () => {
+  test('a value containing a double quote cannot break out of an attribute', () => {
+    const { html } = render({
+      resetUrl: 'https://x.test/" onmouseover="alert(1)',
+    })
+    assert.ok(
+      !html.includes('onmouseover="alert(1)"'),
+      `attribute broke out:\n${html}`
+    )
+    assert.ok(
+      html.includes('href="https://x.test/&quot; onmouseover=&quot;alert(1)"'),
+      `quote was not escaped:\n${html}`
+    )
+  })
+
+  test('a value containing markup renders escaped, with no raw script tag', () => {
+    const { html } = render({
+      resetUrl: '"><script>alert(1)</script><a href="',
+    })
+    assert.ok(!html.includes('<script>'), `raw <script> present:\n${html}`)
+    assert.ok(html.includes('&lt;script&gt;alert(1)&lt;/script&gt;'))
+  })
+
+  test('a value containing handlebars is not re-expanded', () => {
+    const { html } = render({ resetUrl: '{{t.passwordReset.note}}' })
+    assert.ok(
+      !html.includes('If you did not ask for this, you can ignore it.</a>'),
+      `caller value was re-expanded as a template:\n${html}`
+    )
+    assert.ok(html.includes('href="{{t.passwordReset.note}}"'))
+  })
+
+  test('a value cannot forge a partial reference', () => {
+    const { html } = render({ resetUrl: '{{> footer}}' })
+    assert.ok(html.includes('href="{{&gt; footer}}"'), html)
+  })
+
+  test('a font stack with embedded quotes renders a valid style attribute', () => {
+    const { html } = render({ resetUrl: 'https://x.test/reset' })
+    assert.ok(
+      html.includes(
+        '<body style="font-family:-apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, sans-serif;color:#101828;">'
+      ),
+      `theme font stack corrupted the style attribute:\n${html}`
+    )
+  })
+
+  test('an app name with an apostrophe and an ampersand stays inside the tag', () => {
+    const { html, subject } = render({
+      appName: "Peet's & Co",
+      resetUrl: 'https://x.test/reset',
+    })
+    assert.ok(
+      html.includes('<title>Reset your Peet&#39;s &amp; Co password</title>'),
+      html
+    )
+    assert.strictEqual(subject, "Reset your Peet's & Co password")
+  })
+
+  test('{{content}} and partials still render raw', () => {
+    const { html } = render({ resetUrl: 'https://x.test/reset' })
+    assert.ok(html.includes('<a href="https://x.test/reset"'), html)
+    assert.ok(html.includes('<div class="footer"'), html)
+    assert.ok(
+      html.includes('>If you did not ask for this, you can ignore it.</div>'),
+      html
+    )
+  })
+
+  test('the triple-brace form is an opt-in raw escape hatch', () => {
+    const { html } = render({
+      resetUrl: 'https://x.test/reset',
+      rawNotice: '<strong>read me</strong>',
+    })
+    assert.ok(html.includes('<p><strong>read me</strong></p>'), html)
+  })
+
+  test('locale strings that reference caller variables still expand', () => {
+    const { subject, text } = render({
+      userName: 'Ada',
+      resetUrl: 'https://x.test/reset',
+    })
+    assert.strictEqual(subject, 'Reset your Pikku App password')
+    assert.ok(text?.includes('Hello Ada.'), text)
+    assert.ok(
+      text?.includes('Choose a new password: https://x.test/reset'),
+      text
+    )
+  })
+
+  test('plain-text outputs are not html escaped', () => {
+    const { text } = render({
+      userName: 'Ada & Bob',
+      resetUrl: 'https://x.test/reset?a=1&b=2',
+    })
+    assert.ok(text?.includes('Hello Ada & Bob.'), text)
+    assert.ok(text?.includes('https://x.test/reset?a=1&b=2'), text)
+  })
+
+  // The recursion bounds are why a malicious partial or locale string cannot
+  // hang the render, and neither is reachable from the generated wrapper's
+  // types — only a template author can trip them.
+  test('a partial that includes itself terminates instead of hanging', () => {
+    const { html } = renderEmail(
+      {
+        ...ASSETS,
+        partials: { loop: '<i>{{> loop}}</i>' },
+        templates: {
+          ...ASSETS.templates,
+          'password-reset': {
+            ...ASSETS.templates['password-reset']!,
+            html: '{{> loop}}',
+          },
+        },
+      },
+      { name: 'password-reset', locale: 'en', data: {} }
+    )
+    assert.equal(html.match(/<i>/g)?.length, 5)
+  })
+
+  test('a locale string that references itself terminates instead of hanging', () => {
+    const { subject } = renderEmail(
+      {
+        ...ASSETS,
+        locales: { en: { loop: 'a{{t.loop}}' } },
+        templates: {
+          ...ASSETS.templates,
+          'password-reset': {
+            ...ASSETS.templates['password-reset']!,
+            subject: '{{t.loop}}',
+          },
+        },
+      },
+      { name: 'password-reset', locale: 'en', data: {} }
+    )
+    // Five trusted passes plus the final substitute pass, and the token the
+    // last one produced is left as text rather than expanded again.
+    assert.equal(subject, 'aaaaaa{{t.loop}}')
+  })
+})
+
+describe('renderEmail lookups', () => {
+  test('an unknown template names itself rather than rendering an empty mail', () => {
+    assert.throws(
+      () => renderEmail(ASSETS, { name: 'nope' }),
+      /Unknown email template: nope/
+    )
+  })
+
+  test('an unknown locale names itself', () => {
+    assert.throws(
+      () => renderEmail(ASSETS, { name: 'password-reset', locale: 'de' }),
+      /Unknown email locale: de/
+    )
+  })
+
+  test('the locale defaults to en', () => {
+    assert.equal(renderEmail(ASSETS, { name: 'password-reset' }).locale, 'en')
+  })
+
+  test('the content hash comes from the rendered locale', () => {
+    assert.equal(render({}).hash, 'content-hash')
+  })
+
+  test('a template with no text produces no text field at all', () => {
+    const result = renderEmail(
+      {
+        ...ASSETS,
+        templates: {
+          'password-reset': {
+            ...ASSETS.templates['password-reset']!,
+            text: '',
+          },
+        },
+      },
+      { name: 'password-reset' }
+    )
+    assert.equal('text' in result, false)
+  })
+})
+
+/**
+ * `content` is the layout's slot, not a name a caller may fill. It is the one
+ * value written without escaping, because by then it holds a body that has
+ * already been rendered and escaped.
+ */
+describe('renderEmail treats content as the layout slot only', () => {
+  const assets = (html: string, layout?: string): EmailAssets => ({
+    theme: { appName: 'Shop' },
+    locales: { en: {} },
+    partials: layout ? { layout } : {},
+    templates: {
+      welcome: {
+        html,
+        subject: 'Hi',
+        text: '',
+        variables: [],
+        hashes: {
+          en: {
+            contentHash: 'h',
+            htmlHash: 'h',
+            subjectHash: 'h',
+            textHash: 'h',
+          },
+        },
+      },
+    },
+  })
+
+  test('caller data named content is escaped like any other value', () => {
+    const { html } = renderEmail(assets('<p>{{ content }}</p>'), {
+      name: 'welcome',
+      data: { content: '<img src=x onerror=alert(1)>' },
+    })
+
+    assert.ok(
+      !html.includes('<img src=x'),
+      `caller content must not be written raw, got: ${html}`
+    )
+    assert.match(html, /&lt;img src=x/)
+  })
+
+  test('the layout still receives the rendered body unescaped', () => {
+    const { html } = renderEmail(
+      assets('<p>hello</p>', '<main>{{ content }}</main>'),
+      { name: 'welcome' }
+    )
+
+    assert.equal(html, '<main><p>hello</p></main>')
+  })
+})