@kolkrabbi/kol-workshop 0.1.0

package/src/engine/doc-helpers.js

@@ -0,0 +1,132 @@
+/**
+ * Shared doc/tag helpers — pure, zero-dependency. Lifted verbatim.
+ *
+ * These bake in the KOL numbered-doc taxonomy (`categoryLabels`, version
+ * conventions, `kolkrabbiPages`). That's correct for a KOL package; a future
+ * consumer with a different scheme would parameterize these — not yet needed.
+ */
+
+export const capitalise = (value) =>
+  value ? value.charAt(0).toUpperCase() + value.slice(1) : value
+
+// Index.md files (e.g. "00-metadata-index", "foundry-index") have no version dots
+export const isIndexFile = (id) => id.endsWith('-index') && !id.includes('.')
+
+export const extractDocNumber = (id) => {
+  if (isIndexFile(id)) {
+    // Main section index: "04-pages-index" → "4.0.0"
+    const folderMatch = id.match(/^(\d+)-[a-z-]+-index$/)
+    if (folderMatch) {
+      const major = folderMatch[1].replace(/^0/, '')
+      return `${major}.0.0`
+    }
+    return 'Index'
+  }
+  // "0.0.1-writing-guidelines" → "0.0.1"
+  const match = id.match(/^(\d+\.\d+\.\d+)/)
+  return match ? match[1] : id
+}
+
+// Main site pages that should have "Kolkrabbi" prefix
+export const kolkrabbiPages = ['4.1.0', '4.2.0', '4.3.0', '4.4.0']
+
+// Subsection prefixes based on version range
+export const subsectionPrefixes = {
+  '4.6': 'Collections',
+}
+
+export const categoryLabels = {
+  0: 'Docs',
+  1: 'Foundation',
+  2: 'Design System',
+  3: 'Components',
+  4: 'Pages',
+  5: 'Workshop',
+  6: 'Foundry',
+  7: 'Research',
+  8: 'Operations',
+  9: 'CDN',
+}
+
+export const cleanTitle = (title, id) => {
+  if (isIndexFile(id)) {
+    const folderMatch = id.match(/^(\d+)-([a-z-]+)-index$/)
+    if (folderMatch) {
+      const major = folderMatch[1].replace(/^0/, '')
+      return `${categoryLabels[major] || 'Section'} Index`
+    }
+    return 'Section Index'
+  }
+
+  let cleaned = title.replace(/^\d+\.\d+\.\d+\s*/, '')
+  cleaned = cleaned.replace(/^[A-Za-z\s]+:\s*/, '')
+  cleaned = cleaned.trim() || title
+
+  const versionMatch = id.match(/^(\d+\.\d+)\.(\d+)/)
+  if (versionMatch) {
+    const majorMinor = versionMatch[1]
+
+    if (kolkrabbiPages.includes(`${majorMinor}.${versionMatch[2]}`)) {
+      return `Kolkrabbi ${cleaned}`
+    }
+
+    const prefix = subsectionPrefixes[majorMinor]
+    if (prefix) {
+      const prefixPattern = new RegExp(`^(${prefix}|${prefix.replace(/s$/, '')})(\\s+|$)`, 'i')
+      cleaned = cleaned.replace(prefixPattern, '').trim()
+      const suffixPattern = new RegExp(`(\\s+|^)(${prefix}|${prefix.replace(/s$/, '')})$`, 'i')
+      cleaned = cleaned.replace(suffixPattern, '').trim()
+      return `${prefix} ${cleaned}`
+    }
+  }
+
+  return cleaned
+}
+
+const TAG_COLORS = ['blue', 'teal', 'green', 'yellow', 'red', 'orange', 'purple', 'dark']
+
+export const getTagColor = (tag) => {
+  let hash = 0
+  for (let i = 0; i < tag.length; i++) {
+    hash = ((hash << 5) - hash + tag.charCodeAt(i)) | 0
+  }
+  return TAG_COLORS[Math.abs(hash) % TAG_COLORS.length]
+}
+
+/** Group docs by major version number. */
+export const groupDocsByMajor = (docs) => {
+  const groups = {}
+  docs.forEach((d) => {
+    const majorMatch = d.id.match(/^(\d+)\./)
+    const indexMatch = d.id.match(/^(\d+)-[a-z]+-index$/)
+
+    let major = null
+    if (majorMatch) {
+      major = majorMatch[1]
+    } else if (indexMatch) {
+      major = indexMatch[1].replace(/^0/, '')
+    } else if (isIndexFile(d.id)) {
+      const titleMatch = d.title.match(/^(\d+)\./)
+      if (titleMatch) {
+        major = titleMatch[1]
+      }
+    }
+
+    if (major !== null) {
+      if (!groups[major]) {
+        groups[major] = []
+      }
+      groups[major].push(d)
+    }
+  })
+
+  Object.keys(groups).forEach((major) => {
+    groups[major].sort((a, b) => {
+      const aNum = extractDocNumber(a.id)
+      const bNum = extractDocNumber(b.id)
+      return aNum.localeCompare(bNum, undefined, { numeric: true })
+    })
+  })
+
+  return groups
+}

