@kyyinfinite/lumina 1.0.0 → 1.0.2

package/src/index.js

@@ -1,151 +1,53 @@
-/**
- * @file index.js
- * @module @kyyinfinite/lumina
- *
- * Lumina — Modern WhatsApp framework built on top of Baileys.
- *
- * Public API surface:
- *
- *   import { Bot } from '@kyyinfinite/lumina'
- *   const bot = new Bot(socket)
- *   await bot.text(jid, 'Halo')
- *
- * Subpath exports (tree-shakable):
- *
- *   import { extractInlineEntities } from '@kyyinfinite/lumina/parsers'
- *   import { MediaService }          from '@kyyinfinite/lumina/services'
- *   import { ButtonBuilder }         from '@kyyinfinite/lumina/builders'
- *   import { ProtoUpdater }          from '@kyyinfinite/lumina/proto'
- *   import { resize }                from '@kyyinfinite/lumina/media'
- */
-
 import { Bot } from './client/bot.js'
 import { Connection } from './client/connection.js'
-
 import { ButtonBuilder } from './builders/button.js'
 import { ButtonV2Builder } from './builders/button-v2.js'
 import { CarouselBuilder } from './builders/carousel.js'
 import { CardBuilder } from './builders/card.js'
 import { AIRichBuilder } from './builders/ai-rich.js'
-
+import { StickerBuilder } from './builders/sticker.js'
+import { toSticker, addExif } from './media/sticker.js'
 import { MediaService } from './services/media-service.js'
 import { ProtoService } from './services/proto-service.js'
 import { MessageService } from './services/message-service.js'
-
 import { extractInlineEntities } from './parsers/inline-entity.js'
 import { tokenizeCode } from './parsers/code-tokenizer.js'
 import { toTableMetadata } from './parsers/table-metadata.js'
-
 import { ProtoUpdater, transformToESM, applyKnownFixes } from './proto/updater.js'
 import { assembleRichResponse } from './proto/rich-response.js'
 import { createInteractiveNodes, createBareInteractiveNodes } from './proto/relay-nodes.js'
-
-// Catalog re-exports — these are imported so that the named exports below
-// are available from the root `@kyyinfinite/lumina` entry point.
 import {
-  MessageType,
-  ForwardOrigin,
-  HeaderType,
-  NativeFlow,
-  BOT_JID,
-  LayoutKind,
-  HighlightType,
-  HighlightLabel,
-  ImagineType,
-  SourceType,
-  PromptType,
-  SessionTransparencyType,
-  TYPENAME,
+  MessageType, ForwardOrigin, HeaderType, NativeFlow, BOT_JID, LayoutKind,
+  HighlightType, HighlightLabel, ImagineType, SourceType, PromptType,
+  SessionTransparencyType, TYPENAME, SimpleButtonType,
 } from './proto/enums.js'
-
 import {
-  markdownTextPrimitive,
-  codePrimitive,
-  tablePrimitive,
-  searchResultPrimitive,
-  reelPrimitive,
-  imaginePrimitive,
-  productCardPrimitive,
-  postPrimitive,
-  metadataTextPrimitive,
-  followUpSuggestionPillPrimitive,
-  shapeSourceEntry,
-  shapeReelEntry,
+  markdownTextPrimitive, codePrimitive, tablePrimitive, searchResultPrimitive,
+  reelPrimitive, imaginePrimitive, productCardPrimitive, postPrimitive,
+  metadataTextPrimitive, followUpSuggestionPillPrimitive, shapeSourceEntry, shapeReelEntry,
 } from './proto/primitives.js'
-
 import { singleLayout, hscrollLayout, actionRowLayout, layoutFor } from './proto/layouts.js'
-
 import { LuminaError, ValidationError, MediaError, ProtoError, ConnectionError, ProtocolError } from './errors.js'
 import { createLogger } from './utils/logger.js'
 
-/** Semver version of the Lumina package. */
 export const VERSION = '1.0.0'
 
