@@ -1,8 +1,10 @@
-import type { BundledLanguage } from 'shiki'
+import type { Readable } from 'node:stream'
+import type { BundledLanguage, BundledTheme } from 'shiki'
 import fs from 'node:fs/promises'
 import { parse } from 'node:path'
 import process from 'node:process'
 import cac from 'cac'
+import { bundledLanguages, isSpecialLang } from 'shiki'
 import { version } from '../package.json'
 import { codeToANSI } from './code-to-ansi'
 
@@ -20,6 +22,34 @@ export function getExtFromUrl(url: string): string {
   }
 }
 
+/**
+ * Unknown languages fall back to plaintext so the CLI can be used as a `cat` replacement.
+ * Known-language grammar load/parse errors are not swallowed.
+ */
+export function resolveLanguage(lang: string): string {
+  const normalized = lang.toLowerCase()
+  if (normalized in bundledLanguages || isSpecialLang(normalized))
+    return normalized
+  return 'text'
+}
+
+async function render(
+  content: string,
+  lang: string,
+  theme: BundledTheme,
+  format: string,
+): Promise<string> {
+  const resolved = resolveLanguage(lang) as BundledLanguage
+  if (format === 'html') {
+    const { codeToHtml } = await import('shiki')
+    return await codeToHtml(content, {
+      lang: resolved,
+      theme,
+    })
+  }
+  return await codeToANSI(content, resolved, theme)
+}
+
 export async function readSource(path: string): Promise<{ content: string, ext: string }> {
   if (isUrl(path)) {
     const response = await fetch(path)
@@ -40,6 +70,7 @@ export async function readSource(path: string): Promise<{ content: string, ext:
 export async function run(
   argv = process.argv,
   log = console.log,
+  stdin: Readable & { isTTY?: boolean } = process.stdin,
 ): Promise<void> {
   const cli = cac('shiki')
 
@@ -62,7 +93,6 @@ export async function run(
   }
 
   if (options.listLangs) {
-    const { bundledLanguages } = await import('shiki')
     for (const lang of Object.keys(bundledLanguages))
       log(lang)
     return
@@ -74,25 +104,15 @@ export async function run(
     // If no files provided, verify if we are in a TTY environment
     // If NOT in TTY (piped), read from stdin
     // If in TTY, show help
-    if (!process.stdin.isTTY) {
+    if (!stdin.isTTY) {
       const content = await new Promise<string>((resolve, reject) => {
         let data = ''
-        process.stdin.on('data', chunk => data += chunk)
-        process.stdin.on('end', () => resolve(data))
-        process.stdin.on('error', reject)
+        stdin.on('data', chunk => data += chunk)
+        stdin.on('end', () => resolve(data))
+        stdin.on('error', reject)
       })
 
-      const lang = options.lang || 'text'
-      if (options.format === 'html') {
-        const { codeToHtml } = await import('shiki')
-        log(await codeToHtml(content, {
-          lang: lang as BundledLanguage,
-          theme: options.theme,
-        }))
-      }
-      else {
-        log(await codeToANSI(content, lang as BundledLanguage, options.theme))
-      }
+      log(await render(content, options.lang || 'text', options.theme, options.format))
       return
     }
 
@@ -102,17 +122,8 @@ export async function run(
 
   const codes = await Promise.all(files.map(async (path) => {
     const { content, ext } = await readSource(path)
-    const lang = (options.lang || ext || 'text').toLowerCase()
-    if (options.format === 'html') {
-      const { codeToHtml } = await import('shiki')
-      return await codeToHtml(content, {
-        lang: lang as BundledLanguage,
-        theme: options.theme,
-      })
-    }
-    else {
-      return await codeToANSI(content, lang as BundledLanguage, options.theme)
-    }
+    const lang = options.lang || ext || 'text'
+    return await render(content, lang, options.theme, options.format)
   }))
 
   for (const code of codes)
 
@@ -1,7 +1,8 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
+import { Readable } from 'node:stream'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { getExtFromUrl, isUrl, readSource, run } from '../src/cli'
+import { getExtFromUrl, isUrl, readSource, resolveLanguage, run } from '../src/cli'
 
 describe('isUrl', () => {
   it('valid URL', () => {
@@ -32,6 +33,32 @@ describe('getExtFromUrl', () => {
   })
 })
 
+describe('resolveLanguage', () => {
+  it('keeps bundled languages and aliases', () => {
+    expect(resolveLanguage('ts')).toBe('ts')
+    expect(resolveLanguage('typescript')).toBe('typescript')
+    expect(resolveLanguage('md')).toBe('md')
+    expect(resolveLanguage('dotenv')).toBe('dotenv')
+  })
+
+  it('keeps special languages', () => {
+    expect(resolveLanguage('text')).toBe('text')
+    expect(resolveLanguage('txt')).toBe('txt')
+    expect(resolveLanguage('plain')).toBe('plain')
+    expect(resolveLanguage('ansi')).toBe('ansi')
+  })
+
+  it('falls back to text for unknown languages', () => {
+    expect(resolveLanguage('example')).toBe('text')
+    expect(resolveLanguage('env.example')).toBe('text')
+  })
+
+  it('normalizes casing before lookup', () => {
+    expect(resolveLanguage('TS')).toBe('ts')
+    expect(resolveLanguage('DOTENV')).toBe('dotenv')
+  })
+})
+
 describe('readSource', () => {
   const testDir = path.join(import.meta.dirname, '__fixtures__')
   const testFile = path.join(testDir, 'test.ts')
@@ -184,6 +211,12 @@ describe('run', () => {
 
     expect(output.length).toBe(1)
     expect(output[0]).toContain('all')
+
+    const asHtml: string[] = []
+    const plain: string[] = []
+    await run(['node', 'shiki', '--format', 'html', noExtFile], msg => asHtml.push(msg))
+    await run(['node', 'shiki', '--lang', 'text', '--format', 'html', noExtFile], msg => plain.push(msg))
+    expect(asHtml[0]).toBe(plain[0])
   })
 
   it('remote URL without file extension falls back to plaintext', async () => {
@@ -201,4 +234,74 @@ describe('run', () => {
 
     vi.unstubAllGlobals()
   })
+
+  it('unknown extension falls back to plaintext without throwing', async () => {
+    const envFile = path.join(testDir, '.env.example')
+    await fs.writeFile(envFile, 'FOO=bar')
+
+    const output: string[] = []
+    await run(['node', 'shiki', '--format', 'html', envFile], msg => output.push(msg))
+
+    const plain: string[] = []
+    await run(['node', 'shiki', '--lang', 'text', '--format', 'html', envFile], msg => plain.push(msg))
+
+    expect(output.length).toBe(1)
+    expect(output[0]).toContain('FOO=bar')
+    expect(output[0]).toBe(plain[0])
+  })
+
+  it('highlights known extensions', async () => {
+    const mdFile = path.join(testDir, 'README.md')
+    await fs.writeFile(mdFile, '# Title')
+
+    const md: string[] = []
+    const mdPlain: string[] = []
+    await run(['node', 'shiki', '--format', 'html', mdFile], msg => md.push(msg))
+    await run(['node', 'shiki', '--lang', 'text', '--format', 'html', mdFile], msg => mdPlain.push(msg))
+    expect(md[0]).toContain('Title')
+    expect(md[0]).not.toBe(mdPlain[0])
+
+    const ts: string[] = []
+    const tsPlain: string[] = []
+    await run(['node', 'shiki', '--format', 'html', testFile], msg => ts.push(msg))
+    await run(['node', 'shiki', '--lang', 'text', '--format', 'html', testFile], msg => tsPlain.push(msg))
+    expect(ts[0]).toContain('const')
+    expect(ts[0]).not.toBe(tsPlain[0])
+  })
+
+  it('respects explicit --lang over unknown extension', async () => {
+    const envFile = path.join(testDir, 'file.env.example')
+    await fs.writeFile(envFile, 'FOO=bar')
+
+    const explicit: string[] = []
+    const fallback: string[] = []
+    await run(['node', 'shiki', '--lang', 'dotenv', '--format', 'html', envFile], msg => explicit.push(msg))
+    await run(['node', 'shiki', '--format', 'html', envFile], msg => fallback.push(msg))
+
+    expect(explicit.length).toBe(1)
+    expect(explicit[0]).toContain('FOO')
+    expect(explicit[0]).not.toBe(fallback[0])
+  })
+
+  it('stdin without --lang uses text', async () => {
+    function createStdin() {
+      const stdin = Readable.from(['const x = 1']) as Readable & { isTTY?: boolean }
+      stdin.isTTY = false
+      return stdin
+    }
+
+    const output: string[] = []
+    await run(['node', 'shiki', '--format', 'html'], msg => output.push(msg), createStdin())
+
+    const plain: string[] = []
+    await run(['node', 'shiki', '--lang', 'text', '--format', 'html'], msg => plain.push(msg), createStdin())
+
+    const asTs: string[] = []
+    await run(['node', 'shiki', '--lang', 'ts', '--format', 'html'], msg => asTs.push(msg), createStdin())
+
+    expect(output.length).toBe(1)
+    expect(output[0]).toContain('const x = 1')
+    expect(output[0]).toBe(plain[0])
+    expect(output[0]).not.toBe(asTs[0])
+  })
 })