npm - @pikku/core - Versions diffs - 0.12.94 → 0.12.96 - Mend

@pikku/core 0.12.94 → 0.12.96

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (62) hide show

package/CHANGELOG.md +179 -0
package/dist/dev/hot-reload.js +24 -4
package/dist/dev/module-runner.d.ts +20 -3
package/dist/dev/module-runner.js +17 -4
package/dist/services/email-template.d.ts +43 -0
package/dist/services/email-template.js +139 -0
package/dist/services/http-personas.d.ts +6 -1
package/dist/services/http-personas.js +4 -1
package/dist/services/index.d.ts +1 -0
package/dist/services/index.js +1 -0
package/dist/wirings/agent/agent-prepare.d.ts +14 -0
package/dist/wirings/agent/agent-prepare.js +24 -0
package/dist/wirings/agent/index.d.ts +1 -1
package/dist/wirings/agent/index.js +1 -1
package/dist/wirings/scheduler/scheduler-runner.js +0 -1
package/dist/wirings/virtual-user/index.d.ts +1 -0
package/dist/wirings/virtual-user/index.js +1 -0
package/dist/wirings/virtual-user/virtual-user-derive.js +9 -0
package/dist/wirings/virtual-user/virtual-user-scaffold.d.ts +267 -0
package/dist/wirings/virtual-user/virtual-user-scaffold.js +400 -0
package/dist/wirings/workflow/index.d.ts +1 -0
package/dist/wirings/workflow/index.js +1 -0
package/dist/wirings/workflow/pikku-workflow-service.js +3 -9
package/dist/wirings/workflow/scenario-prose.d.ts +23 -1
package/dist/wirings/workflow/scenario-prose.js +12 -3
package/dist/wirings/workflow/scenario-run.types.d.ts +7 -0
package/dist/wirings/workflow/workflow-queue-routing.d.ts +18 -0
package/dist/wirings/workflow/workflow-queue-routing.js +35 -0
package/dist/wirings/workflow/workflow-status-stream.d.ts +28 -0
package/dist/wirings/workflow/workflow-status-stream.js +105 -0
package/package.json +1 -1
package/src/dev/hot-reload.test.ts +42 -0
package/src/dev/hot-reload.ts +30 -4
package/src/dev/module-runner.test.ts +56 -13
package/src/dev/module-runner.ts +32 -10
package/src/public-surface.json +17 -1
package/src/services/email-template.test.ts +311 -0
package/src/services/email-template.ts +254 -0
package/src/services/http-personas.ts +10 -2
package/src/services/index.ts +8 -0
package/src/services/persona-sign-in.test.ts +22 -0
package/src/wirings/agent/agent-helpers.test.ts +63 -0
package/src/wirings/agent/agent-prepare.ts +25 -0
package/src/wirings/agent/index.ts +1 -0
package/src/wirings/scheduler/scheduler-runner.test.ts +178 -0
package/src/wirings/scheduler/scheduler-runner.ts +0 -1
package/src/wirings/virtual-user/index.ts +20 -0
package/src/wirings/virtual-user/virtual-user-derive.test.ts +33 -5
package/src/wirings/virtual-user/virtual-user-derive.ts +9 -0
package/src/wirings/virtual-user/virtual-user-scaffold.test.ts +795 -0
package/src/wirings/virtual-user/virtual-user-scaffold.ts +634 -0
package/src/wirings/workflow/index.ts +4 -0
package/src/wirings/workflow/pikku-workflow-service.test.ts +71 -2
package/src/wirings/workflow/pikku-workflow-service.ts +5 -11
package/src/wirings/workflow/scenario-prose.test.ts +134 -9
package/src/wirings/workflow/scenario-prose.ts +37 -2
package/src/wirings/workflow/scenario-run.types.ts +7 -0
package/src/wirings/workflow/workflow-child-run-session.test.ts +79 -0
package/src/wirings/workflow/workflow-queue-routing.ts +44 -0
package/src/wirings/workflow/workflow-status-stream.test.ts +354 -0
package/src/wirings/workflow/workflow-status-stream.ts +144 -0
package/tsconfig.tsbuildinfo +1 -1

package/src/public-surface.json CHANGED Viewed

@@ -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",
@@ -384,6 +399,7 @@
     "getStubTracker",
     "isTestRun",
     "pikkuWebhookWorkerFunc",
+    "renderEmail",
     "scenarioArtifactContentType",
     "scenarioRunSummary",
     "spy",

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

@@ -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>')
+  })
+})

package/src/services/email-template.ts ADDED Viewed