-// Public API
 export {
-  Bot,
-  Connection,
-  // Builders
-  ButtonBuilder,
-  ButtonV2Builder,
-  CarouselBuilder,
-  CardBuilder,
-  AIRichBuilder,
-  // Services
-  MediaService,
-  ProtoService,
-  MessageService,
-  // Parsers
-  extractInlineEntities,
-  tokenizeCode,
-  toTableMetadata,
-  // Proto
-  ProtoUpdater,
-  transformToESM,
-  applyKnownFixes,
-  assembleRichResponse,
-  createInteractiveNodes,
-  createBareInteractiveNodes,
-  // Catalog
-  MessageType,
-  ForwardOrigin,
-  HeaderType,
-  NativeFlow,
-  BOT_JID,
-  LayoutKind,
-  HighlightType,
-  HighlightLabel,
-  ImagineType,
-  SourceType,
-  PromptType,
-  SessionTransparencyType,
-  TYPENAME,
-  // Primitive factories
-  markdownTextPrimitive,
-  codePrimitive,
-  tablePrimitive,
-  searchResultPrimitive,
-  reelPrimitive,
-  imaginePrimitive,
-  productCardPrimitive,
-  postPrimitive,
-  metadataTextPrimitive,
-  followUpSuggestionPillPrimitive,
-  shapeSourceEntry,
-  shapeReelEntry,
-  // Layout factories
-  singleLayout,
-  hscrollLayout,
-  actionRowLayout,
-  layoutFor,
-  // Errors
-  LuminaError,
-  ValidationError,
-  MediaError,
-  ProtoError,
-  ConnectionError,
-  ProtocolError,
-  // Utils
+  Bot, Connection,
+  ButtonBuilder, ButtonV2Builder, CarouselBuilder, CardBuilder, AIRichBuilder, StickerBuilder,
+  toSticker, addExif,
+  MediaService, ProtoService, MessageService,
+  extractInlineEntities, tokenizeCode, toTableMetadata,
+  ProtoUpdater, transformToESM, applyKnownFixes,
+  assembleRichResponse, createInteractiveNodes, createBareInteractiveNodes,
+  MessageType, ForwardOrigin, HeaderType, NativeFlow, BOT_JID, LayoutKind,
+  HighlightType, HighlightLabel, ImagineType, SourceType, PromptType,
+  SessionTransparencyType, TYPENAME, SimpleButtonType,
+  markdownTextPrimitive, codePrimitive, tablePrimitive, searchResultPrimitive,
+  reelPrimitive, imaginePrimitive, productCardPrimitive, postPrimitive,
+  metadataTextPrimitive, followUpSuggestionPillPrimitive, shapeSourceEntry, shapeReelEntry,
+  singleLayout, hscrollLayout, actionRowLayout, layoutFor,
+  LuminaError, ValidationError, MediaError, ProtoError, ConnectionError, ProtocolError,
   createLogger,
 }
 

package/src/media/fetch.js

@@ -1,29 +1,5 @@
-/**
- * @file fetch.js
- * @module lumina/media/fetch
- *
- * HTTP fetcher for media URLs. Returns a Buffer. Honours a configurable
- * timeout and an opt-in `silent` mode (default OFF — fail loud).
- */
-
 import { MediaError } from '../errors.js'
 
-/**
- * @typedef {object} FetchOptions
- * @property {boolean} [silent=false]  Swallow HTTP errors and return Buffer.alloc(0).
- * @property {number}  [timeout=30000] Request timeout in milliseconds.
- * @property {Record<string, string>} [headers] Additional request headers.
- * @property {AbortSignal} [signal]    External abort signal.
- */
-
-/**
- * Fetch a URL and return its body as a Buffer.
- *
- * @param {string} url
- * @param {FetchOptions} [opts]
- * @returns {Promise<Buffer>}
- * @throws {MediaError}  When `silent` is false (default) and the request fails.
- */
 export async function fetchBuffer(url, opts = {}) {
   const { silent = false, timeout = 30_000, headers, signal } = opts
 
@@ -34,23 +10,16 @@ export async function fetchBuffer(url, opts = {}) {
 
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), timeout)
-    // Combine external signal with our timeout signal.
     if (signal) {
       if (signal.aborted) controller.abort()
       else signal.addEventListener('abort', () => controller.abort(), { once: true })
     }
 
-    const response = await fetch(url, {
-      headers,
-      signal: controller.signal,
-      redirect: 'follow',
-    })
+    const response = await fetch(url, { headers, signal: controller.signal, redirect: 'follow' })
     clearTimeout(timer)
 
     if (!response.ok) {
-      throw new MediaError(`HTTP ${response.status} for ${url}`, {
-        code: 'LUMINA_MEDIA_HTTP_ERROR',
-      })
+      throw new MediaError(`HTTP ${response.status} for ${url}`, { code: 'LUMINA_MEDIA_HTTP_ERROR' })
     }
 
     return Buffer.from(await response.arrayBuffer())

