fix(scanner): narrow as const class properties to their literal type

A class field like `readonly provider = 'threads' as const` emitted
`provider: unknown` in the generated .d.ts instead of `provider: 'threads'`.
`inferLiteralType`/`inferTypeFromDefault` never stripped the `as const`
suffix (so the string-literal check failed and fell through to `unknown`),
and instance `readonly` fields weren't treated as const-like, so `as const`
initializers were routed to the widening path.

`inferLiteralType` now strips `as const` before inferring, and the class
field path routes any `as const` initializer through it — so `as const`
narrows to the literal type regardless of modifiers (matching tsc). Adds a
regression test.

Author: chrisbbreuer

packages/dtsx/src/extractor/scanner.ts

@@ -1560,7 +1560,11 @@ export function scanDeclarations(_source: string, _filename: string, _keepCommen
 
   /** Infer literal type from initializer value (for const-like / static readonly) */
   function inferLiteralType(value: string): string {
-    const v = value.trim()
+    let v = value.trim()
+    // `x as const` narrows to the literal type of `x` — strip the assertion
+    // and infer from the underlying value (e.g. `'threads' as const` → "threads").
+    if (v.endsWith('as const'))
+      v = v.slice(0, -8).trim()
     if (v === 'true' || v === 'false')
       return v
     if (isNumericLiteral(v))
@@ -2506,8 +2510,12 @@ export function scanDeclarations(_source: string, _filename: string, _keepCommen
             type = asType
           }
           else {
+            // `as const` always narrows to the literal type (like tsc), no
+            // matter the modifiers; otherwise only static-readonly
+            // ("const-like") fields narrow and plain fields widen.
+            const isConstAssertion = initText.endsWith('as const')
             const isConstLike = isStatic && isReadonly
-            type = isConstLike ? inferLiteralType(initText) : inferTypeFromDefault(initText)
+            type = (isConstAssertion || isConstLike) ? inferLiteralType(initText) : inferTypeFromDefault(initText)
           }
         }
         else {

packages/dtsx/test/comprehensive.test.ts

@@ -1811,6 +1811,25 @@ describe('Class static members', () => {
     expect(result).toContain('static readonly DEFAULT_TIMEOUT: number;')
     expect(result).toContain('static instance: Config | null;')
   })
+
+  it('should narrow `as const` class properties to literal types', () => {
+    const source = `
+      export class C {
+        readonly provider = 'threads' as const
+        static readonly apiVersion = '1.0' as const
+        readonly count = 42 as const
+        mutableConst = 'x' as const
+      }
+    `
+    const result = processSource(source)
+    // `as const` narrows to the literal type regardless of modifiers
+    // (previously these emitted `unknown`).
+    expect(result).toContain('readonly provider: \'threads\';')
+    expect(result).toContain('static readonly apiVersion: \'1.0\';')
+    expect(result).toContain('readonly count: 42;')
+    expect(result).toContain('mutableConst: \'x\';')
+    expect(result).not.toContain('unknown')
+  })
 })
 
 // ============================================================