package/src/engine/frontmatter.js

@@ -0,0 +1,41 @@
+/**
+ * Handrolled YAML-subset frontmatter parser — no gray-matter / js-yaml.
+ * Handles `key: value`, block lists (`  - item`), and inline `[a, b]` arrays.
+ * Keys are lowercased. Lifted verbatim from the monorepo.
+ */
+export const parseFrontmatter = (raw) => {
+  const metadata = {}
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/)
+  if (!match) return metadata
+
+  const lines = match[1].split(/\r?\n/)
+  for (let i = 0; i < lines.length; i++) {
+    const kvMatch = lines[i].match(/^([A-Za-z][A-Za-z0-9 -]*):\s*(.*)$/)
+    if (kvMatch) {
+      const key = kvMatch[1].toLowerCase()
+      const value = kvMatch[2].trim()
+      if (!value) {
+        // YAML block-list continuation lines (  - item)
+        const items = []
+        while (i + 1 < lines.length && lines[i + 1].match(/^\s+-\s+/)) {
+          i++
+          items.push(lines[i].replace(/^\s+-\s+/, '').trim())
+        }
+        metadata[key] = items.length ? items : ''
+      } else {
+        metadata[key] = value
+      }
+    }
+  }
+
+  // Parse tags array from YAML "[foo, bar, baz]" string into JS array
+  if (typeof metadata.tags === 'string' && metadata.tags.startsWith('[')) {
+    metadata.tags = metadata.tags
+      .slice(1, -1)
+      .split(',')
+      .map((t) => t.trim())
+      .filter(Boolean)
+  }
+
+  return metadata
+}

package/src/engine/index.js

@@ -0,0 +1,20 @@
+/**
+ * The pure docs engine — zero dependencies, no React, no Vite.
+ * Everything here is a plain function over strings/data.
+ */
+export { parseDocsMarkdown, extractHashtags } from './parse-markdown.js'
+export { parseFrontmatter } from './frontmatter.js'
+export { buildInventory, buildInventoryCounts } from './build-inventory.js'
+export { matchSearchItems } from './search.js'
+export { buildTagCounts, buildTagCooccurrence } from './tags.js'
+export {
+  capitalise,
+  isIndexFile,
+  extractDocNumber,
+  kolkrabbiPages,
+  subsectionPrefixes,
+  categoryLabels,
+  cleanTitle,
+  getTagColor,
+  groupDocsByMajor,
+} from './doc-helpers.js'

package/src/engine/parse-markdown.js

