@softize/opus 11.1.1 → 12.0.0

package/bin/lib/postinstall.mjs

@@ -14,9 +14,9 @@
  * ["@softize/opus"]`) ou aprovar. Sob npm roda direto.
  */
 
-import { promises as fs } from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { canonicalProjectDirectory, readProjectFile } from '@softize/base/project-path'
 
 import { initProject } from './init.mjs'
 
@@ -26,19 +26,20 @@ const REGISTRY_DIR = path.join(PACKAGE_ROOT, 'registry')
 async function main() {
   if (process.env.OPUS_SKIP_INIT) return
 
-  const projectDir = process.env.INIT_CWD || process.cwd()
+  const requestedProjectDir = process.env.INIT_CWD || process.cwd()
+  const projectDir = canonicalProjectDirectory(requestedProjectDir)
   // Não inicializa o próprio Opus.
   if (projectDir === PACKAGE_ROOT || projectDir.startsWith(PACKAGE_ROOT + path.sep)) return
 
   let pkg
   try {
-    pkg = JSON.parse(await fs.readFile(path.join(projectDir, 'package.json'), 'utf-8'))
+    pkg = JSON.parse(readProjectFile(projectDir, 'package.json').content)
   } catch {
     return // Sem package.json → não é projeto.
   }
   if (pkg.name === '@softize/opus') return
   const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) }
-  if (!deps['@softize/opus']) return // Não é consumidor da base.
+  if (!deps['@softize/opus']) return // Não é consumidor do Opus.
 
   const r = await initProject(REGISTRY_DIR, projectDir)
   if (!r.materialization.ok) {
@@ -47,7 +48,7 @@ async function main() {
   }
   const n = r.created.length + r.synced.length
   console.log(
-    `\x1b[36m[opus]\x1b[0m base v${r.version} — ${r.wasInitialized ? 'sincronizada' : 'inicializada'}` +
+    `\x1b[36m[opus]\x1b[0m Opus v${r.version} — ${r.wasInitialized ? 'sincronizado' : 'inicializado'}` +
       (n ? ` (${n} arquivo(s))` : '') +
       `. Veja base.json / opus.json.`,
   )

package/bin/lib/validate-skill.mjs

@@ -1,40 +1,512 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs'
-import { basename, join } from 'node:path'
+import { closeSync, existsSync, fstatSync, lstatSync, openSync, readFileSync, readdirSync, realpathSync } from 'node:fs'
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path'
+import MarkdownIt from 'markdown-it'
+import parseHtmlInline from 'markdown-it/lib/rules_inline/html_inline.mjs'
 
-const NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
 const PROHIBITED = new Set(['README.md', 'CHANGELOG.md', 'INSTALLATION_GUIDE.md', 'QUICK_REFERENCE.md'])
+const NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+const ROUTE = /^\s*<!--\s+softize-skill-route:\s+\$([a-z0-9]+(?:-[a-z0-9]+)*)\s+-->\s*$/
+const ROUTE_ATTEMPT = /softize-skill-\s*route\b/gu
+const URI_SCHEME = /^[a-z][a-z0-9+.-]*:/iu
+const DRIVE_DESIGNATOR = /^[a-z]:/iu
+const WINDOWS_ROOTED = /^(?:\\|%5c)/iu
+const UNC_PATH = /^(?:\\\\|\/\/)/u
+const ENCODED_SEPARATOR_OR_NUL = /%(?:00|2f|5c)/iu
+const MARKDOWN = new MarkdownIt({ html: true })
+const NATIVE_PATH = { isAbsolute, relative, sep }
+const markdownItValidateLink = MARKDOWN.validateLink.bind(MARKDOWN)
+MARKDOWN.validateLink = (target) => /^file:/iu.test(target) || markdownItValidateLink(target)
+MARKDOWN.inline.ruler.at('html_inline', (state, silent) => {
+  const sourceStart = state.pos
+  const matched = parseHtmlInline(state, silent)
+  if (matched && !silent) {
+    const token = state.tokens.at(-1)
+    if (token?.type === 'html_inline') token.meta = { ...token.meta, sourceStart }
+  }
+  return matched
+})
+
+function markdownDocument(text) {
+  const lines = text.split(/\r?\n/u)
+  const possibleFrontmatterEnd = lines[0] === '---' ? lines.indexOf('---', 1) : -1
+  const frontmatterEnd =
+    possibleFrontmatterEnd > 1 && lines.slice(1, possibleFrontmatterEnd).some((line) => /^[a-zA-Z0-9_-]+:\s*/u.test(line))
+      ? possibleFrontmatterEnd
+      : -1
+  const lineOffset = frontmatterEnd + 1
+  const env = {}
+  return {
+    env,
+    lines,
+    lineOffset,
+    tokens: MARKDOWN.parse(lines.slice(lineOffset).join('\n'), env),
+  }
+}
+
+function lineAt(content, offset, firstLine) {
+  let line = firstLine
+  for (let index = 0; index < offset; index += 1) {
+    if (content[index] === '\n') line += 1
+  }
+  return line
+}
+
+function attemptLines(content, firstLine) {
+  return [...content.matchAll(ROUTE_ATTEMPT)].map((match) => lineAt(content, match.index, firstLine))
+}
+
+function analyzeRoutes(text) {
+  const { lines, lineOffset, tokens } = markdownDocument(text)
+  const references = []
+  const errors = new Set()
+  const operational = new Set()
+
+  for (const token of tokens) {
+    if (token.map === null) continue
+    const firstLine = lineOffset + token.map[0]
+    const lastLine = lineOffset + token.map[1]
+
+    if (token.type === 'html_block') {
+      const route = lastLine === firstLine + 1 ? ROUTE.exec(token.content) : null
+      const attempts = attemptLines(token.content, firstLine)
+      if (route !== null) {
+        references.push(route[1])
+        operational.add(firstLine)
+      } else {
+        for (const line of attempts) errors.add(line)
+        if (lastLine === firstLine + 1) operational.add(firstLine)
+      }
+      continue
+    }
 
-function frontmatter(content) {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/.exec(content)
+    if (token.type !== 'inline') continue
+    for (const child of token.children ?? []) {
+      if (child.type !== 'html_inline') continue
+      const childLine = lineAt(token.content, child.meta.sourceStart, firstLine)
+      for (let line = childLine; line <= childLine + child.content.split('\n').length - 1; line += 1) {
+        operational.add(line)
+      }
+      for (const line of attemptLines(child.content, childLine)) errors.add(line)
+    }
+  }
+
+  return { errors: [...errors].sort((left, right) => left - right), lines, operational, references }
+}
+
+export function operationalMarkdownLines(text) {
+  const analysis = analyzeRoutes(text)
+  return analysis.lines.map((line, index) => ({ line, index, operational: analysis.operational.has(index) }))
+}
+
+function frontmatter(text) {
+  const match = /^---\n([\s\S]*?)\n---\n/.exec(text)
   if (match === null) return null
-  const entries = match[1].split(/\r?\n/).filter(Boolean).map((line) => {
-    const at = line.indexOf(':')
-    return at === -1 ? [line, ''] : [line.slice(0, at).trim(), line.slice(at + 1).trim()]
-  })
-  return Object.fromEntries(entries)
+  const fields = new Map()
+  for (const line of match[1].split('\n')) {
+    const field = /^([a-zA-Z0-9_-]+):\s*(.*)$/.exec(line)
+    if (field !== null) fields.set(field[1], field[2].replace(/^['"]|['"]$/g, '').trim())
+  }
+  return fields
+}
+
+export function referencedSkills(text) {
+  return [...new Set(analyzeRoutes(text).references)]
+}
+
+export function skillRouteErrors(text) {
+  return analyzeRoutes(text).errors.map((line) => `encaminhamento operacional malformado na linha ${line + 1}.`)
+}
+
+export function isPathInside(root, target, pathApi = NATIVE_PATH) {
+  const path = pathApi.relative(root, target)
+  return path === '' || (path !== '..' && !path.startsWith(`..${pathApi.sep}`) && !pathApi.isAbsolute(path))
+}
+
+function referenceTargetKind(target) {
+  if (DRIVE_DESIGNATOR.test(target) || WINDOWS_ROOTED.test(target) || UNC_PATH.test(target)) {
+    return 'absolute-filesystem'
+  }
+  if (/^file:/iu.test(target)) return 'unsupported-file-url'
+  if (URI_SCHEME.test(target)) return 'external-url'
+  return 'local'
+}
+
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino
+}
+
+function markdownResourceError(relativePath) {
+  return `${relativePath}: recurso Markdown deve ser arquivo regular e contido na skill.`
+}
+
+function entryExists(path) {
+  try {
+    lstatSync(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function inspectRegularResource(root, canonicalRoot, path, error) {
+  try {
+    const info = lstatSync(path)
+    const canonical = realpathSync(path)
+    if (
+      !info.isFile() ||
+      info.isSymbolicLink() ||
+      !isPathInside(root, path) ||
+      !isPathInside(canonicalRoot, canonical)
+    ) {
+      return { error }
+    }
+    return { canonical, info }
+  } catch {
+    return { error }
+  }
+}
+
+function inspectMarkdownResource(root, canonicalRoot, path, relativePath) {
+  const inspected = inspectRegularResource(root, canonicalRoot, path, markdownResourceError(relativePath))
+  if (inspected.error !== undefined) return inspected
+  return { resource: { path, relative: relativePath } }
+}
+
+function inspectReferenceDirectory(root, canonicalRoot, path, relativePath) {
+  try {
+    const info = lstatSync(path)
+    const canonical = realpathSync(path)
+    if (
+      !info.isDirectory() ||
+      info.isSymbolicLink() ||
+      !isPathInside(root, path) ||
+      !isPathInside(canonicalRoot, canonical)
+    ) {
+      return { error: `${relativePath}: diretório de referências deve ser real e contido na skill.` }
+    }
+    return { canonical, info }
+  } catch {
+    return { error: `${relativePath}: diretório de referências deve ser real e contido na skill.` }
+  }
+}
+
+function collectReferenceResources(root, canonicalRoot, current, resources, errors) {
+  const currentRelative = relative(root, current)
+  const before = inspectReferenceDirectory(root, canonicalRoot, current, currentRelative)
+  if (before.error !== undefined) {
+    errors.push(before.error)
+    return
+  }
+
+  let entries
+  try {
+    entries = readdirSync(current, { withFileTypes: true })
+  } catch {
+    errors.push(`${currentRelative}: diretório de referências não pôde ser lido com segurança.`)
+    return
+  }
+
+  const after = inspectReferenceDirectory(root, canonicalRoot, current, currentRelative)
+  if (
+    after.error !== undefined ||
+    !sameIdentity(before.info, after.info) ||
+    before.canonical !== after.canonical
+  ) {
+    errors.push(after.error ?? `${currentRelative}: diretório de referências mudou durante a leitura.`)
+    return
+  }
+
+  for (const entry of entries) {
+    const path = join(current, entry.name)
+    const relativePath = relative(root, path)
+    if (entry.isSymbolicLink()) {
+      errors.push(
+        extname(entry.name) === '.md'
+          ? markdownResourceError(relativePath)
+          : `${relativePath}: entrada simbólica não é permitida em references.`,
+      )
+    } else if (entry.isDirectory()) {
+      collectReferenceResources(root, canonicalRoot, path, resources, errors)
+    } else if (extname(entry.name) === '.md') {
+      const inspected = inspectMarkdownResource(root, canonicalRoot, path, relativePath)
+      if (inspected.error !== undefined) errors.push(inspected.error)
+      else resources.push(inspected.resource)
+    }
+  }
 }
 
-export function validateSkill(root) {
+function markdownResources(root) {
+  const resources = []
   const errors = []
-  const slug = basename(root)
-  const path = join(root, 'SKILL.md')
-  if (!existsSync(path)) return ['SKILL.md ausente.']
-  const content = readFileSync(path, 'utf8')
-  const metadata = frontmatter(content)
-  if (metadata === null) errors.push('frontmatter ausente ou inválido.')
+  let canonicalRoot
+  try {
+    const rootInfo = lstatSync(root)
+    if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink()) {
+      return { errors: ['raiz da skill deve ser um diretório real.'], resources }
+    }
+    canonicalRoot = realpathSync(root)
+  } catch {
+    return { errors: ['raiz da skill deve ser um diretório real.'], resources }
+  }
+
+  const skill = join(root, 'SKILL.md')
+  if (!entryExists(skill)) errors.push('SKILL.md ausente.')
   else {
-    if (Object.keys(metadata).sort().join(',') !== 'description,name') errors.push('frontmatter deve conter somente name e description.')
-    if (metadata.name !== slug) errors.push(`name deve ser igual à pasta (${slug}).`)
-    if (!NAME.test(metadata.name ?? '') || slug.length > 64) errors.push('name deve usar lowercase kebab-case e no máximo 64 caracteres.')
-    if (!/(use|usar|quando)/i.test(metadata.description ?? '')) errors.push('description deve declarar quando usar a skill.')
-  }
-  if (content.split(/\r?\n/).length > 500) errors.push('SKILL.md excede 500 linhas.')
-  if (/\bTODO\b|\bTBD\b|\[placeholder\]/i.test(content)) errors.push('skill contém placeholder.')
-  for (const name of readdirSync(root)) if (PROHIBITED.has(name)) errors.push(`${name} não pertence a uma skill.`)
-  const links = [...content.matchAll(/\[[^\]]+\]\(([^)]+)\)/g)].map((match) => match[1]).filter((link) => !/^[a-z]+:|^#/.test(link))
-  for (const link of links) if (!existsSync(join(root, link))) errors.push(`recurso inexistente: ${link}.`)
-  const ui = join(root, 'agents/openai.yaml')
-  if (!existsSync(ui)) errors.push('agents/openai.yaml ausente.')
-  else if (!readFileSync(ui, 'utf8').includes(`$${slug}`)) errors.push(`default_prompt deve mencionar $${slug}.`)
+    const inspected = inspectMarkdownResource(root, canonicalRoot, skill, 'SKILL.md')
+    if (inspected.error !== undefined) errors.push(inspected.error)
+    else resources.push(inspected.resource)
+  }
+
+  const references = join(root, 'references')
+  if (entryExists(references)) collectReferenceResources(root, canonicalRoot, references, resources, errors)
+  return { canonicalRoot, errors, resources }
+}
+
+function readRegularResource(root, canonicalRoot, resource, error) {
+  let descriptor
+  try {
+    const before = lstatSync(resource.path)
+    const canonicalBefore = realpathSync(resource.path)
+    if (
+      !before.isFile() ||
+      before.isSymbolicLink() ||
+      !isPathInside(root, resource.path) ||
+      !isPathInside(canonicalRoot, canonicalBefore)
+    ) {
+      return { error }
+    }
+
+    descriptor = openSync(resource.path, 'r')
+    const opened = fstatSync(descriptor)
+    if (!opened.isFile() || !sameIdentity(before, opened)) {
+      return { error }
+    }
+    const text = readFileSync(descriptor, 'utf8')
+    const after = fstatSync(descriptor)
+    const atPath = lstatSync(resource.path)
+    const canonicalAfter = realpathSync(resource.path)
+    if (
+      !after.isFile() ||
+      atPath.isSymbolicLink() ||
+      !sameIdentity(opened, after) ||
+      !sameIdentity(opened, atPath) ||
+      opened.size !== after.size ||
+      opened.mtimeMs !== after.mtimeMs ||
+      canonicalBefore !== canonicalAfter ||
+      !isPathInside(canonicalRoot, canonicalAfter)
+    ) {
+      return { error }
+    }
+    return { text }
+  } catch {
+    return { error }
+  } finally {
+    if (descriptor !== undefined) closeSync(descriptor)
+  }
+}
+
+function readMarkdownResource(root, canonicalRoot, resource) {
+  return readRegularResource(root, canonicalRoot, resource, markdownResourceError(resource.relative))
+}
+
+function readOpenaiMetadata(root, canonicalRoot) {
+  if (canonicalRoot === undefined) return {}
+  const agents = join(root, 'agents')
+  if (!entryExists(agents)) return { error: 'agents/openai.yaml ausente.' }
+  const directoryError = 'agents: diretório deve ser real e contido na skill.'
+  const before = inspectReferenceDirectory(root, canonicalRoot, agents, 'agents')
+  if (before.error !== undefined) return { error: directoryError }
+
+  const openai = join(agents, 'openai.yaml')
+  if (!entryExists(openai)) return { error: 'agents/openai.yaml ausente.' }
+  const fileError = 'agents/openai.yaml deve ser arquivo regular e contido na skill.'
+  const inspected = inspectRegularResource(root, canonicalRoot, openai, fileError)
+  if (inspected.error !== undefined) return inspected
+  const read = readRegularResource(root, canonicalRoot, { path: openai }, fileError)
+  if (read.error !== undefined) return read
+
+  const after = inspectReferenceDirectory(root, canonicalRoot, agents, 'agents')
+  if (
+    after.error !== undefined ||
+    !sameIdentity(before.info, after.info) ||
+    before.canonical !== after.canonical
+  ) {
+    return { error: directoryError }
+  }
+  return { text: read.text }
+}
+
+function readMarkdownResources(root, inventory) {
+  const errors = [...inventory.errors]
+  const resources = []
+  if (inventory.canonicalRoot === undefined) return { errors, resources }
+  for (const resource of inventory.resources) {
+    const read = readMarkdownResource(root, inventory.canonicalRoot, resource)
+    if (read.error !== undefined) errors.push(read.error)
+    else resources.push({ ...resource, text: read.text })
+  }
+  return { errors, resources }
+}
+
+function htmlWhitespace(code) {
+  return code === 0x09 || code === 0x0a || code === 0x0c || code === 0x0d || code === 0x20
+}
+
+function containsOnlyHtmlComments(content) {
+  let cursor = 0
+  let comments = 0
+
+  while (cursor < content.length) {
+    while (cursor < content.length && htmlWhitespace(content.charCodeAt(cursor))) cursor += 1
+    if (cursor === content.length) break
+    if (!content.startsWith('<!--', cursor)) return false
+    const end = content.indexOf('-->', cursor + 4)
+    if (end === -1) return false
+    comments += 1
+    cursor = end + 3
+  }
+
+  return comments > 0
+}
+
+function markdownLinks(text) {
+  const { env, tokens } = markdownDocument(text)
+  const targets = new Set()
+  const errors = new Set()
+  const visit = (token) => {
+    if (token.type === 'link_open') targets.add(token.attrGet('href'))
+    else if (token.type === 'image') targets.add(token.attrGet('src'))
+    else if (
+      (token.type === 'html_inline' || token.type === 'html_block') &&
+      !containsOnlyHtmlComments(token.content)
+    ) errors.add('HTML ou SVG cru renderizável não é permitido; use Markdown ou um recurso referenciado.')
+    for (const child of token.children ?? []) visit(child)
+  }
+  for (const token of tokens) visit(token)
+  for (const reference of Object.values(env.references ?? {})) targets.add(reference.href)
+  return {
+    errors: [...errors],
+    targets: [...targets].filter((target) => typeof target === 'string'),
+  }
+}
+
+function validLinkTarget(root, source, renderedTarget) {
+  if (
+    renderedTarget.trim() !== renderedTarget ||
+    /[\u0000-\u001f\u007f]/u.test(renderedTarget) ||
+    !markdownItValidateLink(renderedTarget)
+  ) {
+    return false
+  }
+  const kind = referenceTargetKind(renderedTarget)
+  if (kind === 'external-url') return true
+  if (kind !== 'local') return false
+  const end = renderedTarget.search(/[?#]/u)
+  const encodedPath = end === -1 ? renderedTarget : renderedTarget.slice(0, end)
+  if (encodedPath === '') return true
+  if (encodedPath.includes('\\') || ENCODED_SEPARATOR_OR_NUL.test(encodedPath)) return false
+  let pathname
+  try {
+    pathname = decodeURIComponent(encodedPath)
+  } catch {
+    return false
+  }
+  if (pathname.includes('\0') || referenceTargetKind(pathname) !== 'local') return false
+  const path = resolve(dirname(source), pathname)
+  if (!isPathInside(root, path) || !existsSync(path)) return false
+  try {
+    return isPathInside(realpathSync(root), realpathSync(path))
+  } catch {
+    return false
+  }
+}
+
+function printableLinkTarget(target) {
+  return target.replace(/[\u0000-\u001f\u007f]/gu, (character) =>
+    `\\u${character.charCodeAt(0).toString(16).padStart(4, '0')}`,
+  )
+}
+
+export function skillReferences(dir) {
+  const root = resolve(dir)
+  const loaded = readMarkdownResources(root, markdownResources(root))
+  return loaded.resources
+    .filter((resource) => basename(resource.path) !== 'evaluations.md')
+    .flatMap((resource) =>
+      referencedSkills(resource.text).map((dependency) => ({
+        dependency,
+        source: resource.relative,
+      })),
+    )
+}
+
+export function validateSkill(dir) {
+  const root = resolve(dir)
+  const inventory = markdownResources(root)
+  const loaded = readMarkdownResources(root, inventory)
+  const openai = readOpenaiMetadata(root, inventory.canonicalRoot)
+  const errors = [...loaded.errors]
+  if (openai.error !== undefined) errors.push(openai.error)
+  if (inventory.canonicalRoot !== undefined) {
+    try {
+      for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (PROHIBITED.has(entry.name)) errors.push(`${entry.name} não pertence a uma skill.`)
+      }
+    } catch {
+      errors.push('raiz da skill não pôde ser lida com segurança.')
+    }
+  }
+  const skillResource = loaded.resources.find((resource) => resource.relative === 'SKILL.md')
+  if (skillResource === undefined) return errors
+
+  const text = skillResource.text
+  const meta = frontmatter(text)
+  if (meta === null) errors.push('frontmatter YAML ausente ou inválido.')
+  else {
+    const keys = [...meta.keys()]
+    if (keys.length !== 2 || !meta.has('name') || !meta.has('description')) {
+      errors.push('frontmatter deve conter somente name e description.')
+    }
+    const name = meta.get('name') ?? ''
+    const description = meta.get('description') ?? ''
+    if (!NAME.test(name) || name.length > 64) errors.push('name deve ser lowercase kebab-case e ter até 64 caracteres.')
+    if (name !== basename(root)) errors.push(`name deve ser igual à pasta (${basename(root)}).`)
+    if (description.length === 0 || description.length > 1024) errors.push('description deve ter entre 1 e 1024 caracteres.')
+    if (!/\b(use|usar|quando|ao)\b/i.test(description)) errors.push('description deve declarar quando usar a skill.')
+  }
+  if (text.split('\n').length > 500) errors.push('SKILL.md deve ter no máximo 500 linhas.')
+  if (/\b(TODO|PLACEHOLDER)\b/.test(text)) errors.push('SKILL.md contém placeholder.')
+
+  for (const resource of loaded.resources.filter((resource) => basename(resource.path) !== 'evaluations.md')) {
+    for (const error of skillRouteErrors(resource.text)) {
+      errors.push(`${resource.relative}: ${error}`)
+    }
+  }
+
+  if (openai.text !== undefined) {
+    const ui = openai.text
+    const name = meta?.get('name') ?? basename(root)
+    if (!ui.includes('display_name:') || !ui.includes('short_description:')) errors.push('openai.yaml sem metadados de interface.')
+    if (!ui.includes(`$${name}`)) errors.push(`default_prompt deve mencionar $${name}.`)
+  }
+
+  for (const resource of loaded.resources) {
+    const links = markdownLinks(resource.text)
+    for (const error of links.errors) errors.push(`${resource.relative}: ${error}`)
+    for (const target of links.targets) {
+      if (!validLinkTarget(root, resource.path, target)) {
+        errors.push(`${resource.relative}: referência local inválida: ${printableLinkTarget(target)}.`)
+      }
+    }
+  }
+
+  for (const resource of loaded.resources.filter((resource) => basename(resource.path) !== 'evaluations.md')) {
+    for (const dependency of referencedSkills(resource.text)) {
+      if (!existsSync(join(dirname(root), dependency, 'SKILL.md'))) {
+        errors.push(`${resource.relative}: skill encaminhada ausente: $${dependency}.`)
+      }
+    }
+  }
+
   return errors
 }