package/src/media/image.js

@@ -1,21 +1,7 @@
-/**
- * @file image.js
- * @module lumina/media/image
- *
- * Image resizing via `sharp`. Sharp is an optional peer dependency — the
- * module lazy-imports it on first use so that users who never touch image
- * resizing do not need it installed.
- */
-
 import { MediaError } from '../errors.js'
 
 let sharpPromise = null
 
-/**
- * Lazy-load sharp. Cached so the import cost is paid only once.
- *
- * @returns {Promise<typeof import('sharp')>}
- */
 async function loadSharp() {
   if (!sharpPromise) {
     sharpPromise = (async () => {
@@ -32,27 +18,9 @@ async function loadSharp() {
   return sharpPromise
 }
 
-/**
- * @typedef {object} ResizeOptions
- * @property {number} [width]
- * @property {number} [height]
- * @property {'cover'|'contain'|'inside'|'outside'} [fit='cover']
- * @property {'png'|'jpeg'|'webp'} [format='png']
- * @property {object} [background]  Background colour for transparent areas.
- */
-
-/**
- * Resize a buffer containing an image. Returns a Buffer in the requested format.
- *
- * @param {Buffer} buffer
- * @param {ResizeOptions} [opts]
- * @returns {Promise<Buffer>}
- */
 export async function resize(buffer, opts = {}) {
   if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
-    throw new MediaError('resize() requires a non-empty Buffer', {
-      code: 'LUMINA_MEDIA_EMPTY_BUFFER',
-    })
+    throw new MediaError('resize() requires a non-empty Buffer', { code: 'LUMINA_MEDIA_EMPTY_BUFFER' })
   }
 
   const { width = 300, height = 300, fit = 'cover', format = 'png', background } = opts
@@ -71,14 +39,6 @@ export async function resize(buffer, opts = {}) {
   return pipeline.toBuffer()
 }
 
-/**
- * Convenience: resize to a square thumbnail (default 300×300 PNG cover).
- *
- * @param {Buffer} buffer
- * @param {number} [size=300]
- * @param {ResizeOptions['format']} [format]
- * @returns {Promise<Buffer>}
- */
 export async function thumbnail(buffer, size = 300, format = 'png') {
   return resize(buffer, { width: size, height: size, fit: 'cover', format })
 }

package/src/media/resolver.js

@@ -1,16 +1,3 @@
-/**
- * @file resolver.js
- * @module lumina/media/resolver
- *
- * Unified media resolver. Accepts URL | base64 string | Buffer | array-of-any
- * and returns a normalised representation per the requested strategy.
- *
- * Bug fix vs legacy: the original `Toolkit.resolveMedia` had two near-identical
- * branches (WAUrl vs non-WAUrl) that both called `fetchBuffer` — collapsed
- * into a single, explicit 3-strategy switch (`auto | url-only | buffer |
- * base64 | upload`).
- */
-
 import { MediaError } from '../errors.js'
 import { fetchBuffer } from './fetch.js'
 import { resize } from './image.js'
@@ -19,42 +6,14 @@ import { uploadToWhatsApp } from './uploader.js'
 const HTTP_RE = /^https?:\/\/.+/i
 const WA_HOST_RE = /^https?:\/\/[^/]*\.whatsapp\.net\//i
 
-/** @typedef {'auto'|'url-only'|'buffer'|'base64'|'upload'} ResolveStrategy */
-
-/**
- * @typedef {object} ResolveOptions
- * @property {'image'|'video'|'audio'|'document'} [mediaType='image']
- * @property {ResolveStrategy} [strategy='auto']
- * @property {{ width: number, height: number, fit?: string }} [resize]   Resize before returning (buffer/base64 only).
- * @property {boolean} [silent=false]
- * @property {string} [jid]  Override upload JID.
- */
-
-/**
- * Resolve a single media source.
- *
- * @param {import('../client/connection.js').Connection} conn
- * @param {string | Buffer} source
- * @param {ResolveOptions} [opts]
- * @returns {Promise<string | Buffer>}
- */
 export async function resolveMedia(conn, source, opts = {}) {
-  const {
-    mediaType = 'image',
-    strategy = 'auto',
-    resize: resizeOpts,
-    silent = false,
-    jid,
-  } = opts
+  const { mediaType = 'image', strategy = 'auto', resize: resizeOpts, silent = false, jid } = opts
 
-  // Array support: recurse with identical opts.
   if (Array.isArray(source)) {
     return Promise.all(source.map((s) => resolveMedia(conn, s, opts)))
   }
 
   const originalIsBuffer = Buffer.isBuffer(source)
-
-  // Stage 1: normalise to either { url } or { buffer }.
   let buffer = null
   let url = null
 
@@ -62,12 +21,9 @@ export async function resolveMedia(conn, source, opts = {}) {
     if (HTTP_RE.test(source)) {
       const isWaUrl = WA_HOST_RE.test(source)
       if (strategy === 'url-only' && isWaUrl) return source
-      // For HTTP URLs we always need the bytes — either because the user
-      // asked for buffer/base64, or because we need to upload to WhatsApp.
       buffer = await fetchBuffer(source, { silent: true })
       url = source
     } else {
-      // Treat as base64.
       buffer = Buffer.from(source, 'base64')
     }
   } else if (originalIsBuffer) {
@@ -85,12 +41,8 @@ export async function resolveMedia(conn, source, opts = {}) {
     })
   }
 
-  // Stage 2: optional resize.
-  if (resizeOpts && buffer) {
-    buffer = await resize(buffer, resizeOpts)
-  }
+  if (resizeOpts && buffer) buffer = await resize(buffer, resizeOpts)
 
-  // Stage 3: format per strategy.
   switch (strategy) {
     case 'buffer':
       return buffer
@@ -98,16 +50,12 @@ export async function resolveMedia(conn, source, opts = {}) {
       return buffer.toString('base64')
     case 'url-only':
       if (url && WA_HOST_RE.test(url)) return url
-      throw new MediaError('url-only strategy requires a wa.me URL', {
-        code: 'LUMINA_MEDIA_URL_ONLY_FAILED',
-      })
+      throw new MediaError('url-only strategy requires a wa.me URL', { code: 'LUMINA_MEDIA_URL_ONLY_FAILED' })
     case 'upload':
       return uploadToWhatsApp(conn, buffer, mediaType, { jid })
     case 'auto':
     default:
       if (url && WA_HOST_RE.test(url)) return url
-      if (originalIsBuffer) return uploadToWhatsApp(conn, buffer, mediaType, { jid })
-      // We have a non-WA URL — upload to WhatsApp so the consumer gets a CDN URL.
       return uploadToWhatsApp(conn, buffer, mediaType, { jid })
   }
 }

package/src/media/sticker.js

@@ -0,0 +1,124 @@
+import fs from 'node:fs'
+import { tmpdir } from 'node:os'
+import crypto from 'node:crypto'
+import path from 'node:path'
+import { MediaError } from '../errors.js'
+
+function tmpPath(ext) {
+  return path.join(tmpdir(), `${crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.${ext}`)
+}
+
+function cleanup(...files) {
+  for (const f of files) {
+    try { fs.unlinkSync(f) } catch {}
+  }
+}
+
+async function loadFfmpeg() {
+  try {
+    const { default: ffmpeg } = await import('fluent-ffmpeg')
+    return ffmpeg
+  } catch {
+    throw new MediaError('fluent-ffmpeg is not installed. Run: npm i fluent-ffmpeg', {
+      code: 'LUMINA_STICKER_NO_FFMPEG',
+    })
+  }
+}
+
+async function loadWebp() {
+  try {
+    const { default: webp } = await import('node-webpmux')
+    return webp
+  } catch {
+    throw new MediaError('node-webpmux is not installed. Run: npm i node-webpmux', {
+      code: 'LUMINA_STICKER_NO_WEBPMUX',
+    })
+  }
+}
+
+const FFMPEG_IMAGE_OPTS = [
+  '-vcodec', 'libwebp',
+  '-vf', "scale='min(320,iw)':min'(320,ih)':force_original_aspect_ratio=decrease,fps=15,pad=320:320:-1:-1:color=white@0.0,split[a][b];[a]palettegen=reserve_transparent=on:transparency_color=ffffff[p];[b][p]paletteuse",
+]
+
+const FFMPEG_VIDEO_OPTS = [
+  '-vcodec', 'libwebp',
+  '-vf', "scale='min(320,iw)':min'(320,ih)':force_original_aspect_ratio=decrease,fps=15,pad=320:320:-1:-1:color=white@0.0,split[a][b];[a]palettegen=reserve_transparent=on:transparency_color=ffffff[p];[b][p]paletteuse",
+  '-loop', '0',
+  '-ss', '00:00:00',
+  '-t', '00:00:05',
+  '-preset', 'default',
+  '-an',
+  '-vsync', '0',
+]
+
+async function convertToWebp(buffer, type) {
+  const ffmpeg = await loadFfmpeg()
+  const inExt = type === 'video' ? 'mp4' : 'jpg'
+  const inFile = tmpPath(inExt)
+  const outFile = tmpPath('webp')
+
+  fs.writeFileSync(inFile, buffer)
+
+  await new Promise((resolve, reject) => {
+    ffmpeg(inFile)
+      .on('error', reject)
+      .on('end', () => resolve())
+      .addOutputOptions(type === 'video' ? FFMPEG_VIDEO_OPTS : FFMPEG_IMAGE_OPTS)
+      .toFormat('webp')
+      .save(outFile)
+  })
+
+  const result = fs.readFileSync(outFile)
+  cleanup(inFile, outFile)
+  return result
+}
+
+function buildExif(metadata) {
+  const json = {
+    'sticker-pack-id': crypto.randomBytes(32).toString('hex'),
+    'sticker-pack-name': metadata.packname ?? 'Lumina',
+    'sticker-pack-publisher': metadata.author ?? '',
+    'emojis': metadata.categories ?? [''],
+    ...metadata.extra,
+  }
+
+  const attr = Buffer.from([
+    0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
+  ])
+  const jsonBuf = Buffer.from(JSON.stringify(json), 'utf8')
+  const exif = Buffer.concat([attr, jsonBuf])
+  exif.writeUIntLE(jsonBuf.length, 14, 4)
+  return exif
+}
+
+async function injectExif(webpBuffer, metadata) {
+  const webp = await loadWebp()
+  const img = new webp.Image()
+  await img.load(webpBuffer)
+  img.exif = buildExif(metadata)
+  return img.save(null)
+}
+
+export async function toSticker(buffer, type = 'image', metadata = {}) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
+    throw new MediaError('toSticker() requires a non-empty Buffer', { code: 'LUMINA_STICKER_EMPTY' })
+  }
+  if (!['image', 'video'].includes(type)) {
+    throw new MediaError(`type must be image or video, got: ${type}`, { code: 'LUMINA_STICKER_BAD_TYPE' })
+  }
+
+  const webp = await convertToWebp(buffer, type)
+  return injectExif(webp, metadata)
+}
+
+export async function addExif(webpBuffer, metadata = {}) {
+  if (!Buffer.isBuffer(webpBuffer) || webpBuffer.length === 0) {
+    throw new MediaError('addExif() requires a non-empty Buffer', { code: 'LUMINA_STICKER_EMPTY' })
+  }
+  return injectExif(webpBuffer, metadata)
+}
+
+export default { toSticker, addExif }

package/src/media/uploader.js

@@ -1,37 +1,7 @@
-/**
- * @file uploader.js
- * @module lumina/media/uploader
- *
- * Thin wrapper around Baileys' `prepareWAMessageMedia` that uploads a buffer
- * (or `{ url }`) to WhatsApp and returns the resulting CDN URL.
- *
- * Bug fix vs legacy: the hardcoded `jid: '@newsletter'` (which silently
- * forced every media upload through the newsletter queue) is replaced by a
- * configurable default that the user can override via the `Connection`
- * options or per-call `jid`.
- */
-
 import { MediaError } from '../errors.js'
 
-/**
- * Default pre-upload JID. Use a stable bot JID that WhatsApp accepts for
- * media pre-uploads — historically the legacy code used `@newsletter`, but
- * that route is rate-limited and intended for broadcast use. The default
- * `s.whatsapp.net` route is more permissive and works for bot accounts.
- */
 export const DEFAULT_UPLOAD_JID = '62831@s.whatsapp.net'
 
-/**
- * Upload a media source to WhatsApp and return its CDN URL.
- *
- * @param {import('../client/connection.js').Connection} conn
- * @param {Buffer | { url: string }} source
- * @param {'image'|'video'|'audio'|'document'} mediaType
- * @param {object} [opts]
- * @param {string} [opts.jid=DEFAULT_UPLOAD_JID]   Pre-upload JID.
- * @param {object} [opts.options]                   Extra options forwarded to `prepareWAMessageMedia`.
- * @returns {Promise<string>}  CDN URL.
- */
 export async function uploadToWhatsApp(conn, source, mediaType, opts = {}) {
   if (!conn?.uploadMedia) {
     throw new MediaError('connection.uploadMedia is not available', {

package/src/media/video.js

@@ -1,17 +1,6 @@
-/**
- * @file video.js
- * @module lumina/media/video
  *
- * Pure-Node MP4 box parser (for duration) + ffmpeg-based thumbnail extractor.
  *
- * The legacy `Toolkit.getMp4Duration` was a hand-rolled ISO-BMFF box walker
- * that worked but had no tests and several silent-failure paths. Lumina
- * keeps the same approach (no native deps for duration) but factors it into
- * a single, documented function.
  *
- * `extractThumbnail` lazy-imports `fluent-ffmpeg` — users who never send
- * video thumbnails do not need it installed.
- */
 
 import { PassThrough, Readable } from 'node:stream'
 
@@ -36,19 +25,8 @@ async function loadFfmpeg() {
   return ffmpegPromise
 }
 
-/**
- * Walk the ISO-BMFF box tree of an MP4 buffer and extract the duration
- * (in seconds) from the first `mvhd` box found inside `moov`.
  *
- * Returns 0 when the buffer is invalid, truncated, or lacks a `moov`/`mvhd`
- * box — `silent: true` (default) preserves the legacy swallow-on-failure
- * behaviour so that video uploads do not hard-fail when metadata is missing.
  *
- * @param {Buffer} buffer
- * @param {object} [opts]
- * @param {boolean} [opts.silent=true]
- * @returns {number}  Duration in seconds (0 on failure).
- */
 export function getMp4Duration(buffer, opts = {}) {
   const { silent = true } = opts
 
@@ -109,24 +87,8 @@ export function getMp4Duration(buffer, opts = {}) {
   }
 }
 
-/**
- * @typedef {object} ThumbnailOptions
- * @property {number|string} [time='auto']   Seek position (seconds) or 'auto' (= 20% of duration, capped at 10s).
- * @property {number} [width=300]
- * @property {number} [height=300]
- * @property {'png'|'jpeg'|'webp'} [format='png']
- * @property {boolean} [resizeOutput=true]   Pass the frame through `sharp.resize()`.
- * @property {boolean} [silent=true]         Swallow ffmpeg errors and return empty Buffer.
- * @property {'buffer'|'base64'} [result='buffer']
- */
-
-/**
- * Extract a single frame from an MP4 buffer at the given timestamp.
+
  *
- * @param {Buffer} videoBuffer
- * @param {ThumbnailOptions} [opts]
- * @returns {Promise<Buffer|string>}  Buffer or base64 string (per `result`).
- */
 export async function extractThumbnail(videoBuffer, opts = {}) {
   const {
     time,

package/src/parsers/code-tokenizer-keywords.js

@@ -1,15 +1,6 @@
-/**
- * @file code-tokenizer-keywords.js
- * @module lumina/parsers/code-tokenizer-keywords
  *
- * Language keyword catalog. Built ONCE at module-load time (vs the legacy
- * `AIRich.tokenizer` which rebuilt a `new Set(...)` on every call).
  *
- * Twelve languages are supported out of the box. To add a new language,
- * append a `Set` here — the lexer picks it up automatically.
- */
 
-/** @type {Record<string, Set<string>>} */
 export const KEYWORDS = {
   javascript: new Set([
     'break', 'case', 'catch', 'continue', 'debugger', 'default', 'delete', 'do', 'else',
@@ -112,15 +103,12 @@ export const KEYWORDS = {
   markdown: new Set(['#', '##', '###', '####', '#####', '######']),
 }
 
-/** Languages where `//` introduces a line comment. */
 export const SLASH_COMMENT_LANGS = new Set([
   'javascript', 'typescript', 'java', 'golang', 'c', 'cpp', 'php', 'rust', 'css',
 ])
 
-/** Languages where `#` introduces a line comment. */
 export const HASH_COMMENT_LANGS = new Set(['python', 'bash', 'php', 'rust'])
 
-/** Languages that support block comments with `/* ... *\/`. */
 export const BLOCK_COMMENT_LANGS = new Set([
   'javascript', 'typescript', 'java', 'c', 'cpp', 'php', 'css',
 ])