polen 0.10.0-next.14 → 0.10.0-next.16

package/src/api/content/$.ts

@@ -1 +1 @@
-export * as Content from './$$.ts'
+export * as Content from './$$.js'

package/src/api/content/navbar.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
-import { createNavbar } from './navbar.ts'
-import type { Page } from './page.ts'
+import { createNavbar } from './navbar.js'
+import type { Page } from './page.js'
 
 const createPage = (path: string[], fileName = 'index', hidden = false): Page => ({
   route: {

package/src/api/content/navbar.ts

@@ -1,5 +1,5 @@
 import { Str } from '@wollybeard/kit'
-import type { Page } from './page.ts'
+import type { Page } from './page.js'
 
 export interface NavbarItem {
   pathExp: string
@@ -33,12 +33,12 @@ export const createNavbar = (pages: Page[]): NavbarItem[] => {
     // For directories, check if there's an index page
     const indexPage = pages.find(p =>
       p.route.logical.path.length === 1
-      && p.route.file.path.relative.name === 'index'
+      && p.route.file.path.relative.name === `index`
     )
 
     // For single non-index files at top level
     const singlePage = pages.length === 1 && pages[0]!.route.logical.path.length === 1
-      && pages[0]!.route.file.path.relative.name !== 'index'
+      && pages[0]!.route.file.path.relative.name !== `index`
 
     // Include in navbar if:
     // 1. It's a directory with an index page, OR

package/src/api/content/page.ts

@@ -1,5 +1,5 @@
 import type { FileRouter } from '#lib/file-router/index'
-import type { Metadata } from './metadata.ts'
+import type { Metadata } from './metadata.js'
 
 export type { Metadata }
 

package/src/api/content/scan.ts

@@ -1,8 +1,8 @@
 import { FileRouter } from '#lib/file-router/index'
 import { Fs, Path, Tree } from '@wollybeard/kit'
 import matter from 'gray-matter'
-import { MetadataSchema } from './metadata.ts'
-import type { Page } from './page.ts'
+import { MetadataSchema } from './metadata.js'
+import type { Page } from './page.js'
 
 export interface ScanResult {
   list: Page[]
@@ -23,7 +23,7 @@ export const scan = async (options: {
   // Scan for routes
   const routeScanResult = await FileRouter.scan({
     dir: options.dir,
-    glob: options.glob ?? '**/*.{md,mdx}',
+    glob: options.glob ?? `**/*.{md,mdx}`,
   })
 
   // Create pages with metadata (id/parentId now come from route)
@@ -53,12 +53,12 @@ export const scan = async (options: {
     // Create a virtual root node to hold all root-level pages
     const virtualRoot: Page & { id: string; parentId: null } = {
       route: {
-        id: '__virtual_root__',
+        id: `__virtual_root__`,
         parentId: null,
         file: {
           path: {
-            absolute: Path.parse(''),
-            relative: Path.parse(''),
+            absolute: Path.parse(``),
+            relative: Path.parse(``),
           },
         },
         logical: {
@@ -66,14 +66,14 @@ export const scan = async (options: {
         },
       },
       metadata: { hidden: true },
-      id: '__virtual_root__',
+      id: `__virtual_root__`,
       parentId: null,
     }
 
     // Update pages to have virtual root as parent if they don't have one
     const pagesWithVirtualRoot = pagesWithIds.map(page => ({
       ...page,
-      parentId: page.parentId || '__virtual_root__',
+      parentId: page.parentId || `__virtual_root__`,
     }))
 
     tree = Tree.fromList([virtualRoot, ...pagesWithVirtualRoot])

package/src/api/content/sidebar.test.ts

@@ -1,8 +1,8 @@
 import * as fc from 'fast-check'
 import { describe, expect, it } from 'vitest'
-import type { Page } from './page.ts'
-import type { ScanResult } from './scan.ts'
-import { buildSidebarIndex, type Item, type SidebarIndex } from './sidebar.ts'
+import type { Page } from './page.js'
+import type { ScanResult } from './scan.js'
+import { buildSidebarIndex } from './sidebar.js'
 
 // Generators
 const pathSegmentArb = fc.stringMatching(/^[a-z][a-z0-9-]{0,19}$/)

package/src/api/content/sidebar.ts

@@ -1,7 +1,7 @@
 import { FileRouter } from '#lib/file-router/index'
 import { Str } from '@wollybeard/kit'
-import type { Page } from './page.ts'
-import type { ScanResult } from './scan.ts'
+import type { Page } from './page.js'
+import type { ScanResult } from './scan.js'
 
 /**
  * Represents a complete sidebar structure with navigation items.
@@ -27,17 +27,17 @@ export type Item = ItemLink | ItemSection
  * ```ts
  * const link: ItemLink = {
  *   type: 'ItemLink',
- *   title: 'Getting Started',
- *   pathExp: 'guide/getting-started'
+ *   title: 'Get Started',
+ *   pathExp: 'guide/get-started'
  * }
  * ```
  */
 export interface ItemLink {
   /** Discriminator for TypeScript union types */
   type: `ItemLink`
-  /** Display title for the link (e.g., "Getting Started") */
+  /** Display title for the link (e.g., "Get Started") */
   title: string
-  /** Path expression relative to the base path, without leading slash (e.g., "guide/getting-started") */
+  /** Path expression relative to the base path, without leading slash (e.g., "guide/get-started") */
   pathExp: string
 }
 
@@ -164,7 +164,7 @@ const buildSidebarForDirectory = (topLevelDir: string, pages: Page[]): Sidebar =
     }
 
     // Get the immediate parent path (e.g., for ['guide', 'advanced', 'tips'], parent is ['guide', 'advanced'])
-    const parentPath = page.route.logical.path.slice(0, -1).join('/')
+    const parentPath = page.route.logical.path.slice(0, -1).join(`/`)
 
     if (!pagesByParent.has(parentPath)) {
       pagesByParent.set(parentPath, [])
@@ -178,12 +178,12 @@ const buildSidebarForDirectory = (topLevelDir: string, pages: Page[]): Sidebar =
   // Sort pages by their directory order (extracted from file path)
   const sortedTopLevelPages = [...topLevelPages].sort((a, b) => {
     // For sections, we need to look at the directory name in the file path
-    const dirA = a.route.file.path.relative.dir.split('/').pop() || ''
-    const dirB = b.route.file.path.relative.dir.split('/').pop() || ''
+    const dirA = a.route.file.path.relative.dir.split(`/`).pop() || ``
+    const dirB = b.route.file.path.relative.dir.split(`/`).pop() || ``
 
     // Extract order from directory names like "10_b", "20_c"
-    const orderMatchA = dirA.match(/^(\d+)[_-]/)
-    const orderMatchB = dirB.match(/^(\d+)[_-]/)
+    const orderMatchA = /^(\d+)[_-]/.exec(dirA)
+    const orderMatchB = /^(\d+)[_-]/.exec(dirB)
 
     const orderA = orderMatchA ? parseInt(orderMatchA[1]!, 10) : Number.MAX_SAFE_INTEGER
     const orderB = orderMatchB ? parseInt(orderMatchB[1]!, 10) : Number.MAX_SAFE_INTEGER
@@ -196,7 +196,7 @@ const buildSidebarForDirectory = (topLevelDir: string, pages: Page[]): Sidebar =
 
   for (const page of sortedTopLevelPages) {
     const pageName = page.route.logical.path[page.route.logical.path.length - 1]!
-    const childPath = page.route.logical.path.join('/')
+    const childPath = page.route.logical.path.join(`/`)
     const childPages = pagesByParent.get(childPath) || []
 
     if (childPages.length > 0 || FileRouter.routeIsFromIndexFile(page.route)) {
@@ -204,7 +204,7 @@ const buildSidebarForDirectory = (topLevelDir: string, pages: Page[]): Sidebar =
       const hasIndex = FileRouter.routeIsFromIndexFile(page.route)
 
       const section: ItemSection = {
-        type: 'ItemSection',
+        type: `ItemSection`,
         title: Str.titlizeSlug(pageName),
         pathExp: childPath,
         isLinkToo: hasIndex,
@@ -221,9 +221,9 @@ const buildSidebarForDirectory = (topLevelDir: string, pages: Page[]): Sidebar =
       for (const childPage of sortedChildPages) {
         if (!FileRouter.routeIsFromIndexFile(childPage.route)) {
           section.links.push({
-            type: 'ItemLink',
+            type: `ItemLink`,
             title: Str.titlizeSlug(childPage.route.logical.path[childPage.route.logical.path.length - 1]!),
-            pathExp: childPage.route.logical.path.join('/'),
+            pathExp: childPage.route.logical.path.join(`/`),
           })
         }
       }
@@ -232,7 +232,7 @@ const buildSidebarForDirectory = (topLevelDir: string, pages: Page[]): Sidebar =
       const allDescendants: Page[] = []
       for (const [parentPath, pagesInParent] of pagesByParent) {
         // Check if this path is a descendant (but not direct child)
-        if (parentPath.startsWith(childPath + '/')) {
+        if (parentPath.startsWith(childPath + `/`)) {
           for (const descendantPage of pagesInParent) {
             if (!FileRouter.routeIsFromIndexFile(descendantPage.route)) {
               allDescendants.push(descendantPage)
@@ -258,11 +258,11 @@ const buildSidebarForDirectory = (topLevelDir: string, pages: Page[]): Sidebar =
 
       for (const descendantPage of allDescendants) {
         section.links.push({
-          type: 'ItemLink',
+          type: `ItemLink`,
           title: Str.titlizeSlug(
             descendantPage.route.logical.path[descendantPage.route.logical.path.length - 1]!,
           ),
-          pathExp: descendantPage.route.logical.path.join('/'),
+          pathExp: descendantPage.route.logical.path.join(`/`),
         })
       }
 
@@ -272,9 +272,9 @@ const buildSidebarForDirectory = (topLevelDir: string, pages: Page[]): Sidebar =
     } else {
       // This is a simple link
       items.push({
-        type: 'ItemLink',
+        type: `ItemLink`,
         title: Str.titlizeSlug(pageName),
-        pathExp: page.route.logical.path.join('/'),
+        pathExp: page.route.logical.path.join(`/`),
       })
     }
   }

package/src/api/index.ts

@@ -1 +1 @@
-export * as Api from './api.ts'
+export * as Api from './api.js'

package/src/api/schema/data-sources/data-sources.ts

@@ -1,3 +1,3 @@
-export * as Memory from './memory/memory.ts'
-export * as SchemaDirectory from './schema-directory/schema-directory.ts'
-export * as SchemaFile from './schema-file/schema-file.ts'
+export * as Memory from './memory/memory.js'
+export * as SchemaDirectory from './schema-directory/schema-directory.js'
+export * as SchemaFile from './schema-file/schema-file.js'

package/src/api/schema/data-sources/index.ts

@@ -1 +1 @@
-export * as DataSources from './data-sources.ts'
+export * as DataSources from './data-sources.js'

package/src/api/schema/data-sources/memory/memory.ts

@@ -2,9 +2,44 @@ import { Grafaid } from '#lib/grafaid/index'
 import { GraphqlChange } from '#lib/graphql-change/index'
 import type { GraphqlChangeset } from '#lib/graphql-changeset/index'
 import { Arr } from '@wollybeard/kit'
-import type { Schema } from '../../schema.ts'
+import type { Schema } from '../../schema.js'
 
+/**
+ * Configuration for defining schemas programmatically in memory.
+ *
+ * Useful for demos, testing, or when schemas are generated dynamically.
+ */
 export interface ConfigInput {
+  /**
+   * Schema versions defined as SDL strings.
+   *
+   * Can be:
+   * - A single SDL string (no changelog)
+   * - Array of SDL strings (uses current date for all)
+   * - Array of objects with date and SDL (full changelog support)
+   *
+   * @example
+   * ```ts
+   * // Single schema
+   * versions: `
+   *   type Query {
+   *     hello: String
+   *   }
+   * `
+   *
+   * // Multiple versions with explicit dates
+   * versions: [
+   *   {
+   *     date: new Date('2024-01-15'),
+   *     value: `type Query { users: [User] }`
+   *   },
+   *   {
+   *     date: new Date('2024-03-20'),
+   *     value: `type Query { users: [User], posts: [Post] }`
+   *   }
+   * ]
+   * ```
+   */
   versions:
     | string
     | string[]

package/src/api/schema/data-sources/schema-directory/file-name-expression/file-name-expression.ts

@@ -58,7 +58,6 @@ const expressionPreviousSerializedPattern = /^(?<year>\d{4})-(?<month>\d{2})-(?<
 //   filePath: string
 // }
 
-// // eslint-disable-next-line
 // const parseExpressionLatestSerialized = (serializedExpression: string): null | {} => {
 //   if (serializedExpression === `latest`) return {}
 //   return null

package/src/api/schema/data-sources/schema-directory/file-name-expression/index.ts

@@ -1 +1 @@
-export * as FileNameExpression from './file-name-expression.ts'
+export * as FileNameExpression from './file-name-expression.js'

package/src/api/schema/data-sources/schema-directory/schema-directory.ts

@@ -4,8 +4,8 @@ import type { GraphqlChangeset } from '#lib/graphql-changeset/index'
 import { debugPolen } from '#singletons/debug'
 import { Arr, Path } from '@wollybeard/kit'
 import { glob } from 'tinyglobby'
-import type { Schema } from '../../schema.ts'
-import { FileNameExpression } from './file-name-expression/index.ts'
+import type { Schema } from '../../schema.js'
+import { FileNameExpression } from './file-name-expression/index.js'
 
 // const debug = debugPolen.sub([`schema`, `data-source-schema-directory`])
 const debug = debugPolen.sub(`schema:data-source-schema-directory`)
@@ -14,7 +14,36 @@ const defaultPaths = {
   schemaDirectory: `./schema`,
 }
 
+/**
+ * Configuration for loading multiple schema versions from a directory.
+ *
+ * Enables the schema changelog feature by loading SDL files with date prefixes.
+ */
 export interface ConfigInput {
+  /**
+   * Path to the directory containing dated SDL files.
+   *
+   * Files should be named with ISO date prefixes: `YYYY-MM-DD.graphql`
+   *
+   * @default './schema'
+   *
+   * @example
+   * ```ts
+   * // Default location
+   * path: './schema'
+   *
+   * // Custom location
+   * path: './graphql/versions'
+   * ```
+   *
+   * Directory structure example:
+   * ```
+   * schema/
+   *   2024-01-15.graphql
+   *   2024-03-20.graphql
+   *   2024-06-10.graphql
+   * ```
+   */
   path?: string
   projectRoot?: string
 }

package/src/api/schema/data-sources/schema-file/schema-file.ts

@@ -2,13 +2,32 @@ import { Grafaid } from '#lib/grafaid/index'
 import { GraphqlChange } from '#lib/graphql-change/index'
 import type { GraphqlChangeset } from '#lib/graphql-changeset/index'
 import { Path } from '@wollybeard/kit'
-import type { Schema } from '../../schema.ts'
+import type { Schema } from '../../schema.js'
 
 const defaultPaths = {
   schemaFile: `./schema.graphql`,
 }
 
+/**
+ * Configuration for loading schema from a single SDL file.
+ */
 export interface ConfigInput {
+  /**
+   * Path to the GraphQL SDL file.
+   *
+   * Can be absolute or relative to the project root.
+   *
+   * @default './schema.graphql'
+   *
+   * @example
+   * ```ts
+   * // Default location
+   * path: './schema.graphql'
+   *
+   * // Custom location
+   * path: './src/graphql/schema.sdl'
+   * ```
+   */
   path?: string
   projectRoot?: string
 }

package/src/api/schema/index.ts

@@ -1 +1 @@
-export * as Schema from './schema.ts'
+export * as Schema from './schema.js'

package/src/api/schema/read.ts

@@ -1,19 +1,60 @@
 import { Arr } from '@wollybeard/kit'
-import * as DataSources from './data-sources/data-sources.ts'
-import type { Schema } from './schema.ts'
+import * as DataSources from './data-sources/data-sources.js'
+import type { Schema } from './schema.js'
 
 export type DataSourceType = `file` | `directory` | `memory` | `data`
 
+/**
+ * Schema configuration for Polen.
+ */
 export interface Config {
   /**
+   * Whether to enable schema loading.
+   *
+   * Set to `false` to disable schema features entirely.
+   *
    * @default `true`
    */
   enabled?: boolean
+  /**
+   * Which data sources to use for loading schemas.
+   *
+   * - `file` - Load from a single SDL file
+   * - `directory` - Load multiple SDL files from a directory
+   * - `memory` - Use schemas defined in configuration
+   * - `data` - Use a pre-built schema object
+   *
+   * If not specified, Polen will try all sources in order until one succeeds.
+   *
+   * @example
+   * ```ts
+   * // Use only file source
+   * useDataSources: 'file'
+   *
+   * // Try multiple sources
+   * useDataSources: ['directory', 'file']
+   * ```
+   */
   useDataSources?: Arr.Maybe<DataSourceType>
+  /**
+   * Configuration for each data source type.
+   */
   dataSources?: {
+    /**
+     * Configuration for loading schema from a single SDL file.
+     */
     file?: DataSources.SchemaFile.ConfigInput
+    /**
+     * Configuration for loading multiple schema versions from a directory.
+     */
     directory?: DataSources.SchemaDirectory.ConfigInput
+    /**
+     * Configuration for defining schemas programmatically.
+     */
     memory?: DataSources.Memory.ConfigInput
+    /**
+     * Pre-built schema object to use directly.
+     */
     data?: Schema
   }
   projectRoot: string

package/src/api/schema/schema.ts

@@ -1,8 +1,8 @@
 import type { GraphqlChangeset } from '#lib/graphql-changeset/index'
 
-export * as DataSources from './data-sources/data-sources.ts'
+export * as DataSources from './data-sources/data-sources.js'
 
-export * from './read.ts'
+export * from './read.js'
 
 export interface Schema {
   versions: [GraphqlChangeset.ChangeSet, ...GraphqlChangeset.ChangeSet[]]

package/src/api/schema-augmentation/augmentations/description.ts

@@ -1,7 +1,7 @@
 import type { GrafaidOld } from '#lib/grafaid-old/index'
 import { neverCase } from '@wollybeard/kit/language'
-import type { Target } from '../target.ts'
-import { locateTargetField, locateTargetType } from '../target.ts'
+import type { Target } from '../target.js'
+import { locateTargetField, locateTargetType } from '../target.js'
 
 export const Placement = {
   Before: `before`,

package/src/api/schema-augmentation/index.ts

@@ -1 +1 @@
-export * as SchemaAugmentation from './schema-augmentation.ts'
+export * as SchemaAugmentation from './schema-augmentation.js'

package/src/api/schema-augmentation/schema-augmentation.ts

@@ -1,6 +1,6 @@
 import type { GrafaidOld } from '#lib/grafaid-old/index'
 import { neverCase } from '@wollybeard/kit/language'
-import * as AugmentationDescription from './augmentations/description.ts'
+import * as AugmentationDescription from './augmentations/description.js'
 
 export { AugmentationDescription }
 
@@ -12,7 +12,6 @@ export const apply = (
 ): GrafaidOld.Schema.Schema => {
   for (const augmentation of augmentations) {
     switch (augmentation.type) {
-      // eslint-disable-next-line
       case `description`: {
         AugmentationDescription.apply(schema, augmentation)
         break

package/src/api/server/report-error.ts

@@ -19,7 +19,7 @@ export const reportError = async (value: unknown): Promise<void> => {
   const snippets = createSnippets(parsedError)
 
   if (snippets) {
-    console.log('\n\n\n\n' + snippets)
+    console.log(`\n\n\n\n` + snippets)
   }
 }
 
@@ -27,15 +27,15 @@ const createSnippets = (parsedError: ParsedError) => {
   const snippets = parsedError.frames.map((frame) => {
     let snippet = createSnippet(frame)
 
-    snippet = frame.fileName + '\n' + frame.lineNumber + '\n\n' + snippet
+    snippet = frame.fileName + `\n` + frame.lineNumber + `\n\n` + snippet
     return snippet
-  }).join('\n\n----------------------------------------------------------------------------------\n\n')
+  }).join(`\n\n----------------------------------------------------------------------------------\n\n`)
   return snippets
 }
 
 const createSnippet = (stackFrame: StackFrame) => {
   const snippet = stackFrame.source?.map(line => {
-    return line.lineNumber.toString().padStart(4, ' ') + `: ` + line.chunk
+    return line.lineNumber.toString().padStart(4, ` `) + `: ` + line.chunk
   }).join(`\n`)
 
   return snippet
@@ -45,7 +45,9 @@ const createSnippet = (stackFrame: StackFrame) => {
 // pathFilter: Fn.compose(Str.isMatchWith(excludePattern), Bool.negate)
 const cleanStackRecursive = (value: unknown, excludePattern: RegExp) => {
   if (value instanceof AggregateError) {
-    value.errors.forEach((error) => cleanStackRecursive(error, excludePattern))
+    value.errors.forEach((error) => {
+      cleanStackRecursive(error, excludePattern)
+    })
   }
   // console.log(`Filtering path: ${path}`, isInclude ? 'Included' : 'Excluded')
   if (value instanceof Error) {

package/src/api/singletons/markdown/index.ts

@@ -1 +1 @@
-export * as Markdown from './markdown.ts'
+export * as Markdown from './markdown.js'

package/src/api/singletons/markdown/markdown.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, test } from 'vitest'
-import { parse } from './markdown.ts'
+import { parse } from './markdown.js'
 
-describe(`markdown parser with syntax highlighting`, () => {
-  test(`parse highlights code blocks`, { timeout: 10000 }, async () => {
+describe('markdown parser', () => {
+  test('parse converts code blocks', async () => {
     const markdown = `
 # Hello
 
@@ -13,17 +13,14 @@ console.log(x)
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`<h1>Hello</h1>`)
-    expect(result).toContain(`<pre`)
-    expect(result).toContain(`shiki`)
-    expect(result).toContain(`console`)
-    expect(result).toContain(`42`)
+    expect(result).toContain('<h1>Hello</h1>')
+    expect(result).toContain('<pre')
+    expect(result).toContain('<code class="language-javascript">')
+    expect(result).toContain('console')
+    expect(result).toContain('42')
   })
 
-  // Note: parseSync cannot be used with async rehype plugins like Shiki
-  // This is a known limitation - syntax highlighting requires async processing
-
-  test(`parse supports GraphQL syntax`, async () => {
+  test('parse supports GraphQL syntax', async () => {
     const markdown = `
 \`\`\`graphql
 type Query {
@@ -33,21 +30,20 @@ type Query {
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`type`)
-    expect(result).toContain(`Query`)
-    // Check that both ID and ! are present (they may be in separate spans)
-    expect(result).toContain(`> ID<`)
-    expect(result).toContain(`>!</`)
+    expect(result).toContain('<code class="language-graphql">')
+    expect(result).toContain('type Query')
+    expect(result).toContain('ID!')
+    expect(result).toContain('User')
   })
 
-  test(`parse handles inline code`, async () => {
-    const markdown = `This is \`inline code\` in a sentence.`
+  test('parse handles inline code', async () => {
+    const markdown = 'This is `inline code` in a sentence.'
     const result = await parse(markdown)
 
-    expect(result).toContain(`<code>inline code</code>`)
+    expect(result).toContain('<code>inline code</code>')
   })
 
-  test(`parse supports GitHub Flavored Markdown`, async () => {
+  test('parse supports GitHub Flavored Markdown', async () => {
     const markdown = `
 | Column 1 | Column 2 |
 |----------|----------|
@@ -58,12 +54,12 @@ type Query {
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`<table>`)
-    expect(result).toContain(`<input`)
-    expect(result).toContain(`checked`)
+    expect(result).toContain('<table>')
+    expect(result).toContain('<input')
+    expect(result).toContain('checked')
   })
 
-  test(`parse handles code blocks without language`, async () => {
+  test('parse handles code blocks without language', async () => {
     const markdown = `
 \`\`\`
 plain text without language
@@ -71,11 +67,11 @@ plain text without language
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`<pre`)
-    expect(result).toContain(`plain text without language`)
+    expect(result).toContain('<pre')
+    expect(result).toContain('plain text without language')
   })
 
-  test(`parse preserves theme CSS variables`, async () => {
+  test('parse converts code blocks without syntax highlighting', async () => {
     const markdown = `
 \`\`\`javascript
 const theme = "light"
@@ -83,7 +79,8 @@ const theme = "light"
 `
     const result = await parse(markdown)
 
-    expect(result).toContain(`--shiki-light`)
-    expect(result).toContain(`--shiki-dark`)
+    expect(result).toContain('<pre>')
+    expect(result).toContain('<code class="language-javascript">')
+    expect(result).toContain('const theme = "light"')
   })
 })