@@ -0,0 +1,254 @@
+/**
+ * The renderer behind a generated `pikku-emails.gen.ts`.
+ *
+ * The generated module supplies the assets — theme, locale strings, partials and
+ * the templates themselves — and a typed wrapper over `renderEmail`. Everything
+ * here is the same for every application, which is why it lives in core rather
+ * than in the string the CLI writes: this is HTML escaping, and code inside a
+ * template literal is never compiled, never linted, and testable only by
+ * matching the text it emits.
+ */
+export interface EmailTemplateHashes {
+  contentHash: string
+  htmlHash: string
+  subjectHash: string
+  textHash: string
+}
+export interface EmailTemplateAssets {
+  html: string
+  subject: string
+  text: string
+  variables: ReadonlyArray<string>
+  hashes: Record<string, EmailTemplateHashes>
+}
+export interface EmailAssets {
+  theme: Record<string, unknown>
+  locales: Record<string, Record<string, unknown>>
+  partials: Record<string, string>
+  templates: Record<string, EmailTemplateAssets>
+}
+export interface RenderEmailRequest {
+  name: string
+  locale?: string
+  data?: Record<string, unknown>
+}
+export interface RenderedEmailResult {
+  locale: string
+  subject: string
+  html: string
+  text?: string
+  variables: ReadonlyArray<string>
+  hash: string
+}
+const HTML_ESCAPES: Record<string, string> = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;',
+}
+const escapeHtml = (value: string): string =>
+  value.replace(/[&<>"']/g, (char) => HTML_ESCAPES[char] ?? char)
+// Matches the raw {{{ value }}} form before the escaped {{ value }} form, so the
+// opt-in escape hatch is never mistaken for a normal substitution.
+const TEMPLATE_TOKEN = /\{\{\{\s*([^{}]+?)\s*\}\}\}|\{\{\s*([^}]+?)\s*\}\}/g
+const PARTIAL_TOKEN = /\{\{\s*>\s*([a-zA-Z0-9-_/.]+)\s*\}\}/g
+const MAX_TEMPLATE_DEPTH = 5
+// theme.json and the locale files ship with the templates, so they are treated as
+// template-author input: expanded before caller data and allowed to contain their
+// own placeholders. Everything else is caller-supplied.
+const TRUSTED_ROOTS = ['theme', 't']
+const isTrustedKey = (key: string): boolean =>
+  TRUSTED_ROOTS.includes(String(key.split('.')[0]))
+const getNestedValue = (
+  source: Record<string, unknown>,
+  path: string
+): string => {
+  const segments = path.split('.')
+  let current: unknown = source
+  for (const segment of segments) {
+    // `hasOwn`, not `in`: `in` walks the prototype chain, so a path is answered
+    // by what an object inherits rather than only by what it carries. Nothing
+    // inherited reaches the output today — every step past a prototype hit lands
+    // on a function, which is neither traversed nor written — so this closes the
+    // lookup rather than fixing a value that escapes through it.
+    if (
+      !current ||
+      typeof current !== 'object' ||
+      !Object.hasOwn(current, segment)
+    ) {
+      return ''
+    }
+    current = (current as Record<string, unknown>)[segment]
+  }
+  return typeof current === 'string' || typeof current === 'number'
+    ? String(current)
+    : ''
+}
+const readToken = (rawTriple: unknown, rawDouble: unknown) => {
+  const raw = typeof rawTriple === 'string'
+  return { raw, key: String(raw ? rawTriple : rawDouble).trim() }
+}
+const expandPartials = (
+  source: string,
+  partials: Record<string, string>,
+  depth = 0
+): string => {
+  if (depth >= MAX_TEMPLATE_DEPTH) return source
+  let found = false
+  const expanded = source.replace(PARTIAL_TOKEN, (_match, partialName) => {
+    found = true
+    const partial = partials[String(partialName).trim()]
+    return typeof partial === 'string' ? partial : ''
+  })
+  return found ? expandPartials(expanded, partials, depth + 1) : expanded
+}
+const expandTrusted = (
+  source: string,
+  context: Record<string, unknown>,
+  escape: boolean
+): string => {
+  let rendered = source
+  for (let i = 0; i < MAX_TEMPLATE_DEPTH; i += 1) {
+    let found = false
+    const next = rendered.replace(
+      TEMPLATE_TOKEN,
+      (match, rawTriple, rawDouble) => {
+        const { raw, key } = readToken(rawTriple, rawDouble)
+        if (!isTrustedKey(key)) return match
+        found = true
+        const value = getNestedValue(context, key)
+        return raw || !escape ? value : escapeHtml(value)
+      }
+    )
+    if (!found || next === rendered) break
+    rendered = next
+  }
+  return rendered
+}
+// A single substitution pass — the replacement text is never rescanned, so a
+// caller-supplied value can never be reinterpreted as a template.
+const substitute = (
+  source: string,
+  context: Record<string, unknown>,
+  escape: boolean,
+  slot?: string
+): string =>
+  source.replace(TEMPLATE_TOKEN, (_match, rawTriple, rawDouble) => {
+    const { raw, key } = readToken(rawTriple, rawDouble)
+    // `content` is the layout's slot for the body that was already rendered and
+    // escaped, so it is the one value written in raw. Only the layout gets it:
+    // honouring it everywhere would let a caller pass `data.content` into a
+    // template that happens to name it and have it emitted unescaped.
+    if (slot !== undefined && key === slot) {
+      return typeof context[slot] === 'string' ? (context[slot] as string) : ''
+    }
+    if (key.startsWith('>')) {
+      return ''
+    }
+    const value = getNestedValue(context, key)
+    return raw || !escape ? value : escapeHtml(value)
+  })
+const renderTemplate = (
+  source: string,
+  partials: Record<string, string>,
+  context: Record<string, unknown>,
+  escape: boolean,
+  slot?: string
+): string => {
+  const composed = expandTrusted(
+    expandPartials(source, partials),
+    context,
+    escape
+  )
+  return substitute(composed, context, escape, slot)
+}
+export const renderEmail = (
+  { theme, locales, partials, templates }: EmailAssets,
+  { name, locale: requestedLocale, data }: RenderEmailRequest
+): RenderedEmailResult => {
+  const locale = requestedLocale ?? 'en'
+  const template = templates[name]
+  if (!template) {
+    throw new Error(`Unknown email template: ${name}`)
+  }
+  const strings = locales[locale]
+  if (!strings) {
+    throw new Error(`Unknown email locale: ${locale}`)
+  }
+  const values = data ?? {}
+  const appName =
+    (typeof values.appName === 'string' && values.appName) ||
+    getNestedValue(theme, 'appName')
+  const baseContext = {
+    ...values,
+    locale,
+    theme,
+    t: strings,
+    appName,
+  }
+  const subject = renderTemplate(
+    template.subject,
+    partials,
+    baseContext,
+    false
+  ).trim()
+  const htmlBody = renderTemplate(
+    template.html,
+    partials,
+    { ...baseContext, subject },
+    true
+  )
+  const html = partials.layout
+    ? renderTemplate(
+        partials.layout,
+        partials,
+        { ...baseContext, subject, content: htmlBody },
+        true,
+        'content'
+      )
+    : htmlBody
+  const text = template.text
+    ? renderTemplate(
+        template.text,
+        partials,
+        { ...baseContext, subject },
+        false
+      ).trim()
+    : undefined
+  return {
+    locale,
+    subject,
+    html,
+    ...(text ? { text } : {}),
+    variables: template.variables,
+    hash: template.hashes[locale]?.contentHash ?? '',
+  }
+}

package/src/services/http-personas.ts CHANGED Viewed

@@ -51,7 +51,12 @@ export interface HttpPersonasConfig {
   operator?: OperatorSignInOptions
   /** Persona id → the declaration with its address filled in. */
   personas: Record<string, ResolvedPersona>
-  /** Sign-in path under apiUrl. Default: the actor plugin's `/auth/sign-in/actor`. */
+  /**
+   * Sign-in path under apiUrl, for whichever of the two paths is in use — an
+   * app that mounts auth under `/api` moves both. Default: the actor plugin's
+   * `/auth/sign-in/actor`, or `/auth/sign-in/fabric` for an operator.
+   * {@link OperatorSignInOptions.signInPath} overrides it.
+   */
   signInPath?: string
   /** Where the session (and its roles) is read back. Default `/auth/get-session`. */
   sessionPath?: string
@@ -92,7 +97,10 @@ export class HttpPersona implements ScenarioPersona {
   ) {
     this.jar = createCookieJar(config.apiUrl)
     if (config.operator) {
-      this.signIn = new OperatorSignIn(config.apiUrl, config.operator)
+      this.signIn = new OperatorSignIn(config.apiUrl, {
+        ...config.operator,
+        signInPath: config.operator.signInPath ?? config.signInPath,
+      })
     } else if (config.secret) {
       this.signIn = new ActorSignIn(
         config.apiUrl,

package/src/services/index.ts CHANGED Viewed

@@ -53,6 +53,14 @@ export type {
   SendTemplateEmailInput,
   SendTextEmailInput,
 } from './email-service.js'
+export {
+  renderEmail,
+  type EmailAssets,
+  type EmailTemplateAssets,
+  type EmailTemplateHashes,
+  type RenderEmailRequest,
+  type RenderedEmailResult,
+} from './email-template.js'
 export {
   DEFAULT_WEBHOOK_RETRIES,
   PIKKU_OUTGOING_WEBHOOK_QUEUE_NAME,

package/src/services/persona-sign-in.test.ts CHANGED Viewed

@@ -115,6 +115,28 @@ describe('operator persona sign-in', () => {
     assert.equal(stage.createdCount, 0)
   })
+  // An app that mounts auth somewhere other than the root moves both sign-in
+  // paths together, and `SCENARIO_SIGN_IN_PATH` is the only place it can say so.
+  test('honours a moved sign-in path the same way the actor path does', async () => {
+    const stage = await startStage([
+      { id: 'user-7', email: 'customer@personas.invalid' },
+    ])
+    servers.push(stage.server)
+    const personas = createHttpPersonas({
+      apiUrl: stage.apiUrl.replace(/\/api$/, ''),
+      operator: { token: OPERATOR_TOKEN },
+      signInPath: '/api/auth/sign-in/fabric',
+      rpcPath: '/api/rpc',
+      personas: { customer: persona('customer@personas.invalid') },
+    })
+    const result = (await personas.customer!.invoke('whoami', {})) as {
+      actingAs: string | null
+    }
+    assert.equal(result.actingAs, 'user-7')
+  })
   test('refuses a persona the stage has no account for', async () => {
     const stage = await startStage([])
     servers.push(stage.server)