dsh-mosaic 0.2.1

package/lib/index.js

@@ -0,0 +1,365 @@
+/**
+ * dsh-mosaic host half.
+ *
+ * Adds a compact visual-answer section to the system prompt, two model tools
+ * (`render_view`, `validate_view`), and a bundled `mosaic` skill with the full
+ * field reference. The browser half renders the `dsh-view` fence and the
+ * `render_view` tool card; it ships no heavy chart or diagram engines.
+ */
+import { readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { readFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createLog } from './log.js'
+import { createPromptController, crossSiteError, PROMPT_ROUTE, readJsonBody } from './prompt-store.js'
+import { createRenderViewTool } from './render-tool.js'
+import { createValidateViewTool } from './validate-tool.js'
+
+const PACKAGE_VERSION = createRequire(import.meta.url)('../package.json').version
+
+export const name = 'dsh-mosaic'
+export const inject = ['systemPrompt']
+
+/* ------------------------------------------------------------------ */
+/* lazy Mermaid engine                                                 */
+/* ------------------------------------------------------------------ */
+
+// `/plugins` belongs to the client module system, so a plugin asset route keeps to a
+// package-private prefix and never shadows or collides with it.
+const ASSET_ROUTE_PATH = '/dsh-mosaic/assets'
+const ASSET_FILE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*\.js$/
+// The unmodified official Mermaid distribution; see THIRD_PARTY_NOTICES.md.
+const MERMAID_ASSET_FILE = 'mermaid.min.js'
+const MERMAID_VERSION = '12.2.0'
+// Client-side diagnostics land here; bounded body, same-origin only.
+const LOG_ROUTE = '/dsh-mosaic/log'
+const LOG_BODY_LIMIT = 4096
+
+/**
+ * Resolve the prompt this plugin contributes to the system prompt. The row's
+ * `config.prompt` overrides the built-in text; an absent, blank, oversized, or
+ * non-string value falls back to it, so a malformed patch can never silence the
+ * visualization guidance.
+ *
+ * @param {unknown} config - the Loader row's config.
+ * @returns {string} the prompt to contribute.
+ */
+export function resolvePrompt(config) {
+  const prompt = config !== null && typeof config === 'object' ? config.prompt : undefined
+  if (typeof prompt !== 'string') return MOSAIC_SECTION_TEXT
+  const trimmed = prompt.trim()
+  if (trimmed === '' || Buffer.byteLength(trimmed, 'utf8') > 128 * 1024) return MOSAIC_SECTION_TEXT
+  return trimmed
+}
+
+async function serveMosaicAsset(req, res) {
+  if (req.method !== 'GET' && req.method !== 'HEAD') {
+    res.writeHead(405)
+    res.end()
+    return
+  }
+  let pathname
+  try {
+    pathname = decodeURIComponent(new URL(req.url ?? '/', 'http://x').pathname)
+  } catch {
+    res.writeHead(400)
+    res.end()
+    return
+  }
+  if (!pathname.startsWith(`${ASSET_ROUTE_PATH}/`)) {
+    res.writeHead(404)
+    res.end()
+    return
+  }
+  const file = pathname.slice(ASSET_ROUTE_PATH.length + 1)
+  if (!ASSET_FILE_RE.test(file)) {
+    res.writeHead(404)
+    res.end()
+    return
+  }
+  try {
+    const moduleDirectory = dirname(fileURLToPath(import.meta.url))
+    const body = await readFile(resolve(moduleDirectory, 'assets', file))
+    const versioned = new URL(req.url ?? '/', 'http://x').searchParams.has('v')
+    res.writeHead(200, {
+      'content-type': 'text/javascript; charset=utf-8',
+      // The client appends ?v=<version>, so a versioned URL can be cached for good;
+      // anything else keeps revalidating.
+      'cache-control': versioned ? 'public, max-age=31536000, immutable' : 'no-cache',
+    })
+    res.end(body)
+  } catch {
+    res.writeHead(404)
+    res.end()
+  }
+}
+
+export const MOSAIC_SECTION_TEXT = `Render a visual answer with a fenced \`dsh-view\` JSON block, or with the \`render_view\` tool when a self-contained card is useful.
+
+\`\`\`dsh-view
+{"title":"Ops snapshot","gap":12,"items":[{"type":"stat","label":"Uptime","value":"99.96%"}]}
+\`\`\`
+
+Mosaic is optional. Use it when a component makes the answer easier to scan; plain prose is fine. Do not add a component just to satisfy a format. When you do use one, prefer a single focal component and do not repeat the same data as both a table and a chart.
+
+Components (fields in the \`mosaic\` skill):
+- Layout: text · row · col · grid · card · divider · spacer
+- Display: stat · badge · progress · list · table · keyvalue · steps · callout · code · diff · chart · diagram
+- Media: image · video · audio · pdf · link
+- Interactive: button · input · select · slider · tabs · quiz
+- Advanced: widget (HTML/CSS/JS in an opaque-origin, no-network sandbox iframe)
+
+Rules:
+- Put \`dsh-view\` in the reply body, never in reasoning. JSON must be strict.
+- The opening fence tag MUST be exactly \`dsh-view\`. Never use \`\`\`json, \`\`\`text, or an unlabelled fence for a full spec; a \`json\` fence is at best a legacy fallback and may not render.
+- Files and Office documents: use a \`link\` card. Mosaic does not read local files or render Office; the host app opens them.
+- Media accepts an http(s) or root-relative URL.
+- Interactions are local by default. A button \`action\` sends \`[mosaic-action]\`; \`local\` supports reset/copy/open/fullscreen. A button with neither is disabled.
+- When you show a flow, sequence, or layered architecture, use \`diagram\` (\`flowchart\`, \`sequence\`, \`timeline\`, \`layers\`); do not hand-write Mermaid unless it is inside a widget. For a long flowchart (more than 6 nodes), prefer \`direction:"TB"\`; \`LR\` becomes horizontally scrollable.
+- Limits: 80 nodes, depth 6, table 40×8, chart 40 points, diagram 12 nodes/20 edges, widget code 20k. \`validate_view\` is available for a preflight check on complex specs.
+
+Field quick reference:
+- text {content, size, align, tone, mono}
+- stat {label, value, delta, spark:[numbers]}
+- table {columns:[strings], rows:[[cells]], types:[text|num|delta|bar|badge], total, export, filter:<field id>, sort:<field id>}
+- chart {kind:bars|line|donut, data:[{label,value}], series:[{label,data:[{label,value}]}], stacked}
+- diagram {kind:flowchart|sequence|timeline|layers, direction:TB|LR, nodes:[{id,label,sub,tone,shape}], edges:[{from,to,label,kind}], participants:[{id,label}], messages:[{from,to,label,kind}], items:[{title,desc,time}], layers:[{title,items}]}
+- callout {content, title, tone:info|success|warning|error}
+- list {items: strings | {title,desc} | components}
+- button {label, action | local:reset|copy|open|fullscreen, text, url, tone}
+- input/select/slider {id, label, ...}; table/list filter binds to an input/select id
+- quiz {question, options:[{label,correct,feedback}], explanation}
+- widget {code, height, title, caption}
+- link {label, href, description}; image/video/audio/pdf {src, ...}
+
+The \`mosaic\` skill carries the full component table, examples, and the widget bridge (\`window.mosaic.action\`, \`window.mosaic.resize\`).`
+
+/**
+ * Externally chosen finite order: `getSectionOrder(name)` resolves centrally allocated
+ * positions reserved for repository-owned contributors, so a plugin names its own slot.
+ * 9800 sits after the deliverable guidance and before the structured-output section.
+ */
+const PROMPT_SECTION_ORDER = 9800
+
+function registerPromptSection(ctx, text) {
+  return ctx.systemPrompt.section({
+    name: 'mosaic:view',
+    order: PROMPT_SECTION_ORDER,
+    text,
+    interpolate: false,
+  })
+}
+
+const BUNDLED_SKILL_PROVIDER = 'dsh-mosaic'
+const BUNDLED_SKILL_NAME = 'mosaic'
+// Lower than the packaged-skill standard rank (600) on purpose: a user-installed skill
+// named `mosaic` should win over this plugin's guidance copy.
+const MOSAIC_SKILL_RANK = 550
+const BUNDLED_SKILL_INVOCATION = { modelInvocable: true, userInvocable: true }
+
+function frontmatterField(front, key) {
+  const match = new RegExp(`^\\s*${key}\\s*:\\s*(.+?)\\s*$`, 'mu').exec(front)
+  return match?.[1]?.replace(/^['"]|['"]$/gu, '')
+}
+
+function bundledSkillProvider() {
+  const skill = bundledSkill()
+  return {
+    name: BUNDLED_SKILL_PROVIDER,
+    // A missing or malformed SKILL.md reports an incomplete catalog instead of
+    // throwing at plugin activation, so the fence and tool channels keep working.
+    list: () => Promise.resolve({
+      candidates: skill === undefined ? [] : [skillEntry(skill)],
+      complete: skill !== undefined,
+    }),
+    get: (candidate) => {
+      if (candidate === undefined) return Promise.resolve(undefined)
+      const current = bundledSkill()
+      if (current === undefined) return Promise.resolve(undefined)
+      return Promise.resolve({ ...skillEntry(current), content: current.raw.slice(current.end + 5) })
+    },
+  }
+}
+
+/** Read the bundled skill, or `undefined` when it cannot be used. */
+function bundledSkill() {
+  const moduleDirectory = dirname(fileURLToPath(import.meta.url))
+  const path = resolve(moduleDirectory, '../SKILL.md')
+  let raw
+  try {
+    raw = readFileSync(path, 'utf8')
+  } catch {
+    return undefined
+  }
+  const end = raw.indexOf('\n---\n', 4)
+  if (!raw.startsWith('---\n') || end < 0) return undefined
+  const description = frontmatterField(raw.slice(4, end), 'description')
+  if (description === undefined) return undefined
+  return { path, raw, end, description }
+}
+
+/** One catalog entry; `locator` is the opaque handle this provider owns. */
+function skillEntry(skill) {
+  return {
+    name: BUNDLED_SKILL_NAME,
+    description: skill.description,
+    invocation: BUNDLED_SKILL_INVOCATION,
+    source: 'bundled',
+    provider: BUNDLED_SKILL_PROVIDER,
+    path: skill.path,
+    resourceBase: { kind: 'directory', path: dirname(skill.path) },
+    rank: MOSAIC_SKILL_RANK,
+    locator: skill.path,
+  }
+}
+/**
+ * Register the Mosaic prompt section, tools, and skill.
+ *
+ * @param {import('@deepseek-ai/cordis').Context} ctx
+ */
+export function apply(ctx, config) {
+  const log = createLog({ ctx, level: config && typeof config === 'object' ? config.logLevel : undefined })
+  const clock = () => Date.now()
+  log.info('plugin.activate', {
+    version: PACKAGE_VERSION,
+    node: process.version,
+    configKeys: config && typeof config === 'object' ? Object.keys(config) : [],
+    logFile: log.file,
+  })
+  ctx.effect(() => () => {
+    log.info('plugin.deactivate', {})
+    void log.flush()
+  }, 'dsh-mosaic: log lifecycle')
+
+  // The effective prompt is the user's saved override, then the row's `config.prompt`,
+  // then the built-in text. The controller owns re-registration on every change, so the
+  // settings page and the profile patch both take effect without a reload.
+  const prompts = createPromptController({
+    ctx,
+    config,
+    log,
+    builtin: MOSAIC_SECTION_TEXT,
+    resolveConfigPrompt: resolvePrompt,
+    registerSection: registerPromptSection,
+    // A version query lets the asset route answer with an immutable cache entry.
+    assets: { mermaid: `${ASSET_ROUTE_PATH}/${MERMAID_ASSET_FILE}?v=${MERMAID_VERSION}` },
+  })
+  ctx.effect(() => prompts.start(), 'dsh-mosaic: prompt section')
+  prompts.hydrate().catch((error) => {
+    log.error('prompt.hydrate-failed', error)
+  })
+
+  // Tools are optional: a host without a tool registry keeps the fence channel.
+  // Every execution is recorded with its outcome and duration, never its arguments.
+  const traced = (definition) => ({
+    ...definition,
+    async execute(args, exec) {
+      const started = clock()
+      try {
+        const value = await definition.execute(args, exec)
+        log.info('tool.execute', {
+          tool: definition.name,
+          status: typeof value?.status === 'string' ? value.status : 'ok',
+          rendered: typeof value?.rendered === 'number' ? value.rendered : undefined,
+          errors: Array.isArray(value?.errors) ? value.errors.length : undefined,
+          ms: clock() - started,
+        })
+        return value
+      } catch (error) {
+        log.error('tool.failed', error, { tool: definition.name, ms: clock() - started })
+        throw error
+      }
+    },
+  })
+  ctx.inject(['tools'], (toolsCtx) => {
+    toolsCtx.effect(function* () {
+      yield toolsCtx.tools.register(traced(createRenderViewTool()))
+      yield toolsCtx.tools.register(traced(createValidateViewTool()))
+    }, 'dsh-mosaic: tools')
+  })
+
+  // The skill is optional too; the compact prompt section remains usable.
+  ctx.inject(['skills'], (skillCtx) => {
+    skillCtx.effect(
+      () => skillCtx.skills.registerProvider(() => {
+        const provider = bundledSkillProvider()
+        return {
+          ...provider,
+          async list(options) {
+            const result = await provider.list(options)
+            log.info('skill.list', { candidates: Array.isArray(result?.candidates) ? result.candidates.length : 0, complete: result?.complete })
+            return result
+          },
+          async get(candidate) {
+            const definition = await provider.get(candidate)
+            log.info('skill.get', { found: definition !== undefined })
+            return definition
+          },
+        }
+      }),
+      'dsh-mosaic: skill provider',
+    )
+  })
+
+  /** Record one served route without changing its response. */
+  const tracedRoute = (name, handler) => async (req, res) => {
+    const started = clock()
+    try {
+      await handler(req, res)
+    } finally {
+      log.info('route', { route: name, method: req.method ?? '?', status: res.statusCode, ms: clock() - started })
+    }
+  }
+
+  /** Accept one bounded diagnostic line from the browser half. */
+  async function handleClientLog(req, res) {
+    if (req.method !== 'POST') {
+      res.writeHead(405)
+      res.end()
+      return
+    }
+    const policy = crossSiteError(req)
+    if (policy !== undefined) {
+      log.warn('client.log-rejected', { reason: policy })
+      res.writeHead(403, { 'content-type': 'application/json; charset=utf-8' })
+      res.end(JSON.stringify({ error: policy }))
+      return
+    }
+    let body
+    try {
+      body = await readJsonBody(req, LOG_BODY_LIMIT)
+    } catch {
+      res.writeHead(400)
+      res.end()
+      return
+    }
+    const event = typeof body?.event === 'string' ? body.event.slice(0, 60) : 'client.event'
+    const detail = body?.detail !== null && typeof body?.detail === 'object' ? body.detail : {}
+    const fields = { source: 'client', ...detail }
+    if (body?.level === 'error') log.error(`client.${event}`, body?.message === undefined ? undefined : new Error(String(body.message)), fields)
+    else log.warn(`client.${event}`, fields)
+    res.writeHead(204)
+    res.end()
+  }
+
+  // Mermaid is a lazy standalone asset, served from this package's own route.
+  // A host without a webserver keeps the built-in SVG fallback.
+  ctx.inject(['webServer'], (webCtx) => {
+    const webServer = webCtx.webServer
+    webCtx.effect(
+      () => webServer.register({ kind: 'prefix', path: ASSET_ROUTE_PATH, handler: tracedRoute('assets', serveMosaicAsset) }),
+      'dsh-mosaic: asset route',
+    )
+    // The settings page reads and writes the prompt here. State-changing requests are
+    // same-origin only; see requestPolicyError for the exact checks.
+    webCtx.effect(
+      () => webServer.register({ kind: 'exact', path: PROMPT_ROUTE, handler: tracedRoute('prompt', (req, res) => prompts.handle(req, res)) }),
+      'dsh-mosaic: prompt route',
+    )
+    webCtx.effect(
+      () => webServer.register({ kind: 'exact', path: LOG_ROUTE, handler: (req, res) => handleClientLog(req, res) }),
+      'dsh-mosaic: log route',
+    )
+  })
+}

package/lib/log.js

@@ -0,0 +1,212 @@
+/**
+ * The plugin's own diagnostic log.
+ *
+ * One JSON object per line, one file per day, under `<DSH_HOME>/logs/dsh-mosaic/`.
+ * A plugin that misbehaves should be diagnosable from this file alone, so every
+ * lifecycle step, route decision and tool execution is recorded; user text never is.
+ *
+ * Design rules, in order of importance:
+ *  1. Never throw. Logging must not be able to break the plugin.
+ *  2. Never record secrets or user content: strings are truncated, prompt-like fields
+ *     are replaced by their length.
+ *  3. Bounded: a size cap rotates the current day's file, and old days are deleted.
+ *  4. Cheap: writes are queued on one promise chain, so callers never await disk IO.
+ */
+import { createHash } from 'node:crypto'
+import { appendFile, mkdir, readdir, rename, stat, unlink } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, join } from 'node:path'
+
+export const LOG_RETENTION_DAYS = 7
+export const LOG_MAX_BYTES_PER_FILE = 2 * 1024 * 1024
+export const LOG_MAX_STRING = 300
+export const LOG_LEVELS = ['debug', 'info', 'warn', 'error']
+
+/** Field names whose value may be user content or a secret; only their size is kept. */
+const REDACTED_FIELD = /^(prompt|text|code|content|secret|token|password|apiKey)$/i
+
+/**
+ * Resolve the log directory for this Host.
+ *
+ * @param {Record<string, string | undefined>} [env] - process environment.
+ * @returns {string} absolute directory path.
+ */
+export function logDirectory(env = process.env) {
+  const home = typeof env.DSH_HOME === 'string' && env.DSH_HOME !== '' ? env.DSH_HOME : join(homedir(), '.dsh')
+  return join(home, 'logs', 'dsh-mosaic')
+}
+
+/** `YYYY-MM-DD` in local time, so a day boundary matches the operator's clock. */
+export function dayStamp(date = new Date()) {
+  const pad = (value) => String(value).padStart(2, '0')
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
+}
+
+/**
+ * Make a value safe for a log line: bounded depth, bounded strings, no user content.
+ *
+ * @param {unknown} value - any structured value.
+ * @param {number} [depth] - remaining nesting budget.
+ * @returns {unknown} a JSON-safe projection.
+ */
+export function sanitizeForLog(value, depth = 0) {
+  if (value === null || value === undefined) return value
+  if (typeof value === 'string') return value.length > LOG_MAX_STRING ? `${value.slice(0, LOG_MAX_STRING)}…(${value.length})` : value
+  if (typeof value === 'number' || typeof value === 'boolean') return value
+  if (typeof value === 'bigint') return String(value)
+  if (typeof value === 'function' || typeof value === 'symbol') return undefined
+  if (value instanceof Error) return describeError(value)
+  if (depth >= 4) return '[depth]'
+  if (Array.isArray(value)) {
+    const items = value.slice(0, 20).map((item) => sanitizeForLog(item, depth + 1))
+    return value.length > 20 ? [...items, `…(${value.length})`] : items
+  }
+  const out = {}
+  for (const [key, child] of Object.entries(value)) {
+    if (REDACTED_FIELD.test(key) && typeof child === 'string') {
+      out[`${key}Chars`] = child.length
+      continue
+    }
+    const safe = sanitizeForLog(child, depth + 1)
+    if (safe !== undefined) out[key] = safe
+  }
+  return out
+}
+
+/**
+ * Describe an error without leaking payloads.
+ *
+ * @param {unknown} error - thrown value.
+ * @returns {{ name: string, message: string, code?: string, stack?: string }} fields.
+ */
+export function describeError(error) {
+  if (!(error instanceof Error)) return { name: 'Error', message: String(error).slice(0, LOG_MAX_STRING) }
+  const code = typeof error.code === 'string' ? error.code : undefined
+  return {
+    name: error.name,
+    message: error.message.slice(0, LOG_MAX_STRING),
+    ...code === undefined ? {} : { code },
+    ...typeof error.stack === 'string' ? { stack: error.stack.split('\n').slice(0, 6).join('\n') } : {},
+  }
+}
+
+/**
+ * Create the plugin log.
+ *
+ * @param {object} [options] - wiring.
+ * @param {object} [options.ctx] - plugin context; `ctx.logger` mirrors warnings upward.
+ * @param {string} [options.dir] - override directory (tests).
+ * @param {() => Date} [options.now] - clock (tests).
+ * @param {string} [options.level] - minimum level to record, from `config.logLevel`.
+ * @param {number} [options.retentionDays] - files older than this are deleted.
+ * @param {number} [options.maxBytes] - rotate the daily file past this size.
+ */
+export function createLog(options = {}) {
+  const {
+    ctx,
+    dir = logDirectory(),
+    now = () => new Date(),
+    level = 'info',
+    retentionDays = LOG_RETENTION_DAYS,
+    maxBytes = LOG_MAX_BYTES_PER_FILE,
+  } = options
+  const threshold = LOG_LEVELS.includes(level) ? LOG_LEVELS.indexOf(level) : LOG_LEVELS.indexOf('info')
+  const state = { disabled: false, warned: false, queue: Promise.resolve(), swept: false, file: undefined }
+
+  const currentFile = () => join(dir, `${dayStamp(now())}.jsonl`)
+
+  async function sweep() {
+    if (state.swept) return
+    state.swept = true
+    const cutoff = now().getTime() - retentionDays * 24 * 60 * 60 * 1000
+    try {
+      for (const name of await readdir(dir)) {
+        if (!name.endsWith('.jsonl')) continue
+        const path = join(dir, name)
+        const info = await stat(path).catch(() => undefined)
+        if (info !== undefined && info.mtimeMs < cutoff) await unlink(path).catch(() => {})
+      }
+    } catch {
+      // A missing or unreadable directory is not an error: the first write creates it.
+    }
+  }
+
+  async function rotateIfNeeded(path) {
+    const info = await stat(path).catch(() => undefined)
+    if (info === undefined || info.size < maxBytes) return
+    await rename(path, join(dir, `${basename(path, '.jsonl')}.1.jsonl`)).catch(() => {})
+  }
+
+  function mirror(entry) {
+    if (entry.level !== 'warn' && entry.level !== 'error') return
+    const logger = ctx?.logger
+    const method = entry.level === 'error' ? 'error' : 'warn'
+    try {
+      logger?.[method]?.(`mosaic: ${entry.event}`)
+    } catch {
+      // Logging upward must never fail the plugin either.
+    }
+  }
+
+  function write(levelName, event, fields, error) {
+    const index = LOG_LEVELS.indexOf(levelName)
+    if (index < threshold) return
+    const entry = {
+      ts: now().toISOString(),
+      level: levelName,
+      event: String(event).slice(0, 80),
+      ...sanitizeForLog(fields) ?? {},
+      ...error === undefined ? {} : { error: describeError(error) },
+    }
+    mirror(entry)
+    if (state.disabled) return
+    const line = `${JSON.stringify(entry)}\n`
+    state.queue = state.queue
+      .then(async () => {
+        await mkdir(dir, { recursive: true, mode: 0o700 })
+        const file = currentFile()
+        state.file = file
+        await sweep()
+        await rotateIfNeeded(file)
+        await appendFile(file, line, { mode: 0o600 })
+      })
+      .catch(() => {
+        // One warning upward, then stay quiet so a broken disk cannot flood anything.
+        if (state.disabled) return
+        state.disabled = true
+        if (!state.warned) {
+          state.warned = true
+          try {
+            ctx?.logger?.warn?.('mosaic: diagnostic log is unwritable; continuing without it')
+          } catch {}
+        }
+      })
+  }
+
+  return {
+    dir,
+    level: LOG_LEVELS[threshold] ?? 'info',
+    /** Path of the file currently being written, once known. */
+    get file() {
+      return state.file ?? currentFile()
+    },
+    /** Whether the directory accepted writes so far. */
+    get writable() {
+      return !state.disabled
+    },
+    debug: (event, fields) => write('debug', event, fields),
+    info: (event, fields) => write('info', event, fields),
+    warn: (event, fields) => write('warn', event, fields),
+    error: (event, error, fields) => write('error', event, fields, error),
+    /** Wait for queued lines; used by tests and by the dispose path. */
+    async flush() {
+      try {
+        await state.queue
+      } catch {}
+    },
+    /** Stable short fingerprint, for correlating two log lines without logging content. */
+    fingerprint(text) {
+      return createHash('sha256').update(String(text)).digest('hex').slice(0, 12)
+    },
+  }
+}