@@ -0,0 +1,352 @@
+/**
+ * Handrolled markdown parser for documentation pages.
+ * Block-level + inline tokenizer — no remark/markdown-it/marked/MDX.
+ * Lifted verbatim from the monorepo, minus the React render layer
+ * (`renderInlineTokens` lives with the docs viewer in Phase 2).
+ *
+ * `parseDocsMarkdown(md)` → { sections, toc, introBlocks, inlineTags }
+ */
+
+/** Extract #hashtags from markdown content. */
+export const extractHashtags = (content) => {
+  // Strip markdown link targets (…) to avoid matching anchor fragments as tags
+  const cleaned = content.replace(/\([^)]*\)/g, '')
+  const regex = /#([a-z0-9-]+)/gi
+  const matches = cleaned.match(regex)
+  return matches ? [...new Set(matches.map((t) => t.slice(1).toLowerCase()))] : []
+}
+
+/**
+ * Process inline markdown within text content.
+ * Supports: bold, italic, inline code, links, images, color swatches, hashtags.
+ * Returns a token array; the render layer turns tokens into elements.
+ */
+const processInlineMarkdown = (text) => {
+  if (!text) return []
+
+  const tokens = []
+  let remaining = text
+
+  while (remaining.length > 0) {
+    // Image: ![alt](src)
+    const imageMatch = remaining.match(/^!\[([^\]]*)\]\(([^)]+)\)/)
+    if (imageMatch) {
+      tokens.push({ type: 'image', alt: imageMatch[1], src: imageMatch[2] })
+      remaining = remaining.slice(imageMatch[0].length)
+      continue
+    }
+
+    // Link: [text](url)
+    const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/)
+    if (linkMatch) {
+      tokens.push({ type: 'link', text: linkMatch[1], url: linkMatch[2] })
+      remaining = remaining.slice(linkMatch[0].length)
+      continue
+    }
+
+    // Color swatch: {#rrggbb}
+    const swatchMatch = remaining.match(/^\{(#[0-9a-fA-F]{6})\}/)
+    if (swatchMatch) {
+      tokens.push({ type: 'colorswatch', color: swatchMatch[1] })
+      remaining = remaining.slice(swatchMatch[0].length)
+      continue
+    }
+
+    // Inline code: `code`
+    const codeMatch = remaining.match(/^`([^`]+)`/)
+    if (codeMatch) {
+      tokens.push({ type: 'code', content: codeMatch[1] })
+      remaining = remaining.slice(codeMatch[0].length)
+      continue
+    }
+
+    // Bold: **text** (must check before italic)
+    const boldMatch = remaining.match(/^\*\*([^*]+)\*\*/)
+    if (boldMatch) {
+      tokens.push({ type: 'bold', content: boldMatch[1] })
+      remaining = remaining.slice(boldMatch[0].length)
+      continue
+    }
+
+    // Italic: *text* (must not match list markers)
+    const italicMatch = remaining.match(/^\*([^*\s][^*]*)\*/)
+    if (italicMatch) {
+      tokens.push({ type: 'italic', content: italicMatch[1] })
+      remaining = remaining.slice(italicMatch[0].length)
+      continue
+    }
+
+    // Text followed by a hashtag (but not inside markdown links)
+    const textBeforeHashtag = remaining.match(/^([^#[]+)(#([a-z0-9-]+))/i)
+    if (textBeforeHashtag && !remaining.startsWith('[')) {
+      if (textBeforeHashtag[1]) {
+        tokens.push({ type: 'text', content: textBeforeHashtag[1] })
+      }
+      tokens.push({ type: 'hashtag', tag: textBeforeHashtag[3].toLowerCase() })
+      remaining = remaining.slice(textBeforeHashtag[1].length + textBeforeHashtag[2].length)
+      continue
+    }
+
+    // Standalone hashtag at start of remaining text
+    const hashtagMatch = remaining.match(/^#([a-z0-9-]+)/i)
+    if (hashtagMatch) {
+      tokens.push({ type: 'hashtag', tag: hashtagMatch[1].toLowerCase() })
+      remaining = remaining.slice(hashtagMatch[0].length)
+      continue
+    }
+
+    // Regular text - take until next special character or end
+    const textMatch = remaining.match(/^([^*`[\]!]+)/)
+    if (textMatch) {
+      tokens.push({ type: 'text', content: textMatch[1] })
+      remaining = remaining.slice(textMatch[0].length)
+      continue
+    }
+
+    // If no match, take one character as text
+    tokens.push({ type: 'text', content: remaining[0] })
+    remaining = remaining.slice(1)
+  }
+
+  return tokens
+}
+
+/**
+ * Parse markdown text into structured blocks.
+ * Returns { sections, toc, introBlocks, inlineTags }.
+ */
+export const parseDocsMarkdown = (markdown) => {
+  if (!markdown) {
+    return { sections: [], toc: [], introBlocks: [], inlineTags: [] }
+  }
+
+  const lines = markdown.split('\n')
+  const sections = []
+  const toc = []
+  const introBlocks = []
+
+  let current = null
+  let inCode = false
+  let inFrontmatter = false
+  let paragraphBuffer = []
+
+  const getTargetBlocks = () => (current ? current.blocks : introBlocks)
+
+  const flushParagraph = () => {
+    if (paragraphBuffer.length > 0) {
+      const text = paragraphBuffer.join(' ').trim()
+      if (text) {
+        getTargetBlocks().push({
+          type: 'paragraph',
+          content: text,
+          tokens: processInlineMarkdown(text),
+        })
+      }
+      paragraphBuffer = []
+    }
+  }
+
+  const startNewSection = (level, heading) => {
+    flushParagraph()
+
+    // H2 starts new section
+    if (level === 2) {
+      if (current) {
+        sections.push(current)
+      }
+      const id = heading.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '')
+      const tocLabel = heading.replace(/^[\d]+[a-z]?[.)]\s*/i, '')
+      toc.push({ id, label: tocLabel, level: 2 })
+      current = { heading, id, level: 2, blocks: [] }
+      return
+    }
+
+    // H3/H4 added as blocks within current section (not in TOC)
+    if (level === 3 || level === 4) {
+      const id = heading.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '')
+      if (current) {
+        current.blocks.push({ type: level === 3 ? 'heading3' : 'heading4', id, content: heading })
+      } else {
+        // H3/H4 before any H2 goes to intro
+        introBlocks.push({ type: level === 3 ? 'heading3' : 'heading4', id, content: heading })
+      }
+    }
+  }
+
+  lines.forEach((line, lineIndex) => {
+    const trimmed = line.trim()
+
+    // Code blocks - check first so content inside code blocks is preserved
+    if (line.startsWith('```')) {
+      if (inCode) {
+        inCode = false
+      } else {
+        flushParagraph()
+        const lang = line.replace(/^```/, '').trim()
+        getTargetBlocks().push({ type: 'code', lang, lines: [] })
+        inCode = true
+      }
+      return
+    }
+
+    // If inside a code block, add line as-is (preserves ---, #, etc.)
+    if (inCode) {
+      const blocks = getTargetBlocks()
+      const lastBlock = blocks[blocks.length - 1]
+      if (lastBlock && lastBlock.type === 'code') {
+        lastBlock.lines.push(line)
+      }
+      return
+    }
+
+    // Handle frontmatter (skip it) - only when not in code block
+    if (trimmed === '---') {
+      if (lineIndex === 0) {
+        inFrontmatter = true
+        return
+      }
+      if (inFrontmatter) {
+        inFrontmatter = false
+        return
+      }
+      // Otherwise it's a divider
+      flushParagraph()
+      getTargetBlocks().push({ type: 'divider' })
+      return
+    }
+
+    if (inFrontmatter) {
+      return
+    }
+
+    // H1 - Title (add to intro, not sections)
+    if (line.startsWith('# ')) {
+      flushParagraph()
+      introBlocks.push({ type: 'heading1', content: line.replace(/^#\s+/, '') })
+      return
+    }
+
+    // H2 - Main sections
+    if (line.startsWith('## ')) {
+      startNewSection(2, line.replace(/^##\s+/, ''))
+      return
+    }
+
+    // H3 - Sub-sections
+    if (line.startsWith('### ')) {
+      startNewSection(3, line.replace(/^###\s+/, ''))
+      return
+    }
+
+    // H4 - Sub-sub-sections
+    if (line.startsWith('#### ')) {
+      startNewSection(4, line.replace(/^####\s+/, ''))
+      return
+    }
+
+    // Empty line
+    if (trimmed === '') {
+      flushParagraph()
+      return
+    }
+
+    // Unordered list
+    const unorderedMatch = line.match(/^[-*]\s+(.*)/)
+    if (unorderedMatch) {
+      flushParagraph()
+      const blocks = getTargetBlocks()
+      const lastBlock = blocks[blocks.length - 1]
+      const itemContent = unorderedMatch[1]
+      if (lastBlock && lastBlock.type === 'list' && !lastBlock.ordered) {
+        lastBlock.items.push({ content: itemContent, tokens: processInlineMarkdown(itemContent) })
+      } else {
+        blocks.push({
+          type: 'list',
+          ordered: false,
+          items: [{ content: itemContent, tokens: processInlineMarkdown(itemContent) }],
+        })
+      }
+      return
+    }
+
+    // Ordered list
+    const orderedMatch = line.match(/^\d+\.\s+(.*)/)
+    if (orderedMatch) {
+      flushParagraph()
+      const blocks = getTargetBlocks()
+      const lastBlock = blocks[blocks.length - 1]
+      const itemContent = orderedMatch[1]
+      if (lastBlock && lastBlock.type === 'list' && lastBlock.ordered) {
+        lastBlock.items.push({ content: itemContent, tokens: processInlineMarkdown(itemContent) })
+      } else {
+        blocks.push({
+          type: 'list',
+          ordered: true,
+          items: [{ content: itemContent, tokens: processInlineMarkdown(itemContent) }],
+        })
+      }
+      return
+    }
+
+    // Blockquote
+    if (line.startsWith('>')) {
+      flushParagraph()
+      const content = line.replace(/^>\s?/, '')
+      getTargetBlocks().push({ type: 'blockquote', content, tokens: processInlineMarkdown(content) })
+      return
+    }
+
+    // Table row (starts with |)
+    if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+      flushParagraph()
+      const blocks = getTargetBlocks()
+      const lastBlock = blocks[blocks.length - 1]
+
+      const cells = trimmed
+        .slice(1, -1)
+        .split('|')
+        .map((cell) => cell.trim())
+
+      // Separator row (|---|---|)
+      const isSeparator = cells.every((cell) => /^:?-+:?$/.test(cell))
+
+      if (isSeparator) {
+        if (lastBlock && lastBlock.type === 'table') {
+          lastBlock.hasSeparator = true
+        }
+        return
+      }
+
+      if (lastBlock && lastBlock.type === 'table') {
+        if (!lastBlock.hasSeparator) {
+          lastBlock.headers = cells
+        } else {
+          lastBlock.rows.push(cells.map((cell) => ({ content: cell, tokens: processInlineMarkdown(cell) })))
+        }
+      } else {
+        blocks.push({ type: 'table', headers: cells, rows: [], hasSeparator: false })
+      }
+      return
+    }
+
+    // Regular text line - add to paragraph buffer
+    paragraphBuffer.push(line)
+  })
+
+  flushParagraph()
+
+  if (current) {
+    sections.push(current)
+  }
+
+  // Extract hashtags from all content
+  const allContent = [
+    ...introBlocks.map((b) => b.content || ''),
+    ...sections.flatMap((s) => [s.heading, ...s.blocks.map((b) => b.content || '')]),
+  ].join(' ')
+  const inlineTags = extractHashtags(allContent)
+
+  return { sections, toc, introBlocks, inlineTags }
+}
+
+export default parseDocsMarkdown

package/src/engine/search.js

@@ -0,0 +1,36 @@
+/**
+ * matchSearchItems — the pure substring-match predicate extracted from
+ * ShellSearchOverlay. Case-insensitive `includes` across each item's
+ * label / tags / headings / keywords, returning the matched items annotated
+ * with `matchedHeading` and `matchedKeyword` for the overlay's subtext rows.
+ *
+ * Match semantics (unchanged from the overlay):
+ *   - an item survives if the query hits ANY of label / tags / headings / keywords
+ *   - `matchedHeading` = the first heading that matched, else null
+ *   - `matchedKeyword` = the first keyword that matched, but ONLY surfaced when
+ *      the label and headings did NOT match (a keyword-only reason-for-inclusion)
+ *
+ * Pure JS, zero dependencies.
+ *
+ * @param {Array<Object>} items  items shaped { label, tags?, headings?, keywords? }
+ * @param {string}        query  raw query string
+ * @returns {Array<Object>} filtered items, each spread with matchedHeading/matchedKeyword
+ */
+export function matchSearchItems(items, query) {
+  if (!query || query.length === 0) return []
+  const q = query.toLowerCase()
+  return (items || [])
+    .map((item) => {
+      const labelMatch = item.label.toLowerCase().includes(q)
+      const tagMatch = (item.tags || []).some((tag) => tag.toLowerCase().includes(q))
+      const headingMatch = (item.headings || []).find((h) => h.toLowerCase().includes(q))
+      const keywordMatch = (item.keywords || []).find((k) => k.toLowerCase().includes(q))
+      if (!labelMatch && !tagMatch && !headingMatch && !keywordMatch) return null
+      return {
+        ...item,
+        matchedHeading: headingMatch || null,
+        matchedKeyword: !labelMatch && !headingMatch && keywordMatch ? keywordMatch : null,
+      }
+    })
+    .filter(Boolean)
+}

package/src/engine/tags.js

@@ -0,0 +1,75 @@
+/**
+ * Pure tag aggregation over a docs inventory — zero dependencies, no React, no d3.
+ *
+ * Extracted from TagModeOverlay (`buildTagCounts`) and TagGraph
+ * (`buildTagCooccurrence`) so the counting/co-occurrence math is testable in
+ * isolation and the components stay presentational. Each takes the docs
+ * `inventory` (array of `{ id, metadata: { tags: string[] } }`) and returns
+ * plain data.
+ *
+ * Case handling is deliberately NOT unified — it preserves the two call sites'
+ * original behaviour:
+ *   - buildTagCounts       keeps tags exact-case (the overlay's tag list)
+ *   - buildTagCooccurrence lowercases tags (the graph's node ids)
+ */
+
+/**
+ * Count docs per tag, tags kept exact-case. Returns `[{ tag, count }]` sorted
+ * by count descending.
+ */
+export const buildTagCounts = (inventory = []) => {
+  const counts = {}
+  inventory.forEach((d) => {
+    if (Array.isArray(d.metadata?.tags)) {
+      d.metadata.tags.forEach((t) => {
+        counts[t] = (counts[t] || 0) + 1
+      })
+    }
+  })
+  return Object.entries(counts)
+    .map(([tag, count]) => ({ tag, count }))
+    .sort((a, b) => b.count - a.count)
+}
+
+/**
+ * Build the tag co-occurrence graph. Tag ids are lowercased. Nodes are all
+ * tags with their doc counts (sorted desc); edges connect any two tags that
+ * share at least one doc, weighted by the number of shared docs.
+ *
+ * Returns `{ nodes: [{ id, count, type: 'tag' }], edges: [{ source, target, weight }] }`.
+ */
+export const buildTagCooccurrence = (inventory = []) => {
+  const tagCounts = {}
+  const tagToDocs = {} // tag -> Set of doc ids
+
+  inventory.forEach((doc) => {
+    const tags = doc.metadata?.tags || []
+    tags.forEach((tag) => {
+      const tagLower = tag.toLowerCase()
+      tagCounts[tagLower] = (tagCounts[tagLower] || 0) + 1
+      if (!tagToDocs[tagLower]) {
+        tagToDocs[tagLower] = new Set()
+      }
+      tagToDocs[tagLower].add(doc.id)
+    })
+  })
+
+  const nodes = Object.entries(tagCounts)
+    .map(([tag, count]) => ({ id: tag, count, type: 'tag' }))
+    .sort((a, b) => b.count - a.count)
+
+  const edges = []
+  const tagList = Object.keys(tagToDocs)
+  for (let i = 0; i < tagList.length; i++) {
+    for (let j = i + 1; j < tagList.length; j++) {
+      const tagA = tagList[i]
+      const tagB = tagList[j]
+      const commonDocs = [...tagToDocs[tagA]].filter((id) => tagToDocs[tagB].has(id))
+      if (commonDocs.length > 0) {
+        edges.push({ source: tagA, target: tagB, weight: commonDocs.length })
+      }
+    }
+  }
+
+  return { nodes, edges }
+}

package/src/index.js

@@ -0,0 +1,15 @@
+/**
+ * @kolkrabbi/kol-workshop — the KOL workshop / docs system.
+ *
+ * Aggregates everything the package now owns: the shell composition
+ * (ShellLayout + ShellSidebar + their contexts), the docs viewer, the tag
+ * system, the example compositions, and the pure React-free engine. Duplicated
+ * chrome (ShellHeader, ShellDrawer, SearchInput, ShellSearchOverlay, DocsToc)
+ * ships from @kolkrabbi/kol-framework + @kolkrabbi/kol-component — consume it
+ * from there, not from here.
+ */
+export * from './shell/index.js'
+export * from './docs/index.js'
+export * from './tags/index.js'
+export * from './compositions/index.js'
+export * from './engine/index.js'